deck-plugin-sdk 1.13.0 → 1.14.0

package/README.md

@@ -62,8 +62,22 @@ actually exposes rather than a hand-written approximation that has drifted.
 Any other npm package is `npm install` and import: the build bundles it into `plugin.js`, with the
 images, fonts and CSS it brings. Writing a plugin, in the Docs, says what cannot work that way.
 
-When the build needs more than that (a worker bundled into the plugin, a dependency's locales left
-out), export esbuild plugins from `deck-plugin.config.mjs` beside `plugin.json`:
+Two things a build often needs are settings, which the registry can still rebuild:
+
+- **A worker of your own:** `import code from "./job.worker.ts?worker"` bundles that file and what
+  it imports into one script and gives its text, to start with
+  `new Worker(URL.createObjectURL(new Blob([code])))`.
+- **Files a package brings that you never use** (a library's translations into every language):
+  regular expressions in `package.json`, matched against each file's path, and each match is
+  bundled empty:
+
+  ```json
+  "deckPlugin": { "leaveOut": ["/locales/(?!en-)[^/]+\\.js$"] }
+  ```
+
+When the build needs more than that, export esbuild plugins from `deck-plugin.config.mjs` beside
+`plugin.json`. The registry does not run your code, so it cannot rebuild a plugin that has one:
+it is listed as build not verified, and misses those points.
 
 ```js
 export const esbuildPlugins = [{ name: "my-step", setup(build) { /* ... */ } }];

package/build-plugin.mjs

@@ -17,7 +17,7 @@ import { cpSync, existsSync, mkdirSync, readdirSync, readFileSync, rmSync, write
 import { createRequire } from "node:module";
 import { dirname, join } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
-import { assetLoaders, fromPackage, packageCss, rawImports } from "./packages.mjs";
+import { assetLoaders, fromPackage, leaveOut, packageCss, rawImports, workerImports } from "./packages.mjs";
 
 const sdk = dirname(fileURLToPath(import.meta.url));
 const require = createRequire(import.meta.url);
@@ -58,11 +58,15 @@ export async function buildPlugin(dir, { entry = "plugin.tsx" } = {}) {
   }
   const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
 
-  // A plugin that needs more from esbuild than this build gives (a worker bundled into it, a
-  // dependency's locales left out) exports `esbuildPlugins` from deck-plugin.config.mjs beside
-  // plugin.json. They run after Deck's own, so they never take over react or the shim.
+  // What a plugin needs beyond the plain build is a setting where it can be: `?worker` imports, and
+  // `"deckPlugin": { "leaveOut": [...] }` in package.json (packages.mjs). Those run none of the
+  // plugin's code, so the registry can rebuild it. Anything more exports `esbuildPlugins` from
+  // deck-plugin.config.mjs beside plugin.json, which runs after Deck's own, so it never takes over
+  // react or the shim, and which the registry will not run.
   const configPath = join(dir, "deck-plugin.config.mjs");
   const config = existsSync(configPath) ? await import(pathToFileURL(configPath).href) : {};
+  const pkgPath = join(dir, "package.json");
+  const settings = (existsSync(pkgPath) ? JSON.parse(readFileSync(pkgPath, "utf8")).deckPlugin : null) ?? {};
 
   const sources = readdirSync(join(dir, "src"), { recursive: true })
     .filter((f) => typeof f === "string" && /\.tsx?$/.test(f))
@@ -150,7 +154,7 @@ ${names.map((n) => `export const ${n} = __src.${n};`).join("\n")}
           .map((k) => k.replace(/[/\\^$*+?.()|[\]{}]/g, "\\$&")).join("|")})$`);
         b.onResolve({ filter }, (a) => (fromPackage(a, dir) ? undefined : { path: shims[a.path] }));
       },
-    }, rawImports, packageCss(manifest.id, dir), ...(config.esbuildPlugins ?? [])],
+    }, rawImports, workerImports, leaveOut(settings.leaveOut), packageCss(manifest.id, dir), ...(config.esbuildPlugins ?? [])],
     logLevel: "info",
   });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "deck-plugin-sdk",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "description": "Build a plugin for Deck, outside the Deck repository.",
   "type": "module",
   "license": "MIT",

