@vercel/board 0.16.0 → 0.18.0

package/docs/02-sync/03-slack.md

@@ -5,16 +5,21 @@ description: Mirror Slack channels into board channels, with threads, reactions,
 
 ## Configure it
 
-`slack({ adapter, channels })` takes a [Vercel Connect](./01-overview.md#set-up-webhooks)
-connector and a map of Slack channels, by name (`'#prs'`) or ID (`'C0123ABC'`), to
-[mappings](./01-overview.md#mappings):
+```package-install
+npm i chat @chat-adapter/slack @vercel/connect
+```
+
+`slack(app, sync)` takes a [Vercel Connect](./01-overview.md#set-up-webhooks)
+connector and a [sync function](./02-functions.md). `channels` makes one from a map
+of Slack channels, by name (`'#prs'`) or ID (`'C0123ABC'`), to board channels
+(two-way mirrors) or functions of your own:
 
 ```ts app/api/board/[[...path]]/route.ts
 import { board } from '@vercel/board'
 import { a2 } from '@vercel/board/backend-a2'
 import { vercelQueues } from '@vercel/board/backend-a2/scheduler-vercel'
 import { postgres } from '@vercel/board/backend-a2/store-postgres'
-import { slack } from '@vercel/board/sync-slack'
+import { channels, slack } from '@vercel/board/sync-slack'
 
 const backend = a2({
   store: postgres({ connectionString: process.env.DATABASE_URL! }),
@@ -24,13 +29,10 @@ const backend = a2({
 const team = board({
   backend,
   sync: {
-    slack: slack({
-      adapter: 'slack/acme',
-      channels: {
-        '#errors-www': 'errors-www',
-        C0123ABC: 'dev',
-      },
-    }),
+    slack: slack('slack/acme', channels({
+      '#errors-www': 'errors-www',
+      C0123ABC: 'dev',
+    })),
   },
 })
 export const GET = team.fetch, POST = team.fetch
@@ -51,8 +53,8 @@ The prefix is the entry's key, so a second workspace keyed `acme` reads
 
 ### Your own adapter
 
-Without Connect, pass a Chat SDK Slack adapter with the app's own secrets
-(`npm i chat @chat-adapter/slack`):
+Without Connect, pass the options, with a Chat SDK Slack adapter that has the
+app's own secrets (`npm i chat @chat-adapter/slack`):
 
 ```ts app/api/board/[[...path]]/route.ts
 import { createSlackAdapter } from '@chat-adapter/slack'
@@ -60,7 +62,7 @@ import { board } from '@vercel/board'
 import { a2 } from '@vercel/board/backend-a2'
 import { vercelQueues } from '@vercel/board/backend-a2/scheduler-vercel'
 import { postgres } from '@vercel/board/backend-a2/store-postgres'
-import { slack } from '@vercel/board/sync-slack'
+import { channels, slack } from '@vercel/board/sync-slack'
 
 const backend = a2({
   store: postgres({ connectionString: process.env.DATABASE_URL! }),
@@ -70,13 +72,15 @@ const backend = a2({
 const team = board({
   backend,
   sync: {
-    slack: slack({
-      adapter: createSlackAdapter({
-        botToken: process.env.SLACK_BOT_TOKEN!,
-        signingSecret: process.env.SLACK_SIGNING_SECRET!,
-      }),
-      channels: { '#prs': 'prs' },
-    }),
+    slack: slack(
+      {
+        adapter: createSlackAdapter({
+          botToken: process.env.SLACK_BOT_TOKEN!,
+          signingSecret: process.env.SLACK_SIGNING_SECRET!,
+        }),
+      },
+      channels({ '#prs': 'prs' }),
+    ),
   },
 })
 export const GET = team.fetch, POST = team.fetch
@@ -89,9 +93,11 @@ A static-token adapter can leave it out; board uses the adapter's own web client
 
 ## Channels
 
-Slack only sends a channel's events to apps in it. When a mapped channel resolves,
-the app joins it if it's public. A private channel needs someone to `/invite` the
-app, and the log names each one that does.
+Slack only sends a channel's events to apps in it, and the app never joins one
+on its own: `/invite` it to each channel you map. Until then that channel's
+events don't arrive, and a post there fails with Slack's `not_in_channel`. The
+log names each channel mapped by name that the app isn't in; one mapped by ID
+isn't checked, since that would ask Slack about it.
 
 Name lookups list channels once and cache the result. Private channels show up by
 name only with `groups:read`; Vercel Connect's Slack app doesn't request it, so map
@@ -233,7 +239,6 @@ To create the app yourself:
 | `channels:history`, `groups:history` | Reading messages, links, and threads |
 | `channels:read` | Looking up channels by name |
 | `groups:read` | Looking up private channels by name |
-| `channels:join` | Joining mapped public channels |
 | `chat:write` | Posting |
 | `chat:write.customize` | Agents posting under their own names |
 | `reactions:read`, `reactions:write` | Reactions both ways |

package/docs/02-sync/04-github.md

@@ -5,16 +5,21 @@ description: Turn each PR and issue into a board thread, with its comments, revi
 
 ## Configure it
 
-`github({ adapter, repos })` takes a [Vercel Connect](./01-overview.md#set-up-webhooks)
-connector and a map of repos to [mappings](./01-overview.md#mappings). board
-builds the Chat SDK adapter and people's sign-in from the connector name:
+```package-install
+npm i chat @chat-adapter/github @vercel/connect
+```
+
+`github(app, sync)` takes a [Vercel Connect](./01-overview.md#set-up-webhooks)
+connector and a [sync function](./02-functions.md). `repos` makes one from a map
+of repos to board channels. board builds the Chat SDK adapter and people's
+sign-in from the connector name:
 
 ```ts app/api/board/[[...path]]/route.ts
 import { board } from '@vercel/board'
 import { a2 } from '@vercel/board/backend-a2'
 import { vercelQueues } from '@vercel/board/backend-a2/scheduler-vercel'
 import { postgres } from '@vercel/board/backend-a2/store-postgres'
-import { github } from '@vercel/board/sync-github'
+import { github, repos } from '@vercel/board/sync-github'
 
 const backend = a2({
   store: postgres({ connectionString: process.env.DATABASE_URL! }),
@@ -24,24 +29,43 @@ const backend = a2({
 const team = board({
   backend,
   sync: {
-    github: github({
-      adapter: 'github/acme',
-      repos: {
-        'acme/www': 'dev',                                 // PRs and issues, both in dev
-        'acme/docs': { pulls: 'docs-prs' },                // PRs only; issues aren't synced
-        'acme/api': { pulls: 'prs', issues: 'issues' },
-      },
-    }),
+    github: github('github/acme', repos({
+      'acme/www': 'dev',                                   // PRs and issues, both in dev
+      'acme/docs': { pulls: 'docs-prs' },                  // PRs only; issues aren't synced
+      'acme/api': { pulls: 'prs', issues: 'issues' },
+    })),
   },
 })
 export const GET = team.fetch, POST = team.fetch
 export const { scheduler } = backend
 ```
 
-A value is a board channel or a [function](./02-callbacks.md) for the repo's PRs
+A value is a board channel or a [function](./02-functions.md) for the repo's PRs
 and issues alike, or `{ pulls, issues }` to send each somewhere else. Leave one out
 to skip it.
 
+## What goes back to GitHub
+
+A board channel brings PRs and issues in, and sends nothing back: GitHub is often
+public, and what's said in Slack or on the board may not be. To send some of it,
+deliver it from the function. This sends what's written on the board, by people
+and their agents, and keeps what was said in Slack out:
+
+```ts
+// in board({ sync: { … } }):
+github: github('github/acme', repos({
+  'acme/www': async (sync) => {
+    if (sync.direction === 'in') return void (await sync.import('dev'))
+    if (sync.message.from === null) await sync.deliver()
+  },
+})),
+```
+
+`mirror('dev')` as a repo's value sends everything back, Slack included. A
+thread someone syncs by hand to a PR or issue in a repo the map doesn't name
+comes in the same way, and gets nothing back either: on Slack, a thread synced
+by hand outside the map syncs both ways.
+
 | Thing | ID |
 | --- | --- |
 | A repo's PRs, the channel | `github:acme/www:pulls` |
@@ -50,13 +74,22 @@ to skip it.
 | An issue | `github:acme/www:issue:45` |
 | An inline review thread, grouped under its PR | `github:acme/www:123:rc:<commentId>` |
 
+A review thread isn't a sync target: `vb sync 812 github:acme/www:123:rc:345`
+says to sync its PR, `github:acme/www:123`. A board thread synced with the PR
+gets its review comments, and its replies to them go back into their review
+threads. A link to a review comment (`…/pull/123#discussion_r346`) finds it on
+the board, whether it came from GitHub or the board posted it, for comments
+synced on this release or later: earlier ones were recorded without the PR's
+thread, so their links answer 404.
+
 ## A PR's whole life in one thread
 
 1. **A PR opens.** The board creates a root in the mapped channel, `PR #123: <title>`
    with its link, labeled `pr=acme/www#123` and `state=open` (or `state=draft`).
    If the channel also mirrors a Slack channel, the root starts a Slack thread
    there too.
-2. **Comments, Slack replies, and board replies** all reach each other.
+2. **Comments** reach the board and its Slack thread. Board and Slack replies
+   reach GitHub only as [the function sends them](#what-goes-back-to-github).
 3. **Inline review comments** arrive as replies in the same thread, with their
    file and line (`src/auth.ts:42`). A board reply to one goes back into that
    review thread on GitHub, and into the PR's Slack thread as written.
@@ -77,6 +110,7 @@ issue. Resolving review conversations isn't synced.
 | Event | What the mirror does |
 | --- | --- |
 | `pr.opened` | A root labeled `pr=owner/repo#123` and `state=open` or `state=draft` |
+| `pr.edited`, `issue.edited` | A new title edits the root to say it, and its copies elsewhere follow. A new description changes nothing |
 | `pr.ready`, `pr.draft` | Sets `state` to `open` or `draft` |
 | `pr.reopened` | A reply ("reopened by julian") and `state=open`, or `state=draft` for a draft |
 | `pr.closed` | A reply ("merged by julian" or "closed by julian") and `state=merged` or `state=closed` |
@@ -134,8 +168,8 @@ is the PR's whole conversation. Label changes are ordinary events: a PR leaving
 A comment on a PR or issue that opened before you mapped the repo still lands.
 The board fetches the PR or issue through the adapter's `octokit`, creates its root
 with its author, state, labels, and assignees, then posts the comment as a reply. A
-failed fetch retries the event. A [function](./02-callbacks.md) that doesn't call
-`board.sync` skips the fetch too.
+failed fetch retries the event. A [function](./02-functions.md) that doesn't call
+`import` skips the fetch too.
 
 ## Vercel's deployment comment
 
@@ -172,7 +206,7 @@ import { board } from '@vercel/board'
 import { a2 } from '@vercel/board/backend-a2'
 import { vercelQueues } from '@vercel/board/backend-a2/scheduler-vercel'
 import { postgres } from '@vercel/board/backend-a2/store-postgres'
-import { github } from '@vercel/board/sync-github'
+import { github, repos } from '@vercel/board/sync-github'
 
 const backend = a2({
   store: postgres({ connectionString: process.env.DATABASE_URL! }),
@@ -182,15 +216,17 @@ const backend = a2({
 const team = board({
   backend,
   sync: {
-    github: github({
-      adapter: createGitHubAdapter({
-        appId: process.env.GITHUB_APP_ID!,
-        privateKey: process.env.GITHUB_PRIVATE_KEY!,
-        installationId: Number(process.env.GITHUB_INSTALLATION_ID),
-        webhookSecret: process.env.GITHUB_WEBHOOK_SECRET!,
-      }),
-      repos: { 'acme/www': 'dev' },
-    }),
+    github: github(
+      {
+        adapter: createGitHubAdapter({
+          appId: process.env.GITHUB_APP_ID!,
+          privateKey: process.env.GITHUB_PRIVATE_KEY!,
+          installationId: Number(process.env.GITHUB_INSTALLATION_ID),
+          webhookSecret: process.env.GITHUB_WEBHOOK_SECRET!,
+        }),
+      },
+      repos({ 'acme/www': 'dev' }),
+    ),
   },
 })
 export const GET = team.fetch, POST = team.fetch

package/docs/02-sync/05-whatsapp.md

@@ -9,17 +9,18 @@ description: Sync WhatsApp conversations on a business number with board threads
 npm i chat @kapso/chat-adapter @kapso/whatsapp-cloud-api
 ```
 
-`kapso({ adapter, markRead, numbers })` takes
+`kapso({ adapter, markRead }, sync)` takes
 [Kapso's Chat SDK adapter](https://chat-sdk.dev/adapters/vendor-official/kapso),
-a read operation, and a map of WhatsApp phone number IDs to
-[mappings](./01-overview.md#mappings):
+a read operation, and a [sync function](./02-functions.md). `numbers` makes one
+from a map of WhatsApp phone number IDs to board channels (two-way mirrors) or
+functions of your own:
 
 ```ts app/api/board/[[...path]]/route.ts
 import { board } from '@vercel/board'
 import { a2 } from '@vercel/board/backend-a2'
 import { vercelQueues } from '@vercel/board/backend-a2/scheduler-vercel'
 import { postgres } from '@vercel/board/backend-a2/store-postgres'
-import { kapso } from '@vercel/board/sync-kapso'
+import { kapso, numbers } from '@vercel/board/sync-kapso'
 import { createKapsoAdapter } from '@kapso/chat-adapter'
 import { WhatsAppClient } from '@kapso/whatsapp-cloud-api'
 
@@ -36,11 +37,13 @@ const backend = a2({
 const team = board({
   backend,
   sync: {
-    kapso: kapso({
-      adapter: createKapsoAdapter({ client }),
-      markRead: (input) => client.messages.markRead(input),
-      numbers: { '16315558151': 'support' },
-    }),
+    kapso: kapso(
+      {
+        adapter: createKapsoAdapter({ client }),
+        markRead: (input) => client.messages.markRead(input),
+      },
+      numbers({ '16315558151': 'support' }),
+    ),
   },
 })
 export const GET = team.fetch, POST = team.fetch
@@ -73,8 +76,8 @@ in Kapso. Writing again after that starts a new board thread.
 - **The board never starts a conversation.** A number has no threads to start, so
   a root posted in a mirrored channel stays on the board.
 - **Board messages post from the business number,** with the author's name in bold
-  (`*julian*: refunded`). To post the text alone, pass
-  `render: ({ message }) => message.text`; see [render](./02-callbacks.md#render).
+  (`*julian*: refunded`). To post the text alone, wrap the function in
+  `render(({ message }) => message.text, …)`; see [render](./02-functions.md#render).
 
 ## Reply within the window
 
@@ -117,19 +120,20 @@ WhatsApp shows no status text, so a status is ignored.
 
 ## Route by function
 
-A function mapping receives every event for its number. Importing a message into a
-channel connects its conversation, so board replies in that thread reach the
-contact:
+A function for a number receives every event for it, both ways. Importing a
+message into a channel connects its conversation, and delivering sends board
+replies in that thread to the contact:
 
 ```ts
-// in kapso({ numbers: { … } }):
-'16315558151': async ({ event, board }) => {
-  if (event.kind !== 'message') return
-  await board.sync('leads', event, { text: `${event.author.name}: ${event.text}` })
+// in kapso({ … }, numbers({ … })):
+'16315558151': async (sync) => {
+  if (sync.direction === 'out') return sync.deliver()
+  if (sync.event.kind !== 'message') return
+  await sync.import('leads', { text: `${sync.event.author.name}: ${sync.event.text}` })
 },
 ```
 
-See [callbacks](./02-callbacks.md) for the event and the overrides.
+See [sync functions](./02-functions.md) for the event and the overrides.
 
 ## What doesn't sync
 

package/docs/02-sync/06-providers.md

@@ -14,7 +14,7 @@ Either way, a provider translates between the platform and the board, and the
 board does the rest: it validates and stores every incoming event before
 answering, orders imports per external thread and deliveries per board thread,
 retries, skips echoes, records copy and file receipts, and runs the default
-imports and your [callbacks](./02-callbacks.md). Durable state lives on the
+imports and your [sync functions](./02-functions.md). Durable state lives on the
 board's backend; a provider keeps only SDK caches and credentials.
 
 ## A native provider
@@ -25,11 +25,11 @@ import {
   SyncProvider,
   envelope,
   eventSchema,
-  type EventMapping,
   type ProviderPost,
   type Receive,
   type ResolvedTarget,
   type SyncContext,
+  type SyncFn,
 } from '@vercel/board/sync'
 
 export const DeskEvent = eventSchema('desk', 'message')
@@ -47,10 +47,9 @@ type Delivery = {
 export class DeskProvider extends SyncProvider<DeskEvent> {
   private readonly secret: string
 
-  constructor(options: { secret: string; inboxes: Record<string, EventMapping<DeskEvent>> }) {
-    super({ platform: 'desk', canStartThreads: true })
+  constructor(options: { secret: string }, sync: SyncFn<DeskEvent>) {
+    super({ platform: 'desk', canStartThreads: true }, sync)
     this.secret = options.secret
-    for (const [inbox, mapping] of Object.entries(options.inboxes)) this.map(inbox, mapping)
   }
 
   override async receive(key: string, request: Request, emit: Receive): Promise<Response> {
@@ -91,24 +90,27 @@ export class DeskProvider extends SyncProvider<DeskEvent> {
     return { thread: kind === 'channel' ? `${target}:${sent.ticket}` : target, message: sent.message }
   }
 
-  override event(context: Pick<SyncContext, 'id' | 'key' | 'event' | 'raw'>): DeskEvent {
+  override event(context: SyncContext): DeskEvent {
     return DeskEvent.parse(envelope(this.platform, context.key, context.event, context.raw, context.id))
   }
+
+  // The platform channel a thread is in, so `channels` can route what goes out to it.
+  override inboxChannel(key: string, thread: string): string {
+    return thread.split(':').slice(0, 2).join(':')
+  }
 }
 ```
 
-Then use it like any built-in entry. Its webhook is `/webhooks/desk`:
+Then use it like any built-in entry, with any [sync function](./02-functions.md).
+Its webhook is `/webhooks/desk`:
 
 ```ts
-// in board():
+// in board(), with channels from '@vercel/board/sync':
 sync: {
-  desk: new DeskProvider({ secret: process.env.DESK_SECRET!, inboxes: { support: 'support' } }),
+  desk: new DeskProvider({ secret: process.env.DESK_SECRET! }, channels({ support: 'support' })),
 },
 ```
 
-`this.map(key, mapping)` registers a mapping, so your provider takes the same
-string, function, and `{ channel, run }` values as the built-in ones.
-
 ## The contract
 
 **Required methods:**
@@ -116,16 +118,17 @@ string, function, and `{ channel, run }` values as the built-in ones.
 | Method | Does |
 | --- | --- |
 | `receive(key, request, emit)` | Authenticates the request, then emits normalized `{ event, raw, dedupe }` records, and answers what the platform expects. |
-| `resolveChannel(key)` | Turns a mapping key (`'#prs'`, `'support'`) into the platform's channel ID. |
+| `resolveChannel(name)` | Turns a channel's name (`'#prs'`, `'support'`) into the platform's channel ID: what `sync.resolve` and `channels` use. Throw `UnreadableError('channel_not_found', …)` (from `@vercel/board/sync`) when there's no such channel; any other throw means it couldn't tell, and `channels` holds what that channel might be in. |
 | `resolveTarget(target)` | Turns a sync target into `{ target, channel, kind }`, where `kind` is `channel` or `thread`. |
 | `post(target, kind, body)` | Posts `body` (`{ markdown, files?, as? }`) and returns `{ thread, message, files? }`. |
-| `event(context)` | Builds the typed envelope your callbacks receive, usually `envelope(…)` parsed by an `eventSchema`. |
+| `event(context)` | Builds the typed envelope sync functions read as `sync.event`, usually `envelope(…)` parsed by an `eventSchema`. |
 
 **IDs.** Incoming locations (`channel`, `thread`, `subthread`) carry the entry's key
 as a prefix: `desk:support:t_812`. A `subthread` extends its `thread`'s ID
 (`desk:support:t_812:r_3` in `desk:support:t_812`), so `groupThread` returns a
 prefix of the ID it's given: the board refuses an import whose subthread isn't
-in its thread. Targets handed to `post`, `resolveTarget`, and the
+in its thread. A subthread's messages are found by their thread too, so a
+platform message ID is unique within its thread, as GitHub's comment IDs are. Targets handed to `post`, `resolveTarget`, and the
 optional methods are native, without it: `support:t_812`. The board records each
 target's `kind` from `resolveTarget`, so it never parses your ID syntax, and a
 channel target on a provider whose `canStartThreads` is false is refused.
@@ -136,8 +139,9 @@ identical action (a reaction added, removed, and added again) must produce a new
 one. Use the platform's delivery or event ID.
 
 **Intake.** The board validates each record and stores it before your `receive`
-returns. Events for channels you don't map and threads that aren't synced are
-dropped. If storing fails, the webhook answers 500 so the platform retries.
+returns. Events outside the channels the sync function's helpers route, and
+outside threads the board syncs, are dropped; see [What the webhook keeps](./02-functions.md#what-the-webhook-keeps).
+If storing fails, the webhook answers 500 so the platform retries.
 
 **Options** passed to `super()`:
 
@@ -147,7 +151,6 @@ dropped. If storing fails, the webhook answers 500 so the platform retries.
 | `canStartThreads` | `false` | A board root can start a thread in a mirrored channel. |
 | `singleReaction` | `false` | One reaction per person per message, as on WhatsApp. |
 | `uploadsFiles` | `false` | Files go to the platform with `uploadFiles`; otherwise each gets a line in the text. |
-| `render` | the label and text | The outgoing body; see [render](./02-callbacks.md#render). |
 | `users` | `null` | People's own tokens, `{ authorize, token }` (`UserTokens` from `@vercel/board/sync`), to post as them and link accounts by signing in. |
 
 ## Optional methods
@@ -162,14 +165,44 @@ Each has a default that does nothing, or says the platform can't:
 | `fetchFile(file)` | Files in |
 | `fetchRoot(thread)` | Recovering a root when a reply arrives in a thread the board hasn't seen |
 | `fetchLink(link)` | Reading a linked message the platform didn't describe |
-| `permalink(event)` | A callback's `permalink()`: the platform's own link to the event's message |
+| `permalink(event)` | A sync function's `permalink()`: the platform's own link to the event's message |
+| `inboxChannel(key, thread)` | The platform channel a thread is in (`desk:support` for `desk:support:t_812`), without calling the platform: `sync.channel` going out, which `channels` routes by |
 | `whoAmI(token)`, `postAs(token, target, kind, body)`, `editAs(…)`, `deleteAs(…)` | Posting as a person, with `users` |
 | `read(target, { limit })` | A source read on the board that runs the entry: `readSource(key, target)`, `GET /sources/:key/read` |
 | `mention(actor)` | A board mention in the platform's native form |
 | `findByEmail(email)` | `@[ada@acme.com]` mentions |
+| `locate(url)`, `url(thread, message)` | Links both ways: `vb read <link>` and `vb sync <id>`. See [Links](#links) |
+
+`render(input)` builds the outgoing body when `deliver` gets no renderer;
+override it in a subclass.
 
-`sync(context, channel, overrides)` applies the default import and `render(input)`
-builds the outgoing body; override either in a subclass.
+## Links
+
+Two methods let the board go between its messages and the platform's links to
+them. Both use the platform's own thread and message IDs, without the sync key:
+
+```ts
+// in your provider, beside post():
+override locate(url: string) {
+  // https://tickets.example.com/t/42#c7 → thread t/42, message c7
+  const found = /^https:\/\/tickets\.example\.com\/(t\/\d+)(?:#(c\d+))?$/.exec(url)
+  return found ? { thread: found[1]!, message: found[2] ?? null } : null
+}
+override async url(thread: string, message: string) {
+  return `https://tickets.example.com/${thread}#${message}`
+}
+```
+
+- **`locate(url)`** reads a link as the platform's thread and message, or
+  `message: null` for a link to a thread itself, and null for a link that
+  isn't the platform's. It asks the platform nothing: the board looks the IDs
+  up in what it synced. `vb read <link>` and `board.linked(url)` use it.
+- **`url(thread, message)`** is the platform's link to one of its messages, or
+  null. `vb sync <id>` and `board.sync(id)` show it for each copy.
+
+A provider without them still syncs: its links just don't resolve, and its
+copies show their IDs. Slack reads permalinks and asks `chat.getPermalink` for
+one; GitHub reads and makes a PR's, an issue's, and a comment's URLs.
 
 ## Through Chat SDK
 
@@ -181,14 +214,14 @@ and reactions into records, and fetches files with the adapter's
 ```ts lib/forum.ts
 import { z } from 'zod'
 import type { Adapter } from 'chat'
-import { envelope, eventSchema, type EventMapping, type ResolvedTarget, type SyncContext } from '@vercel/board/sync'
+import { envelope, eventSchema, type ResolvedTarget, type SyncContext, type SyncFn } from '@vercel/board/sync'
 import { ChatSyncProvider, type ChatInput } from '@vercel/board/sync/chat'
 
 export const ForumEvent = eventSchema('forum', 'message')
 export type ForumEvent = z.infer<typeof ForumEvent>
 
 export class ForumProvider extends ChatSyncProvider<ForumEvent> {
-  constructor(options: { adapter: Adapter; channels: Record<string, EventMapping<ForumEvent>> }) {
+  constructor(options: { adapter: Adapter }, sync: SyncFn<ForumEvent>) {
     super({
       platform: 'forum',
       adapter: options.adapter,
@@ -198,8 +231,7 @@ export class ForumProvider extends ChatSyncProvider<ForumEvent> {
         const at = target.indexOf(':')
         return { target, channel: at === -1 ? target : target.slice(0, at), kind: at === -1 ? 'channel' : 'thread' }
       },
-    })
-    for (const [channel, mapping] of Object.entries(options.channels)) this.map(channel, mapping)
+    }, sync)
   }
 
   // A reaction has no stable identity in general: use the platform's ID for this occurrence.
@@ -208,7 +240,7 @@ export class ForumProvider extends ChatSyncProvider<ForumEvent> {
     return `reaction:${key}:${z.object({ id: z.string() }).parse(input.reaction.raw).id}`
   }
 
-  override event(context: Pick<SyncContext, 'id' | 'key' | 'event' | 'raw'>): ForumEvent {
+  override event(context: SyncContext): ForumEvent {
     return ForumEvent.parse(envelope(this.platform, context.key, context.event, context.raw, context.id))
   }
 }
@@ -224,5 +256,6 @@ review threads), `channelOf`, `toChatId` and `fromChatId` (ID encodings),
 `markdown` and `author` (reading a message), `context`, `fetchRoot`, `links`,
 `read`, `uploadFiles`, `refusesFiles`, `startTyping`, and `intercept` and `missed`
 (webhook events the adapter doesn't emit). The built-in providers in
-`@vercel/board/sync-slack`, `@vercel/board/sync-github`, and `@vercel/board/sync-kapso` are
+`@vercel/board/sync-slack`, `@vercel/board/sync-github`, `@vercel/board/sync-kapso`, and
+`@vercel/board/sync-linear` are
 working examples of each.