@vercel/board 0.16.0 → 0.17.0

package/dist/stream-buffer-DrTyiIuo-BKy-vI14.mjs

@@ -0,0 +1,53 @@
+import { i as PRESENCE_TIMINGS } from "./internal-CvsrprnU-CRY89I-b.mjs";
+//#region ../../node_modules/.pnpm/experimental-a2@0.22.0_@upstash+qstash@2.12.0_@vercel+queue@0.7.0_ai@7.0.130_zod@4.6.5__52060f00b21aecfab049c27fa3abd2f9/node_modules/experimental-a2/dist/stream-buffer-DrTyiIuo.js
+const key = ({ participant, field }) => JSON.stringify([participant, field]);
+function presenceTombstones() {
+	const stamps = /* @__PURE__ */ new Map();
+	const prune = () => {
+		const cutoff = Date.now() - PRESENCE_TIMINGS.tombstoneMs;
+		for (const [id, stamp] of stamps) {
+			if (stamp.keptAtMs > cutoff) return;
+			stamps.delete(id);
+		}
+	};
+	return {
+		outranks(write) {
+			if (stamps.size === 0) return false;
+			prune();
+			const stamp = stamps.get(key(write));
+			return stamp !== void 0 && stamp.atMs > write.at.getTime();
+		},
+		keep(deletion) {
+			prune();
+			const id = key(deletion);
+			stamps.delete(id);
+			stamps.set(id, {
+				atMs: deletion.at.getTime(),
+				keptAtMs: Date.now()
+			});
+		},
+		drop(field) {
+			if (stamps.size > 0) stamps.delete(key(field));
+		}
+	};
+}
+const isSerializedEvent = (event) => "payloadJson" in event;
+const parseSerializedEvent = (event) => ({
+	id: event.id,
+	type: event.type,
+	payload: JSON.parse(event.payloadJson),
+	index: event.index,
+	sessionId: event.sessionId,
+	createdAt: new Date(event.createdAtMs)
+});
+/**
+* The next event a stream iterator already holds, removed without
+* awaiting its `next()`, which then continues after it; `undefined` when
+* it holds none. Call only while no `next()` is pending. The SSE encoder
+* writes these with the event `next()` just returned, so a buffered
+* backlog leaves in few writes.
+*/
+const bufferedEvents = /* @__PURE__ */ new WeakMap();
+const takeBuffered = (iterator) => bufferedEvents.get(iterator)?.();
+//#endregion
+export { takeBuffered as a, presenceTombstones as i, isSerializedEvent as n, parseSerializedEvent as r, bufferedEvents as t };

package/dist/sync-github.d.mts

@@ -1,5 +1,5 @@
-import { d as ResolvedTarget, g as UserTokens, i as ProviderDelivery, m as SyncHandler, p as SyncContext, s as ProviderPost, t as EventMapping, u as RenderInput, v as withUserTokens } from "./provider-BGjz-mDa.mjs";
-import { n as ChatSyncProvider } from "./chat-provider-XCnQlxq6.mjs";
+import { S as SyncUnit, _ as withUserTokens, d as ResolvedTarget, f as SyncContext, h as UserTokens, o as ProviderPost, r as ProviderDelivery, y as SyncFn } from "./provider-B0b9Qxw4.mjs";
+import { n as ChatSyncProvider } from "./chat-provider-DNJQyajS.mjs";
 import { z } from "zod";
 import { Adapter } from "chat";
 //#region src/sync/github.d.ts
@@ -314,6 +314,7 @@ export declare const GitHubEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
   owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
   reply: z.ZodNullable<z.ZodString>;
   createRoot: z.ZodBoolean;