package/packages.mjs

@@ -105,3 +105,47 @@ export const rawImports = {
     b.onLoad({ filter: /.*/, namespace: "deck-raw" }, (args) => ({ contents: readFileSync(args.path), loader: args.pluginData?.as === "base64" ? "base64" : "text" }));
   },
 };
+
+/**
+ * `import code from "./x.worker.ts?worker"` bundles that file and what it imports into one script
+ * and gives its text, for a Worker started from a Blob URL: a plugin is one plugin.js, so the
+ * worker cannot be a file beside it. Only esbuild runs, as for the plugin itself.
+ */
+export const workerImports = {
+  name: "deck-worker",
+  setup(b) {
+    b.onResolve({ filter: /\?worker$/ }, async (args) => {
+      const r = await b.resolve(args.path.slice(0, -"?worker".length), { kind: args.kind, resolveDir: args.resolveDir, importer: args.importer });
+      if (r.errors.length) return { errors: r.errors };
+      return { path: r.path, namespace: "deck-worker" };
+    });
+    b.onLoad({ filter: /.*/, namespace: "deck-worker" }, async (args) => {
+      const out = await b.esbuild.build({ entryPoints: [args.path], bundle: true, write: false, format: "iife", target: "es2022", minify: true, metafile: true });
+      return { contents: out.outputFiles[0].text, loader: "text", watchFiles: Object.keys(out.metafile.inputs) };
+    });
+  },
+};
+
+/**
+ * `"deckPlugin": { "leaveOut": [...] }` in package.json: regular expressions, and a file whose path
+ * (with forward slashes) matches one is bundled as an empty module. For what a package bundles but
+ * the plugin never uses, such as a library's translations into every language. Matched on load
+ * rather than on import, so a file reached by a pattern import (`import(\`./locales/${l}.js\`)`) is
+ * left out too. A setting rather than code, so the registry can still rebuild the plugin.
+ */
+export function leaveOut(patterns = []) {
+  if (!Array.isArray(patterns) || patterns.some((p) => typeof p !== "string" || p.length > 200)) {
+    throw new Error('package.json\'s "deckPlugin.leaveOut" must be a list of regular expressions, each under 200 characters');
+  }
+  const res = patterns.map((p) => new RegExp(p));
+  return {
+    name: "deck-leave-out",
+    setup(b) {
+      if (!res.length) return;
+      b.onLoad({ filter: /.*/ }, (a) => {
+        const path = a.path.replace(/\\/g, "/");
+        return res.some((r) => r.test(path)) ? { contents: "export default {};", loader: "js" } : undefined;
+      });
+    },
+  };
+}

package/permissions.json

@@ -112,6 +112,7 @@
     "fsTrash": "files",
     "fsWrite": "files",
     "fsWriteBytes": "files",
+    "ghAvatar": "network",
     "ghPrLineComment": "network",
     "ghPrThreads": "network",
     "ghRun": "processes",

package/shim/bridge.js

@@ -121,6 +121,7 @@ export const fsTrash = (...a) => b().fsTrash(...a);
 export const fsWrite = (...a) => b().fsWrite(...a);
 export const fsWriteBytes = (...a) => b().fsWriteBytes(...a);
 export const getAutostart = (...a) => b().getAutostart(...a);
+export const ghAvatar = (...a) => b().ghAvatar(...a);
 export const ghPrLineComment = (...a) => b().ghPrLineComment(...a);
 export const ghPrThreads = (...a) => b().ghPrThreads(...a);
 export const ghRun = (...a) => b().ghRun(...a);

package/shim/p2p.js

@@ -10,7 +10,7 @@ const t = () => {
   return x;
 };
 
