@vercel/board 0.16.0 → 0.17.0

package/dist/backend-B-SJ7p6p.d.mts

@@ -0,0 +1,680 @@
+import { t as Access } from "./access-CV96SYgr.mjs";
+import { m as RuleFunction, n as AccessRule, r as Authenticate, s as Granted, t as AccessFunction, u as Known } from "./auth-CU56Q2Xh.mjs";
+import { i as Attachment, o as Author, p as Labels } from "./schemas-CWxs3ECJ.mjs";
+import { t as Actor, u as ExternalEvent } from "./folds-CRYY14kc.mjs";
+import { $ as Discovery, Et as PostBody, F as BoardClient, Ft as ScheduleBody, Gt as SourceReadQuery, Kt as SyncAccountBody, Mt as RegistrationView, Qt as SyncCopiesView, Rt as ScheduleView, St as MessagesQuery, Tt as PersonView, Wt as SourceRead, X as BoardEventView, Xt as SyncCodeView, Yt as SyncCodeBody, Z as ChannelView, Zt as SyncCopiesQuery, _n as UploadStartBody, _t as MatchView, bt as MessageView, cn as SyncUnlinkBody, ct as InboxEntry, dn as ThreadView, dt as InboxPushBody, en as SyncFindQuery, et as EditBody, fn as ThreadsPage, ft as InboxQuery, gt as LinkedQuery, hn as TypingBody, ht as LinkedAccount, in as SyncReceiptBody, jt as RegisterBody, kt as ReactBody, ln as SyncedView, lt as InboxItem, nn as SyncImportBody, nt as EventsQuery, on as SyncRootsQuery, ot as IdentityView, p as SyncProvider, pn as ThreadsQuery, pt as LabelBody, q as AckBody, sn as SyncThreadView, st as InboxAckBody, tn as SyncFindView, tt as EventsPage, ut as InboxNextQuery, vn as UploadTicket, vt as MatchesQuery, xt as MessagesPage, yt as Me, z as ProfileOption, zt as SchedulesQuery } from "./provider-B0b9Qxw4.mjs";
+import { z } from "zod";
+//#region src/api/protocol.d.ts
+type Input<S extends z.ZodType> = NonNullable<z.output<S>>;
+type Id = {
+  id: string;
+};
+type Key = {
+  key: string;
+};
+type Nothing = Record<string, never>;
+/**
+ * The protocol, method by method: what each takes and what it answers, as the wire carries them.
+ * board() serves each at its route in `routes` and calls the backend's method of the same name.
+ */
+type Protocol = {
+  /** Where the board is and what it syncs, for a client to mint a token from: it needs none itself. */
+  discovery: {
+    input: Nothing;
+    output: Discovery;
+  };
+  me: {
+    input: Nothing;
+    output: Me;
+  };
+  channels: {
+    input: Nothing;
+    output: {
+      channels: ChannelView[];
+      cursor: string;
+    };
+  };
+  actors: {
+    input: Nothing;
+    output: {
+      actors: (Actor & {
+        person?: PersonView;
+      })[];
+      cursor: string;
+    };
+  };
+  identity: {
+    input: Nothing;
+    output: IdentityView;
+  };
+  messages: {
+    input: Input<typeof MessagesQuery>;
+    output: MessagesPage;
+  };
+  threads: {
+    input: Input<typeof ThreadsQuery>;
+    output: ThreadsPage;
+  };
+  message: {
+    input: Id;
+    output: ThreadView;
+  };
+  post: {
+    input: Input<typeof PostBody>;
+    output: {
+      message: MessageView;
+      unknownMentions?: string[];
+    };
+  };
+  /** The caller's own post with client ID `id`, as it landed: 404 `post_not_found` when there's none. */
+  posted: {
+    input: Id;
+    output: {
+      message: MessageView;
+    };
+  };
+  edit: {
+    input: Id & Input<typeof EditBody>;
+    output: {
+      ok: true;
+      unknownMentions?: string[];
+    };
+  };
+  delete: {
+    input: Id;
+    output: {
+      ok: true;
+    };
+  };
+  react: {
+    input: Id & Input<typeof ReactBody>;
+    output: {
+      ok: true;
+    };
+  };
+  label: {
+    input: Id & Input<typeof LabelBody>;
+    output: {
+      ok: true;
+    };
+  };
+  schedule: {
+    input: Input<typeof ScheduleBody>;
+    output: {
+      schedule: ScheduleView;
+      unknownMentions?: string[];
+    };
+  };
+  schedules: {
+    input: Input<typeof SchedulesQuery>;
+    output: {
+      schedules: ScheduleView[];
+    };
+  };
+  cancelSchedule: {
+    input: Id;
+    output: {
+      schedule: ScheduleView;
+      canceled: boolean;
+    };
+  };
+  upload: {
+    input: {
+      data: Uint8Array;
+      name: string | null;
+      type: string | null;
+    };
+    output: {
+      attachment: Attachment;
+    };
+  };
+  attachment: {
+    input: Id;
+    output: {
+      attachment: Attachment;
+      data: Uint8Array | ReadableStream<Uint8Array>;
+    };
+  };
+  /** A direct upload's ticket: where to `PUT` a file too big for `upload`. 501 `no_direct_uploads` when the blob store can't sign one. */
+  uploadStart: {
+    input: Input<typeof UploadStartBody>;
+    output: UploadTicket;
+  };
+  /** The attachment, once the bytes are in the store: 409 `not_uploaded` before. Finishing one twice answers the same. */
+  uploadFinish: {
+    input: Id;
+    output: {
+      attachment: Attachment;
+    };
+  };
+  watchers: {
+    input: Nothing;
+    output: {
+      watchers: RegistrationView[];
+    };
+  };
+  register: {
+    input: Input<typeof RegisterBody>;
+    output: RegistrationView;
+  };
+  matches: {
+    input: Input<typeof MatchesQuery>;
+    output: {
+      matches: MatchView[];
+    };
+  };
+  ack: {
+    input: Id & Input<typeof AckBody>;
+    output: {
+      ok: true;
+    };
+  };
+  /** Long-polls with `wait`. board() serves SSE from it, so a backend has one way to read events. */
+  events: {
+    input: Input<typeof EventsQuery>;
+    output: EventsPage;
+  };
+  /** Typing in the platform threads the message's thread is synced to: needs `post` there. Answers the threads that took it. */
+  typing: {
+    input: Id & Input<typeof TypingBody>;
+    output: {
+      targets: string[];
+    };
+  };
+  /** A platform channel or thread, read with sync entry `key`'s app where that sync runs: needs `manage` everywhere. */
+  readSource: {
+    input: Key & Input<typeof SourceReadQuery>;
+    output: SourceRead;
+  };
+  /** Where a message's thread is synced, and its copy on each target, from sync's records: needs `read` where it is. */
+  synced: {
+    input: Id;
+    output: SyncedView;
+  };
+  /**
+   * The thread of the board message a platform link names, from sync's records: the platform is
+   * never asked. 404 `message_not_found` for a link the board didn't sync, or one the caller can't read.
+   */
+  linked: {
+    input: Input<typeof LinkedQuery>;
+    output: ThreadView;
+  };
+  /**
+   * A platform's write as its platform author, idempotent per platform event. `dropped`: the
+   * middleware kept a post or an edit off the board, and what it responded, for sync to tell the
+   * author on the platform.
+   */
+  syncImport: {
+    input: Input<typeof SyncImportBody>;
+    output: {
+      message: string | null;
+      dropped?: string[];
+    };
+  };
+  /** A delivery, its files, a failure, or a thread's new target. `attached` is false for a target the thread had. */
+  syncReceipt: {
+    input: Input<typeof SyncReceiptBody>;
+    output: {
+      ok: true;
+      attached?: boolean;
+    };
+  };
+  syncThread: {
+    input: {
+      thread: string;
+    };
+    output: SyncThreadView;
+  };
+  syncFind: {
+    input: Input<typeof SyncFindQuery>;
+    output: SyncFindView;
+  };
+  /** Messages' copies on platforms that the caller's sync recorded, by target: another sync's never show. */
+  syncCopies: {
+    input: Input<typeof SyncCopiesQuery>;
+    output: SyncCopiesView;
+  };
+  syncRoots: {
+    input: Input<typeof SyncRootsQuery>;
+    output: {
+      roots: MessageView[];
+    };
+  };
+  /** Platform events into the caller's inbox, deduplicated by their platform IDs. */
+  inboxPush: {
+    input: Key & Input<typeof InboxPushBody>;
+    output: {
+      ok: true;
+    };
+  };
+  /** The caller's next inbox events, leased, one platform thread at a time and in order. */
+  inboxNext: {
+    input: Key & Input<typeof InboxNextQuery>;
+    output: {
+      items: InboxItem[];
+    };
+  };
+  inboxAck: {
+    input: Key & Id & Input<typeof InboxAckBody>;
+    output: {
+      ok: true;
+    };
+  };
+  /** Raw platform events, newest first, for debugging sync. */
+  inbox: {
+    input: Key & Input<typeof InboxQuery>;
+    output: {
+      events: InboxEntry[];
+    };
+  };
+  /** A code for linking the caller's account, and the sign-in that carries it when the entry signs people in. */
+  syncCode: {
+    input: Input<typeof SyncCodeBody>;
+    output: SyncCodeView;
+  };
+  /** 404 `bad_code` for a code that isn't live. */
+  syncAccount: {
+    input: Input<typeof SyncAccountBody>;
+    output: {
+      person: string;
+      link: LinkedAccount;
+    };
+  };
+  syncUnlink: {
+    input: Input<typeof SyncUnlinkBody>;
+    output: {
+      ok: true;
+    };
+  };
+};
+type Method = keyof Protocol;
+//#endregion
+//#region src/server/errors.d.ts
+declare class HttpError extends Error {
+  readonly status: number;
+  readonly code: string;
+  constructor(status: number, code: string, message: string);
+}
+//#endregion
+//#region src/server/middleware.d.ts
+/** Where a write came from, as the middleware sees it. */
+type WriteSource =
+/** The HTTP API: the CLI, the SDK, scripts, CI. */
+{
+  kind: 'api';
+} |
+/** A synced platform's event, or a sync callback's own writes. `thread` is the platform thread. */
+{
+  kind: 'sync';
+  key: string;
+  platform: string;
+  channel: string;
+  thread: string;
+} |
+/** The board's handle in this deployment: `team.post(…)`, or `team.as(name).post(…)`. `name` is null for the handle itself. */
+{
+  kind: 'client';
+  name: string | null;
+} |
+/** A watcher's in-process client. */
+{
+  kind: 'watcher';
+  id: string;
+} |
+/** A scheduled message's send. */
+{
+  kind: 'schedule';
+  id: number;
+};
+/** The message a write would put on the board. `re` is its thread's root, and IDs are as clients see them. */
+type Write = {
+  kind: 'post';
+  channel: string;
+  re: string | null;
+  text: string;
+  labels: Labels;
+  attachments: readonly Attachment[];
+} | {
+  kind: 'edit';
+  id: string;
+  channel: string;
+  re: string | null;
+  text: string;
+};
+/** What `next` may change before the write lands. Labels apply to posts only. */
+type WritePatch = {
+  text?: string;
+  labels?: Labels;
+};
+type MiddlewareContext = {
+  write: Readonly<Write>;
+  /** Who's writing. */
+  author: Readonly<Actor>;
+  source: Readonly<WriteSource>;
+  /**
+   * What to tell whoever wrote it when the write is dropped, where they wrote it from: a reply in
+   * their platform thread for sync, the error the API answers with otherwise.
+   */
+  respond(text: string): Promise<void>;
+  /** The board, acting as `board:middleware`. Its writes skip the middleware. */
+  board: Board;
+  /**
+   * Hands the write to the next middleware, and after the last one, to the board.
+   * Not calling it drops the write, and so does emptying a write that has no files.
+   */
+  next(patch?: WritePatch): Promise<void>;
+};
+type Middleware = (context: MiddlewareContext) => unknown;
+/** A write the middleware didn't let through: the API answers 422 with what it responded. */
+declare class DroppedError extends HttpError {
+  /** What the middleware responded, in order: none when it dropped the write without a word. */
+  readonly responses: readonly string[];
+  constructor(responses: readonly string[]);
+}
+//#endregion
+//#region src/server/policy.d.ts
+/** Who may use a board, and what they may do: `board()`'s options for it. */
+type PolicyOptions = {
+  /**
+   * Who a request is: `oidcTokens()` from `@vercel/board/access` by default, which checks its bearer token
+   * for the board's URL (pass it `local` for `vb serve`'s, or test issuers). Or a host's own
+   * verifier, `(request) => ({ id, kind, handle })`: who the request is in the board's ID scheme,
+   * from its credential or its headers (a session cookie). It replaces the built-in one, so no
+   * token's audience or the board's own project counts then, unless it calls `oidcTokens()` itself.
+   * Null when it recognizes nothing; to reject, return or throw a `Response`.
+   */
+  authenticate?: Authenticate;
+  /**
+   * Who besides the board's people and its own deployments in the environment it runs in may use
+   * it, and what they may do in each channel: `vercelProject()`, `githubActions()`, `oidc()` from
+   * `@vercel/board/access`, and functions of your own, `(principal) => can`, for principals your
+   * `authenticate` returns. The first rule that matches decides; a function's undefined leaves it to
+   * the next. A production board's previews need a rule, as
+   * `vercelProject({ project: 'self', environments: ['preview'], can })`.
+   *
+   * Or a host's own model: one function of the principal its `authenticate` returned, giving what it
+   * may do in each channel (`'all'`, `['read']`, `{ 'dev/': ['post'] }`), or null for nothing.
+   * Nothing else is trusted then, not the board's own people or deployments.
+   *
+   * On `http()`, a board with none serves no requests but wake-ups and webhooks; with one, it serves
+   * its callers within it, as its project on the board it uses.
+   */
+  access?: readonly (AccessRule | RuleFunction)[] | AccessFunction;
+  /**
+   * The board's Vercel project: `self` in the rules, whose people's development tokens it takes,
+   * and what discovery names for clients to mint them. Defaults to `VERCEL_PROJECT_ID` or
+   * `.vercel/project.json`.
+   */
+  project?: {
+    id: string;
+    teamId?: string;
+  };
+};
+//#endregion
+//#region src/server/origin.d.ts
+/**
+ * Where a write came from: `middleware` is the middleware's own client, which skips it, and
+ * `engine` is sync's own lookups and receipts.
+ */
+type Via = WriteSource | {
+  kind: 'middleware';
+} | {
+  kind: 'engine';
+};
+/**
+ * How a write reaches the middleware: where it's from, and how to answer there. `schedule` marks a
+ * schedule's send, which a backend's own schedules set in-process: no request carries it.
+ */
+type WriteOrigin = {
+  via?: Via;
+  respond?: (text: string) => Promise<void>;
+  schedule?: {
+    id: number;
+    n: number;
+  };
+};
+//#endregion
+//#region src/server/watcher.d.ts
+/** What a watcher's `run` gets. */
+type WatcherContext = {
+  /** Exactly what `vb tail --json` prints. */
+  event: BoardEventView;
+  /** The board, acting as this watcher. */
+  board: Board;
+};
+/** A `vb tail` the board runs for you: every event the tail would print, handed to `run`. */
+type Watcher = {
+  /**
+   * A `vb tail` expression without `vb tail`: `firehose --label status=needs-agent`. `--all` adds
+   * delivery receipts, as in `vb tail`: `message.synced` says where a message landed on a platform.
+   */
+  tail: string;
+  /**
+   * `matches` (the default) runs on every event the tail prints. `enters` runs only when a
+   * message enters the view: it didn't match before the event and does after it.
+   */
+  when?: 'matches' | 'enters';
+  run: (context: WatcherContext) => unknown;
+};
+//#endregion
+//#region src/server/board.d.ts
+/**
+ * `board()`'s options: where the board lives, who may use it and what its writes go through, and
+ * what runs here. The backend keeps or reaches the log; the policy is the board's.
+ */
+type BoardOptions = PolicyOptions & {
+  /**
+   * Where the board lives: `a2({ … })` from `@vercel/board/backend-a2` keeps it here, `http(url)` from
+   * `@vercel/board/backend-http` uses another, or your own. By default, `http()`: in Node, the board the
+   * environment points at (`BOARD_URL`, the repo's link, or `vb use`'s).
+   */
+  backend?: Backend;
+  /**
+   * Runs on every post and edit before it reaches the backend, whatever it came from: requests (a
+   * board on `http()` using this one included), watchers, schedules, the handle, and sync's imports.
+   * Each calls `next()` to pass the write on; one that doesn't drops it.
+   */
+  middleware?: readonly Middleware[];
+  /** Tails the board runs for you, keyed by an id you choose: `{ triage: { tail: 'firehose', run } }`. */
+  watch?: Record<string, Watcher>;
+  /**
+   * Two-way sync, keyed by a name you choose: `{ slack: slack('slack/acme', channels({...})) }`. It
+   * runs here, wherever the board lives: webhooks land at `<board>/webhooks/<key>`, and what the
+   * board's channels say goes out to the platforms. On `http()`, the board it uses must let this
+   * deployment `sync` in those channels.
+   */
+  sync?: Record<string, SyncProvider>;
+  /** The board's public URL, which every token's audience must equal. Inferred from requests otherwise. */
+  url?: string;
+  /** The mount path, e.g. `/api/board`. Inferred from requests otherwise: the shallowest one they show. */
+  basePath?: string;
+  /** SSE streams close after this long, before the platform's limit; clients reconnect. */
+  streamMaxMs?: number;
+};
+/**
+ * The handle on a board: its methods act as the board's caller, through board(), which calls the
+ * backend's methods, and `fetch` serves it. Over `http()` the caller is whoever its `fetch`'s
+ * credentials say, with the profile `BOARD_AS` or the agent it runs in picks; on a board it keeps
+ * (`a2()`), its own code, as `board:client`.
+ */
+type Board = BoardClient & {
+  /**
+   * The board's HTTP handler, for a route file (`export const GET = team.fetch, POST = team.fetch`)
+   * or any runtime that takes one function.
+   */
+  fetch(request: Request): Promise<Response>;
+  /**
+   * The handle, acting with `profile`: `<principal>+<profile>` over HTTP, `board:client:<profile>`
+   * on `a2()`. `null` acts as yourself, outside any agent session.
+   */
+  as(profile: ProfileOption): Board;
+};
+//#endregion
+//#region src/server/backend.d.ts
+/**
+ * Who a verified caller is: its principal, with what board()'s `access` lets it do now (its scope
+ * included, which only narrows), the author record its writes carry, and the actor it writes as.
+ * `records: false`: its writes leave the board's record of its actor (name, avatar) as it is, for
+ * a platform user a sync that can't sync everywhere writes as.
+ */
+type Identity = {
+  principal: Granted;
+  author: Author;
+  actor: Actor;
+  records?: false;
+};
+/**
+ * A caller board() verified, and what its policy lets it do: a request's, or for work a backend does
+ * outside requests, the one it does it for (a schedule's creator, at its send). A backend trusts it
+ * as it is: only board() makes one, in process.
+ */
+type VerifiedCaller = {
+  identity: Identity;
+  origin: WriteOrigin;
+};
+/** This deployment's own code, as it calls the backend through board(). */
+type SelfCaller = {
+  /**
+   * A handle (`via: client`, with the profile from `as(profile)`, or null for the board's own), a
+   * watcher, the middleware's handle (`via: middleware`), or sync (`via: engine`). Each backend
+   * decides who that is on its board: `board:client` and `board:client:<profile>` on a2(), the
+   * token's holder with that profile elsewhere.
+   */
+  self: string | null;
+  /**
+   * What `as(profile)` asked for, its avatar included, or null for yourself. Absent on the
+   * handle itself, whose caller is whoever the environment picks: a backend elsewhere sends
+   * the profile `BOARD_AS` or the agent it runs in names.
+   */
+  profile?: ProfileOption;
+  origin: WriteOrigin;
+};
+/** Who's calling a backend's method: one board() verified, or this deployment's own code. Every method honors what it may do. */
+type Caller = VerifiedCaller | SelfCaller;
+/** One method per protocol route: the caller, the parsed input, and the request's signal. */
+type ProtocolMethods = { [M in keyof Protocol]: (caller: Caller, input: Protocol[M]['input'], signal: AbortSignal) => Promise<Protocol[M]['output']>; };
+/** A route of a backend's own, beside the protocol: http()'s wake-ups. */
+type BackendRoute = {
+  method: 'GET' | 'POST';
+  /** Under the board's mount, with `:param` segments, e.g. `/wake`. One at a protocol route's path takes its place. */
+  path: string;
+  /** `caller` is this deployment's own code, or null for a request, which board() doesn't verify for it: the route checks what it needs. */
+  handle(request: Request, context: {
+    caller: Caller | null;
+    param: string | null;
+  }): Promise<Response>;
+};
+/** What runs on a board's events. */
+type Subscription =
+/** A watcher: every event its tail prints. */
+{
+  kind: 'tail';
+  tail: string;
+  when: 'matches' | 'enters';
+} |
+/** Sync's outbound: every post, change, and thread sync in every channel, as its own code sees them. */
+{
+  kind: 'sync';
+};
+/** One of board()'s sync entries: its key, its platform, and whether it can sign people in. */
+type SyncEntry = {
+  key: string;
+  platform: string;
+  signIn: boolean;
+};
+/** A platform event sync pushed to an inbox, as the backend delivers it back. */
+type InboxDelivery = {
+  event: ExternalEvent;
+  raw: unknown;
+};
+/** What a backend gets from the board it serves: once, in memory, when board() is created. */
+type BoardBinding = {
+  /** What runs on this board's events, by ID: this project's watchers, and sync's outbound at `SYNC` when it syncs. */
+  subscriptions: Record<string, Subscription>;
+  /**
+   * Runs one subscription on an event. A throw is the backend's to retry; `attempt` counts tries
+   * from 1, and sync gives up on a delivery, and says so, before A2 would dead-letter it.
+   */
+  run(id: string, event: WatcherContext['event'], meta: {
+    trigger: string;
+    attempt: number;
+  }): Promise<void>;
+  /**
+   * Runs one platform event this board's sync pushed to the backend's inbox, for a backend that
+   * delivers them in-process: one platform thread at a time, in order. `id` is the event's in the
+   * inbox, which the writes it makes derive their IDs from. A throw is the backend's to retry.
+   */
+  receive(key: string, item: InboxDelivery, meta: {
+    id: string;
+    attempt: number;
+    signal: AbortSignal;
+  }): Promise<void>;
+  /** Pulls and runs what this board's sync queued in a backend's inbox, for one that queues them: http()'s, when it's woken. */
+  pull(): Promise<number>;
+  /** board()'s sync entries: what its sync imports through, and what discovery lists. */
+  sync: readonly SyncEntry[];
+  /**
+   * Reads a platform channel or thread with sync entry `key`'s app, which only board() has: what
+   * `readSource` answers. 404 `not_synced_here` for an entry it doesn't run.
+   */
+  readSource(key: string, target: string, limit: number): Promise<SourceRead>;
+  /**
+   * The message a platform link names, as each platform this board syncs reads it: the platform,
+   * and its own thread and message IDs, the message null for a link to a thread. Any entry of that
+   * platform may have synced it, so a lookup tries each. Empty when no entry here reads it. It asks
+   * no platform anything.
+   */
+  locate(url: string): {
+    platform: string;
+    thread: string;
+    message: string | null;
+  }[];
+  /** The platform's link to a copy sync recorded, by entry `key` here: null when none runs it, or its platform has none. */
+  linkOf(key: string, thread: string, message: string): Promise<string | null>;
+  /**
+   * Shows typing in the platform threads a board thread (`messages`, its root first) is synced to,
+   * through board()'s sync: what `typing` answers. Answers the threads that took it.
+   */
+  typing(messages: readonly MessageView[], status: string | undefined): Promise<string[]>;
+  /**
+   * What a principal the backend stored may do now, under board()'s `access`: a schedule's creator
+   * at each send, a registrant at each event and pull. Null once it may do nothing.
+   */
+  accessNow(principal: Known): Promise<Access | null>;
+  /** The board's own Vercel project and team, as board() knows them: what discovery names, for clients to mint tokens with. */
+  project(): Promise<{
+    id: string | null;
+    teamId: string | null;
+  }>;
+  /**
+   * A handle through board(), as `caller`: what a backend writes for someone outside a request
+   * goes through it, so board()'s middleware sees it, a schedule's send as its creator, say. A
+   * verified caller's posts keep the IDs they're given.
+   */
+  handle(caller: Caller): Board;
+  /** The board's own URL, where a board elsewhere can wake it, once it's known. */
+  url(): string | null;
+};
+/**
+ * Where a board lives. board() serves the protocol over HTTP: it routes, validates, verifies each
+ * caller, applies `access`, runs the middleware, watchers, and sync, and calls these with the caller
+ * it verified. A backend stores and answers, honoring what each caller may do.
+ */
+interface Backend extends ProtocolMethods {
+  /** Routes of its own, beside the protocol: one at a protocol route's path takes its place. */
+  readonly routes: readonly BackendRoute[];
+  /**
+   * Whether the board lives here. One that keeps it (`a2()`) lets in, when board()'s `access` is left
+   * out, its people and the board's own deployments; one that uses another board (`http()`) serves no
+   * requests then but wake-ups and webhooks, and with an `access`, serves its callers as that board's
+   * project.
+   */
+  readonly keeps: boolean;
+  /**
+   * board() calls it once, when it's created, before any request: what background work needs
+   * from the board (its subscriptions, its sync, its policy, a handle through it). It does no I/O.
+   */
+  bind(board: BoardBinding): void;
+}
+//#endregion
+export { Protocol as C, Method as S, MiddlewareContext as _, Identity as a, WriteSource as b, SelfCaller as c, Board as d, BoardOptions as f, Middleware as g, DroppedError as h, Caller as i, Subscription as l, WatcherContext as m, BackendRoute as n, InboxDelivery as o, Watcher as p, BoardBinding as r, ProtocolMethods as s, Backend as t, VerifiedCaller as u, Write as v, HttpError as x, WritePatch as y };