@vercel/board 0.16.0 → 0.18.0

package/dist/sync-linear.d.mts

@@ -0,0 +1,219 @@
+import { S as SyncUnit, c as ReceivedEvent, d as ResolvedTarget, f as SyncContext, 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/linear.d.ts
+export declare const LinearEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  channel: z.ZodString;
+  thread: z.ZodString;
+  subthread: z.ZodNullable<z.ZodString>;
+  kind: z.ZodLiteral<"message">;
+  message: z.ZodString;
+  isRoot: z.ZodBoolean;
+  text: z.ZodString;
+  context: z.ZodNullable<z.ZodString>;
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    avatar: z.ZodNullable<z.ZodString>;
+    isBot: z.ZodBoolean;
+  }, z.core.$strip>;
+  files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    type: z.ZodEnum<{
+      audio: "audio";
+      file: "file";
+      image: "image";
+      video: "video";
+    }>;
+    name: z.ZodOptional<z.ZodString>;
+    mimeType: z.ZodOptional<z.ZodString>;
+    size: z.ZodOptional<z.ZodNumber>;
+    url: z.ZodOptional<z.ZodString>;
+    fetchMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  }, z.core.$strip>>>;
+  links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    url: z.ZodString;
+    thread: z.ZodString;
+    message: z.ZodString;
+    snapshot: z.ZodNullable<z.ZodObject<{
+      author: z.ZodString;
+      text: z.ZodString;
+      createdAt: z.ZodNullable<z.ZodString>;
+      files: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>>;
+  id: z.ZodString;
+  key: z.ZodString;
+  raw: z.ZodUnknown;
+  platform: z.ZodLiteral<"linear">;
+  type: z.ZodLiteral<"comment">;
+}, z.core.$strip>, z.ZodObject<{
+  channel: z.ZodString;
+  thread: z.ZodString;
+  subthread: z.ZodNullable<z.ZodString>;
+  kind: z.ZodLiteral<"edited">;
+  message: z.ZodString;
+  text: z.ZodString;
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    avatar: z.ZodNullable<z.ZodString>;
+    isBot: z.ZodBoolean;
+  }, z.core.$strip>;
+  links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    url: z.ZodString;
+    thread: z.ZodString;
+    message: z.ZodString;
+    snapshot: z.ZodNullable<z.ZodObject<{
+      author: z.ZodString;
+      text: z.ZodString;
+      createdAt: z.ZodNullable<z.ZodString>;
+      files: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        url: z.ZodNullable<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>>>;
+  linksOnly: z.ZodOptional<z.ZodBoolean>;
+  id: z.ZodString;
+  key: z.ZodString;
+  raw: z.ZodUnknown;
+  platform: z.ZodLiteral<"linear">;
+  type: z.ZodLiteral<"message.edited">;
+}, z.core.$strip>, z.ZodObject<{
+  channel: z.ZodString;
+  thread: z.ZodString;
+  subthread: z.ZodNullable<z.ZodString>;
+  kind: z.ZodLiteral<"deleted">;
+  message: z.ZodString;
+  id: z.ZodString;
+  key: z.ZodString;
+  raw: z.ZodUnknown;
+  platform: z.ZodLiteral<"linear">;
+  type: z.ZodLiteral<"message.deleted">;
+}, z.core.$strip>, z.ZodObject<{
+  channel: z.ZodString;
+  thread: z.ZodString;
+  subthread: z.ZodNullable<z.ZodString>;
+  kind: z.ZodLiteral<"reaction">;
+  message: z.ZodString;
+  emoji: z.ZodString;
+  added: z.ZodBoolean;
+  author: z.ZodObject<{
+    id: z.ZodString;
+    handle: z.ZodString;
+    name: z.ZodString;
+    avatar: z.ZodNullable<z.ZodString>;
+    isBot: z.ZodBoolean;
+  }, z.core.$strip>;
+  id: z.ZodString;
+  key: z.ZodString;
+  raw: z.ZodUnknown;
+  platform: z.ZodLiteral<"linear">;
+  type: z.ZodEnum<{
+    "reaction.added": "reaction.added";
+    "reaction.removed": "reaction.removed";
+  }>;
+}, z.core.$strip>, z.ZodObject<{
+  channel: z.ZodString;
+  thread: z.ZodString;
+  subthread: z.ZodNullable<z.ZodString>;
+  kind: z.ZodLiteral<"lifecycle">;
+  type: z.ZodString;
+  title: z.ZodString;
+  url: z.ZodNullable<z.ZodString>;
+  labels: z.ZodRecord<z.ZodString, z.ZodString>;
+  unset: z.ZodArray<z.ZodString>;
+  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;
+    name: z.ZodString;
+    avatar: z.ZodNullable<z.ZodString>;
+    isBot: z.ZodBoolean;
+  }, z.core.$strip>;
+  id: z.ZodString;
+  key: z.ZodString;
+  raw: z.ZodUnknown;
+  platform: z.ZodLiteral<"linear">;
+}, z.core.$strip>], "kind">;
+export type LinearEvent = z.infer<typeof LinearEvent>;
+export type LinearOptions = {
+  /**
+   * A Vercel Connect connector (`'linear/acme'`) holding a Linear app's token: board builds the
+   * Chat SDK adapter from it. Or your own adapter from `createLinearAdapter`, in its default
+   * `comments` mode, with the app's own token: the adapter skips what its token's user writes.
+   */
+  adapter: Adapter | string;
+};
+/**
+ * Syncs Linear with the board: `app` is a Vercel Connect connector (`'linear/acme'`) or the
+ * options, and `sync` is what each event does, both ways, like `teams({ ENG: 'dev' })`. Each
+ * issue is a thread: its comments are replies, and a board root in a mirrored team opens an issue.
+ */
+export declare function linear(app: string | LinearOptions, sync: SyncFn<LinearEvent>): LinearProvider;
+/**
+ * Routes each event by its Linear team. Keys are team keys (`'ENG'`, the prefix of `ENG-123`);
+ * values are a board channel to `mirror`, or a sync function.
+ */
+export declare const teams: (map: Record<string, SyncUnit<LinearEvent>>) => SyncFn<LinearEvent>;
+export declare class LinearProvider extends ChatSyncProvider<LinearEvent> {
+  private readonly linear;
+  private readonly teamIds;
+  constructor(given: LinearOptions, sync: SyncFn<LinearEvent>);
+  /**
+   * Runs a Linear API call. A Connect token lives in the adapter's request context, which only a
+   * webhook sets up: anything else (a delivery, a root fetched on a later pull) asks for one here.
+   */
+  private api;
+  resolveChannel(key: string): Promise<string>;
+  /**
+   * `ENG` is a team; `ENG:<uuid>`, a bare UUID, or `ENG-12` is an issue, by its team and UUID:
+   * comments come in under the UUID, which stays when the issue is renamed.
+   */
+  resolveTarget(target: string): Promise<ResolvedTarget>;
+  fetchRoot(thread: string): Promise<{
+    text: string;
+    raw: {
+      issue: {
+        id: string;
+        identifier: string;
+        title: string;
+        url: string;
+      };
+    };
+    author: {
+      id: string;
+      handle: string;
+      name: string;
+      avatar: string | null;
+      isBot: boolean;
+    };
+    labels: {
+      issue: string;
+      state?: string | undefined;
+    };
+  }>;
+  private client;
+  /** A team's ID from its key, which Linear's API asks for to open an issue. */
+  private team;
+  protected normalize(key: string, input: ChatInput): Promise<ReceivedEvent>;
+  private teamOfIssue;
+  inboxChannel(key: string, thread: string): string;
+  /** A root in a mirrored team opens an issue, titled with its first line; a reply is a comment. */
+  post(target: string, kind: ResolvedTarget['kind'], post: ProviderPost): Promise<ProviderDelivery>;
+  edit(thread: string, message: string, post: ProviderPost): Promise<undefined>;
+  delete(thread: string, message: string): Promise<void>;
+  react(thread: string, message: string, emoji: string, added: boolean): Promise<void>;
+  startTyping(): Promise<void>;
+  event(context: SyncContext): LinearEvent;
+}
+//#endregion