-export const cleanCode = (...a) => t().cleanCode(...a);
-export const newCode = (...a) => t().newCode(...a);
-export const selfId = (...a) => t().selfId(...a);
-export const share = (...a) => t().share(...a);
+export const myTeamId = (...a) => t().myTeamId(...a);
+export const subscribeTeams = (...a) => t().subscribeTeams(...a);
+export const teamChannel = (...a) => t().teamChannel(...a);
+export const teamsView = (...a) => t().teamsView(...a);

package/template/plugin.json

@@ -5,6 +5,6 @@
   "icon": "Sparkles",
   "color": "#a78bfa",
   "version": "0.1.0",
-  "minDeck": "1.13.0",
+  "minDeck": "1.14.0",
   "permissions": []
 }

package/template/src/assets.d.ts

@@ -14,3 +14,5 @@ declare module "*.wasm" { const bytes: Uint8Array; export default bytes; }
 declare module "*?raw" { const text: string; export default text; }
 // `import data from "some/file?base64"`: any file's bytes, as a base64 string.
 declare module "*?base64" { const base64: string; export default base64; }
+// `import code from "./job.worker.ts?worker"`: that worker, bundled, as the text of a script.
+declare module "*?worker" { const code: string; export default code; }

package/types/core/app/p2p.d.ts

@@ -1,117 +1,3 @@
 // GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
-/** What can travel: anything JSON can carry. */
-export type Json = string | number | boolean | null | Json[] | {
-    [k: string]: Json;
-};
-/** Whether someone may change what is shared, or only watch. */
-export type Mode = "edit" | "view";
-/** Who may change things: a default for everyone, and a choice per person that wins over it. */
-export interface Roles {
-    def: Mode;
-    per: Record<string, Mode>;
-}
-/** Why a share ended for a joiner: the host stopped, vanished, removed this Deck, turned it away,
- *  or speaks another version. */
-export type Gone = "ended" | "lost" | "removed" | "denied" | "version";
-export interface Person {
-    id: string;
-    name: string; /** Round trip in ms, once measured. */
-    ms?: number;
-}
-/** What a share's bar and dialogs show. Replaced, never mutated, so React sees a change. */
-export interface ShareView {
-    /** Who is in and connected: on the host, everyone let in; on a joiner, the host and the others. */
-    peers: Person[];
-    /** On the host: who is asking to be let in. */
-    knocking: Person[];
-    /** On a joiner: the host is there but has not let this Deck in yet. */
-    waiting: boolean;
-    /** On a joiner: no host heard from for a while (wrong code, or a network that blocks it). */
-    stuck: boolean;
-    gone: Gone | null;
-    hostName: string;
-    /** A passing line: someone on another version, or whatever the plugin `say`s. */
-    note: string;
-    roles: Roles;
-    /** Whether this Deck may change things. */
-    canEdit: boolean;
-}
-export interface ShareOptions {
-    /** What the share is for, e.g. "canvas-share". Decks only meet others using the same one. */
-    app: string;
-    /** The share code, which names the room (see newCode). */
-    code: string;
-    /** Optional extra secret, needed with the code to connect at all. Sharing works without one. */
-    password?: string;
-    /** The plugin's message channel, at most 12 bytes (Trystero's cap). Defaults to "msg". */
-    channel?: string;
-    /** Whether this Deck is the one sharing. */
-    host: boolean;
-    /** Shown to the others: in the host's knock, on cursors, in the list of who is here. */
-    name: string;
-    /** The plugin's own protocol version. Decks on different versions do not share. */
-    version: number;
-    /** The host's default for who may change things. Joiners may until the host says otherwise. */
-    mode?: Mode;
-}
-export interface ShareHandlers<T> {
-    /** A plugin message, only ever from someone let in (and the host). Check `mayEdit(peer)` before
-     *  applying a change: a view-only person's edits are to be dropped by every Deck. */
-    message: (msg: T, peer: string) => void;
-    /** On the host: someone was just let in. Send them what they need to start, e.g. the board. */
-    welcome?: (peer: string) => void;
-    /** Someone left or was removed: forget what was kept for them (a cursor). */
-    left?: (peer: string) => void;
-}
-export interface P2pShare<T> {
-    readonly host: boolean;
-    /** Send a plugin message to everyone let in, or to one of them. Sends nothing before this Deck is
-     *  let in. Settles once handed to the connection, so awaiting it paces the sender. */
-    send(msg: T, to?: string): Promise<void>;
-    /** Whether a peer may change things: the host always, anyone else by the roles. */
-    mayEdit(peer: string): boolean;
-    /** The host: let someone in, or turn them away. */
-    allow(peer: string): void;
-    deny(peer: string): void;
-    /** The host: remove someone who was let in. They cannot come back with the same Deck. */
-    kick(peer: string): void;
-    /** The host: everyone's default, and one person's own choice (`null` follows the default). */
-    setDefault(mode: Mode): void;
-    setPerson(peer: string, mode: Mode | null): void;
-    /** Show a passing line in the view for a few seconds. */
-    say(note: string): void;
-    /** Leave. With `announce` (the host ending on purpose) everyone is told first, so they end at
-     *  once rather than when the connection times out. Safe to call twice. */
-    close(announce?: boolean): Promise<void>;
-    /** For useSyncExternalStore. */
-    subscribe(fn: () => void): () => void;
-    getView(): ShareView;
-}
-/** The part of a Trystero room a share uses: a seam, so the check can run a share without a network. */
-export interface RoomLike {
-    /** This Deck's id in the room; Trystero's own is `selfId()`. */
-    selfId?: string;
-    makeAction(name: string, config: {
-        onMessage: (data: any, ctx: {
-            peerId: string;
-        }) => void;
-    }): {
-        send(data: any, options?: {
-            target?: string | string[];
-        }): Promise<void>;
-    };
-    ping(peer: string): Promise<number>;
-    leave(): Promise<void>;
-    getPeers(): Record<string, unknown>;
-    onPeerJoin: ((peer: string) => void) | null;
-    onPeerLeave: ((peer: string) => void) | null;
-}
-/** This Deck's id in every share: the one the others know it by. The same for the whole session,
- *  so someone let in who rejoins after a dropped connection is let straight back in. */
-export declare function selfId(): string;
-/** Start sharing (`host`), or ask to join someone's share. */
-export declare function share<T extends Json>(opts: ShareOptions, on: ShareHandlers<T>, room?: RoomLike): P2pShare<T>;
-/** A share code: 16 random characters in four groups, easy to read out or paste. */
-export declare function newCode(random?: (n: number) => Uint8Array): string;
-/** A pasted code, tidied: spaces dropped, case folded. Empty when it is not a code. */
-export declare function cleanCode(text: string): string;
+export type { Json } from "./p2pshare";
+export { teamChannel, teamsView, subscribeTeams, myTeamId, type Member, type TeamView, type TeamChannel, type ChannelHandlers } from "./teams";

