@vercel/board 0.16.0 → 0.18.0

package/dist/folds-CRYY14kc.d.mts

@@ -0,0 +1,534 @@
+import { i as Attachment, o as Author, p as Labels, r as ActorKind } from "./schemas-CWxs3ECJ.mjs";
+import { z } from "zod";
+//#region src/contract/events.d.ts
+/** The board's one log. Every board fact is an event in session `board`. */
+declare const boardEvents: {
+  'message.posted': z.ZodObject<{
+    channel: z.ZodString;
+    text: z.ZodUnion<readonly [z.ZodString, z.ZodLiteral<"">]>;
+    re: z.ZodNullable<z.ZodNumber>;
+    replyTo: z.ZodNullable<z.ZodNumber>;
+    thread: z.ZodString;
+    labels: z.ZodRecord<z.ZodString, z.ZodString>;
+    noSync: z.ZodBoolean;
+    mentions: z.ZodArray<z.ZodString>;
+    by: z.ZodObject<{
+      actor: z.ZodString;
+      principal: z.ZodString;
+      profile: z.ZodNullable<z.ZodString>;
+      session: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    origin: z.ZodNullable<z.ZodObject<{
+      channel: z.ZodOptional<z.ZodString>;
+      thread: z.ZodString;
+      subthread: z.ZodNullable<z.ZodString>;
+      message: z.ZodString;
+      context: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    from: z.ZodNullable<z.ZodString>;
+    attachments: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      type: z.ZodString;
+      size: z.ZodNumber;
+    }, z.core.$strip>>>;
+    links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+      url: z.ZodString;
+      message: z.ZodNullable<z.ZodNumber>;
+      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>>;
+      unavailable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    schedule: z.ZodOptional<z.ZodObject<{
+      id: z.ZodNumber;
+      n: z.ZodNumber;
+    }, z.core.$strip>>;
+    blind: z.ZodOptional<z.ZodLiteral<true>>;
+    importedBy: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  /** A message's links changed: an edit linked something new, or the platform sent what a link says. */
+  'message.linked': z.ZodObject<{
+    id: z.ZodNumber;
+    thread: z.ZodString;
+    links: z.ZodArray<z.ZodObject<{
+      url: z.ZodString;
+      message: z.ZodNullable<z.ZodNumber>;
+      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>>;
+      unavailable: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    by: z.ZodObject<{
+      actor: z.ZodString;
+      principal: z.ZodString;
+      profile: z.ZodNullable<z.ZodString>;
+      session: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    from: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+  'message.edited': z.ZodObject<{
+    id: z.ZodNumber;
+    thread: z.ZodString;
+    text: z.ZodString;
+    mentions: z.ZodArray<z.ZodString>;
+    by: z.ZodObject<{
+      actor: z.ZodString;
+      principal: z.ZodString;
+      profile: z.ZodNullable<z.ZodString>;
+      session: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    from: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+  'message.deleted': z.ZodObject<{
+    id: z.ZodNumber;
+    thread: z.ZodString;
+    by: z.ZodObject<{
+      actor: z.ZodString;
+      principal: z.ZodString;
+      profile: z.ZodNullable<z.ZodString>;
+      session: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    from: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+  'reaction.added': z.ZodObject<{
+    id: z.ZodNumber;
+    thread: z.ZodString;
+    emoji: z.ZodString;
+    by: z.ZodObject<{
+      actor: z.ZodString;
+      principal: z.ZodString;
+      profile: z.ZodNullable<z.ZodString>;
+      session: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    from: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+  'reaction.removed': z.ZodObject<{
+    id: z.ZodNumber;
+    thread: z.ZodString;
+    emoji: z.ZodString;
+    by: z.ZodObject<{
+      actor: z.ZodString;
+      principal: z.ZodString;
+      profile: z.ZodNullable<z.ZodString>;
+      session: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+    from: z.ZodNullable<z.ZodString>;
+  }, z.core.$strip>;
+  'labels.changed': z.ZodObject<{
+    id: z.ZodNumber;
+    thread: z.ZodString;
+    set: z.ZodRecord<z.ZodString, z.ZodString>;
+    unset: z.ZodArray<z.ZodString>;
+    by: z.ZodObject<{
+      actor: z.ZodString;
+      principal: z.ZodString;
+      profile: z.ZodNullable<z.ZodString>;
+      session: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+  /** A thread is synced with an external channel (start a thread there) or thread (join it). */
+  'thread.synced': z.ZodObject<{
+    thread: z.ZodString;
+    target: z.ZodString;
+    cause: z.ZodEnum<{
+      config: "config";
+      request: "request";
+    }>;
+    kind: z.ZodOptional<z.ZodEnum<{
+      channel: "channel";
+      thread: "thread";
+    }>>;
+    by: z.ZodObject<{
+      actor: z.ZodString;
+      principal: z.ZodString;
+      profile: z.ZodNullable<z.ZodString>;
+      session: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+  /** An outbound delivery receipt: board message `id` exists on the platform as `external`. */
+  'message.synced': z.ZodObject<{
+    id: z.ZodNumber;
+    thread: z.ZodString;
+    target: z.ZodString;
+    external: z.ZodObject<{
+      thread: z.ZodString;
+      message: z.ZodString;
+      asUser: z.ZodOptional<z.ZodLiteral<true>>;
+    }, z.core.$strip>;
+    syncedBy: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  /**
+   * Board message `id`'s files reached `target` after its text: `files` are the
+   * platform's IDs for them, or null when the platform refused files and the
+   * text got a line for each instead.
+   */
+  'message.files_synced': z.ZodObject<{
+    id: z.ZodNumber;
+    thread: z.ZodString;
+    target: z.ZodString;
+    files: z.ZodNullable<z.ZodArray<z.ZodString>>;
+    syncedBy: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>;
+  /** A delivery that gave up: board message `id` didn't reach `target`, and `error` says why. */
+  'message.sync_failed': z.ZodObject<{
+    id: z.ZodNumber;
+    thread: z.ZodString;
+    target: z.ZodString;
+    error: z.ZodString;
+  }, z.core.$strip>;
+  'actor.seen': z.ZodObject<{
+    actor: z.ZodString;
+    kind: z.ZodUnion<readonly [z.ZodEnum<{
+      agent: "agent";
+      deployment: "deployment";
+      external: "external";
+      person: "person";
+      workflow: "workflow";
+    }>, z.ZodLiteral<"profile">]>;
+    handle: z.ZodString;
+    name: z.ZodString;
+    avatar: z.ZodNullable<z.ZodString>;
+    host: z.ZodOptional<z.ZodLiteral<true>>;
+  }, z.core.$strip>;
+  /**
+   * A platform actor (`slack:user:U0456`) is the same person as a principal
+   * (`vercel:user:…`): for display, `--by`, and mentions, never for permissions.
+   * `method` says how it was proved: a one-time code posted from that account,
+   * or the account's own sign-in (`consent`).
+   */
+  'actor.linked': z.ZodObject<{
+    actor: z.ZodString;
+    to: z.ZodString;
+    method: z.ZodEnum<{
+      code: "code";
+      consent: "consent";
+    }>;
+    by: z.ZodObject<{
+      actor: z.ZodString;
+      principal: z.ZodString;
+      profile: z.ZodNullable<z.ZodString>;
+      session: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+  'actor.unlinked': z.ZodObject<{
+    actor: z.ZodString;
+    by: z.ZodObject<{
+      actor: z.ZodString;
+      principal: z.ZodString;
+      profile: z.ZodNullable<z.ZodString>;
+      session: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>;
+  }, z.core.$strip>;
+};
+declare const BOARD_SESSION = "board";
+type BoardEvents = typeof boardEvents;
+/** One event of the board log, of type `K`: the shape A2 stores it in (its `ContractEvent`). */
+type BoardEvent<K extends keyof BoardEvents & string = keyof BoardEvents & string> = { [T in keyof BoardEvents & string]: {
+  id: string;
+  type: T;
+  payload: z.output<BoardEvents[T]>;
+  index: number;
+  sessionId: string;
+  createdAt: Date;
+}; }[K];
+//#endregion
+//#region src/contract/external.d.ts
+/** Where a message came from on a platform. `thread` is grouped (GitHub review threads fold into their PR). */
+declare const Origin: z.ZodObject<{
+  channel: z.ZodOptional<z.ZodString>;
+  thread: z.ZodString;
+  subthread: z.ZodNullable<z.ZodString>;
+  message: z.ZodString;
+  context: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * A platform message linked from a message (a Slack permalink): the board message
+ * it was synced to, if any, and a snapshot of it, or why the board couldn't read it.
+ */
+declare const Link: z.ZodObject<{
+  url: z.ZodString;
+  message: z.ZodNullable<z.ZodNumber>;
+  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>>;
+  unavailable: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+type Link = z.infer<typeof Link>;
+type Origin = z.infer<typeof Origin>;
+declare const ExternalAuthor: z.ZodObject<{
+  id: z.ZodString;
+  handle: z.ZodString;
+  name: z.ZodString;
+  avatar: z.ZodNullable<z.ZodString>;
+  isBot: z.ZodBoolean;
+}, z.core.$strip>;
+/**
+ * A file on a platform message, as Chat SDK describes it: enough for the
+ * platform's adapter to fetch it later (`rehydrateAttachment`), never the bytes.
+ */
+declare const ExternalFile: 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>;
+type ExternalFile = z.infer<typeof ExternalFile>;
+/**
+ * A platform message a platform message links to, at intake: where it lives
+ * (`thread`, with the sync key prefix, and `message`), and what it said when the
+ * platform sent that along (Slack's unfurl).
+ */
+declare const ExternalLink: 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>;
+type ExternalLink = z.infer<typeof ExternalLink>;
+/** A platform event, normalized at intake. Thread IDs are external IDs with the sync key prefix. */
+declare const ExternalEvent: 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">;
+type ExternalEvent = z.infer<typeof ExternalEvent>;
+type ExternalAuthor = z.infer<typeof ExternalAuthor>;
+//#endregion
+//#region src/contract/folds.d.ts
+type Message = {
+  id: number;
+  channel: string;
+  text: string;
+  re: number | null;
+  replyTo: number | null;
+  /** The thread key: the root's event ID. */
+  thread: string;
+  labels: Labels;
+  reactions: Record<string, string[]>;
+  mentions: string[];
+  by: Author;
+  noSync: boolean;
+  /** Where it came from on a platform, if it did. */
+  origin: Origin | null;
+  /** The sync key it came from, or null when written on the board. */
+  from: string | null;
+  createdAt: string;
+  editedAt: string | null;
+  deleted: boolean;
+  /** Sync targets this message didn't reach, with why. A later delivery clears its entry. */
+  undelivered: Record<string, string>;
+  attachments: Attachment[];
+  /** Platform messages it links to (Slack permalinks), each with what it said. */
+  links: Link[];
+  /** Set when a schedule posted it: the schedule's ID and which send this was, from 0. */
+  schedule?: {
+    id: number;
+    n: number;
+  };
+  /**
+   * Set when its author couldn't read its channel, as `authorizeOwn` checks: where they can't read,
+   * it's theirs to edit and delete only then. Its event's payload says so too.
+   */
+  blind?: true;
+  /** The index of the last event that changed it. Folds from before it existed leave it out. */
+  version?: number;
+};
+type MessagesState = {
+  byId: Record<string, Message>;
+  /** Thread root → reply IDs, in log order. */
+  replies: Record<string, number[]>;
+};
+type Channel = {
+  path: string;
+  lastIndex: number;
+  messages: number;
+  threads: number;
+};
+type ChannelsState = Record<string, Channel>;
+type Actor = {
+  id: string;
+  kind: ActorKind;
+  handle: string;
+  name: string;
+  avatar: string | null;
+  /** A host's principal, or one of its profiles: once it's seen as one, it stays one. Views leave it out. */
+  host?: true;
+};
+/** A platform actor proved to be a principal (`actor.linked`). */
+type ActorLink = {
+  to: string;
+  method: 'code' | 'consent';
+  at: string;
+};
+type ActorsState = {
+  byId: Record<string, Actor>;
+  /** Lowercased handle → actor IDs. Handles aren't reserved, so several can share one. */
+  byHandle: Record<string, string[]>;
+  /** Platform actor → the principal it's linked to. Display and filtering only, never permissions. */
+  links: Record<string, ActorLink>;
+};
+/** A copy of a board message on a platform. */
+/** `files`: the platform's IDs for the message's files, or null when it refused them; unset until they're sent. */
+/** `asUser`: posted with its author's own token, so editing or deleting it needs that token too. */
+/** `by`: the principal of the sync elsewhere that recorded it, whose copy it is to change; none for the board's own sync's. */
+type ExternalCopy = {
+  thread: string;
+  message: string;
+  files?: string[] | null;
+  asUser?: true;
+  by?: string;
+};
+type SyncedThread = {
+  root: number;
+  channel: string;
+  kinds?: Record<string, 'channel' | 'thread'>;
+  /** External channels (start a thread there) and threads (joined), in sync order. */
+  targets: string[];
+  /** Target → the external thread it resolved to. A thread target resolves to itself. */
+  external: Record<string, string>;
+};
+//#endregion
+export { BoardEvents as _, ExternalCopy as a, SyncedThread as c, ExternalFile as d, ExternalLink as f, BoardEvent as g, BOARD_SESSION as h, ChannelsState as i, ExternalAuthor as l, Origin as m, ActorsState as n, Message as o, Link as p, Channel as r, MessagesState as s, Actor as t, ExternalEvent as u };

package/dist/{reducers-mUPFuFJV.mjs → folds-Dyjput8M.mjs}

@@ -1,9 +1,8 @@
 import { b as actorKind } from "./schemas-Be08nyfW.mjs";
-import { f as boardContract, p as identityContract } from "./contract-CuJmlrhw.mjs";
+import { c as externalMessageKey, l as isThreadTarget } from "./external-BV_cUncs.mjs";
 import { t as canonicalEmoji } from "./emoji-CTLpvH-A.mjs";
 import { n as setOwn, t as own } from "./own-OwgPWdmh.mjs";
-import { reducer } from "experimental-a2";
-//#region src/contract/reducers.ts
+//#region src/contract/folds.ts
 const iso = (date) => typeof date === "string" ? date : date.toISOString();
 function foldMessages(state, event) {
 	const changed = foldMessage(state, event);
@@ -111,40 +110,6 @@ function foldMessage(state, event) {
 		default: return;
 	}
 }
-const messagesReducer = reducer({
-	contract: boardContract,
-	name: "board.messages.v5",
-	initialState: {
-		byId: {},
-		replies: {}
-	}
-}).fold(foldMessages);
-reducer({
-	contract: boardContract,
-	name: "board.posted.v1",
-	initialState: {}
-}).fold((state, event) => {
-	if (event.type === "message.posted") setOwn(state, event.id, event.index);
-	return state;
-});
-const channelsReducer = reducer({
-	contract: boardContract,
-	name: "board.channels.v1",
-	initialState: {}
-}).fold((state, event) => {
-	if (event.type !== "message.posted") return state;
-	const { channel, re } = event.payload;
-	const entry = own(state, channel) ?? setOwn(state, channel, {
-		path: channel,
-		lastIndex: 0,
-		messages: 0,
-		threads: 0
-	});
-	entry.lastIndex = event.index;
-	entry.messages += 1;
-	if (re === null) entry.threads += 1;
-	return state;
-});
 /** The principal an actor belongs to: its link, its own principal for a profile (`…+claude`), or itself. */
 function personOf(actors, actor) {
 	const linked = own(actors.links, actor)?.to;
@@ -189,18 +154,6 @@ function foldActors(state, event) {
 	if (!ids.includes(actor)) ids.push(actor);
 	return state;
 }
-const actorsReducer = reducer({
-	contract: boardContract,
-	name: "board.actors.v2",
-	initialState: {
-		byId: {},
-		byHandle: {},
-		links: {}
-	}
-}).fold(foldActors);
-/** `slack:C0123ABC:1727.1234` is a thread; `slack:C0123ABC` and `github:owner/repo` are channels. */
-const isThreadTarget = (target) => target.slice(target.indexOf(":") + 1).includes(":");
-const externalMessageKey = (thread, message) => `${thread}|${message}`;
 const addTarget = (thread, target) => {
 	if (!thread.targets.includes(target)) thread.targets.push(target);
 };
@@ -230,6 +183,7 @@ function foldSync(state, event) {
 				...payload.importedBy ? { by: payload.importedBy } : {}
 			});
 			state.byExternalMessage[externalMessageKey(precise, origin.message)] = event.index;
+			if (precise !== origin.thread) state.byExternalMessage[externalMessageKey(origin.thread, origin.message)] = event.index;
 			return state;
 		}
 		case "thread.synced": {
@@ -257,6 +211,8 @@ function foldSync(state, event) {
 			});
 			state.byExternalMessage[externalMessageKey(external.thread, external.message)] = id;
 			const thread = own(state.threads, event.payload.thread);
+			const main = thread ? own(thread.external, target) : void 0;
+			if (main && main !== external.thread) state.byExternalMessage[externalMessageKey(main, external.message)] = id;
 			if (thread && thread.root === id && ((thread.kinds && own(thread.kinds, target)) ?? (isThreadTarget(target) ? "thread" : "channel")) === "channel") {
 				setOwn(thread.external, target, external.thread);
 				setOwn(state.byExternalThread, external.thread, event.payload.thread);
@@ -266,28 +222,5 @@ function foldSync(state, event) {
 		default: return state;
 	}
 }
-const identityCodesReducer = reducer({
-	contract: identityContract,
-	name: "board.identity-codes.v1",
-	initialState: {}
-}).fold((state, event) => {
-	if (event.type === "identity.code_issued") {
-		const { hash, principal, sync, expiresAt } = event.payload;
-		state[hash] ??= {
-			principal,
-			sync,
-			expiresAt,
-			usedBy: null,
-			usedIn: null
-		};
-	} else if (event.type === "identity.code_used") {
-		const code = state[event.payload.hash];
-		if (code && code.usedBy === null) {
-			code.usedBy = event.payload.actor;
-			code.usedIn = event.payload.message ?? null;
-		}
-	}
-	return state;
-});
 //#endregion
-export { foldMessages as a, isThreadTarget as c, messagesReducer as d, personOf as f, foldActors as i, iso as l, channelsReducer as n, foldSync as o, externalMessageKey as r, identityCodesReducer as s, actorsReducer as t, linkedTo as u };
+export { linkedTo as a, iso as i, foldMessages as n, personOf as o, foldSync as r, foldActors as t };

package/dist/ids-C6AYo1bu.mjs

@@ -0,0 +1,31 @@
+//#region src/client/ids.ts
+const hex = (bytes) => Array.from(bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+/** SHA-256 of `text`, in hex. */
+async function sha256(text) {
+	return hex(new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(text))));
+}
+/**
+* A UUIDv8 from `parts`, exactly as A2's `idempotentId` makes one: the IDs a board derives for the
+* writes its own code makes, which no request may post with.
+*/
+async function derivedId(...parts) {
+	const bytes = new Uint8Array(await crypto.subtle.digest("SHA-256", new TextEncoder().encode(JSON.stringify(parts)))).slice(0, 16);
+	bytes[6] = bytes[6] & 15 | 128;
+	bytes[8] = bytes[8] & 63 | 128;
+	const text = hex(bytes);
+	return `${text.slice(0, 8)}-${text.slice(8, 12)}-${text.slice(12, 16)}-${text.slice(16, 20)}-${text.slice(20, 32)}`;
+}
+/** A derived ID's shape. */
+const DERIVED_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-8[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/;
+/**
+* A post's ID, from one derived for it, under `principal`: a board takes a `key:<principal>:` ID
+* only from that principal, so no one else can post with it first.
+*/
+const keyId = async (principal, derived) => `key:${principal}:${(await sha256(`board-key\u001f${derived}`)).slice(0, 32)}`;
+/**
+* Whether `id` is exactly the shape `keyId` makes for `principal`. A prefix check isn't enough:
+* a principal's ID can be the start of another's (`oidc:gitlab.com:acme` and `oidc:gitlab.com:acme:ci`).
+*/
+const isKeyIdOf = (id, principal) => id.startsWith(`key:${principal}:`) && /^[0-9a-f]{32}$/.test(id.slice(`key:${principal}:`.length));
+//#endregion
+export { sha256 as a, keyId as i, derivedId as n, isKeyIdOf as r, DERIVED_ID as t };