@vercel/board 0.0.0 → 0.16.0

package/dist/backend-http-Bid7RIpC.d.mts

@@ -0,0 +1,630 @@
+import { i as Attachment } from "./schemas-CWxs3ECJ.mjs";
+import { t as Actor } from "./reducers-B_vUGQRp.mjs";
+import { Bt as SyncCodeView, G as Discovery, Gt as SyncFindView, Ht as SyncCopiesView, Ot as ScheduleView, Pt as SourceRead, Q as IdentityView, St as RegistrationView, U as ChannelView, Zt as SyncThreadView, ct as MatchView, dt as MessageView, en as ThreadView, et as InboxEntry, ft as MessagesPage, ht as PersonView, j as ProfileOption, q as EventsPage, sn as UploadTicket, st as LinkedAccount, tn as ThreadsPage, tt as InboxItem, ut as Me } from "./provider-BGjz-mDa.mjs";
+import { a as BackendRoute, o as BoardBinding, s as Caller } from "./a2-D24cvwpN.mjs";
+//#region src/server/backend-http.d.ts
+type HttpOptions = {
+  /**
+   * How requests reach the board, with the credentials it recognizes. In Node it defaults to what
+   * `vb` uses: a token from `BOARD_TOKEN`, `vb serve`'s, GitHub Actions, Vercel, or `vercel login`,
+   * through Deployment Protection. In a browser, `fetch`, sending the page's own session (a cookie,
+   * say), which the board's `authenticate` recognizes.
+   */
+  fetch?: typeof fetch;
+};
+/**
+ * What finds a board and reaches it, in the Node build: the environment, its files, and
+ * `vercel login`. A browser has none.
+ */
+type Environment = {
+  /** The board the environment points at. Throws `no_board` when it points at none. */
+  url(): string;
+  /** The fetch for the board at `url` when none is given: the credentials `vb` uses, through Deployment Protection. */
+  fetch(url: string): typeof fetch;
+  /** The profile the environment picks (`BOARD_AS`, or the coding agent it runs in), and that agent's session. */
+  profile(): {
+    profile: ProfileOption;
+    session: string | null;
+  };
+};
+/**
+ * Another board that speaks the protocol, at `url` (in Node, the one the environment points at
+ * by default): this board keeps nothing, and this deployment reads and writes that one as itself.
+ * Its watchers' tails are registered there. The remote wakes it when one matches, with nothing in
+ * the wake-up but a hash, and it pulls what matched with its own credentials, runs it, and acks
+ * it. When it can't be woken (no https URL of its own: a dev server, say), it pulls on its own.
+ */
+declare function createHttp(url: string | undefined, options: HttpOptions, environment: Environment | null): {
+  discovery: (caller: Caller, input: {
+    [x: string]: never;
+  }, signal: AbortSignal) => Promise<Discovery>;
+  me: (caller: Caller, input: {
+    [x: string]: never;
+  }, signal: AbortSignal) => Promise<Me>;
+  channels: (caller: Caller, input: {
+    [x: string]: never;
+  }, signal: AbortSignal) => Promise<{
+    channels: ChannelView[];
+    cursor: string;
+  }>;
+  actors: (caller: Caller, input: {
+    [x: string]: never;
+  }, signal: AbortSignal) => Promise<{
+    actors: (Actor & {
+      person?: PersonView;
+    })[];
+    cursor: string;
+  }>;
+  identity: (caller: Caller, input: {
+    [x: string]: never;
+  }, signal: AbortSignal) => Promise<IdentityView>;
+  messages: (caller: Caller, input: {
+    channel?: string | undefined;
+    re?: string | undefined;
+    by?: string | undefined;
+    mentions?: string | undefined;
+    label?: (readonly [string, null] | readonly [string, string[]])[] | undefined;
+    from?: string | undefined;
+    text?: string | undefined;
+    after?: string | undefined;
+    before?: string | undefined;
+    limit?: number | undefined;
+  }, signal: AbortSignal) => Promise<MessagesPage>;
+  threads: (caller: Caller, input: {
+    channel?: string | undefined;
+    re?: string | undefined;
+    by?: string | undefined;
+    mentions?: string | undefined;
+    label?: (readonly [string, null] | readonly [string, string[]])[] | undefined;
+    from?: string | undefined;
+    text?: string | undefined;
+    after?: string | undefined;
+    limit?: number | undefined;
+  }, signal: AbortSignal) => Promise<ThreadsPage>;
+  message: (caller: Caller, input: {
+    id: string;
+  }, signal: AbortSignal) => Promise<ThreadView>;
+  post: (caller: Caller, input: {
+    channel?: string | undefined;
+    re?: string | undefined;
+    text: string;
+    labels?: Record<string, string> | undefined;
+    noSync?: boolean | undefined;
+    sync?: (string | {
+      target: string;
+      kind: "channel" | "thread";
+    })[] | undefined;
+    id?: string | undefined;
+    attachments?: string[] | undefined;
+  }, signal: AbortSignal) => Promise<{
+    message: MessageView;
+    unknownMentions?: string[];
+  }>;
+  posted: (caller: Caller, input: {
+    id: string;
+  }, signal: AbortSignal) => Promise<{
+    message: MessageView;
+  }>;
+  edit: (caller: Caller, input: {
+    id: string;
+  } & {
+    text: string;
+  }, signal: AbortSignal) => Promise<{
+    ok: true;
+    unknownMentions?: string[];
+  }>;
+  delete: (caller: Caller, input: {
+    id: string;
+  }, signal: AbortSignal) => Promise<{
+    ok: true;
+  }>;
+  react: (caller: Caller, input: {
+    id: string;
+  } & {
+    emoji: string;
+    remove?: boolean | undefined;
+  }, signal: AbortSignal) => Promise<{
+    ok: true;
+  }>;
+  label: (caller: Caller, input: {
+    id: string;
+  } & {
+    set?: Record<string, string> | undefined;
+    unset?: string[] | undefined;
+  }, signal: AbortSignal) => Promise<{
+    ok: true;
+  }>;
+  schedule: (caller: Caller, input: {
+    channel?: string | undefined;
+    re?: string | undefined;
+    text: string;
+    labels?: Record<string, string> | undefined;
+    noSync?: boolean | undefined;
+    attachments?: string[] | undefined;
+    in?: string | undefined;
+    at?: string | undefined;
+    every?: string | undefined;
+    until?: string | undefined;
+    for?: string | undefined;
+    times?: number | undefined;
+  }, signal: AbortSignal) => Promise<{
+    schedule: ScheduleView;
+    unknownMentions?: string[];
+  }>;
+  schedules: (caller: Caller, input: {
+    re?: string | undefined;
+    channel?: string | undefined;
+    by?: string | undefined;
+    all?: boolean | undefined;
+  }, signal: AbortSignal) => Promise<{
+    schedules: ScheduleView[];
+  }>;
+  cancelSchedule: (caller: Caller, input: {
+    id: string;
+  }, signal: AbortSignal) => Promise<{
+    schedule: ScheduleView;
+    canceled: boolean;
+  }>;
+  upload: (caller: Caller, input: {
+    data: Uint8Array;
+    name: string | null;
+    type: string | null;
+  }, signal: AbortSignal) => Promise<{
+    attachment: Attachment;
+  }>;
+  attachment: (caller: Caller, input: {
+    id: string;
+  }, signal: AbortSignal) => Promise<{
+    attachment: Attachment;
+    data: Uint8Array | ReadableStream<Uint8Array>;
+  }>;
+  uploadStart: (caller: Caller, input: {
+    name?: string | null | undefined;
+    type?: string | null | undefined;
+    size: number;
+  }, signal: AbortSignal) => Promise<UploadTicket>;
+  uploadFinish: (caller: Caller, input: {
+    id: string;
+  }, signal: AbortSignal) => Promise<{
+    attachment: Attachment;
+  }>;
+  watchers: (caller: Caller, input: {
+    [x: string]: never;
+  }, signal: AbortSignal) => Promise<{
+    watchers: RegistrationView[];
+  }>;
+  register: (caller: Caller, input: {
+    url?: string | null | undefined;
+    watch: Record<string, {
+      tail: string;
+      when: "enters" | "matches";
+    }>;
+    sync?: {
+      key: string;
+      platform: string;
+      signIn: boolean;
+    }[] | undefined;
+  }, signal: AbortSignal) => Promise<RegistrationView>;
+  matches: (caller: Caller, input: {
+    limit?: number | undefined;
+    wait?: number | undefined;
+  }, signal: AbortSignal) => Promise<{
+    matches: MatchView[];
+  }>;
+  ack: (caller: Caller, input: {
+    id: string;
+  } & {
+    lease: string;
+    error?: string | undefined;
+    skip?: boolean | undefined;
+  }, signal: AbortSignal) => Promise<{
+    ok: true;
+  }>;
+  events: (caller: Caller, input: {
+    channel?: string | undefined;
+    re?: string | undefined;
+    by?: string | undefined;
+    mentions?: string | undefined;
+    label?: (readonly [string, null] | readonly [string, string[]])[] | undefined;
+    from?: string | undefined;
+    text?: string | undefined;
+    after?: string | undefined;
+    wait?: number | undefined;
+    all?: boolean | undefined;
+  }, signal: AbortSignal) => Promise<EventsPage>;
+  typing: (caller: Caller, input: {
+    id: string;
+  } & {
+    status?: string | undefined;
+  }, signal: AbortSignal) => Promise<{
+    targets: string[];
+  }>;
+  readSource: (caller: Caller, input: {
+    key: string;
+  } & {
+    target: string;
+    limit?: number | undefined;
+  }, signal: AbortSignal) => Promise<SourceRead>;
+  syncImport: (caller: Caller, input: {
+    author: {
+      id: string;
+      handle: string;
+      name: string;
+      isBot: boolean;
+      avatar: string | null;
+    };
+    from: string | null;
+    op: "post";
+    origin: {
+      channel?: string | undefined;
+      thread: string;
+      subthread: string | null;
+      message: string;
+      context: string | null;
+    } | null;
+    source?: {
+      key: string;
+      channel: string;
+      thread: string;
+    } | undefined;
+    channel?: string | undefined;
+    re?: string | undefined;
+    text: string;
+    labels?: Record<string, string> | undefined;
+    noSync?: boolean | undefined;
+    attachments?: string[] | undefined;
+    links?: {
+      url: string;
+      snapshot: {
+        author: string;
+        text: string;
+        createdAt: string | null;
+        files: {
+          name: string;
+          url: string | null;
+        }[];
+      } | null;
+      unavailable: string | null;
+      message: string | null;
+    }[] | undefined;
+    id?: string | undefined;
+  } | {
+    author: {
+      id: string;
+      handle: string;
+      name: string;
+      isBot: boolean;
+      avatar: string | null;
+    };
+    from: string | null;
+    origin?: {
+      thread: string;
+      message?: string | undefined;
+    } | undefined;
+    message?: string | undefined;
+    op: "edit";
+    text: string;
+    source?: {
+      key: string;
+      channel: string;
+      thread: string;
+    } | undefined;
+  } | {
+    author: {
+      id: string;
+      handle: string;
+      name: string;
+      isBot: boolean;
+      avatar: string | null;
+    };
+    from: string | null;
+    origin?: {
+      thread: string;
+      message?: string | undefined;
+    } | undefined;
+    message?: string | undefined;
+    op: "delete";
+  } | {
+    author: {
+      id: string;
+      handle: string;
+      name: string;
+      isBot: boolean;
+      avatar: string | null;
+    };
+    from: string | null;
+    origin?: {
+      thread: string;
+      message?: string | undefined;
+    } | undefined;
+    message?: string | undefined;
+    op: "react";
+    emoji: string;
+    remove?: boolean | undefined;
+  } | {
+    author: {
+      id: string;
+      handle: string;
+      name: string;
+      isBot: boolean;
+      avatar: string | null;
+    };
+    from: string | null;
+    origin?: {
+      thread: string;
+      message?: string | undefined;
+    } | undefined;
+    message?: string | undefined;
+    op: "labels";
+    set?: Record<string, string> | undefined;
+    unset?: string[] | undefined;
+  } | {
+    author: {
+      id: string;
+      handle: string;
+      name: string;
+      isBot: boolean;
+      avatar: string | null;
+    };
+    from: string | null;
+    origin?: {
+      thread: string;
+      message?: string | undefined;
+    } | undefined;
+    message?: string | undefined;
+    op: "links";
+    links: {
+      url: string;
+      snapshot: {
+        author: string;
+        text: string;
+        createdAt: string | null;
+        files: {
+          name: string;
+          url: string | null;
+        }[];
+      } | null;
+      unavailable: string | null;
+      message: string | null;
+    }[];
+  } | {
+    op: "seen";
+    author: {
+      id: string;
+      handle: string;
+      name: string;
+      isBot: boolean;
+      avatar: string | null;
+    };
+  }, signal: AbortSignal) => Promise<{
+    message: string | null;
+    dropped?: string[];
+  }>;
+  syncReceipt: (caller: Caller, input: {
+    kind: "message";
+    message: string;
+    target: string;
+    external: {
+      thread: string;
+      message: string;
+      asUser?: true | undefined;
+    };
+    files?: string[] | null | undefined;
+  } | {
+    kind: "files";
+    message: string;
+    target: string;
+    files: string[] | null;
+  } | {
+    kind: "failed";
+    message: string;
+    target: string;
+    error: string;
+  } | {
+    kind: "thread";
+    message: string;
+    target: string;
+    targetKind: "channel" | "thread";
+    cause: "config" | "request";
+  }, signal: AbortSignal) => Promise<{
+    ok: true;
+    attached?: boolean;
+  }>;
+  syncThread: (caller: Caller, input: {
+    thread: string;
+  }, signal: AbortSignal) => Promise<SyncThreadView>;
+  syncFind: (caller: Caller, input: {
+    code?: string | undefined;
+    post?: string | undefined;
+    thread?: string | undefined;
+    message?: string | undefined;
+    account?: string | undefined;
+    person?: string | undefined;
+  }, signal: AbortSignal) => Promise<SyncFindView>;
+  syncCopies: (caller: Caller, input: {
+    message: string[];
+  }, signal: AbortSignal) => Promise<SyncCopiesView>;
+  syncRoots: (caller: Caller, input: {
+    by: string;
+    since: number;
+  }, signal: AbortSignal) => Promise<{
+    roots: MessageView[];
+  }>;
+  inboxPush: (caller: Caller, input: {
+    key: string;
+  } & {
+    events: {
+      id: string;
+      event: {
+        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;
+      } | {
+        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;
+      } | {
+        channel: string;
+        thread: string;
+        subthread: string | null;
+        kind: "deleted";
+        message: 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;
+        };
+      } | {
+        channel: string;
+        thread: string;
+        kind: "lifecycle";
+        type: string;
+        title: string;
+        url: string | null;
+        labels: Record<string, string>;
+        unset: string[];
+        owns?: string[] | undefined;
+        reply: string | null;
+        createRoot: boolean;
+        author: {
+          id: string;
+          handle: string;
+          name: string;
+          avatar: string | null;
+          isBot: boolean;
+        };
+      };
+      raw: unknown;
+    }[];
+  }, signal: AbortSignal) => Promise<{
+    ok: true;
+  }>;
+  inboxNext: (caller: Caller, input: {
+    key: string;
+  } & {
+    limit?: number | undefined;
+  }, signal: AbortSignal) => Promise<{
+    items: InboxItem[];
+  }>;
+  inboxAck: (caller: Caller, input: {
+    key: string;
+  } & {
+    id: string;
+  } & {
+    lease: string;
+    error?: string | undefined;
+  }, signal: AbortSignal) => Promise<{
+    ok: true;
+  }>;
+  inbox: (caller: Caller, input: {
+    key: string;
+  } & {
+    channel?: string | undefined;
+    limit?: number | undefined;
+  }, signal: AbortSignal) => Promise<{
+    events: InboxEntry[];
+  }>;
+  syncCode: (caller: Caller, input: {
+    sync: string;
+  }, signal: AbortSignal) => Promise<SyncCodeView>;
+  syncAccount: (caller: Caller, input: {
+    sync: string;
+    account: {
+      id: string;
+      handle: string;
+      name: string;
+      isBot: boolean;
+      avatar: string | null;
+    };
+    code: string;
+    message?: string | undefined;
+    method?: "code" | "consent" | undefined;
+  }, signal: AbortSignal) => Promise<{
+    person: string;
+    link: LinkedAccount;
+  }>;
+  syncUnlink: (caller: Caller, input: {
+    account: string;
+  }, signal: AbortSignal) => Promise<{
+    ok: true;
+  }>;
+  routes: BackendRoute[];
+  keeps: boolean;
+  bind(next: BoardBinding): void;
+  /** Registers this board's watchers with the board it uses now, as `POST /watchers` does. */
+  registerWatchers: () => Promise<RegistrationView>;
+  /** Stops pulling, for a board that pulls on its own. */
+  close: () => void;
+};
+type HttpBackend = ReturnType<typeof createHttp>;
+//#endregion
+export { HttpOptions as n, HttpBackend as t };