package/types/core/app/p2pshare.d.ts

@@ -0,0 +1,131 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+/** What can travel: anything JSON can carry. */
+export type Json = string | number | boolean | null | Json[] | {
+    [k: string]: Json;
+};
+/** Whether someone may change what is shared, or only watch. */
+export type Mode = "edit" | "view";
+/** Who may change things: a default for everyone, and a choice per person that wins over it. */
+export interface Roles {
+    def: Mode;
+    per: Record<string, Mode>;
+}
+/** Why a share ended for a joiner: the host stopped, vanished, removed this Deck, turned it away,
+ *  or speaks another version. */
+export type Gone = "ended" | "lost" | "removed" | "denied" | "version";
+export interface Person {
+    id: string;
+    name: string; /** Round trip in ms, once measured. */
+    ms?: number;
+}
+/** What a share's bar and dialogs show. Replaced, never mutated, so React sees a change. */
+export interface ShareView {
+    /** Who is in and connected: on the host, everyone let in; on a joiner, the host and the others. */
+    peers: Person[];
+    /** On the host: who is asking to be let in. */
+    knocking: Person[];
+    /** On a joiner: the host is there but has not let this Deck in yet. */
+    waiting: boolean;
+    /** On a joiner: no host heard from for a while (wrong code, or a network that blocks it). */
+    stuck: boolean;
+    gone: Gone | null;
+    hostName: string;
+    /** A passing line: someone on another version, or whatever the plugin `say`s. */
+    note: string;
+    roles: Roles;
+    /** Whether this Deck may change things. */
+    canEdit: boolean;
+}
+export interface ShareOptions {
+    /** What the share is for, e.g. "canvas-share". Decks only meet others using the same one. */
+    app: string;
+    /** The share code, which names the room (see newCode). */
+    code: string;
+    /** Optional extra secret, needed with the code to connect at all. Sharing works without one. */
+    password?: string;
+    /** The plugin's message channel, at most 12 bytes (Trystero's cap). Defaults to "msg". */
+    channel?: string;
+    /** Whether this Deck is the one sharing. */
+    host: boolean;
+    /** Shown to the others: in the host's knock, on cursors, in the list of who is here. */
+    name: string;
+    /** The plugin's own protocol version. Decks on different versions do not share. */
+    version: number;
+    /** The host's default for who may change things. Joiners may until the host says otherwise. */
+    mode?: Mode;
+    /**
+     * The host: who is let in, decided here rather than by a knock. Asked for each Deck that says
+     * hello: true lets it straight in, false turns it away (no knock at all). For a team share
+     * (teams.ts): only a Deck checked as a current member of the team, so a code and password that
+     * reached anyone else, or a member removed since, let no one in.
+     */
+    admit?: (peer: string) => boolean;
+    /**
+     * A joiner: who may be the host. Without it, the first Deck that says it hosts is believed. For a
+     * team share: only the member who sent the invite.
+     */
+    trustHost?: (peer: string) => boolean;
+    /** The largest message taken from anyone, in bytes (12 MB unless set). */
+    maxBytes?: number;
+}
+export interface ShareHandlers<T> {
+    /** A plugin message, only ever from someone let in (and the host). Check `mayEdit(peer)` before
+     *  applying a change: a view-only person's edits are to be dropped by every Deck. */
+    message: (msg: T, peer: string) => void;
+    /** On the host: someone was just let in. Send them what they need to start, e.g. the board. */
+    welcome?: (peer: string) => void;
+    /** Someone left or was removed: forget what was kept for them (a cursor). */
+    left?: (peer: string) => void;
+}
+export interface P2pShare<T> {
+    readonly host: boolean;
+    /** Send a plugin message to everyone let in, or to one of them. Sends nothing before this Deck is
+     *  let in. Settles once handed to the connection, so awaiting it paces the sender. */
+    send(msg: T, to?: string): Promise<void>;
+    /** Whether a peer may change things: the host always, anyone else by the roles. */
+    mayEdit(peer: string): boolean;
+    /** The host: let someone in, or turn them away. */
+    allow(peer: string): void;
+    deny(peer: string): void;
+    /** The host: remove someone who was let in. They cannot come back with the same Deck. */
+    kick(peer: string): void;
+    /** The host: everyone's default, and one person's own choice (`null` follows the default). */
+    setDefault(mode: Mode): void;
+    setPerson(peer: string, mode: Mode | null): void;
+    /** Show a passing line in the view for a few seconds. */
+    say(note: string): void;
+    /** Leave. With `announce` (the host ending on purpose) everyone is told first, so they end at
+     *  once rather than when the connection times out. Safe to call twice. */
+    close(announce?: boolean): Promise<void>;
+    /** For useSyncExternalStore. */
+    subscribe(fn: () => void): () => void;
+    getView(): ShareView;
+}
+/** The part of a Trystero room a share uses: a seam, so the check can run a share without a network. */
+export interface RoomLike {
+    /** This Deck's id in the room; Trystero's own is `selfId()`. */
+    selfId?: string;
+    makeAction(name: string, config: {
+        onMessage: (data: any, ctx: {
+            peerId: string;
+        }) => void;
+    }): {
+        send(data: any, options?: {
+            target?: string | string[];
+        }): Promise<void>;
+    };
+    ping(peer: string): Promise<number>;
+    leave(): Promise<void>;
+    getPeers(): Record<string, unknown>;
+    onPeerJoin: ((peer: string) => void) | null;
+    onPeerLeave: ((peer: string) => void) | null;
+}
+/** This Deck's id in every share: the one the others know it by. The same for the whole session,
+ *  so someone let in who rejoins after a dropped connection is let straight back in. */
+export declare function selfId(): string;
+/** Start sharing (`host`), or ask to join someone's share. */
+export declare function share<T extends Json>(opts: ShareOptions, on: ShareHandlers<T>, room?: RoomLike): P2pShare<T>;
+/** A share code: 16 random characters in four groups, easy to read out or paste. */
+export declare function newCode(random?: (n: number) => Uint8Array): string;
+/** A pasted code, tidied: spaces dropped, case folded. Empty when it is not a code. */
+export declare function cleanCode(text: string): string;