+  retitled: z.ZodOptional<z.ZodBoolean>;
   author: z.ZodObject<{
     id: z.ZodString;
     handle: z.ZodString;
@@ -324,7 +325,7 @@ export declare const GitHubEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
   id: z.ZodString;
   key: z.ZodString;
   platform: z.ZodLiteral<"github">;
-  type: z.ZodLiteral<"pr.assigned" | "pr.closed" | "pr.draft" | "pr.labeled" | "pr.opened" | "pr.ready" | "pr.reopened" | "pr.unassigned" | "pr.unlabeled" | "review.dismissed" | "review.submitted">;
+  type: z.ZodLiteral<"pr.assigned" | "pr.closed" | "pr.draft" | "pr.edited" | "pr.labeled" | "pr.opened" | "pr.ready" | "pr.reopened" | "pr.unassigned" | "pr.unlabeled" | "review.dismissed" | "review.submitted">;
   subject: z.ZodObject<{
     repo: z.ZodString;
     number: z.ZodNumber;
@@ -373,6 +374,7 @@ export declare const GitHubEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
   owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
   reply: z.ZodNullable<z.ZodString>;
   createRoot: z.ZodBoolean;
+  retitled: z.ZodOptional<z.ZodBoolean>;
   author: z.ZodObject<{
     id: z.ZodString;
     handle: z.ZodString;
@@ -383,7 +385,7 @@ export declare const GitHubEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
   id: z.ZodString;
   key: z.ZodString;
   platform: z.ZodLiteral<"github">;
-  type: z.ZodLiteral<"issue.assigned" | "issue.closed" | "issue.labeled" | "issue.opened" | "issue.reopened" | "issue.unassigned" | "issue.unlabeled">;
+  type: z.ZodLiteral<"issue.assigned" | "issue.closed" | "issue.edited" | "issue.labeled" | "issue.opened" | "issue.reopened" | "issue.unassigned" | "issue.unlabeled">;
   subject: z.ZodObject<{
     repo: z.ZodString;
     number: z.ZodNumber;
@@ -422,10 +424,9 @@ export declare const GitHubEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
   }, z.core.$loose>;
 }, z.core.$strip>)[]], "type">;
 export type GitHubEvent = z.infer<typeof GitHubEvent>;