package/dist/backend-http.d.mts

@@ -0,0 +1,10 @@
+import { n as HttpOptions, t as HttpBackend } from "./backend-http-Bid7RIpC.mjs";
+//#region src/backend-http/index.default.d.ts
+/**
+ * The board at `url`, which keeps the log. Outside Node there's no environment to find it or a
+ * token in: `fetch` (the global one by default) sends the page's own session, which the board's
+ * `authenticate` recognizes.
+ */
+export declare function http(url?: string, options?: HttpOptions): HttpBackend;
+//#endregion
+export type { HttpBackend, HttpOptions };

package/dist/backend-http.mjs

@@ -0,0 +1,2 @@
+import { t as http } from "./index.default-Bkg77Pxn.mjs";
+export { http };

package/dist/backend-http.node.d.mts

@@ -0,0 +1,10 @@
+import { n as HttpOptions, t as HttpBackend } from "./backend-http-Bid7RIpC.mjs";
+//#region src/backend-http/index.d.ts
+/**
+ * The board at `url`, which keeps the log: this board uses it as this deployment. Without a
+ * `url`, the one the environment points at: `BOARD_URL`, the repo's link, or `vb use`'s.
+ * Without a `fetch`, it sends the credentials `vb` would.
+ */
+export declare function http(url?: string, options?: HttpOptions): HttpBackend;
+//#endregion
+export type { HttpBackend, HttpOptions };