package/types/core/app/settingsstore.d.ts

@@ -23,4 +23,6 @@ export declare function stepZoom(dir: -1 | 0 | 1): void;
 /** Current settings for non-React callers (the palette's providers). */
 export declare const getSettings: () => Settings;
 export declare function userName(): Promise<string>;
+/** Told after every change to the settings, from anywhere (Settings, a file edited elsewhere). */
+export declare const subscribeSettings: (cb: () => void) => () => void;
 export declare function useSettings(): Settings;

package/types/core/app/teams.d.ts

@@ -0,0 +1,122 @@
+// GENERATED by sdk/gen-types.mjs from Deck's source — do not edit.
+import { share, type Json, type RoomLike, type P2pShare } from "./p2pshare";
+export type Member = {
+    id: string;
+    pub: string;
+    name: string;
+};
+/** A team's members, as the owner signed them. */
+export type MemberList = {
+    team: string;
+    name: string;
+    owner: string;
+    ownerPub: string;
+    rev: number;
+    members: Member[];
+    sig: string; /** The owner ended the team. */
+    ended?: boolean;
+};
+/** What this Deck keeps for a team. The key is secret: it names and encrypts the room. */
+export type Team = {
+    id: string;
+    key: string;
+    list: MemberList; /** Each member's name as last heard from them: theirs to change. */
+    seen?: Record<string, string>; /** When this Deck heard the team was ended: kept as a tombstone until ENDED_DAYS after. */
+    endedAt?: number;
+};
+/** A team as the Teams page shows it. */
+export interface TeamView {
+    id: string;
+    name: string;
+    owner: boolean;
+    ownerId: string;
+    members: (Member & {
+        me: boolean;
+        online: boolean;
+    })[];
+}
+export interface TeamChannel<T> {
+    /** Send to every member online, or to one (`to`: a member id). Nothing goes to anyone else. */
+    send(msg: T, to?: string): Promise<void>;
+    /** The members connected and checked right now, this Deck not included. */
+    online(): Member[];
+    close(): void;
+}
+export interface ChannelHandlers<T> {
+    message: (msg: T, from: Member) => void;
+    /** A member connected and was checked: send them what they need to catch up. */
+    joined?: (m: Member) => void;
+    left?: (m: Member) => void;
+}
+/** Where teams keep things and how they reach the network: a seam, so the check runs without either. */
+export interface TeamDeps {
+    read(name: string): Promise<string>;
+    write(name: string, text: string): Promise<void>;
+    /** This Deck's name, as the others see it. */
+    name(): Promise<string>;
+    /** A team's room: Trystero's, or a fake one. */
+    room(key: string, id: string): RoomLike;
+    /** Told when this Deck's name may have changed (the settings changed). */
+    watchName(cb: () => void): void;
+    share: typeof share;
+}
+/** For the check: replace the storage, the name and the network. */
+export declare function _setTeamDeps(d: Partial<TeamDeps>): void;
+/** A short code for an identity, to read out and compare: whoever invites shows theirs, whoever joins sees it. */
+export declare const fingerprint: (id: string) => string;
+/** A member's id: the first half of the hash of their public key. */
+export declare function idOf(pub: string): Promise<string>;
+/** Whether a list is the owner's own: signed by them, for this team, with ids that match the keys. */
+export declare function validList(l: MemberList, ownerPub?: string): Promise<boolean>;
+/** A plugin's line to a team: its messages, only to and from checked members. */
+export declare function teamChannel<T extends Json>(teamId: string, app: string, on: ChannelHandlers<T>): TeamChannel<T>;
+export declare function teamsView(): TeamView[];
+export declare function subscribeTeams(fn: () => void): () => void;
+/** This Deck's member id. */
+export declare const myTeamId: () => Promise<string>;
+/** Start a team, with this Deck as its owner and only member. */
+export declare function createTeam(name: string): Promise<string>;
+/** The owner takes someone off the team. */
+export declare function removeMember(teamId: string, memberId: string): Promise<void>;
+/**
+ * Leave a team: this Deck forgets it, and the others still list it until the owner removes it. The
+ * owner leaving ends the team for everyone: a last signed list says so, sent to those online now
+ * and, through the tombstones, to the others when they come back.
+ */
+export declare function leaveTeam(teamId: string): Promise<void>;
+type InviteMsg = {
+    t: "join";
+    id: string;
+    pub: string;
+    name: string;
+} | {
+    t: "team";
+    team: Team;
+};
+/**
+ * The owner invites: a code to give someone, and a share where they knock and are let in, as a
+ * live share's people are (`share.allow`). Whoever is let in is added to the team and sent it.
+ */
+export declare function inviteToTeam(teamId: string): Promise<{
+    code: string;
+    share: P2pShare<InviteMsg>;
+    fingerprint: string;
+    joined: Promise<string>;
+}>;
+/**
+ * Join a team with the code its owner gave you: knock, and once let in, say who you are and take
+ * the team the owner sends. Resolves with the team's id.
+ */
+/** A team offered by an invite: who owns it, to compare, and keeping it. */
+export interface TeamOffer {
+    id: string;
+    name: string;
+    owner: string;
+    fingerprint: string;
+    keep: () => Promise<string>;
+}
+export declare function joinTeam(code: string): Promise<{
+    share: P2pShare<InviteMsg>;
+    done: Promise<TeamOffer>;
+}>;
+export {};

