@vercel/board 0.16.0 → 0.18.0

package/dist/{provider-BGjz-mDa.d.mts → provider-B0b9Qxw4.d.mts}

@@ -1,6 +1,6 @@
 import { n as AccessSummary } from "./access-CV96SYgr.mjs";
 import { i as Attachment } from "./schemas-CWxs3ECJ.mjs";
-import { _ as ExternalFile, a as ExternalCopy, g as ExternalEvent, h as ExternalAuthor, o as Message, p as BoardEvent, r as Channel, t as Actor, v as ExternalLink, y as Link } from "./reducers-B_vUGQRp.mjs";
+import { a as ExternalCopy, d as ExternalFile, f as ExternalLink, g as BoardEvent, l as ExternalAuthor, o as Message, p as Link, r as Channel, t as Actor, u as ExternalEvent } from "./folds-CRYY14kc.mjs";
 import { z } from "zod";
 //#region src/api/routes.d.ts
 /**
@@ -26,6 +26,8 @@ declare const Filters$1: z.ZodObject<{
   from: z.ZodOptional<z.ZodString>;
   text: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
+/** The filters a query asks for, as the board parsed them. */
+type ParsedFilters = z.output<typeof Filters$1>;
 declare const MessagesQuery: z.ZodObject<{
   channel: z.ZodOptional<z.ZodString>;
   re: z.ZodOptional<z.ZodString>;
@@ -148,6 +150,10 @@ declare const SourceReadQuery: z.ZodObject<{
   target: z.ZodString;
   limit: z.ZodOptional<z.ZodCoercedNumber<unknown>>;
 }, z.core.$strip>;
+/** A platform's link to a message or thread, such as a Slack permalink or a GitHub comment's URL. */
+declare const LinkedQuery: z.ZodObject<{
+  url: z.ZodString;
+}, z.core.$strip>;
 declare const IdentityUnlinkBody: z.ZodObject<{
   actor: z.ZodString;
 }, z.core.$strip>;
@@ -468,6 +474,7 @@ declare const InboxPushBody: 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;
@@ -791,6 +798,25 @@ type MessagesPage = {
   messages: MessageView[];
   cursor: string;
 };
+/**
+ * Where a message's thread is synced: each target, the platform thread it is there, and this
+ * message's copy, with the platform's link to it when the sync that knows the platform runs here.
+ */
+type SyncedView = {
+  targets: {
+    /** As the thread's sync records it: `slack:C0123ABC`, `github:acme/www:12`. */
+    target: string;
+    /** The sync entry it belongs to: `slack`. */
+    key: string;
+    /** The platform thread this message's copy is in, or the one the target is, once it has one. */
+    thread: string | null;
+    /** This message's copy there, by the platform's ID: null when it has none. */
+    message: string | null;
+    url: string | null;
+    /** Why the message didn't reach it, when it didn't. */
+    undelivered: string | null;
+  }[];
+};
 type ThreadView = {
   message: MessageView;
   replies: MessageView[];
@@ -973,6 +999,19 @@ declare const routes: {
       target: z.ZodString;
     }, z.core.$strip>;
   };
+  /** Where the message's thread is synced, and its copy on each target: needs `read` where it is. */
+  readonly synced: {
+    readonly method: 'GET';
+    readonly path: '/messages/:id/sync';
+  };
+  /** The board message a platform link names, from what the board synced: 404 `message_not_found` for one it didn't, or that the caller can't read. */
+  readonly linked: {
+    readonly method: 'GET';
+    readonly path: '/links';
+    readonly query: z.ZodObject<{
+      url: z.ZodString;
+    }, z.core.$strip>;
+  };
   /** Ephemeral: shows typing in the thread's synced platform threads, and writes nothing to the log. Needs `post` where the thread is. */
   readonly typing: {
     readonly method: 'POST';
@@ -1141,6 +1180,7 @@ declare const routes: {
           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;
@@ -1752,11 +1792,22 @@ declare function createBoardClient(options: ClientOptions): {
    * `status` replaces "Typing…" on Slack ("running tests…").
    */
   typing: (id: string, status?: string) => Promise<string[]>;
-  /** Attaches the message's thread to an external target, backfilling it. Attaching twice is a no-op. */
-  sync: (id: string, target: string) => Promise<{
-    target: string;
-    attached: boolean;
-  }>;
+  /**
+   * With a target, attaches the message's thread to it, backfilling it: attaching twice is a no-op.
+   * Without one, where the thread is synced, and this message's copy on each target, with its link.
+   */
+  sync: {
+    (id: string): Promise<SyncedView>;
+    (id: string, target: string): Promise<{
+      target: string;
+      attached: boolean;
+    }>;
+  };
+  /**
+   * The thread of the board message a platform link names (a Slack permalink, a GitHub comment's
+   * URL), from what the board synced: the platform is never asked. 404 for one it didn't sync.
+   */
+  linked: (url: string) => Promise<ThreadView>;
   /** Raw platform events for a sync entry, newest first. */
   inbox: (key: string, opts?: {
     channel?: string;
@@ -2003,6 +2054,7 @@ declare function envelope(platform: string, key: string, event: ExternalEvent, r
   owns?: string[] | undefined;
   reply: string | null;
   createRoot: boolean;
+  retitled?: boolean | undefined;
   author: {
     id: string;
     handle: string;
@@ -2145,6 +2197,7 @@ declare function eventSchema<P extends string, M extends string>(platform: P, me
   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;
@@ -2181,6 +2234,88 @@ type SyncResult = {
   message: string | null;
 };
 //#endregion
+//#region src/sync/fn.d.ts
+/** An event coming in from the platform. */
+type SyncIn<E extends ProviderEvent = ProviderEvent> = {
+  direction: 'in';
+  /** The sync entry's key: `slack` in `sync: { slack: slack(…) }`. */
+  key: string;
+  /** The platform channel it happened in, as the platform names it: `C0123ABC`, `owner/repo:pulls`, a phone number ID. */
+  channel: string;
+  /** The event, validated and frozen. */
+  event: E;
+  /** The board, as the platform user the event came from: its writes are theirs. */
+  board: BoardClient;
+  /**
+   * Imports the event: into its board thread when the board syncs its platform thread, otherwise
+   * as a new root in `channel`. Without a channel, an event in a thread the board doesn't sync
+   * stays off it. Runs once: a second call answers what the first did.
+   */
+  import(channel?: string, overrides?: SyncOverrides): Promise<SyncResult>;
+  /** The platform's own link to the event's message, or null when it has none. Nothing is synced or joined. */
+  permalink(): Promise<string | null>;
+  /** A platform channel's ID from its name (`#dev` → `C0123ABC`), as `channel` names it. */
+  resolve(name: string): Promise<string>;
+};
+/** A board event going out to the platform. */
+type SyncOut = {
+  direction: 'out';
+  key: string;
+  /** The platform channel `target` is in, as the platform names it; null for a new root, which isn't on the platform yet. */
+  channel: string | null;
+  event: BoardEventView;
+  /** The message the event is about, as it is now. */
+  message: MessageView;
+  /** Where it goes: a platform thread or channel the board thread syncs with (`slack:C0123ABC:1727000000.123456`), or null for a new root. */
+  target: string | null;
+  /**
+   * Sends the event to `target`: a new thread's root and what's been said in it, a reply, an
+   * edit, a delete, a reaction, or the copy a label change re-renders. A new root has no target
+   * yet, so it sends nothing. Runs once: a second call answers what the first did.
+   */
+  deliver(options?: {
+    render?: Renderer;
+  }): Promise<void>;
+  /**
+   * Syncs the message's thread with a platform channel (`#dev`, `C0123ABC`): the board starts a
+   * thread there, and its root and replies follow. Never the channel it came from.
+   */
+  start(channel: string): Promise<void>;
+  resolve(name: string): Promise<string>;
+};
+type Sync<E extends ProviderEvent = ProviderEvent> = SyncIn<E> | SyncOut;
+/**
+ * What every event does, both ways. Inbound, it calls `import` to bring the event onto the board;
+ * outbound, `deliver` to send it to the platform, or `start` to open a new root's thread there.
+ * One that calls neither does nothing. A throw is retried.
+ *
+ * The webhook keeps an event (stores it in the inbox for the function) when the board syncs its
+ * thread, or when its channel is one that `channels`, `repos`, or `numbers` routes. A function of
+ * your own at the top keeps every event the platform sends, so keep the helper outermost.
+ */
+type SyncFn<E extends ProviderEvent = ProviderEvent> = (sync: Sync<E>) => unknown;
+/** A sync function, or a board channel: what a string means is up to the helper that takes it. */
+type SyncUnit<E extends ProviderEvent = ProviderEvent> = string | SyncFn<E>;
+/**
+ * A two-way mirror of a board channel: what comes in lands in `channel`, what's said on the
+ * board goes out, and a new root in `channel` starts a thread in the platform channel.
+ */
+declare function mirror(channel: string): SyncFn;
+/** Imports into a board channel, and sends nothing back. */
+declare function into(channel: string): SyncFn;
+/** `inner`, delivering with `renderer` unless it passes its own. */
+declare function render<E extends ProviderEvent = ProviderEvent>(renderer: Renderer, inner: SyncFn<E>): SyncFn<E>;
+/**
+ * Routes each event by its platform channel. Keys are platform channels, by name (`'#dev'`) or
+ * ID (`'C0123ABC'`); values are a board channel to `mirror`, or a sync function. A new root goes
+ * to every channel's function, with `channel` set to that one. A thread the board syncs outside
+ * these channels (someone ran `vb sync` on it) stays synced both ways. A key the platform says
+ * doesn't exist is skipped. While one can't be checked, an event outside the resolved channels
+ * throws, so it's retried, rather than going past that key's function to the default. A new root
+ * starts only in the channels that resolved.
+ */
+declare function channels<E extends ProviderEvent = ProviderEvent>(map: Record<string, SyncUnit<E>>): SyncFn<E>;
+//#endregion
 //#region src/sync/users.d.ts
 /**
  * People's own platform tokens, so a board message they wrote reaches Slack or
@@ -2201,8 +2336,8 @@ type UserTokens = {
 };
 /**
  * Gives an adapter people's tokens, for your own OAuth: `slack({ adapter:
- * withUserTokens(createSlackAdapter(...), { authorize, token }) })`. A Connect
- * connector name (`adapter: 'slack/acme'`) does this for you.
+ * withUserTokens(createSlackAdapter(...), { authorize, token }) }, sync)`. A
+ * Connect connector name (`slack('slack/acme', sync)`) does this for you.
  */
 declare function withUserTokens<A extends object>(adapter: A, tokens: UserTokens): A;
 /** Vercel Connect's user tokens for `connector`: the subject is the board's principal, so Connect binds the account to it. */
@@ -2218,32 +2353,12 @@ declare const ResolvedTarget: z.ZodObject<{
   }>;
 }, z.core.$strict>;
 type ResolvedTarget = z.infer<typeof ResolvedTarget>;
-type SyncClient<E extends ProviderEvent = ProviderEvent> = Omit<BoardClient, 'sync'> & {
-  sync(id: string, target: string): ReturnType<BoardClient['sync']>;
-  sync(channel: string, event: E, overrides?: SyncOverrides): Promise<SyncResult>;
-};
-type SyncHandler<E extends ProviderEvent> = (args: {
-  event: E;
-  board: SyncClient<E>;
-  /**
-   * The platform's own link to the event's message (Slack's `chat.getPermalink`), fetched on
-   * the first call and kept for the rest of the callback. Null when the event has no single
-   * message or the platform has no links. It only reads the URL: nothing is synced or joined.
-   */
-  permalink(): Promise<string | null>;
-}) => unknown;
+/** The fields a provider's `event` builds its typed event from. */
 type SyncContext = {
   id: string;
   key: string;
   event: ExternalEvent;
   raw: unknown;
-  board: BoardClient;
-  client<E extends ProviderEvent>(event: E): SyncClient<E>;
-  apply(channel: string, overrides?: SyncOverrides): Promise<SyncResult>;
-};
-type ProviderMapping = {
-  channel?: string;
-  run?: (context: SyncContext) => unknown;
 };
 type RenderInput = {
   /** The message as clients see it: its IDs are refs. */
@@ -2254,16 +2369,19 @@ type RenderInput = {
   label: string;
   target: string;
 };
-type EventMapping<E extends ProviderEvent> = string | SyncHandler<E> | {
-  channel: string;
-  run: SyncHandler<E>;
-};
+/** How a platform shows a board message: markdown, which the platform converts to its own format. */
+type Renderer = (input: RenderInput) => string;
 type FileDelivery = {
   message: string;
   files: string[];
 };
 /** What a linked message said, or why the platform wouldn't say. */
 type FetchedLink = Pick<Link, 'snapshot' | 'unavailable'>;
+/** Why a platform wouldn't read a channel or thread on demand. Its message is shown as is. */
+declare class UnreadableError extends Error {
+  readonly code: string;
+  constructor(code: string, message: string);
+}
 /** A file to send: its bytes (a Node `Buffer` is one), its name, and its type. */
 type ProviderFile = {
   data: Uint8Array;
@@ -2293,7 +2411,6 @@ type ProviderOptions = {
   canStartThreads?: boolean;
   singleReaction?: boolean;
   uploadsFiles?: boolean;
-  render?: (input: RenderInput) => string;
   /** People's own tokens, to post as them and to link accounts by signing in. */
   users?: UserTokens | null;
 };
@@ -2403,6 +2520,7 @@ declare const ReceivedEvent: 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;
@@ -2421,11 +2539,11 @@ declare abstract class SyncProvider<E extends ProviderEvent = ProviderEvent> {
   readonly canStartThreads: boolean;
   readonly singleReaction: boolean;
   readonly uploadsFiles: boolean;
-  readonly mappings: Record<string, ProviderMapping>;
+  private readonly fn;
   /** People's tokens, when the adapter has them: messages they write post as them. */
   readonly users: UserTokens | null;
   protected readonly options: ProviderOptions;
-  constructor(options: ProviderOptions);
+  constructor(options: ProviderOptions, sync: SyncFn<E>);
   abstract receive(key: string, request: Request, emit: Receive): Promise<Response>;
   abstract resolveChannel(key: string): Promise<string>;
   abstract resolveTarget(target: string): Promise<ResolvedTarget>;
@@ -2444,6 +2562,17 @@ declare abstract class SyncProvider<E extends ProviderEvent = ProviderEvent> {
   permalink(_event: E): Promise<string | null>;
   /** A linked message the platform didn't describe, read from the platform. */
   fetchLink(_link: ExternalLink): Promise<FetchedLink>;
+  /**
+   * The message a URL of this platform's names, by its own thread and message IDs, or null for a
+   * URL that isn't one. `message` is null for a link to a thread itself. It asks the platform
+   * nothing: the board answers from what it synced (`vb read <url>`).
+   */
+  locate(_url: string): {
+    thread: string;
+    message: string | null;
+  } | null;
+  /** The platform's URL for one of its messages, by its own IDs, or null when it has none (`vb sync <id>`). */
+  url(_thread: string, _message: string): Promise<string | null>;
   /**
    * A channel or thread, read on demand for whoever asked: nothing is synced,
    * stored, or joined. Throws `UnreadableError` for what it won't read.
@@ -2464,10 +2593,11 @@ declare abstract class SyncProvider<E extends ProviderEvent = ProviderEvent> {
   deleteFiles(_ids: string[]): Promise<void>;
   refusesFiles(_error: unknown): boolean;
   uploadFiles(_thread: string, _files: ProviderFile[]): Promise<FileDelivery>;
-  abstract event(context: Pick<SyncContext, 'id' | 'key' | 'event' | 'raw'>): E;
-  sync(context: SyncContext, channel: string, overrides?: SyncOverrides): Promise<SyncResult>;
+  abstract event(context: SyncContext): E;
+  /** Runs the sync function the provider was made with: what every event does, both ways. */
+  sync(sync: Sync<E>): unknown;
+  /** The default rendering: `**${label}**: ${text}`. A `Renderer` passed to `deliver` replaces it. */
   render(input: RenderInput): string;
-  protected map(key: string, value: EventMapping<E>): void;
 }
 //#endregion
-export { InboxAckBody as $, ThreadSummaryView as $t, PostOptions as A, SchedulesQueryInput as At, ActorView as B, SyncCodeView as Bt, SyncResult as C, ResolvedSyncTarget as Ct, BoardClient as D, ScheduleInput as Dt, eventSchema as E, ScheduleBodyOutput as Et, UploadInput as F, SourceReadQuery as Ft, Discovery as G, SyncFindView as Gt, BoardEventView as H, SyncCopiesView as Ht, WaitOptions as I, SyncAccountBody as It, EventsQuery as J, SyncReceiptBody as Jt, EditBody as K, SyncImportBody as Kt, Written as L, SyncAccountInput as Lt, ReplyOptions as M, SignInQuery as Mt, ScheduleOptions as N, SourceMessage as Nt, BoardError as O, ScheduleView as Ot, ScheduleTiming as P, SourceRead as Pt, IdentityView as Q, SyncUnlinkBody as Qt, duration as R, SyncBody as Rt, SyncOverrides as S, RegistrationView as St, envelope as T, ScheduleBody as Tt, ChannelView as U, SyncFindInput as Ut, ApiError as V, SyncCopiesQuery as Vt, DeleteBody as W, SyncFindQuery as Wt, FiltersInput as X, SyncRootsQuery as Xt, EventsQueryInput as Y, SyncReceiptInput as Yt, IdentityUnlinkBody as Z, SyncThreadView as Zt, connectUserTokens as _, PostInput as _t, ProviderFile as a, TypingResult as an, LabelBody as at, ProviderEvent as b, Ref as bt, Receive as c, routes as cn, MatchView as ct, ResolvedTarget as d, MessageView as dt, ThreadView as en, InboxEntry as et, SyncClient as f, MessagesPage as ft, UserTokens as g, PostBody as gt, SyncProvider as h, PersonView as ht, ProviderDelivery as i, TypingBody as in, InboxQuery as it, ProfileOption as j, SchedulesQueryOutput as jt, Filters as k, SchedulesQuery as kt, ReceivedEvent as l, MatchesQuery as lt, SyncHandler as m, MessagesQueryInput as mt, FetchedLink as n, ThreadsQuery as nn, InboxNextQuery as nt, ProviderOptions as o, UploadStartBody as on, LinkView as ot, SyncContext as p, MessagesQuery as pt, EventsPage as q, SyncImportInput as qt, FileDelivery as r, ThreadsQueryInput as rn, InboxPushBody as rt, ProviderPost as s, UploadTicket as sn, LinkedAccount as st, EventMapping as t, ThreadsPage as tn, InboxItem as tt, RenderInput as u, Me as ut, withUserTokens as v, REGISTERED_WATCHERS_MAX as vt, SyncRoot as w, RouteName as wt, RootOverride as x, RegisterBody as xt, EventBase as y, ReactBody as yt, AckBody as z, SyncCodeBody as zt };
+export { Discovery as $, SyncFindInput as $t, SyncOverrides as A, Ref as At, ReplyOptions as B, SchedulesQueryInput as Bt, channels as C, MessagesQueryInput as Ct, EventBase as D, PostInput as Dt, render as E, PostBody as Et, BoardClient as F, ScheduleBody as Ft, Written as G, SourceReadQuery as Gt, ScheduleTiming as H, SignInQuery as Ht, BoardError as I, ScheduleBodyOutput as It, ActorView as J, SyncBody as Jt, duration as K, SyncAccountBody as Kt, Filters as L, ScheduleInput as Lt, SyncRoot as M, RegistrationView as Mt, envelope as N, ResolvedSyncTarget as Nt, ProviderEvent as O, REGISTERED_WATCHERS_MAX as Ot, eventSchema as P, RouteName as Pt, DeleteBody as Q, SyncCopiesView as Qt, PostOptions as R, ScheduleView as Rt, SyncUnit as S, MessagesQuery as St, mirror as T, PersonView as Tt, UploadInput as U, SourceMessage as Ut, ScheduleOptions as V, SchedulesQueryOutput as Vt, WaitOptions as W, SourceRead as Wt, BoardEventView as X, SyncCodeView as Xt, ApiError as Y, SyncCodeBody as Yt, ChannelView as Z, SyncCopiesQuery as Zt, withUserTokens as _, UploadStartBody as _n, MatchView as _t, ProviderOptions as a, SyncReceiptInput as an, IdentityUnlinkBody as at, SyncIn as b, MessageView as bt, ReceivedEvent as c, SyncUnlinkBody as cn, InboxEntry as ct, ResolvedTarget as d, ThreadView as dn, InboxPushBody as dt, SyncFindQuery as en, EditBody as et, SyncContext as f, ThreadsPage as fn, InboxQuery as ft, connectUserTokens as g, TypingResult as gn, LinkedQuery as gt, UserTokens as h, TypingBody as hn, LinkedAccount as ht, ProviderFile as i, SyncReceiptBody as in, FiltersInput as it, SyncResult as j, RegisterBody as jt, RootOverride as k, ReactBody as kt, RenderInput as l, SyncedView as ln, InboxItem as lt, UnreadableError as m, ThreadsQueryInput as mn, LinkView as mt, FileDelivery as n, SyncImportBody as nn, EventsQuery as nt, ProviderPost as o, SyncRootsQuery as on, IdentityView as ot, SyncProvider as p, ThreadsQuery as pn, LabelBody as pt, AckBody as q, SyncAccountInput as qt, ProviderDelivery as r, SyncImportInput as rn, EventsQueryInput as rt, Receive as s, SyncThreadView as sn, InboxAckBody as st, FetchedLink as t, SyncFindView as tn, EventsPage as tt, Renderer as u, ThreadSummaryView as un, InboxNextQuery as ut, Sync as v, UploadTicket as vn, MatchesQuery as vt, into as w, ParsedFilters as wt, SyncOut as x, MessagesPage as xt, SyncFn as y, routes as yn, Me as yt, ProfileOption as z, SchedulesQuery as zt };

package/dist/provider-B3DpYSDq.mjs

@@ -0,0 +1,220 @@
+import { n as ExternalEvent } from "./external-BV_cUncs.mjs";
+import { z } from "zod";
+//#region src/sync/fn.ts
+const ROUTES = Symbol.for("board.syncRoutes");
+/** A helper's function, marked with the channels it routes. */
+function withRoutes(fn, routes) {
+	Object.defineProperty(fn, ROUTES, {
+		value: routes,
+		enumerable: false,
+		configurable: true
+	});
+	return fn;
+}
+/** The channels a helper's function routes; undefined for a function of your own, which keeps everything. */
+const routesOf = (fn) => fn[ROUTES];
+/**
+* A two-way mirror of a board channel: what comes in lands in `channel`, what's said on the
+* board goes out, and a new root in `channel` starts a thread in the platform channel.
+*/
+function mirror(channel) {
+	return async (sync) => {
+		if (sync.direction === "in") return void await sync.import(channel);
+		if (sync.target !== null) return sync.deliver();
+		if (sync.channel !== null && sync.message.channel === channel) await sync.start(sync.channel);
+	};
+}
+/** Imports into a board channel, and sends nothing back. */
+function into(channel) {
+	return async (sync) => {
+		if (sync.direction === "in") await sync.import(channel);
+	};
+}
+/** `inner`, delivering with `renderer` unless it passes its own. */
+function render(renderer, inner) {
+	const fn = (sync) => inner(sync.direction === "in" ? sync : {
+		...sync,
+		deliver: (options = {}) => sync.deliver({
+			render: renderer,
+			...options
+		})
+	});
+	const routes = routesOf(inner);
+	return routes ? withRoutes(fn, routes) : fn;
+}
+/** What a thread the board syncs does outside the mapped channels: it stays synced, both ways. */
+const follow = async (sync) => {
+	if (sync.direction === "in") await sync.import();
+	else await sync.deliver();
+};
+/**
+* Routes each event by its platform channel. Keys are platform channels, by name (`'#dev'`) or
+* ID (`'C0123ABC'`); values are a board channel to `mirror`, or a sync function. A new root goes
+* to every channel's function, with `channel` set to that one. A thread the board syncs outside
+* these channels (someone ran `vb sync` on it) stays synced both ways. A key the platform says
+* doesn't exist is skipped. While one can't be checked, an event outside the resolved channels
+* throws, so it's retried, rather than going past that key's function to the default. A new root
+* starts only in the channels that resolved.
+*/
+function channels(map) {
+	const units = Object.entries(map).map(([name, unit]) => [name, typeof unit === "string" ? mirror(unit) : unit]);
+	const resolved = async (resolve) => {
+		const ids = await Promise.allSettled(units.map(([name]) => resolve(name)));
+		const found = /* @__PURE__ */ new Map();
+		let unchecked;
+		ids.forEach((id, i) => {
+			if (id.status === "fulfilled") found.set(id.value, units[i][1]);
+			else if (!channelMissing(id.reason)) unchecked ??= { reason: id.reason };
+		});
+		return {
+			found,
+			unchecked
+		};
+	};
+	const fn = async (sync) => {
+		const { found, unchecked } = await resolved(sync.resolve);
+		if (sync.direction === "out" && sync.target === null) {
+			for (const [channel, unit] of found) await unit({
+				...sync,
+				channel
+			});
+			return;
+		}
+		const unit = found.get(sync.channel);
+		if (unit) return void await unit(sync);
+		if (unchecked) throw unchecked.reason;
+		await follow(sync);
+	};
+	return withRoutes(fn, async (channel, resolve) => (await resolved(resolve)).found.has(channel));
+}
+//#endregion
+//#region src/sync/provider.ts
+const ResolvedTarget = z.object({
+	target: z.string().min(1),
+	channel: z.string().min(1),
+	kind: z.enum(["channel", "thread"])
+}).strict();
+/** Why a platform wouldn't read a channel or thread on demand. Its message is shown as is. */
+var UnreadableError = class extends Error {
+	code;
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+	}
+};
+/**
+* Whether `resolveChannel` failed because the platform has no such channel, so no event can be
+* in it, rather than because it couldn't tell (a failed listing, a missing scope).
+*/
+const channelMissing = (error) => error instanceof UnreadableError && error.code === "channel_not_found";
+const ReceivedEvent = z.object({
+	event: ExternalEvent,
+	raw: z.unknown(),
+	dedupe: z.string().min(1)
+});
+const routed = /* @__PURE__ */ new WeakMap();
+/** The channels a provider's sync function routes, when a helper made it: the webhook keeps only theirs. */
+const routesFor = (provider) => routed.get(provider);
+var SyncProvider = class {
+	platform;
+	canStartThreads;
+	singleReaction;
+	uploadsFiles;
+	fn;
+	/** People's tokens, when the adapter has them: messages they write post as them. */
+	users;
+	options;
+	constructor(options, sync) {
+		if (typeof sync !== "function") throw new Error(`${options.platform} needs a sync function: what each event does, like channels({ '#dev': 'dev' })`);
+		this.fn = { run: sync };
+		const routes = routesOf(sync);
+		if (routes) routed.set(this, routes);
+		this.options = options;
+		this.users = options.users ?? null;
+		this.platform = options.platform;
+		this.canStartThreads = options.canStartThreads ?? false;
+		this.singleReaction = options.singleReaction ?? false;
+		this.uploadsFiles = options.uploadsFiles ?? false;
+	}
+	/** The platform account a person's token belongs to. */
+	async whoAmI(_token) {
+		throw new Error(`${this.platform} can't post as a person`);
+	}
+	/** `post`, as the person whose token this is. */
+	async postAs(_token, _target, _kind, _body) {
+		throw new Error(`${this.platform} can't post as a person`);
+	}
+	async editAs(_token, _thread, _message, _body) {}
+	async deleteAs(_token, _thread, _message) {}
+	async findByEmail(_email) {
+		return null;
+	}
+	mention(_actor) {
+		return null;
+	}
+	async fetchRoot(_thread) {
+		return null;
+	}
+	async fetchFile(_file) {
+		return null;
+	}
+	/** The platform's own link to an event's message, or null when it has none. */
+	async permalink(_event) {
+		return null;
+	}
+	/** A linked message the platform didn't describe, read from the platform. */
+	async fetchLink(_link) {
+		return {
+			snapshot: null,
+			unavailable: `${this.platform} can't read it`
+		};
+	}
+	/**
+	* The message a URL of this platform's names, by its own thread and message IDs, or null for a
+	* URL that isn't one. `message` is null for a link to a thread itself. It asks the platform
+	* nothing: the board answers from what it synced (`vb read <url>`).
+	*/
+	locate(_url) {
+		return null;
+	}
+	/** The platform's URL for one of its messages, by its own IDs, or null when it has none (`vb sync <id>`). */
+	async url(_thread, _message) {
+		return null;
+	}
+	/**
+	* A channel or thread, read on demand for whoever asked: nothing is synced,
+	* stored, or joined. Throws `UnreadableError` for what it won't read.
+	*/
+	async read(_target, _options) {
+		throw new UnreadableError("unsupported", `${this.platform} can't be read on demand`);
+	}
+	async edit(_thread, _message, _body) {}
+	async delete(_thread, _message) {}
+	async react(_thread, _message, _emoji, _added) {}
+	async startTyping(_thread, _latest, _status) {}
+	/**
+	* The channel whose inbox a thread's events land in (`slack:C0123ABC` for `slack:C0123ABC:1727.1234`),
+	* worked out without calling the platform. Null when the provider can't tell: a key's inbox then
+	* lists only the mapped channels'.
+	*/
+	inboxChannel(_key, _thread) {
+		return null;
+	}
+	async deleteFiles(_ids) {}
+	refusesFiles(_error) {
+		return false;
+	}
+	async uploadFiles(_thread, _files) {
+		throw new Error(`${this.platform} does not support file uploads`);
+	}
+	/** Runs the sync function the provider was made with: what every event does, both ways. */
+	sync(sync) {
+		return this.fn.run(sync);
+	}
+	/** The default rendering: `**${label}**: ${text}`. A `Renderer` passed to `deliver` replaces it. */
+	render(input) {
+		return `**${input.label}**: ${input.message.text}`;
+	}
+};
+//#endregion
+export { channelMissing as a, into as c, withRoutes as d, UnreadableError as i, mirror as l, ResolvedTarget as n, routesFor as o, SyncProvider as r, channels as s, ReceivedEvent as t, render as u };