package/dist/backend-http.node.mjs

@@ -0,0 +1,2 @@
+import { t as http } from "./backend-http-0roEmjl0.mjs";
+export { http };

package/dist/blob-C0J3wbGv.d.mts

@@ -0,0 +1,39 @@
+import "./schemas-CWxs3ECJ.mjs";
+//#region src/server/blob.d.ts
+/**
+ * Where attachments' bytes live. The board writes each file once, under a key
+ * it chose, and never overwrites it; `vercelBlob()` from `@vercel/board/backend-a2/blob-vercel` is the
+ * production one.
+ */
+type BlobStore = {
+  put(key: string, data: Uint8Array, contentType: string): Promise<void>;
+  /** Null when there's nothing under the key. */
+  get(key: string): Promise<{
+    data: ReadableStream<Uint8Array> | Uint8Array;
+    contentType: string;
+  } | null>;
+  /**
+   * For direct uploads, files too big for a request: a URL a client `PUT`s `key`'s bytes to,
+   * straight to the store, with `headers`. The store must bind it to `key`, refuse more than
+   * `maxBytes`, refuse to overwrite what's there, and stop taking it at `expiresAt`. With `head`,
+   * the board takes files up to `DIRECT_UPLOAD_BYTES_MAX`; without, uploads stay at 4 MB.
+   */
+  uploadUrl?(key: string, options: {
+    contentType: string;
+    maxBytes: number;
+    expiresAt: Date;
+  }): Promise<{
+    url: string;
+    headers: Record<string, string>;
+  }>;
+  /** The size of what's under the key, or null when there's nothing: how the board checks a direct upload landed. */
+  head?(key: string): Promise<{
+    size: number;
+  } | null>;
+};
+/** Files in memory, for tests: forgets everything when the process ends. */
+declare function memoryBlob(): BlobStore;
+/** Files on disk, for development and `vb serve`: under `dir`, `.a2/attachments` by default. */
+declare function fsBlob(dir?: string): BlobStore;
+//#endregion
+export { fsBlob as n, memoryBlob as r, BlobStore as t };