@vercel/board 0.17.0 → 0.18.1

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/{watchers-hash-DojIuoFg.mjs → watchers-hash-qlnbKQQ0.mjs}

@@ -631,7 +631,7 @@ const routes = {
 const SYNC = "@sync";
 //#endregion
 //#region src/version.ts
-const VERSION = "0.17.0";
+const VERSION = "0.18.1";
 //#endregion
 //#region src/server/routing.ts
 /** board()'s own routes: the files it serves, and sync's, which run where board() does. */

package/docs/02-sync/01-overview.md

@@ -116,8 +116,9 @@ Slack, `'owner/repo'` for GitHub, a phone number ID for WhatsApp.
    something (WhatsApp edits, GitHub typing), that delivery is skipped.
 2. **Starting threads.** A root posted on the board, by anyone or any watcher,
    goes to the sync function of each platform that can start threads in a
-   channel, which may `start` one; `mirror` does in its channel. Slack can.
-   GitHub and WhatsApp can't, so roots never open an issue or a conversation.
+   channel, which may `start` one; `mirror` does in its channel. Slack and
+   Linear can; on Linear a root opens an issue. GitHub and WhatsApp can't, so
+   roots never open an issue or a conversation there.
 3. **Inbound.** A platform event goes to the sync function when its thread is
    already synced, or when its channel is one the helpers route (their keys;
    a function of your own at the top gets every channel). The function decides
@@ -255,7 +256,8 @@ branch, a custom environment).
 **Without Connect,** create the app on the platform yourself, point its webhook
 at the same route, and pass the platform's own secrets to the Chat SDK adapter.
 Each platform page has the steps: [Slack](./03-slack.md#setup),
-[GitHub](./04-github.md#setup), [WhatsApp](./05-whatsapp.md#setup).
+[GitHub](./04-github.md#setup), [WhatsApp](./05-whatsapp.md#setup),
+[Linear](./07-linear.md#setup).
 
 ## When delivery fails
 

package/docs/02-sync/02-functions.md

@@ -116,7 +116,7 @@ call, like `import`.
 
 ## Helpers
 
-`channels`, `repos`, and `numbers` take a map from platform channels to what
+`channels`, `repos`, `numbers`, and `teams` take a map from platform channels to what
 each one does: a sync function, or a board channel as a string.
 
 | Helper | From | Keys | A string means |
@@ -124,11 +124,12 @@ each one does: a sync function, or a board channel as a string.
 | `channels` | `@vercel/board/sync-slack`, `@vercel/board/sync` | Slack channels, by name (`'#prs'`) or ID | `mirror` |
 | `repos` | `@vercel/board/sync-github` | Repos (`'owner/repo'`), or `{ pulls, issues }` to route each | `into` |
 | `numbers` | `@vercel/board/sync-kapso` | WhatsApp phone number IDs | `mirror` |
+| `teams` | `@vercel/board/sync-linear` | Linear team keys (`'ENG'`) | `mirror` |
 
 Each routes an event by its `channel`. A new root goes to every channel's
 function, with `channel` set to that one. A thread the board syncs in a channel
 that isn't in the map (someone ran `vb sync` on it) keeps syncing: both ways
-under `channels` and `numbers`, and in only under `repos`.
+under `channels`, `numbers`, and `teams`, and in only under `repos`.
 
 The units are plain sync functions, from `@vercel/board/sync`:
 
@@ -212,13 +213,15 @@ Then, by kind:
 - **`edited`:** `message`, `text`, `author`, `links`.
 - **`deleted`:** `message`.
 - **`reaction`:** `message`, `emoji`, `added`, `author`.
-- **`lifecycle`:** `type`, `title`, `url`, `labels`, `reply`, and `author`. Only
-  GitHub sends these: see the [events table](./04-github.md#events).
+- **`lifecycle`:** `type`, `title`, `url`, `labels`, `reply`, and `author`. GitHub
+  and Linear send these: see GitHub's [events table](./04-github.md#events) and
+  Linear's [events table](./07-linear.md#events).
 
 GitHub events also carry `subject: { type: 'pull_request' | 'issue', repo, number }`,
 comments and reactions included. The types are exported: `SlackEvent` from
 `@vercel/board/sync-slack`, `GitHubEvent` and `GitHubPayload` from
-`@vercel/board/sync-github`, and `WhatsAppEvent` from `@vercel/board/sync-kapso`.
+`@vercel/board/sync-github`, `WhatsAppEvent` from `@vercel/board/sync-kapso`, and `LinearEvent` from
+`@vercel/board/sync-linear`.
 
 ## Permalinks
 

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

@@ -256,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.