package/dist/sync-linear.mjs

@@ -0,0 +1,311 @@
+import { i as UnreadableError, 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 "zod";
+import { connectLinearAdapter } from "@vercel/connect/chat";
+import { createLinearAdapter } from "@chat-adapter/linear";
+//#region src/sync/linear.ts
+const LinearEvent = eventSchema("linear", "comment");
+/**
+* Syncs Linear with the board: `app` is a Vercel Connect connector (`'linear/acme'`) or the
+* options, and `sync` is what each event does, both ways, like `teams({ ENG: 'dev' })`. Each
+* issue is a thread: its comments are replies, and a board root in a mirrored team opens an issue.
+*/
+function linear(app, sync) {
+	return new LinearProvider(typeof app === "string" ? { adapter: app } : app, sync);
+}
+/**
+* Routes each event by its Linear team. Keys are team keys (`'ENG'`, the prefix of `ENG-123`);
+* values are a board channel to `mirror`, or a sync function.
+*/
+const teams = (map) => channels(map);
+/** A person's handle, the end of their profile URL (`…/profiles/ada`), as the adapter reads it. */
+const handleOf = (user) => /\/profiles\/([^/?#]+)/.exec(user?.url ?? "")?.[1] ?? user?.displayName ?? user?.name;
+const author = (user, isBot) => ({
+	id: `linear:user:${user?.id ?? "unknown"}`,
+	handle: handleOf(user) ?? "unknown",
+	name: user?.name ?? user?.displayName ?? "unknown",
+	avatar: user?.avatarUrl ?? null,
+	isBot: isBot || user?.type !== void 0 && user.type !== "user"
+});
+/** `ENG` from `ENG-123`, or from a Linear URL that names an issue (`…/issue/ENG-123/…`). */
+const teamOf = (identifierOrUrl) => /(?:^|\/issue\/)([A-Z0-9_]+)-\d+/i.exec(identifierOrUrl ?? "")?.[1]?.toUpperCase() ?? null;
+/** The copy of an issue the board opened: the issue itself, not a comment. */
+const OPENED = "issue";
+/** A root's copy: one the board opened, or imported (`lifecycle:<event>`, `root:<event>`). Comment IDs are UUIDs. */
+const isIssue = (message) => message === OPENED || message.includes(":");
+const UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+/** `ENG:<issueId>`, or `ENG:<issueId>:c:<commentId>` (a comment thread): the team, and the issue's UUID. */
+function parseThread(thread) {
+	const match = /^([A-Z0-9_]+):([^:]+)(?::c:([^:]+))?$/i.exec(thread);
+	if (!match) throw new Error(`invalid Linear thread: ${thread}`);
+	return {
+		team: match[1].toUpperCase(),
+		issue: match[2],
+		comment: match[3] ?? null
+	};
+}
+/** A board message's first line, as an issue title: Linear titles are plain text. */
+function titleOf(markdown) {
+	return (markdown.split("\n").map((text) => text.trim()).find(Boolean) ?? "").replace(/^\*\*[^*\n]+\*\*:\s*/, "").replace(/\*\*|__|`/g, "").replace(/^[#>\s]+/, "").replace(/\s+/g, " ").trim().slice(0, 255) || "Untitled";
+}
+function stateOf(state) {
+	return state?.type ?? state?.name?.toLowerCase() ?? null;
+}
+var LinearProvider = class extends ChatSyncProvider {
+	linear;
+	teamIds = /* @__PURE__ */ new Map();
+	constructor(given, sync) {
+		const adapter = typeof given.adapter === "string" ? createLinearAdapter({
+			...connectLinearAdapter(given.adapter),
+			mode: "comments"
+		}) : given.adapter;
+		super({
+			platform: "linear",
+			adapter,
+			canStartThreads: true,
+			resolveChannel: (key) => Promise.resolve(key.toUpperCase()),
+			resolveTarget: (target) => Promise.resolve({
+				target,
+				channel: target,
+				kind: "channel"
+			}),
+			groupThread: (thread) => thread.replace(/:c:[^:]+$/, ""),
+			channelOf: (thread) => thread.slice(0, thread.indexOf(":")),
+			toChatId: (id) => id.slice(id.indexOf(":") + 1),
+			isRoot: () => false,
+			context: () => null,
+			markdown(message) {
+				const body = message.raw?.comment?.body;
+				return typeof body === "string" && body.trim() ? body.trim() : markdownOf(message);
+			},
+			async avatar(message) {
+				return message.raw?.comment?.user?.avatarUrl ?? null;
+			},
+			missed(_headers, body) {
+				let payload;
+				try {
+					payload = JSON.parse(body);
+				} catch {
+					return [];
+				}
+				if (payload.type !== "Comment" || payload.action !== "update" && payload.action !== "remove") return [];
+				const { data } = payload;
+				const issueId = data.issueId ?? data.issue?.id;
+				if (!issueId || !data.user) return [];
+				const message = adapter.parseMessage({
+					kind: "comment",
+					organizationId: payload.organizationId,
+					comment: {
+						...data,
+						issueId,
+						parentId: data.parentId ?? void 0,
+						url: payload.url,
+						user: {
+							type: "user",
+							id: data.user.id,
+							displayName: handleOf(data.user) ?? "unknown",
+							fullName: data.user.name ?? "unknown",
+							email: void 0,
+							avatarUrl: data.user.avatarUrl ?? void 0
+						}
+					}
+				});
+				if (message.author.isMe) return [];
+				return payload.action === "update" ? [{
+					kind: "edited",
+					message
+				}] : [{
+					kind: "deleted",
+					thread: message.threadId,
+					message: message.id,
+					raw: payload
+				}];
+			},
+			intercept(key, headers, body) {
+				let payload;
+				try {
+					payload = JSON.parse(body);
+				} catch {
+					return [];
+				}
+				if (payload.type !== "Issue" || !payload.data?.identifier) return [];
+				const { data } = payload;
+				const created = payload.action === "create";
+				const moved = payload.action === "update" && payload.updatedFrom?.stateId !== void 0;
+				const retitled = payload.action === "update" && payload.updatedFrom?.title !== void 0;
+				if (!created && !moved && !retitled) return [];
+				const team = data.team?.key ?? teamOf(data.identifier);
+				const state = stateOf(data.state);
+				const own = payload.actor?.id !== void 0 && payload.actor.id === adapter.defaultBotUserId;
+				const delivery = headers.get("linear-delivery") ?? `${payload.webhookId}:${payload.webhookTimestamp}`;
+				return [{
+					event: {
+						kind: "lifecycle",
+						channel: `${key}:${team}`,
+						thread: `${key}:${team}:${data.id}`,
+						type: created ? "issue.created" : "issue.updated",
+						title: `${data.identifier}: ${data.title}`,
+						url: data.url ?? payload.url ?? null,
+						labels: {
+							issue: data.identifier,
+							...state && (created || moved) ? { state } : {}
+						},
+						unset: [],
+						reply: null,
+						createRoot: created && !own,
+						...retitled ? { retitled: true } : {},
+						author: author(payload.actor, own)
+					},
+					raw: payload,
+					dedupe: `lifecycle:${delivery}`
+				}];
+			}
+		}, sync);
+		this.linear = adapter;
+	}
+	/**
+	* Runs a Linear API call. A Connect token lives in the adapter's request context, which only a
+	* webhook sets up: anything else (a delivery, a root fetched on a later pull) asks for one here.
+	*/
+	async api(fn) {
+		await this.ready();
+		return this.linear.isConnectMode() ? this.linear.withConnectClient(void 0, fn) : fn();
+	}
+	async resolveChannel(key) {
+		await this.team(key);
+		return key.toUpperCase();
+	}
+	/**
+	* `ENG` is a team; `ENG:<uuid>`, a bare UUID, or `ENG-12` is an issue, by its team and UUID:
+	* comments come in under the UUID, which stays when the issue is renamed.
+	*/
+	async resolveTarget(target) {
+		if (/:c:[^:]+$/.test(target)) throw new Error(`a comment thread can't be a target; sync its issue, ${target.replace(/:c:[^:]+$/, "")}`);
+		if (/^[A-Z0-9_]+$/i.test(target)) return {
+			target: target.toUpperCase(),
+			channel: target.toUpperCase(),
+			kind: "channel"
+		};
+		const scoped = /^([A-Z0-9_]+):([^:]+)$/i.exec(target);
+		if (scoped && UUID.test(scoped[2])) return {
+			target: `${scoped[1].toUpperCase()}:${scoped[2]}`,
+			channel: scoped[1].toUpperCase(),
+			kind: "thread"
+		};
+		if (!UUID.test(target) && !/^[A-Z0-9_]+-\d+$/i.test(target)) throw new Error(`invalid Linear target: ${target}`);
+		const issue = await this.api(() => this.client().issue(target));
+		const team = teamOf(issue.identifier) ?? await this.api(async () => (await issue.team)?.key);
+		if (!team) throw new Error(`Linear didn't say which team ${target} is in`);
+		return {
+			target: `${team.toUpperCase()}:${issue.id}`,
+			channel: team.toUpperCase(),
+			kind: "thread"
+		};
+	}
+	async fetchRoot(thread) {
+		return this.api(async () => {
+			const issue = await this.client().issue(parseThread(thread).issue);
+			const [state, creator] = await Promise.all([issue.state, issue.creator]);
+			const found = stateOf(state);
+			return {
+				text: `${issue.identifier}: ${issue.title}\n${issue.url}`,
+				raw: { issue: {
+					id: issue.id,
+					identifier: issue.identifier,
+					title: issue.title,
+					url: issue.url
+				} },
+				author: author(creator, false),
+				labels: {
+					issue: issue.identifier,
+					...found ? { state: found } : {}
+				}
+			};
+		});
+	}
+	client() {
+		return this.linear.linearClient;
+	}
+	/** A team's ID from its key, which Linear's API asks for to open an issue. */
+	async team(key) {
+		const wanted = key.toUpperCase();
+		const known = this.teamIds.get(wanted);
+		if (known) return known;
+		const { nodes } = await this.api(() => this.client().teams({ filter: { key: { eq: wanted } } }));
+		const team = nodes.find((node) => node.key.toUpperCase() === wanted);
+		if (!team) throw new UnreadableError("channel_not_found", `no Linear team ${wanted}`);
+		this.teamIds.set(wanted, team.id);
+		return team.id;
+	}
+	async normalize(key, input) {
+		const received = await super.normalize(key, input);
+		if (input.kind === "reaction") return received;
+		const raw = input.kind === "deleted" ? input.raw : input.message.raw;
+		const comment = raw?.comment ?? raw?.data;
+		const issue = comment?.issueId ?? raw?.data?.issue?.id;
+		const root = comment?.parentId || comment?.id;
+		if (!issue || !root) return received;
+		const team = teamOf(raw?.comment?.url ?? raw?.url) ?? teamOf(raw?.data?.issue?.identifier) ?? await this.teamOfIssue(issue);
+		const thread = `${key}:${team}:${issue}`;
+		const event = {
+			...received.event,
+			channel: `${key}:${team}`,
+			thread,
+			subthread: `${thread}:c:${root}`
+		};
+		return {
+			...received,
+			event
+		};
+	}
+	async teamOfIssue(id) {
+		return this.api(async () => {
+			const issue = await this.client().issue(id);
+			const team = teamOf(issue.identifier) ?? (await issue.team)?.key;
+			if (!team) throw new Error(`Linear didn't say which team issue ${id} is in`);
+			return team.toUpperCase();
+		});
+	}
+	inboxChannel(key, thread) {
+		return `${key}:${parseThread(thread.slice(key.length + 1)).team}`;
+	}
+	/** A root in a mirrored team opens an issue, titled with its first line; a reply is a comment. */
+	async post(target, kind, post) {
+		if (kind === "thread") return {
+			...await this.api(() => super.post(target, kind, post)),
+			thread: target
+		};
+		const teamId = await this.team(target);
+		const created = await this.api(() => this.client().createIssue({
+			teamId,
+			title: titleOf(post.markdown),
+			description: post.markdown
+		}));
+		if (!created.issueId) throw new Error(`Linear didn't return the issue it opened in ${target}`);
+		return {
+			thread: `${target.toUpperCase()}:${created.issueId}`,
+			message: OPENED
+		};
+	}
+	async edit(thread, message, post) {
+		if (message === OPENED) return void await this.api(() => this.client().updateIssue(parseThread(thread).issue, { description: post.markdown }));
+		if (!isIssue(message)) await this.api(() => super.edit(thread, message, post));
+	}
+	async delete(thread, message) {
+		if (!isIssue(message)) await this.api(() => super.delete(thread, message));
+	}
+	async react(thread, message, emoji, added) {
+		if (added && !isIssue(message)) await this.api(() => super.react(thread, message, emoji, added));
+	}
+	async startTyping() {}
+	event(context) {
+		const base = envelope(this.platform, context.key, context.event, context.raw ?? {}, context.id);
+		return LinearEvent.parse({
+			...base,
+			type: context.event.kind === "message" ? "comment" : base.type
+		});
+	}
+};
+//#endregion
+export { LinearEvent, LinearProvider, linear, teams };

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 };