-export type GitHubHandler = SyncHandler<GitHubEvent>;
-export type GitHubRepo = EventMapping<GitHubEvent> | {
-  pulls?: EventMapping<GitHubEvent>;
-  issues?: EventMapping<GitHubEvent>;
+export type GitHubRepo = SyncUnit<GitHubEvent> | {
+  pulls?: SyncUnit<GitHubEvent>;
+  issues?: SyncUnit<GitHubEvent>;
 };
 export type GitHubOptions = {
   /**
@@ -439,19 +440,25 @@ export type GitHubOptions = {
    * board looks it up from the installation token; set it to skip that call.
    */
   botUserId?: number;
-  render?: (input: RenderInput) => string;
-  repos: Record<string, GitHubRepo>;
 };
 /**
- * Syncs GitHub repos with board channels. Keys are repos (`'owner/repo'`);
- * values are a board channel (PRs and issues become threads there), a
- * function, or `{ pulls, issues }` to send each somewhere else. Roots never
- * flow into GitHub: a board thread doesn't open an issue.
+ * Syncs GitHub with the board: `app` is a Vercel Connect connector
+ * (`'github/acme'`) or the options, and `sync` is what each event does, both
+ * ways, like `repos({ 'acme/www': 'prs' })`. A board thread never opens an
+ * issue: GitHub threads start on GitHub.
  */
-export declare function github(options: GitHubOptions): GitHubProvider;
+export declare function github(app: string | GitHubOptions, sync: SyncFn<GitHubEvent>): GitHubProvider;
+/**
+ * Routes each event by its repo. Keys are repos (`'owner/repo'`); values are a board channel
+ * that PRs and issues are imported `into`, a sync function, or `{ pulls, issues }` to route
+ * each its own way. A string imports and sends nothing back: what's said on the board stays
+ * there unless a function delivers it. A thread the board syncs in another repo keeps
+ * importing.
+ */
+export declare function repos(map: Record<string, GitHubRepo>): SyncFn<GitHubEvent>;
 export declare class GitHubProvider extends ChatSyncProvider<GitHubEvent> {
   private readonly body;
-  constructor(given: GitHubOptions);
+  constructor(given: GitHubOptions, sync: SyncFn<GitHubEvent>);
   whoAmI(token: string): Promise<{
     id: string;
     handle: string;
@@ -467,7 +474,7 @@ export declare class GitHubProvider extends ChatSyncProvider<GitHubEvent> {
    * (`root:<event>` or `lifecycle:<event>`), so its reactions go on the PR or issue.
    */
   react(thread: string, message: string, emoji: string, added: boolean): Promise<void>;
-  event(context: Pick<SyncContext, 'id' | 'key' | 'event' | 'raw'>): GitHubEvent;
+  event(context: SyncContext): GitHubEvent;
 }
 //#endregion
 export { type UserTokens, withUserTokens };

package/dist/sync-github.mjs

@@ -1,6 +1,7 @@
-import { c as eventSchema, s as envelope } from "./provider-CuewcDNZ.mjs";
-import { r as withUserTokens, t as connectUserTokens } from "./users-Dls7_ANV.mjs";
-import { r as markdownOf, t as ChatSyncProvider } from "./chat-provider-jFSeyNmB.mjs";
+import { c as into, d as withRoutes } from "./provider-B3DpYSDq.mjs";
+import { i as eventSchema, r as envelope } from "./events-CewD4kw7.mjs";
+import { r as withUserTokens, t as connectUserTokens } from "./users-yryHKFMo.mjs";
+import { r as markdownOf, t as ChatSyncProvider } from "./chat-provider-YHy-WbrB.mjs";
 import { z } from "zod";
 import { connectGitHubAdapter } from "@vercel/connect/chat";
 import { createGitHubAdapter } from "@chat-adapter/github";
@@ -85,6 +86,20 @@ function lifecycle(name, body) {
 					createRoot: true
 				}
 			};
+			case "edited":
+				if (!body.changes?.title) return null;
+				return {
+					number: pr.number,
+					user: sender ?? {},
+					lifecycle: {
+						...base,
+						type: "pr.edited",
+						labels: {},
+						reply: null,
+						createRoot: false,
+						retitled: true
+					}
+				};
 			case "ready_for_review": return {
 				number: pr.number,
 				user: sender ?? {},
@@ -207,6 +222,18 @@ function lifecycle(name, body) {
 				createRoot: true
 			}
 		};
+		if (action === "edited" && body.changes?.title) return {
+			number: issue.number,
+			user: sender ?? {},
+			lifecycle: {
+				...base,
+				type: "issue.edited",
+				labels: {},
+				reply: null,
+				createRoot: false,
+				retitled: true
+			}
+		};
 		if (action === "closed") return {
 			number: issue.number,
 			user: sender ?? {},
@@ -257,6 +284,7 @@ const GitHubPayload = z.looseObject({
 });
 const prTypes = [
 	"pr.opened",
+	"pr.edited",
 	"pr.ready",
 	"pr.draft",
 	"pr.reopened",
@@ -270,6 +298,7 @@ const prTypes = [
 ];
 const issueTypes = [
 	"issue.opened",
+	"issue.edited",
 	"issue.closed",
 	"issue.reopened",
 	"issue.labeled",
@@ -330,13 +359,39 @@ async function asPerson(token, method, path, body) {
 	return response.status === 204 ? null : response.json();
 }
 /**
-* Syncs GitHub repos with board channels. Keys are repos (`'owner/repo'`);
-* values are a board channel (PRs and issues become threads there), a
-* function, or `{ pulls, issues }` to send each somewhere else. Roots never
-* flow into GitHub: a board thread doesn't open an issue.
+* Syncs GitHub with the board: `app` is a Vercel Connect connector
+* (`'github/acme'`) or the options, and `sync` is what each event does, both
+* ways, like `repos({ 'acme/www': 'prs' })`. A board thread never opens an
+* issue: GitHub threads start on GitHub.
+*/
+function github(app, sync) {
+	return new GitHubProvider(typeof app === "string" ? { adapter: app } : app, sync);
+}
+/**
+* Routes each event by its repo. Keys are repos (`'owner/repo'`); values are a board channel
+* that PRs and issues are imported `into`, a sync function, or `{ pulls, issues }` to route
+* each its own way. A string imports and sends nothing back: what's said on the board stays
+* there unless a function delivers it. A thread the board syncs in another repo keeps
+* importing.
 */
-function github(options) {
-	return new GitHubProvider(options);
+function repos(map) {
+	const unit = (value) => typeof value === "string" ? into(value) : value;
+	const routes = /* @__PURE__ */ new Map();
+	for (const [repo, value] of Object.entries(map)) {
+		const { pulls, issues } = typeof value === "object" ? value : {
+			pulls: value,
+			issues: value
+		};
+		const [forPulls, forIssues] = [unit(pulls), unit(issues)];
+		if (forPulls) routes.set(`${repo}:pulls`, forPulls);
+		if (forIssues) routes.set(`${repo}:issues`, forIssues);
+	}
+	const fn = async (sync) => {
+		const route = sync.channel === null ? void 0 : routes.get(sync.channel);
+		if (route) await route(sync);
+		else if (sync.direction === "in") await sync.import();
+	};
+	return withRoutes(fn, async (channel) => routes.has(channel));
 }
 /**
 * A connector's GitHub adapter, finding its own bot user ID. Chat SDK skips detection
@@ -368,13 +423,12 @@ function fromConnector(connector, botUserId) {
 }
 var GitHubProvider = class extends ChatSyncProvider {
 	body;
-	constructor(given) {
+	constructor(given, sync) {
 		const options = {
 			...given,
 			adapter: typeof given.adapter === "string" ? fromConnector(given.adapter, given.botUserId) : given.adapter
 		};
 		super({
-			render: options.render,
 			platform: "github",
 			adapter: options.adapter,
 			canStartThreads: false,
@@ -383,6 +437,25 @@ var GitHubProvider = class extends ChatSyncProvider {
 			groupThread: (thread) => thread.replace(/:rc:[^:]+$/, ""),
 			channelOf,
 			isRoot: () => false,
+			locate(url) {
+				const match = /^https:\/\/github\.com\/([^/\s]+)\/([^/\s]+)\/(pull|issues)\/(\d+)[^#\s]*(?:#(issuecomment-|discussion_r)(\d+))?$/.exec(url.trim());
+				if (!match) return null;
+				const [, owner, repo, kind, number, anchor, id] = match;
+				const thread = `${owner}/${repo}:${kind === "issues" ? "issue:" : ""}${number}`;
+				if (anchor === "discussion_r" && kind !== "pull") return null;
+				return {
+					thread,
+					message: anchor ? id : null
+				};
+			},
+			async url(thread, message) {
+				const match = /^([^/]+)\/([^:]+):(issue:)?(\d+)(:rc:\d+)?$/.exec(thread);
+				if (!match) return null;
+				const [, owner, repo, issue, number, review] = match;
+				const page = `https://github.com/${owner}/${repo}/${issue ? "issues" : "pull"}/${number}`;
+				if (!/^\d+$/.test(message)) return page;
+				return `${page}#${review ? "discussion_r" : "issuecomment-"}${message}`;
+			},
 			async fetchRoot(thread) {
 				const match = /^([^/]+)\/([^:]+):(issue:)?(\d+)$/.exec(thread);
 				if (!match) throw new Error(`invalid GitHub thread: ${thread}`);
@@ -497,7 +570,9 @@ var GitHubProvider = class extends ChatSyncProvider {
 				}];
 			},
 			async resolveTarget(target) {
-				if (!/^[^/]+\/[^:]+(?::(?:issue:)?\d+(?::rc:[^:]+)?)?$/.test(target)) throw new Error(`invalid GitHub target: ${target}`);
+				const review = /^([^/]+\/[^:]+:\d+):rc:[^:]+$/.exec(target);
+				if (review) throw new Error(`a review thread can't be a target; sync its PR, ${review[1]}`);
+				if (!/^[^/]+\/[^:]+(?::(?:issue:)?\d+)?$/.test(target)) throw new Error(`invalid GitHub target: ${target}`);
 				const at = target.indexOf(":");
 				return {
 					target,
@@ -505,7 +580,7 @@ var GitHubProvider = class extends ChatSyncProvider {
 					kind: at === -1 ? "channel" : "thread"
 				};
 			}
-		});
+		}, sync);
 		const converter = options.adapter.formatConverter;
 		this.body = (post) => {
 			try {
@@ -514,14 +589,6 @@ var GitHubProvider = class extends ChatSyncProvider {
 				return post.markdown;
 			}
 		};
-		for (const [repo, value] of Object.entries(options.repos)) {
-			const { pulls, issues } = typeof value === "object" && !("run" in value) ? value : {
-				pulls: value,
-				issues: value
-			};
-			if (pulls) this.map(`${repo}:pulls`, pulls);
-			if (issues) this.map(`${repo}:issues`, issues);
-		}
 	}
 	async whoAmI(token) {
 		const user = await asPerson(token, "GET", "/user");
@@ -600,4 +667,4 @@ var GitHubProvider = class extends ChatSyncProvider {
 	}
 };
 //#endregion
-export { GitHubEvent, GitHubPayload, GitHubProvider, github, withUserTokens };
+export { GitHubEvent, GitHubPayload, GitHubProvider, github, repos, withUserTokens };

package/dist/sync-kapso.d.mts

@@ -1,5 +1,5 @@
-import { m as SyncHandler, p as SyncContext, t as EventMapping, u as RenderInput } from "./provider-BGjz-mDa.mjs";
-import { n as ChatSyncProvider, t as ChatInput } from "./chat-provider-XCnQlxq6.mjs";
+import { S as SyncUnit, f as SyncContext, y as SyncFn } from "./provider-B0b9Qxw4.mjs";
+import { n as ChatSyncProvider, t as ChatInput } from "./chat-provider-DNJQyajS.mjs";
 import { z } from "zod";
 import { Adapter } from "chat";
 //#region src/sync/kapso.d.ts
@@ -132,6 +132,7 @@ export declare const WhatsAppEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
   owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
   reply: z.ZodNullable<z.ZodString>;
   createRoot: z.ZodBoolean;
+  retitled: z.ZodOptional<z.ZodBoolean>;
   author: z.ZodObject<{
     id: z.ZodString;
     handle: z.ZodString;
@@ -152,24 +153,25 @@ type MarkRead = (input: {
     type: 'text';
   };
 }) => Promise<unknown>;
-export type KapsoHandler = SyncHandler<WhatsAppEvent>;
 export type KapsoOptions = {
   adapter: Adapter;
-  render?: (input: RenderInput) => string;
   markRead: MarkRead;
-  numbers: Record<string, EventMapping<WhatsAppEvent>>;
 };
 /**
- * Syncs WhatsApp numbers on Kapso with board channels. Keys are phone number
- * IDs (`'16315558151'`); values are a board channel (a two-way mirror) or a
- * callback that handles every incoming event. 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 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.
  */
-export declare function kapso(options: KapsoOptions): KapsoProvider;
+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);
+  constructor(options: KapsoOptions, sync: SyncFn<WhatsAppEvent>);
   eventId(key: string, input: ChatInput): string;
-  event(context: Pick<SyncContext, 'id' | 'key' | 'event' | 'raw'>): WhatsAppEvent;
+  event(context: SyncContext): WhatsAppEvent;
 }
 //#endregion

package/dist/sync-kapso.mjs

@@ -1,27 +1,31 @@
-import { c as eventSchema, s as envelope } from "./provider-CuewcDNZ.mjs";
-import { r as markdownOf, t as ChatSyncProvider } from "./chat-provider-jFSeyNmB.mjs";
+import { s as channels } from "./provider-B3DpYSDq.mjs";
+import { i as eventSchema, r as envelope } from "./events-CewD4kw7.mjs";
+import { r as markdownOf, t as ChatSyncProvider } from "./chat-provider-YHy-WbrB.mjs";
 import { z } from "zod";
 //#region src/sync/kapso.ts
 const decode = (id) => id.split(":").map((part) => Buffer.from(part, "base64url").toString("utf8")).join(":");
 const encode = (id) => id.split(":").map((part) => Buffer.from(part, "utf8").toString("base64url")).join(":");
 const WhatsAppEvent = eventSchema("whatsapp", "message");
 /**
-* Syncs WhatsApp numbers on Kapso with board channels. Keys are phone number
-* IDs (`'16315558151'`); values are a board channel (a two-way mirror) or a
-* callback that handles every incoming event. 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 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.
 */
-function kapso(options) {
-	return new KapsoProvider(options);
+function kapso(options, sync) {
+	return new KapsoProvider(options, sync);
 }
+/**
+* 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.
+*/
+const numbers = (map) => channels(map);
 var KapsoProvider = class extends ChatSyncProvider {
-	constructor(options) {
+	constructor(options, sync) {
 		if (typeof options.markRead !== "function") throw new Error("kapso requires a public markRead operation for cross-instance read and typing");
 		const fileIds = (raw) => (raw?.responses ?? []).flatMap((response) => response.messages?.[0]?.id ?? []);
 		super({
 			fileIds,
-			render: options.render,
 			platform: "whatsapp",
 			adapter: options.adapter,
 			canStartThreads: false,
@@ -69,8 +73,7 @@ var KapsoProvider = class extends ChatSyncProvider {
 					kind: parts.length === 1 ? "channel" : "thread"
 				};
 			}
-		});
-		for (const [key, value] of Object.entries(options.numbers)) this.map(key, value);
+		}, sync);
 	}
 	eventId(key, input) {
 		if (input.kind !== "reaction") return super.eventId(key, input);
@@ -83,4 +86,4 @@ var KapsoProvider = class extends ChatSyncProvider {
 	}
 };
 //#endregion
-export { KapsoProvider, WhatsAppEvent, kapso };
+export { KapsoProvider, WhatsAppEvent, kapso, numbers };

package/dist/sync-slack.d.mts

@@ -1,6 +1,6 @@
-import { v as ExternalLink } from "./reducers-B_vUGQRp.mjs";
-import { d as ResolvedTarget, g as UserTokens, i as ProviderDelivery, m as SyncHandler, p as SyncContext, s as ProviderPost, t as EventMapping, u as RenderInput, v as withUserTokens } from "./provider-BGjz-mDa.mjs";
-import { n as ChatSyncProvider, t as ChatInput } from "./chat-provider-XCnQlxq6.mjs";
+import { f as ExternalLink } from "./folds-CRYY14kc.mjs";
+import { C as channels, _ as withUserTokens, d as ResolvedTarget, f as SyncContext, h as UserTokens, o as ProviderPost, r as ProviderDelivery, y as SyncFn } from "./provider-B0b9Qxw4.mjs";
+import { n as ChatSyncProvider, t as ChatInput } from "./chat-provider-DNJQyajS.mjs";
 import { z } from "zod";
 import { Adapter } from "chat";
 //#region src/sync/slack.d.ts
@@ -26,9 +26,6 @@ export type SlackClient = {
     }): Promise<{
       channel?: SlackChannel;
     }>;
-    join(args: {
-      channel: string;
-    }): Promise<unknown>;
     /** Reads a linked message or a thread; needs `channels:history` (`groups:history` for private channels). */
     replies?(args: {
       channel: string;
@@ -300,6 +297,7 @@ export declare const SlackEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
   owns: z.ZodOptional<z.ZodArray<z.ZodString>>;
   reply: z.ZodNullable<z.ZodString>;
   createRoot: z.ZodBoolean;
+  retitled: z.ZodOptional<z.ZodBoolean>;
   author: z.ZodObject<{
     id: z.ZodString;
     handle: z.ZodString;
@@ -313,7 +311,6 @@ export declare const SlackEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
   platform: z.ZodLiteral<"slack">;
 }, z.core.$strip>], "kind">;
 export type SlackEvent = z.infer<typeof SlackEvent>;
-export type SlackHandler = SyncHandler<SlackEvent>;
 export type SlackOptions = {
   /**
    * A Vercel Connect connector (`'slack/acme'`): board builds the Slack adapter,
@@ -321,22 +318,20 @@ export type SlackOptions = {
    * Or your own Chat SDK adapter, wrapped in `withUserTokens` to post as people.
    */
   adapter: Adapter | string;
-  render?: (input: RenderInput) => string;
   /** Not needed with a connector. */
   client?: () => Promise<SlackClient>;
-  channels: Record<string, EventMapping<SlackEvent>>;
 };
 /**
- * Syncs Slack channels with board channels. Keys are channels by name
- * (`'#prs'`) or ID (`'C0123ABC'`); values are a board channel (a two-way
- * mirror) or a callback that handles every incoming event. The app joins public
- * channels it isn't in; private ones need an invite.
+ * Syncs a Slack workspace with the board: `app` is a Vercel Connect connector
+ * (`'slack/acme'`) or the options, and `sync` is what each event does, both ways,
+ * like `channels({ '#prs': 'prs' })`. Invite the app to each channel it syncs:
+ * it never joins one on its own.
  */
-export declare function slack(options: SlackOptions): SlackProvider;
+export declare function slack(app: string | SlackOptions, sync: SyncFn<SlackEvent>): SlackProvider;
 export declare class SlackProvider extends ChatSyncProvider<SlackEvent> {
   private readonly web;
   private customize;
-  constructor(given: SlackOptions);
+  constructor(given: SlackOptions, sync: SyncFn<SlackEvent>);
   /**
    * An agent's message goes out under its own name (`clever-lemur via vboard-factory`), and its
    * picture when it has one Slack can show, instead of the app's, with the text's
@@ -358,7 +353,7 @@ export declare class SlackProvider extends ChatSyncProvider<SlackEvent> {
    */
   permalink(event: SlackEvent): Promise<string | null>;
   eventId(key: string, input: ChatInput): string;
-  event(context: Pick<SyncContext, 'id' | 'key' | 'event' | 'raw'>): SlackEvent;
+  event(context: SyncContext): SlackEvent;
 }
 //#endregion
-export { type UserTokens, withUserTokens };
+export { type UserTokens, channels, withUserTokens };