@vercel/board 0.30.0 → 0.31.0

package/dist/{provider-Bm46LAdp.d.mts → provider-gynDUoyW.d.mts}

@@ -1,5 +1,5 @@
-import { d as ExternalFile, f as ExternalLink, l as ExternalAuthor, p as Link, t as Actor, u as ExternalEvent } from "./folds-8wRRXjAt.mjs";
-import { H as MessageView, _ as BoardEventView, ft as SourceJoin, ht as SourceRead, t as BoardClient } from "./client-CjAatpV4.mjs";
+import { d as ExternalFile, f as ExternalLink, l as ExternalAuthor, p as Link, t as Actor, u as ExternalEvent } from "./folds-DLUzfibJ.mjs";
+import { U as MessageView, _ as BoardEventView, dt as SourceJoin, mt as SourceRead, t as BoardClient } from "./client-COfYrgfV.mjs";
 import { z } from "zod";
 //#region src/sync/events.d.ts
 declare const EventBase: z.ZodObject<{
@@ -401,33 +401,6 @@ declare function render<E extends ProviderEvent = ProviderEvent>(renderer: Rende
  */
 declare function channels<E extends ProviderEvent = ProviderEvent>(map: Record<string, SyncUnit<E>>): SyncFn<E>;
 //#endregion
-//#region src/sync/users.d.ts
-/**
- * People's own platform tokens, so a board message they wrote reaches Slack or
- * GitHub as them, and signing in proves an account is theirs. The board never
- * stores a token: it asks for one at each delivery, and a person without one
- * (never signed in, revoked, expired) is delivered as the bot, as before.
- */
-type UserTokens = {
-  /**
-   * A sign-in URL that binds whoever completes it to `principal`. Show it only to them. With
-   * `callback`, the platform sends them there once they've approved.
-   */
-  authorize(principal: string, options?: {
-    callback?: string;
-  }): Promise<string>;
-  /** `principal`'s token on the platform, or null when they haven't signed in. */
-  token(principal: string): Promise<string | null>;
-};
-/**
- * Gives an adapter people's tokens, for your own OAuth: `slack({ adapter:
- * withUserTokens(createSlackAdapter(...), { authorize, token }) }, sync)`. A
- * Connect connector name (`slack('slack/acme', sync)`) does this for you.
- */
-declare function withUserTokens<A extends object>(adapter: A, tokens: UserTokens): A;
-/** Vercel Connect's user tokens for `connector`: the subject is the board's principal, so Connect binds the account to it. */
-declare function connectUserTokens(connector: string): UserTokens;
-//#endregion
 //#region src/sync/provider.d.ts
 declare const ResolvedTarget: z.ZodObject<{
   target: z.ZodString;
@@ -449,7 +422,7 @@ type RenderInput = {
   /** The message as clients see it: its IDs are refs. */
   message: Readonly<MessageView>;
   author: Readonly<Actor> | null;
-  /** How this platform mentions an actor, through linked accounts; null when it can't. */
+  /** How this platform mentions an actor when it's one of its own (`<@U123>`); null for anyone else. */
   mentionOf: (actor: string) => string | null;
   label: string;
   target: string;
@@ -498,8 +471,6 @@ type ProviderOptions = {
   uploadsFiles?: boolean;
   /** Whether a new thread's root can carry its files in the same message as its text. */
   startsThreadsWithFiles?: boolean;
-  /** People's own tokens, to post as them and to link accounts by signing in. */
-  users?: UserTokens | null;
 };
 declare const ReceivedEvent: z.ZodObject<{
   event: z.ZodDiscriminatedUnion<[z.ZodObject<{
@@ -629,28 +600,27 @@ declare abstract class SyncProvider<E extends ProviderEvent = ProviderEvent> {
   readonly uploadsFiles: boolean;
   readonly startsThreadsWithFiles: boolean;
   private readonly fn;
-  /** People's tokens, when the adapter has them: messages they write post as them. */
-  readonly users: UserTokens | null;
   protected readonly options: ProviderOptions;
   constructor(options: ProviderOptions, sync: SyncFn<E>);
   abstract receive(key: string, request: Request, emit: Receive): Promise<Response>;
   abstract resolveChannel(key: string): Promise<string>;
   abstract resolveTarget(target: string): Promise<ResolvedTarget>;
   abstract post(target: string, kind: ResolvedTarget['kind'], body: ProviderPost): Promise<ProviderDelivery>;
-  /** The platform account a person's token belongs to. */
-  whoAmI(_token: string): Promise<ExternalAuthor>;
-  /** `post`, as the person whose token this is. */
-  postAs(_token: string, _target: string, _kind: ResolvedTarget['kind'], _body: ProviderPost): Promise<ProviderDelivery>;
-  editAs(_token: string, _thread: string, _message: string, _body: ProviderPost): Promise<void>;
-  deleteAs(_token: string, _thread: string, _message: string): Promise<void>;
   findByEmail(_email: string): Promise<ExternalAuthor | null>;
   mention(_actor: Actor): string | null;
   fetchRoot(_thread: string): Promise<SyncRoot | null>;
   fetchFile(_file: ExternalFile): Promise<Uint8Array | null>;
   /** The platform's own link to an event's message, or null when it has none. */
   permalink(_event: E): Promise<string | null>;
-  /** A linked message the platform didn't describe, read from the platform. */
-  fetchLink(_link: ExternalLink): Promise<FetchedLink>;
+  /**
+   * A linked message the platform didn't describe, read from the platform. `linker` is the
+   * platform message that links it, by its own IDs: what the platform says about the link may be
+   * there by now.
+   */
+  fetchLink(_link: ExternalLink, _linker: {
+    thread: string;
+    message: string;
+  }): Promise<FetchedLink>;
   /**
    * The message a URL of this platform's names, by its own thread and message IDs, or null for a
    * URL that isn't one. `message` is null for a link to a thread itself. It asks the platform
@@ -692,4 +662,4 @@ declare abstract class SyncProvider<E extends ProviderEvent = ProviderEvent> {
   render(input: RenderInput): string;
 }
 //#endregion
-export { SyncOverrides as A, channels as C, EventBase as D, render as E, SyncRoot as M, envelope as N, ProviderEvent as O, eventSchema as P, SyncUnit as S, mirror as T, withUserTokens as _, ProviderOptions as a, SyncIn as b, ReceivedEvent as c, ResolvedTarget as d, SyncContext as f, connectUserTokens as g, UserTokens as h, ProviderFile as i, SyncResult as j, RootOverride as k, RenderInput as l, UnreadableError as m, FileDelivery as n, ProviderPost as o, SyncProvider as p, ProviderDelivery as r, Receive as s, FetchedLink as t, Renderer as u, Sync as v, into as w, SyncOut as x, SyncFn as y };
+export { envelope as A, render as C, SyncOverrides as D, RootOverride as E, SyncResult as O, mirror as S, ProviderEvent as T, SyncIn as _, ProviderOptions as a, channels as b, ReceivedEvent as c, ResolvedTarget as d, SyncContext as f, SyncFn as g, Sync as h, ProviderFile as i, eventSchema as j, SyncRoot as k, RenderInput as l, UnreadableError as m, FileDelivery as n, ProviderPost as o, SyncProvider as p, ProviderDelivery as r, Receive as s, FetchedLink as t, Renderer as u, SyncOut as v, EventBase as w, into as x, SyncUnit as y };

package/dist/{redis-tables-BWJZHUGg.mjs → redis-tables-DHf85ixI.mjs}

@@ -5,7 +5,7 @@ import { m as nullProtoRecord, n as NOTIFY_TIMINGS, v as stateTailReaders } from
 import { i as presenceTombstones, n as isSerializedEvent, r as parseSerializedEvent, t as bufferedEvents } from "./stream-buffer-DrTyiIuo-Be10yOBR.mjs";
 import { i as streamActivities, n as defaultSleep, r as pollingStream, t as createStreamActivity } from "./store-polling-BZt2Rf3D-Div-bJ_D.mjs";
 import { t as retryableLazy } from "./retryable-lazy-DZWmHpii-DpTc5PIP.mjs";
-import { i as syncReads, n as project, r as projectSync, t as concernedMessageId } from "./project-C_2xs57L.mjs";
+import { i as syncReads, n as project, r as projectSync, t as concernedMessageId } from "./project-CQ4VUibA.mjs";
 import { i as idempotentReplay, n as decodeCause } from "./store-codec-pAG2oPgQ-SqDXlPBR.mjs";
 import { t as pollPresence } from "./store-presence-polling-JuAy2Ck2-Dh-g_KYM.mjs";
 //#region ../../node_modules/.pnpm/experimental-a2@0.24.0_@upstash+qstash@2.12.0_@vercel+queue@0.7.0_ai@7.0.130_zod@4.6.5__b1e2c243a963f2620a5d202817417c26/node_modules/experimental-a2/dist/store-redis-notify-ys_-VrSP.js
@@ -3278,12 +3278,6 @@ local out = {}
 for i = 1, #KEYS do out[i] = redis.call('HGETALL', KEYS[i]) end
 return out
 `;
-/** A person's roots posted at or after ARGV[1]. KEYS: messages, their roots by creation time. */
-const RECENT = `
-local ids = redis.call('ZRANGEBYSCORE', KEYS[2], ARGV[1], '+inf')
-if #ids == 0 then return {} end
-return redis.call('HMGET', KEYS[1], unpack(ids))
-`;
 /**
 * What an event reads before it applies, in one script so it reads the primary,
 * where the position check runs: a replica can lag it. Nothing, when the
@@ -3412,8 +3406,6 @@ function redisTables(send, prefix, options = {}) {
 		mention: (actor) => `${p}:i:mn:${actor}`,
 		attachment: (id) => `${p}:i:at:${id}`,
 		from: (from) => `${p}:i:f:${from}`,
-		/** A person's roots, by when they were posted: for the echo check. */
-		rootsBy: (principal) => `${p}:rr:${principal}`,
 		label: (token) => `${p}:i:${token}`,
 		copies: (id) => `${p}:cp:${id}`
 	};
@@ -3522,7 +3514,6 @@ function redisTables(send, prefix, options = {}) {
 				re: m.re,
 				c: m.channel,
 				t: m.text.toLowerCase(),
-				ca: Date.parse(m.createdAt),
 				d: m.deleted
 			};
 			out.push([
@@ -3577,12 +3568,6 @@ function redisTables(send, prefix, options = {}) {
 					id,
 					id
 				]);
-				else out.push([
-					"ZADD",
-					k.rootsBy(m.by.principal),
-					String(meta.ca),
-					id
-				]);
 			}
 			if (change.message.terms) {
 				const old = read.message;
@@ -3903,9 +3888,6 @@ function redisTables(send, prefix, options = {}) {
 				return message ? [message] : [];
 			});
 		},
-		async recentRoots(principal, since) {
-			return (await evaluate(RECENT, [k.messages, k.rootsBy(principal)], [since])).map((row) => parse(row)).sort((a, b) => a.id - b.id);
-		},
 		async close() {}
 	};
 }

package/dist/{reducers-8jqLewgw.mjs → reducers-DcENwtwZ.mjs}

@@ -2,7 +2,7 @@ import { S as storable, _ as RemoteWatcherId, c as ChannelPath, d as LabelKey, g
 import { a as Link, i as ExternalTarget, n as ExternalEvent, o as Origin } from "./external-D3p5T57R.mjs";
 import { n as setOwn, t as own } from "./own-OwgPWdmh.mjs";
 import { a as reducer, i as makeReducerBuilder, t as assertSyncSchema } from "./reducer-Bswr11ar-P324o9vn.mjs";
-import { n as foldMessages, t as foldActors } from "./folds-DGYkMW19.mjs";
+import { n as foldMessages, t as foldActors } from "./folds-Cu9Q9zyQ.mjs";
 import { z } from "zod";
 //#region ../../node_modules/.pnpm/experimental-a2@0.24.0_@upstash+qstash@2.12.0_@vercel+queue@0.7.0_ai@7.0.130_zod@4.6.5__b1e2c243a963f2620a5d202817417c26/node_modules/experimental-a2/dist/contract-DqfBSIqJ.js
 function contract(options) {
@@ -80,6 +80,14 @@ const boardEvents = {
 		*/
 		importedBy: ActorId.optional()
 	}),
+	/**
+	* A channel made before anything posted to it. A post makes one too, with no event of its own:
+	* this is only for one that's empty. It names no message, so it carries no `id`.
+	*/
+	"channel.created": z.object({
+		channel: ChannelPath,
+		by: Author
+	}),
 	/** A message's links changed: an edit linked something new, or the platform sent what a link says. */
 	"message.linked": z.object({
 		id: MessageId,
@@ -138,9 +146,7 @@ const boardEvents = {
 		target: ExternalTarget,
 		external: z.object({
 			thread: ExternalTarget,
-			message: z.string().min(1).max(300),
-			/** Posted with its author's own platform token, so it shows as them. Older receipts have none. */
-			asUser: z.literal(true).optional()
+			message: z.string().min(1).max(300)
 		}),
 		/**
 		* (server) The principal of the sync elsewhere that recorded it: its copy is that sync's to
@@ -179,22 +185,6 @@ const boardEvents = {
 		* signs in, whatever its ID or kind, so sync never writes as it. Others have none.
 		*/
 		host: z.literal(true).optional()
-	}),
-	/**
-	* A platform actor (`slack:user:U0456`) is the same person as a principal
-	* (`vercel:user:…`): for display, `--by`, and mentions, never for permissions.
-	* `method` says how it was proved: a one-time code posted from that account,
-	* or the account's own sign-in (`consent`).
-	*/
-	"actor.linked": z.object({
-		actor: ActorId,
-		to: ActorId,
-		method: z.enum(["code", "consent"]),
-		by: Author
-	}),
-	"actor.unlinked": z.object({
-		actor: ActorId,
-		by: Author
 	})
 };
 const BOARD_SESSION = "board";
@@ -328,7 +318,9 @@ const StoredPrincipal = z.object({
 		/** The board's own Vercel team, as the board knew it when it verified the token. */
 		team: z.string().max(200).optional()
 	}).optional(),
-	scope: z.string().max(SCOPE_MAX).optional()
+	scope: z.string().max(SCOPE_MAX).optional(),
+	/** The board token it came with: what it stores stops when the token does. */
+	token: z.string().min(1).max(64).optional()
 });
 /** A watcher as a board on `http()` registers it: its tail, and when it runs. */
 const WatcherSpec = z.object({
@@ -350,11 +342,13 @@ const registryContract = contract({
 		/** Where to wake it: `<url>/wake`. Without one, it pulls on its own. */
 		url: z.string().url().max(500).nullable(),
 		watch: z.record(RemoteWatcherId, WatcherSpec),
-		/** Its sync entries: with any, its sync subscribes too, to every post, change, and thread sync where it may sync. Older registrations have none. */
+		/**
+		* Its sync entries: with any, its sync subscribes too, to every post, change, and thread sync
+		* where it may sync. Older registrations have none.
+		*/
 		sync: z.array(z.object({
 			key: z.string().min(1).max(64),
-			platform: z.string().min(1).max(64),
-			signIn: z.boolean()
+			platform: z.string().min(1).max(64)
 		})).max(32).optional(),
 		/** `watchersHash(watch)`, which every wake-up carries so the board can tell it's stale. */
 		hash: z.string().min(1).max(100)
@@ -444,31 +438,53 @@ const schedulesContract = contract({
 	}
 });
 const SCHEDULES_SESSION = "schedules";
+const Grant = z.union([z.literal("all"), z.array(z.string().min(1).max(16)).max(8)]);
+/** A `can`, as config writes it: board() checks it before it's kept. */
+const Can = z.union([Grant, z.record(z.string().min(1).max(300), Grant)]);
+const ClaimValue = z.string().min(1).max(1e3);
 /**
-* One-time codes for linking accounts, outside the board log: a code is a secret
-* until it's used, and only its hash is kept. Session `identity`.
+* Who the board trusts beside its code's rules, outside the board log: grants, and the tokens it
+* issued, of which only a hash is kept. Session `access`. A grant's and a token's ID is the index
+* of the event that made it.
 */
-const identityContract = contract({
-	name: "board-identity",
+const accessContract = contract({
+	name: "board-access",
 	events: {
-		"identity.code_issued": z.object({
-			hash: z.string().min(1).max(128),
-			/** Who the account it's posted from links to. */
-			principal: ActorId,
-			/** The sync entry it must be posted through. */
-			sync: z.string().min(1).max(64),
-			expiresAt: z.string().max(64)
+		/** A grant, or a new `can` for the grant with this issuer and claims. */
+		"grant.set": z.object({
+			issuer: z.string().min(1).max(1e3),
+			claims: z.record(z.string().min(1).max(200), z.union([ClaimValue, z.array(ClaimValue).min(1).max(32)])),
+			can: Can,
+			by: ActorId
+		}),
+		"grant.revoked": z.object({
+			id: z.number().int().positive(),
+			by: ActorId
+		}),
+		"token.minted": z.object({
+			/** The secret's SHA-256, hex. */
+			hash: z.string().regex(/^[0-9a-f]{64}$/),
+			name: z.string().min(1).max(64),
+			/** Who it acts as, its scope narrowed to what the token may do. */
+			minter: StoredPrincipal,
+			profile: z.string().min(1).max(32).nullable(),
+			avatar: z.string().max(2048).nullable(),
+			session: z.string().min(1).max(128).nullable(),
+			/** A person's handle and name when they minted it. */
+			handle: Handle.nullable(),
+			personName: z.string().min(1).max(128).nullable(),
+			expiresAt: Millis,
+			/** The token it was minted with, which it stops with. */
+			parent: z.number().int().positive().nullable(),
+			by: ActorId
 		}),
-		/** The first account to post it wins; any later post is just a message. */
-		"identity.code_used": z.object({
-			hash: z.string().min(1).max(128),
-			actor: ActorId,
-			/** The message that used it (`externalMessageKey`): only a retry of that one claims it again. */
-			message: z.string().max(1024).optional()
+		"token.revoked": z.object({
+			id: z.number().int().positive(),
+			by: ActorId
 		})
 	}
 });
-const IDENTITY_SESSION = "identity";
+const ACCESS_SESSION = "access";
 //#endregion
 //#region src/contract/reducers.ts
 const messagesReducer = reducer({
@@ -487,19 +503,24 @@ reducer({
 	if (event.type === "message.posted") setOwn(state, event.id, event.index);
 	return state;
 });
+const emptyChannel = (path) => ({
+	path,
+	lastIndex: 0,
+	messages: 0,
+	threads: 0
+});
 const channelsReducer = reducer({
 	contract: boardContract,
-	name: "board.channels.v1",
+	name: "board.channels.v2",
 	initialState: {}
 }).fold((state, event) => {
+	if (event.type === "channel.created") {
+		if (!own(state, event.payload.channel)) setOwn(state, event.payload.channel, emptyChannel(event.payload.channel));
+		return state;
+	}
 	if (event.type !== "message.posted") return state;
 	const { channel, re } = event.payload;
-	const entry = own(state, channel) ?? setOwn(state, channel, {
-		path: channel,
-		lastIndex: 0,
-		messages: 0,
-		threads: 0
-	});
+	const entry = own(state, channel) ?? setOwn(state, channel, emptyChannel(channel));
 	entry.lastIndex = event.index;
 	entry.messages += 1;
 	if (re === null) entry.threads += 1;
@@ -510,32 +531,8 @@ const actorsReducer = reducer({
 	name: "board.actors.v2",
 	initialState: {
 		byId: {},
-		byHandle: {},
-		links: {}
+		byHandle: {}
 	}
 }).fold(foldActors);
-const identityCodesReducer = reducer({
-	contract: identityContract,
-	name: "board.identity-codes.v1",
-	initialState: {}
-}).fold((state, event) => {
-	if (event.type === "identity.code_issued") {
-		const { hash, principal, sync, expiresAt } = event.payload;
-		state[hash] ??= {
-			principal,
-			sync,
-			expiresAt,
-			usedBy: null,
-			usedIn: null
-		};
-	} else if (event.type === "identity.code_used") {
-		const code = state[event.payload.hash];
-		if (code && code.usedBy === null) {
-			code.usedBy = event.payload.actor;
-			code.usedIn = event.payload.message ?? null;
-		}
-	}
-	return state;
-});
 //#endregion
-export { BOARD_SESSION as _, IDENTITY_SESSION as a, SCHEDULES_SESSION as c, inboxContract as d, inboxSession as f, watchSession as g, watchContract as h, messagesReducer as i, boardContract as l, schedulesContract as m, channelsReducer as n, INBOXES_SESSION as o, registryContract as p, identityCodesReducer as r, REGISTRY_SESSION as s, actorsReducer as t, identityContract as u };
+export { INBOXES_SESSION as a, accessContract as c, inboxSession as d, registryContract as f, BOARD_SESSION as g, watchSession as h, ACCESS_SESSION as i, boardContract as l, watchContract as m, channelsReducer as n, REGISTRY_SESSION as o, schedulesContract as p, messagesReducer as r, SCHEDULES_SESSION as s, actorsReducer as t, inboxContract as u };

package/dist/{serve-lPoBDEds.mjs → serve-CTmow-YH.mjs}

@@ -1,9 +1,9 @@
-import { u as BoardError } from "./errors-C_5rB8Iz.mjs";
-import { s as localTokenFile } from "./node-D8Rtg1su.mjs";
-import { t as board } from "./server-D82a4uMe.mjs";
-import { t as oidcTokens } from "./tokens-C5_yGRlL.mjs";
-import { t as a2 } from "./a2-D_28Pdip.mjs";
-import { a as fsBlob } from "./blob-DQK5prXT.mjs";
+import { u as BoardError } from "./errors-CJXhhzvT.mjs";
+import { s as localTokenFile } from "./node-BgeGcwX0.mjs";
+import { t as board } from "./server-DG8D6VV0.mjs";
+import { t as oidcTokens } from "./tokens-Dnyd_y1n.mjs";
+import { t as a2 } from "./a2-DngWY2Eb.mjs";
+import { a as fsBlob } from "./blob-WbB2DJKn.mjs";
 import { t as localScheduler } from "./local-C76Fy5ad.mjs";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { userInfo } from "node:os";

package/dist/{server-D82a4uMe.mjs → server-DG8D6VV0.mjs}

@@ -1,5 +1,5 @@
-import { t as createBoard } from "./exports-CG0P8Qi4.mjs";
-import { t as http } from "./backend-http-16SbvnAK.mjs";
+import { t as createBoard } from "./exports-CWIdN0Ub.mjs";
+import { t as http } from "./backend-http-D8mUzuKQ.mjs";
 //#region src/server/index.ts
 /**
 * The handle on a board. With a `backend`, the board lives there: `a2()` keeps it in this
@@ -9,8 +9,8 @@ import { t as http } from "./backend-http-16SbvnAK.mjs";
 function board(options = {}) {
 	return createBoard(options, {
 		http: () => http(),
-		sync: () => import("./engine-DkdkXQEy.mjs"),
-		serving: () => import("./serving-DKny38LK.mjs")
+		sync: () => import("./engine-DurYIRt8.mjs"),
+		serving: () => import("./serving-DBFRo6U_.mjs")
 	});
 }
 //#endregion

package/dist/{serving-DKny38LK.mjs → serving-DBFRo6U_.mjs}

@@ -1,2 +1,2 @@
-import { i as ownTeamId, n as discoveryIdentity, r as ownProjectId, t as oidcTokens } from "./tokens-C5_yGRlL.mjs";
+import { i as ownTeamId, n as discoveryIdentity, r as ownProjectId, t as oidcTokens } from "./tokens-Dnyd_y1n.mjs";
 export { discoveryIdentity, oidcTokens, ownProjectId, ownTeamId };

package/dist/{sql-Bj0fk6dn.mjs → sql-CT5xVuGr.mjs}

@@ -1,6 +1,6 @@
 import { c as externalMessageKey } from "./external-D3p5T57R.mjs";
 import { n as setOwn } from "./own-OwgPWdmh.mjs";
-import { i as syncReads, n as project, r as projectSync, t as concernedMessageId } from "./project-C_2xs57L.mjs";
+import { i as syncReads, n as project, r as projectSync, t as concernedMessageId } from "./project-CQ4VUibA.mjs";
 //#region src/store/sql.ts
 /** The projection's name in `board_positions`, and the A2 consumer that runs it. */
 const TABLES_CONSUMER = "board-tables";
@@ -61,7 +61,7 @@ function ddl(dialect) {
   key text primary key,
   message_id ${big} not null
 )`,
-		"create index if not exists board_messages_recent on board_messages (by_principal, created_at) where re is null",
+		"drop index if exists board_messages_recent",
 		...dialect === "postgres" ? ["drop function if exists board_apply(text, bigint, boolean, jsonb, jsonb, jsonb)", APPLY_FUNCTION] : []
 	];
 }
@@ -558,12 +558,6 @@ order by m.id`,
 				values: [clean(attachment)]
 			})).map((found) => parse(found));
 		},
-		async recentRoots(principal, since) {
-			return (await db.all({
-				text: "select data from board_messages where by_principal = $1 and re is null and created_at >= $2 order by id",
-				values: [principal, since]
-			})).map((found) => parse(found));
-		},
 		close: () => db.close()
 	};
 }

package/dist/{sqlite-db-Dc8G78XV.mjs → sqlite-db-0WeSOEZN.mjs}

@@ -1,4 +1,4 @@
-import { n as ddl } from "./sql-Bj0fk6dn.mjs";
+import { n as ddl } from "./sql-CT5xVuGr.mjs";
 import { mkdirSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 //#region src/store/sqlite-db.ts

package/dist/{sync-kapso.d.mts → sync-chat-sdk.d.mts}

@@ -1,9 +1,9 @@
-import { S as SyncUnit, f as SyncContext, y as SyncFn } from "./provider-Bm46LAdp.mjs";
-import { n as ChatSyncProvider, t as ChatInput } from "./chat-provider-D6jVT4wS.mjs";
+import { b as channels, g as SyncFn, p as SyncProvider } from "./provider-gynDUoyW.mjs";
+import { r as ChatTransport, t as ChatInput } from "./chat-provider-BChYrrA7.mjs";
 import { z } from "zod";
-import { Adapter } from "chat";
-//#region src/sync/kapso.d.ts
-export declare const WhatsAppEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+import { ReactionEvent } from "chat";
+//#region src/sync/chat-sdk.d.ts
+declare const schemaOf: <P extends string>(platform: P) => z.ZodDiscriminatedUnion<[z.ZodObject<{
   channel: z.ZodString;
   thread: z.ZodString;
   subthread: z.ZodNullable<z.ZodString>;
@@ -49,7 +49,7 @@ export declare const WhatsAppEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
   id: z.ZodString;
   key: z.ZodString;
   raw: z.ZodUnknown;
-  platform: z.ZodLiteral<"whatsapp">;
+  platform: z.ZodLiteral<P>;
   type: z.ZodLiteral<"message">;
 }, z.core.$strip>, z.ZodObject<{
   channel: z.ZodString;
@@ -83,7 +83,7 @@ export declare const WhatsAppEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
   id: z.ZodString;
   key: z.ZodString;
   raw: z.ZodUnknown;
-  platform: z.ZodLiteral<"whatsapp">;
+  platform: z.ZodLiteral<P>;
   type: z.ZodLiteral<"message.edited">;
 }, z.core.$strip>, z.ZodObject<{
   channel: z.ZodString;
@@ -94,7 +94,7 @@ export declare const WhatsAppEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
   id: z.ZodString;
   key: z.ZodString;
   raw: z.ZodUnknown;
-  platform: z.ZodLiteral<"whatsapp">;
+  platform: z.ZodLiteral<P>;
   type: z.ZodLiteral<"message.deleted">;
 }, z.core.$strip>, z.ZodObject<{
   channel: z.ZodString;
@@ -114,7 +114,7 @@ export declare const WhatsAppEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
   id: z.ZodString;
   key: z.ZodString;
   raw: z.ZodUnknown;
-  platform: z.ZodLiteral<"whatsapp">;
+  platform: z.ZodLiteral<P>;
   type: z.ZodEnum<{
     "reaction.added": "reaction.added";
     "reaction.removed": "reaction.removed";
@@ -144,35 +144,31 @@ export declare const WhatsAppEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
   id: z.ZodString;
   key: z.ZodString;
   raw: z.ZodUnknown;
-  platform: z.ZodLiteral<"whatsapp">;
+  platform: z.ZodLiteral<P>;
 }, z.core.$strip>], "kind">;
-export type WhatsAppEvent = z.infer<typeof WhatsAppEvent>;
-type MarkRead = (input: {
-  phoneNumberId: string;
-  messageId: string;
-  typingIndicator: {
-    type: 'text';
-  };
-}) => Promise<unknown>;
-export type KapsoOptions = {
-  adapter: Adapter;
-  markRead: MarkRead;
+/** What a `chatSdk()` entry's sync function reads as `sync.event`. `P` is its platform's name. */
+export type ChatSdkEvent<P extends string = string> = z.infer<ReturnType<typeof schemaOf<P>>>;
+/** The adapter, and hooks for what board can't read from it. Every hook is optional. */
+export type ChatSdkOptions<P extends string = string> = Omit<ChatTransport, 'platform'> & {
+  /** The platform's name, in author IDs, author labels, and `vb sources`. The adapter's `name` unless given. */
+  platform?: P;
+  /**
+   * Whether a new board root opens a thread of its own in a mirrored channel, as on Discord or
+   * Teams. Off unless given: on most platforms a chat is one conversation, so the root stays on
+   * the board, and threads that came from the platform sync both ways.
+   */
+  canStartThreads?: boolean;
+  /** The platform's ID for one reaction occurrence, the same on every redelivery. Without it, a reaction is known by the webhook that brought it. */
+  reactionId?(reaction: ReactionEvent): string;
 };
 /**
- * Syncs WhatsApp numbers on Kapso with the board: `sync` is what each event
- * does, both ways, like `numbers({ '16315558151': 'support' })`. Each Kapso
- * conversation is a thread. WhatsApp has no threads in a number, so a board
- * thread never starts one: a board root in a mirrored channel stays on the board.
+ * Syncs any Chat SDK adapter with the board: `sync` is what each event does, both ways, like
+ * `channels({ '-1001234567890': 'support' })`. Channels are the adapter's own IDs, without its
+ * prefix. Slack, GitHub, and Linear have entries of their own, with more than this reads.
  */
-export declare function kapso(options: KapsoOptions, sync: SyncFn<WhatsAppEvent>): KapsoProvider;
-/**
- * Routes each event by its WhatsApp number. Keys are phone number IDs (`'16315558151'`), not
- * the numbers; values are a board channel to `mirror`, or a sync function.
- */
-export declare const numbers: (map: Record<string, SyncUnit<WhatsAppEvent>>) => SyncFn<WhatsAppEvent>;
-export declare class KapsoProvider extends ChatSyncProvider<WhatsAppEvent> {
-  constructor(options: KapsoOptions, sync: SyncFn<WhatsAppEvent>);
-  eventId(key: string, input: ChatInput): string;
-  event(context: SyncContext): WhatsAppEvent;
-}
-//#endregion
+export declare function chatSdk<P extends string>(options: ChatSdkOptions<P> & {
+  platform: P;
+}, sync: SyncFn<ChatSdkEvent<P>>): SyncProvider<ChatSdkEvent<P>>;
+export declare function chatSdk(options: ChatSdkOptions, sync: SyncFn<ChatSdkEvent>): SyncProvider<ChatSdkEvent>;
+//#endregion
+export { type ChatInput, channels };

package/dist/sync-chat-sdk.mjs

@@ -0,0 +1,44 @@
+import { f as channels, i as eventSchema, r as envelope } from "./events-lujPA3gQ.mjs";
+import { t as ChatSyncProvider } from "./chat-provider-DkFp2hrh.mjs";
+import { createHash } from "node:crypto";
+//#region src/sync/chat-sdk.ts
+const schemaOf = (platform) => eventSchema(platform, "message");
+function chatSdk(options, sync) {
+	if (!options?.adapter?.name) throw new Error("chatSdk needs a Chat SDK adapter: chatSdk({ adapter }, channels({ … }))");
+	return new ChatSdkProvider(options, sync);
+}
+var ChatSdkProvider = class extends ChatSyncProvider {
+	schema;
+	reactionId;
+	constructor({ platform, reactionId, ...transport }, sync) {
+		const name = platform ?? transport.adapter.name;
+		super({
+			...transport,
+			platform: name
+		}, sync);
+		this.schema = schemaOf(name);
+		this.reactionId = reactionId;
+	}
+	eventId(key, input) {
+		if (input.kind !== "reaction") return super.eventId(key, input);
+		const reaction = input.reaction;
+		const occurrence = this.reactionId?.(reaction) ?? this.occurrence();
+		return `reaction:${key}:${this.toNative(reaction.threadId)}|${reaction.messageId}|${reaction.rawEmoji}|${reaction.user.userId}|${reaction.added}|${occurrence}`;
+	}
+	/**
+	* A reaction's occurrence, when the platform gives it no ID: the webhook that brought it. A
+	* platform redelivers the same body, and sends a new one for each occurrence, even where the
+	* payload has nothing that tells two apart (Discord's forwarded reactions carry a timestamp
+	* beside it).
+	*/
+	occurrence() {
+		const delivery = this.delivery();
+		if (delivery === null) throw new Error(`${this.platform}: a reaction outside a webhook has no identity; pass reactionId`);
+		return createHash("sha256").update(delivery).digest("base64url");
+	}
+	event(context) {
+		return this.schema.parse(envelope(this.platform, context.key, context.event, context.raw, context.id));
+	}
+};
+//#endregion
+export { channels, chatSdk };