@vercel/board 0.25.0 → 0.25.1

package/dist/provider-Cdg1qadh.d.mts

@@ -0,0 +1,688 @@
+import { d as ExternalFile, f as ExternalLink, l as ExternalAuthor, p as Link, t as Actor, u as ExternalEvent } from "./folds-jS9wlh9_.mjs";
+import { V as MessageView, _ as BoardEventView, dt as SourceJoin, mt as SourceRead, t as BoardClient } from "./client-xLxeDz0f.mjs";
+import { z } from "zod";
+//#region src/sync/events.d.ts
+declare const EventBase: z.ZodObject<{
+  channel: z.ZodString;
+  thread: z.ZodString;
+  subthread: z.ZodNullable<z.ZodString>;
+  id: z.ZodString;
+  platform: z.ZodString;
+  key: z.ZodString;
+  raw: z.ZodUnknown;
+}, z.core.$strip>;
+type EventBase<P extends string = string> = Omit<z.infer<typeof EventBase>, 'platform'> & {
+  platform: P;
+};
+type ProviderEvent = EventBase & ExternalEvent & {
+  type: string;
+};
+declare function envelope(platform: string, key: string, event: ExternalEvent, raw: unknown, id: string): {
+  channel: string;
+  thread: string;
+  subthread: string | null;
+  kind: "message";
+  message: string;
+  isRoot: boolean;
+  text: string;
+  context: string | null;
+  author: {
+    id: string;
+    handle: string;
+    name: string;
+    avatar: string | null;
+    isBot: boolean;
+  };
+  files?: {
+    type: "audio" | "file" | "image" | "video";
+    name?: string | undefined;
+    mimeType?: string | undefined;
+    size?: number | undefined;
+    url?: string | undefined;
+    fetchMetadata?: Record<string, string> | undefined;
+  }[] | undefined;
+  links?: {
+    url: string;
+    thread: string;
+    message: string;
+    snapshot: {
+      author: string;
+      text: string;
+      createdAt: string | null;
+      files: {
+        name: string;
+        url: string | null;
+      }[];
+    } | null;
+  }[] | undefined;
+  id: string;
+  platform: string;
+  key: string;
+  raw: unknown;
+  type: string;
+} | {
+  channel: string;
+  thread: string;
+  subthread: string | null;
+  kind: "edited";
+  message: string;
+  text: string;
+  author: {
+    id: string;
+    handle: string;
+    name: string;
+    avatar: string | null;
+    isBot: boolean;
+  };
+  links?: {
+    url: string;
+    thread: string;
+    message: string;
+    snapshot: {
+      author: string;
+      text: string;
+      createdAt: string | null;
+      files: {
+        name: string;
+        url: string | null;
+      }[];
+    } | null;
+  }[] | undefined;
+  linksOnly?: boolean | undefined;
+  id: string;
+  platform: string;
+  key: string;
+  raw: unknown;
+  type: string;
+} | {
+  channel: string;
+  thread: string;
+  subthread: string | null;
+  kind: "deleted";
+  message: string;
+  id: string;
+  platform: string;
+  key: string;
+  raw: unknown;
+  type: string;
+} | {
+  channel: string;
+  thread: string;
+  subthread: string | null;
+  kind: "reaction";
+  message: string;
+  emoji: string;
+  added: boolean;
+  author: {
+    id: string;
+    handle: string;
+    name: string;
+    avatar: string | null;
+    isBot: boolean;
+  };
+  id: string;
+  platform: string;
+  key: string;
+  raw: unknown;
+  type: string;
+} | {
+  channel: string;
+  thread: string;
+  subthread: string | null;
+  kind: "lifecycle";
+  title: string;
+  url: string | null;
+  labels: Record<string, string>;
+  unset: string[];
+  owns?: string[] | undefined;
+  reply: string | null;
+  createRoot: boolean;
+  retitled?: boolean | undefined;
+  author: {
+    id: string;
+    handle: string;
+    name: string;
+    avatar: string | null;
+    isBot: boolean;
+  };
+  id: string;
+  platform: string;
+  key: string;
+  raw: unknown;
+  type: string;
+};
+declare function eventSchema<P extends string, M extends string>(platform: P, messageType: M): 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<P>;
+  type: z.ZodLiteral<M>;
+}, 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<P>;
+  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<P>;
+  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<P>;
+  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<P>;
+}, z.core.$strip>], "kind">;
+type SyncRoot = {
+  text: string;
+  labels: Record<string, string>;
+  author: ExternalAuthor;
+  raw: unknown;
+};
+type RootOverride = (root: Readonly<SyncRoot>) => {
+  text?: string;
+  labels?: Record<string, string>;
+};
+declare const SyncOverrides: z.ZodObject<{
+  root: z.ZodOptional<z.ZodCustom<RootOverride, RootOverride>>;
+  text: z.ZodOptional<z.ZodString>;
+  labels: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  unset: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  noSync: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strict>;
+type SyncOverrides = z.infer<typeof SyncOverrides>;
+/** What an import made: its thread's root and the message, as IDs clients pass back as they got them. */
+type SyncResult = {
+  root: string | null;
+  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
+ * GitHub as them, and signing in proves an account is theirs. The board never
+ * stores a token: it asks for one at each delivery, and a person without one
+ * (never signed in, revoked, expired) is delivered as the bot, as before.
+ */
+type UserTokens = {
+  /**
+   * A sign-in URL that binds whoever completes it to `principal`. Show it only to them. With
+   * `callback`, the platform sends them there once they've approved.
+   */
+  authorize(principal: string, options?: {
+    callback?: string;
+  }): Promise<string>;
+  /** `principal`'s token on the platform, or null when they haven't signed in. */
+  token(principal: string): Promise<string | null>;
+};
+/**
+ * Gives an adapter people's tokens, for your own OAuth: `slack({ adapter:
+ * 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. */
+declare function connectUserTokens(connector: string): UserTokens;
+//#endregion
+//#region src/sync/provider.d.ts
+declare const ResolvedTarget: z.ZodObject<{
+  target: z.ZodString;
+  channel: z.ZodString;
+  kind: z.ZodEnum<{
+    channel: "channel";
+    thread: "thread";
+  }>;
+}, z.core.$strict>;
+type ResolvedTarget = z.infer<typeof ResolvedTarget>;
+/** The fields a provider's `event` builds its typed event from. */
+type SyncContext = {
+  id: string;
+  key: string;
+  event: ExternalEvent;
+  raw: unknown;
+};
+type RenderInput = {
+  /** The message as clients see it: its IDs are refs. */
+  message: Readonly<MessageView>;
+  author: Readonly<Actor> | null;
+  /** How this platform mentions an actor, through linked accounts; null when it can't. */
+  mentionOf: (actor: string) => string | null;
+  label: string;
+  target: string;
+};
+/** 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;
+  filename: string;
+  mimeType?: string;
+};
+/**
+ * Who a post is from, for a platform that can show it as the sender (Slack's per-message
+ * username and icon): `name` is the label the text opens with (`**name**: …`).
+ */
+type ProviderSender = {
+  name: string;
+  avatar: string | null;
+};
+type ProviderPost = {
+  markdown: string;
+  files?: ProviderFile[];
+  as?: ProviderSender;
+};
+type ProviderDelivery = {
+  thread: string;
+  message: string;
+  files?: string[];
+};
+type ProviderOptions = {
+  platform: string;
+  canStartThreads?: boolean;
+  singleReaction?: boolean;
+  uploadsFiles?: boolean;
+  /** People's own tokens, to post as them and to link accounts by signing in. */
+  users?: UserTokens | null;
+};
+declare const ReceivedEvent: z.ZodObject<{
+  event: 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>>>;
+  }, 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>;
+  }, z.core.$strip>, z.ZodObject<{
+    channel: z.ZodString;
+    thread: z.ZodString;
+    subthread: z.ZodNullable<z.ZodString>;
+    kind: z.ZodLiteral<"deleted">;
+    message: z.ZodString;
+  }, 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>;
+  }, z.core.$strip>, z.ZodObject<{
+    channel: z.ZodString;
+    thread: 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>;
+  }, z.core.$strip>], "kind">;
+  raw: z.ZodUnknown;
+  dedupe: z.ZodString;
+}, z.core.$strip>;
+type ReceivedEvent = z.infer<typeof ReceivedEvent>;
+type Receive = (received: ReceivedEvent) => Promise<void>;
+declare abstract class SyncProvider<E extends ProviderEvent = ProviderEvent> {
+  readonly platform: string;
+  readonly canStartThreads: boolean;
+  readonly singleReaction: boolean;
+  readonly uploadsFiles: boolean;
+  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, 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>;
+  abstract post(target: string, kind: ResolvedTarget['kind'], body: ProviderPost): Promise<ProviderDelivery>;
+  /** The platform account a person's token belongs to. */
+  whoAmI(_token: string): Promise<ExternalAuthor>;
+  /** `post`, as the person whose token this is. */
+  postAs(_token: string, _target: string, _kind: ResolvedTarget['kind'], _body: ProviderPost): Promise<ProviderDelivery>;
+  editAs(_token: string, _thread: string, _message: string, _body: ProviderPost): Promise<void>;
+  deleteAs(_token: string, _thread: string, _message: string): Promise<void>;
+  findByEmail(_email: string): Promise<ExternalAuthor | null>;
+  mention(_actor: Actor): string | null;
+  fetchRoot(_thread: string): Promise<SyncRoot | null>;
+  fetchFile(_file: ExternalFile): Promise<Uint8Array | null>;
+  /** The platform's own link to an event's message, or null when it has none. */
+  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.
+   */
+  read(_target: string, _options: {
+    limit: number;
+  }): Promise<SourceRead>;
+  /** Adds the board's app to a channel so `read` can read it, where the board opted in. Throws `UnreadableError` otherwise. */
+  join(_target: string): Promise<SourceJoin>;
+  edit(_thread: string, _message: string, _body: ProviderPost): Promise<void>;
+  delete(_thread: string, _message: string): Promise<void>;
+  react(_thread: string, _message: string, _emoji: string, _added: boolean): Promise<void>;
+  startTyping(_thread: string, _latest: string | null, _status?: string): Promise<void>;
+  /**
+   * 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: string, _thread: string): string | null;
+  deleteFiles(_ids: string[]): Promise<void>;
+  refusesFiles(_error: unknown): boolean;
+  uploadFiles(_thread: string, _files: ProviderFile[]): Promise<FileDelivery>;
+  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;
+}
+//#endregion
+export { SyncOverrides as A, channels as C, EventBase as D, render as E, SyncRoot as M, envelope as N, ProviderEvent as O, eventSchema as P, SyncUnit as S, mirror as T, withUserTokens as _, ProviderOptions as a, SyncIn as b, ReceivedEvent as c, ResolvedTarget as d, SyncContext as f, connectUserTokens as g, UserTokens as h, ProviderFile as i, SyncResult as j, RootOverride as k, RenderInput as l, UnreadableError as m, FileDelivery as n, ProviderPost as o, SyncProvider as p, ProviderDelivery as r, Receive as s, FetchedLink as t, Renderer as u, Sync as v, into as w, SyncOut as x, SyncFn as y };

package/dist/{serve-DYQ64Q5R.mjs → serve-D2O0C6Kk.mjs}

@@ -1,8 +1,8 @@
-import { t as BoardError } from "./client-BY-BCggB.mjs";
-import { i as localTokenFile } from "./node-C51_xzCb.mjs";
-import { t as board } from "./server-BgK1sgj7.mjs";
-import { t as oidcTokens } from "./tokens-U-XRlEfq.mjs";
-import { n as fsBlob, t as a2 } from "./a2-CQ3WcqMv.mjs";
+import { t as BoardError } from "./client-D0Px7KzF.mjs";
+import { i as localTokenFile } from "./node-Bkd1x0QI.mjs";
+import { t as board } from "./server-BF4WJ7qi.mjs";
+import { t as oidcTokens } from "./tokens-BuCU-61R.mjs";
+import { n as fsBlob, t as a2 } from "./a2-A830f5NS.mjs";
 import { t as localScheduler } from "./local-DhkrAqPP.mjs";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import { userInfo } from "node:os";