package/types/core/bridge.d.ts

@@ -1077,6 +1077,8 @@ export declare const gitAiCommitMsg: (dir: string, command: string, args: string
 export declare const ghRun: (dir: string, args: string[]) => Promise<string>;
 /** Pull request N's review threads, as GitHub's GraphQL JSON (parsed by prs.ts parseThreads). */
 export declare const ghPrThreads: (dir: string, number: number) => Promise<string>;
+/** The GitHub profile picture's address of whoever commits as `email` in this repo, "" when none. */
+export declare const ghAvatar: (dir: string, email: string) => Promise<string>;
 /** Comment on one line of a PR's diff: side "RIGHT" is the new version, "LEFT" the old. */
 export declare const ghPrLineComment: (dir: string, number: number, commit: string, path: string, line: number, side: "LEFT" | "RIGHT", body: string) => Promise<string>;
 export declare const ghThreadReply: (dir: string, thread: string, body: string) => Promise<string>;
@@ -1084,8 +1086,8 @@ export declare const ghThreadResolve: (dir: string, thread: string, resolve: boo
 /** The GitLab CLI, `glab mr …` only. Rejects with "glab-missing" when glab is not installed. */
 export declare const glabRun: (dir: string, args: string[]) => Promise<string>;
 /**
- * One GitLab REST request about this repo's merge requests (`projects/:id/merge_requests…` or
- * `user`). `fields` go as strings; `json` values must be objects or arrays.
+ * One GitLab REST request about this repo's merge requests (`projects/:id/merge_requests…`, `user`,
+ * or `avatar?email=` for someone's picture). `fields` go as strings; `json` values must be objects or arrays.
  */
 export declare const glabApi: (dir: string, method: "GET" | "POST" | "PUT", path: string, fields?: [string, string][], json?: Record<string, object>) => Promise<string>;
 /** The files that differ between two revisions. */