letagents 0.12.34 → 0.12.36

package/shared/code-highlighting.mjs

@@ -0,0 +1,345 @@
+export const CANONICAL_LANGUAGES = Object.freeze([
+  'javascript',
+  'typescript',
+  'python',
+  'bash',
+  'json',
+  'yaml',
+  'xml',
+  'css',
+  'sql',
+  'diff',
+  'rust',
+  'go',
+  'c',
+  'cpp',
+  'java',
+  'csharp',
+  'dockerfile',
+  'ruby',
+  'php',
+  'swift',
+  'kotlin',
+  'ini',
+]);
+
+const CANONICAL_SET = new Set(CANONICAL_LANGUAGES);
+
+export const LANGUAGE_ALIASES = new Map([
+  // JavaScript
+  ['js', 'javascript'],
+  ['jsx', 'javascript'],
+  ['mjs', 'javascript'],
+  ['cjs', 'javascript'],
+  // TypeScript
+  ['ts', 'typescript'],
+  ['tsx', 'typescript'],
+  ['mts', 'typescript'],
+  ['cts', 'typescript'],
+  // Python
+  ['py', 'python'],
+  // Bash / Shell
+  ['sh', 'bash'],
+  ['zsh', 'bash'],
+  ['shell', 'bash'],
+  // YAML
+  ['yml', 'yaml'],
+  // XML / HTML / SVG
+  ['html', 'xml'],
+  ['xhtml', 'xml'],
+  ['svg', 'xml'],
+  // Rust
+  ['rs', 'rust'],
+  // Go
+  ['golang', 'go'],
+  // C / C++
+  ['c++', 'cpp'],
+  ['cc', 'cpp'],
+  ['cxx', 'cpp'],
+  ['hpp', 'cpp'],
+  ['h', 'c'],
+  // C#
+  ['cs', 'csharp'],
+  // Dockerfile
+  ['docker', 'dockerfile'],
+  // Ruby
+  ['rb', 'ruby'],
+  // Kotlin
+  ['kt', 'kotlin'],
+  ['kts', 'kotlin'],
+  // INI / TOML
+  ['toml', 'ini'],
+]);
+
+export const MAX_HIGHLIGHT_CHARS = 5_000;
+export const MAX_HIGHLIGHT_LINES = 250;
+export const MAX_HIGHLIGHT_LINE_LENGTH = 1_000;
+export const MAX_CACHE_ENTRIES = 500;
+export const MAX_CACHE_CHARS = 2_000_000;
+
+export const DEFAULT_TIME_BUDGET_MS = 250;
+export const DEFAULT_TIME_WINDOW_MS = 1_000;
+
+export function escapeHtml(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;');
+}
+
+export function escapeAttribute(value) {
+  return String(value ?? '')
+    .replace(/&/g, '&amp;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&#39;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+export function resolveLanguage(rawTag) {
+  if (!rawTag || typeof rawTag !== 'string') return null;
+  const normalized = rawTag.trim().toLowerCase();
+  if (!normalized) return null;
+
+  if (CANONICAL_SET.has(normalized)) {
+    return {
+      canonical: normalized,
+      label: normalized,
+    };
+  }
+
+  const aliasTarget = LANGUAGE_ALIASES.get(normalized);
+  if (aliasTarget && CANONICAL_SET.has(aliasTarget)) {
+    return {
+      canonical: aliasTarget,
+      label: normalized,
+    };
+  }
+
+  return null;
+}
+
+export class CodeHighlightCache {
+  constructor(maxEntries = MAX_CACHE_ENTRIES, maxChars = MAX_CACHE_CHARS) {
+    this.maxEntries = maxEntries;
+    this.maxChars = maxChars;
+    this.map = new Map();
+    this.currentChars = 0;
+  }
+
+  get(key) {
+    if (!this.map.has(key)) return undefined;
+    const value = this.map.get(key);
+    this.map.delete(key);
+    this.map.set(key, value);
+    return value;
+  }
+
+  set(key, value) {
+    const entryChars = key.length + value.length;
+    if (this.map.has(key)) {
+      const oldVal = this.map.get(key);
+      this.currentChars -= (key.length + oldVal.length);
+      this.map.delete(key);
+    }
+    this.currentChars += entryChars;
+    this.map.set(key, value);
+    while (this.map.size > this.maxEntries || this.currentChars > this.maxChars) {
+      const oldestKey = this.map.keys().next().value;
+      if (oldestKey === undefined) break;
+      const oldestVal = this.map.get(oldestKey);
+      this.currentChars -= (oldestKey.length + oldestVal.length);
+      this.map.delete(oldestKey);
+    }
+  }
+
+  clear() {
+    this.map.clear();
+    this.currentChars = 0;
+  }
+
+  get size() {
+    return this.map.size;
+  }
+
+  get totalChars() {
+    return this.currentChars;
+  }
+}
+
+export function createCodeHighlighter(options) {
+  const highlight = options?.highlight;
+  const now = options?.now ?? (() => (typeof performance !== 'undefined' ? performance.now() : Date.now()));
+  const maxBudgetMs = options?.maxBudgetMs ?? DEFAULT_TIME_BUDGET_MS;
+  const windowMs = options?.windowMs ?? DEFAULT_TIME_WINDOW_MS;
+
+  const cache = new CodeHighlightCache();
+
+  // Sliding window execution time tracker
+  // Worst-case main-thread freeze per second:
+  // An attacker sending 200 distinct worst-case blocks in a single message can trigger
+  // at most one block that starts when spentTime < 250ms (e.g. at 249ms plus one block
+  // taking ~60ms), bounding synchronous computation to ~310ms per 1,000ms sliding window.
+  // Once the 250ms budget is reached, subsequent blocks in that window immediately
+  // fall back to plain escaped text (<0.01ms each) without caching the fallback.
+  const budgetEntries = [];
+
+  function getSpentTime(currentTime) {
+    const cutoff = currentTime - windowMs;
+    while (budgetEntries.length > 0 && budgetEntries[0].timestamp <= cutoff) {
+      budgetEntries.shift();
+    }
+    let total = 0;
+    for (let i = 0; i < budgetEntries.length; i++) {
+      total += budgetEntries[i].duration;
+    }
+    return total;
+  }
+
+  function renderCodeBlock(code, rawTag) {
+    const resolved = resolveLanguage(rawTag);
+    const codeString = String(code ?? '');
+
+    let exceedsSize = codeString.length > MAX_HIGHLIGHT_CHARS;
+    if (!exceedsSize) {
+      let lineCount = 1;
+      let currentLineLen = 0;
+      for (let i = 0; i < codeString.length; i++) {
+        const ch = codeString.charCodeAt(i);
+        if (ch === 10) {
+          lineCount++;
+          if (lineCount > MAX_HIGHLIGHT_LINES) {
+            exceedsSize = true;
+            break;
+          }
+          currentLineLen = 0;
+        } else {
+          currentLineLen++;
+          if (currentLineLen > MAX_HIGHLIGHT_LINE_LENGTH) {
+            exceedsSize = true;
+            break;
+          }
+        }
+      }
+    }
+
+    let codeHtml;
+    if (!resolved || exceedsSize || typeof highlight !== 'function') {
+      codeHtml = escapeHtml(codeString);
+    } else {
+      const cacheKey = `${resolved.canonical}:${codeString}`;
+      const cached = cache.get(cacheKey);
+      if (cached !== undefined) {
+        // Cache hit: costs nothing against the sliding time budget
+        codeHtml = cached;
+      } else {
+        const currentTime = now();
+        const spent = getSpentTime(currentTime);
+        if (spent >= maxBudgetMs) {
+          // Budget exhausted: fall back to plain escaped text, do NOT cache
+          codeHtml = escapeHtml(codeString);
+        } else {
+          const t0 = now();
+          try {
+            const highlighted = highlight(codeString, resolved.canonical);
+            codeHtml = typeof highlighted === 'string' ? highlighted : escapeHtml(codeString);
+          } catch {
+            codeHtml = escapeHtml(codeString);
+          }
+          const t1 = now();
+          const duration = Math.max(0, t1 - t0);
+          budgetEntries.push({ timestamp: t0, duration });
+          cache.set(cacheKey, codeHtml);
+        }
+      }
+    }
+
+    const headerContent = resolved
+      ? `<span class="fenced-code-block-lang" data-lang="${escapeAttribute(resolved.label)}"></span><button type="button" class="fenced-code-block-copy" data-code-copy aria-label="Copy code"></button>`
+      : `<button type="button" class="fenced-code-block-copy" data-code-copy aria-label="Copy code"></button>`;
+
+    const langClass = resolved ? ` language-${escapeAttribute(resolved.label)}` : '';
+
+    return `<div class="fenced-code-block"><div class="fenced-code-block-header">${headerContent}</div><pre><code class="fenced-code-block-content${langClass}">${codeHtml}</code></pre></div>`;
+  }
+
+  return {
+    renderCodeBlock,
+    cache,
+    resolveLanguage,
+  };
+}
+
+export async function executeCodeBlockCopy(button, textToCopy, copyFn, copyTimers = new WeakMap()) {
+  let success = false;
+  if (textToCopy !== null && typeof textToCopy === 'string') {
+    try {
+      success = Boolean(await copyFn(textToCopy));
+    } catch {
+      success = false;
+    }
+  }
+
+  // Clear previous timer AFTER the await to avoid timer races on rapid clicks
+  const prevTimer = copyTimers.get(button);
+  if (prevTimer !== undefined) {
+    clearTimeout(prevTimer);
+    copyTimers.delete(button);
+  }
+
+  if (!button.isConnected) return { success, timerId: null };
+
+  if (success) {
+    button.setAttribute('data-copied', 'true');
+    button.setAttribute('aria-label', 'Copied to clipboard');
+  } else {
+    button.setAttribute('data-copied', 'error');
+    button.setAttribute('aria-label', 'Failed to copy to clipboard');
+  }
+
+  const timerId = setTimeout(() => {
+    if (copyTimers.get(button) === timerId) {
+      copyTimers.delete(button);
+    }
+    if (button.isConnected) {
+      button.removeAttribute('data-copied');
+      button.setAttribute('aria-label', 'Copy code');
+    }
+  }, 2000);
+
+  copyTimers.set(button, timerId);
+  return { success, timerId };
+}
+
+export function setupCodeBlockCopyListener(copyFn) {
+  if (typeof document === 'undefined') return () => {};
+
+  const copyTimers = new WeakMap();
+
+  async function handleCopyClick(event) {
+    const target = event?.target;
+    const button = target && typeof target.closest === 'function' ? target.closest('[data-code-copy]') : null;
+    if (!button) return;
+
+    // Prevent default button actions, but do NOT stop propagation so outside-click
+    // listeners (e.g. popover dismissal) still see the event.
+    event.preventDefault();
+
+    const container = button.closest('.fenced-code-block');
+    const codeEl = container?.querySelector('pre code.fenced-code-block-content') || container?.querySelector('code');
+    if (!codeEl) {
+      await executeCodeBlockCopy(button, null, copyFn, copyTimers);
+      return;
+    }
+
+    const textToCopy = codeEl.textContent ?? '';
+    await executeCodeBlockCopy(button, textToCopy, copyFn, copyTimers);
+  }
+
+  document.addEventListener('click', handleCopyClick, true);
+  return () => {
+    document.removeEventListener('click', handleCopyClick, true);
+  };
+}

package/shared/codex-owner-isolation.mjs

@@ -9,8 +9,10 @@ import { join, parse } from "node:path";
 // The owner's config, auth and session history are not modified, and the
 // project's own skills and AGENTS.md still load. Codex has no launch switch
 // for its global AGENTS.md or its saved command rules, so those still reach
-// the agent. Shared by the desktop and the published MCP package, so it uses
-// nothing but Node.
+// the agent. A matching saved rule lets a command out of Codex's sandbox, so
+// the desktop gives an agent at a sandboxed access level a Codex home that has
+// none (codex-agent-home.ts). Shared by the desktop and the published MCP
+// package, so it uses nothing but Node.
 
 /** Plugins (with their MCP servers and skills), app connectors, computer and browser use, hooks, memories, notifier. */
 export const CODEX_OWNER_FEATURE_OVERRIDES = Object.freeze([
@@ -188,7 +190,7 @@ export function assertProjectKeepsLetAgentsServer(inProject, outsideProject) {
 /**
  * Every override a LetAgents launch adds: the features, each personal skill,
  * and every MCP server but LetAgents. `cwd` is where the app-server starts and
- * `configOverrides` are the launch's own (for example project trust), used to
+ * `configOverrides` are the launch's own (for example the room's server), used to
  * list servers as the launch will see them. A launch that cannot list its
  * servers, or whose project changes the LetAgents server, fails here.
  */

package/shared/codex-read-only-room-tools.d.mts

@@ -0,0 +1,2 @@
+/** The room tools a Read-only Codex agent may use; every other room tool is refused for it. */
+export const CODEX_READ_ONLY_ROOM_TOOLS: ReadonlySet<string>;

package/shared/codex-read-only-room-tools.mjs

@@ -0,0 +1,24 @@
+/**
+ * The room tools a Read-only Codex agent may use, and the only ones.
+ *
+ * These read what the room says, and say something in it: a message, a
+ * status, visible reasoning, a question for a person, and where the final
+ * answer goes. Each takes room identifiers and text, never a folder. None
+ * changes the task board, joins or creates a room, submits a review, saves
+ * room memory, sets a wake rule, or inspects or writes a repository on this
+ * Mac. A tool is allowed only by being named here, so one the room server
+ * gains later is refused until someone decides about it.
+ *
+ * Two places keep the list, and both read it from here. Codex is told to run
+ * these without asking and to refuse the others, since a Read-only agent has
+ * nobody to ask. The background service refuses the others itself, where
+ * every room tool call of such an agent passes, so the limit does not rest on
+ * what Codex does with an approval mode.
+ */
+export const CODEX_READ_ONLY_ROOM_TOOLS = new Set([
+  // What the room says.
+  "read_messages", "get_current_room", "get_room_guidelines", "get_room_memory", "get_human_requests",
+  "get_board", "get_board_settings", "list_board_intents", "list_wake_rules", "get_room_artifacts", "get_room_events",
+  // What the agent says in it.
+  "send_message", "send_thread_message", "post_status", "post_reasoning", "request_human_input", "set_reply_thread",
+]);

package/shared/mcp-workspace-capture-worker.mjs

@@ -12,7 +12,8 @@ try {
   if (workerData.operation === 'begin') {
     parentPort.postMessage({ baseline: await captureWorkspaceTree(capture.workspace, identity) });
   } else {
-    const pair = await captureWorkspacePair(capture.workspace, capture.base_revision, capture.baseline, `${identity}:${capture.preparation_id}`);
+    // The starting snapshot was taken on `base_revision`. With what the remotes held then, it tells a base update from the work.
+    const pair = await captureWorkspacePair(capture.workspace, capture.base_revision, capture.baseline, `${identity}:${capture.preparation_id}`, capture.base_revision, workerData.remoteTips ?? null);
     pair.contribution.summary = text;
     const { review, ...preview } = pair;
     const summary = { version: 3, recorded_state: 'completed', evidence_incomplete: true, elapsed_ms: null,

package/shared/message-link-preview-store.d.mts

@@ -0,0 +1,10 @@
+import type { LinkPreviewReference, MessageLinkPreview, MessageLinkPreviewsResponse } from "./message-link-previews.mjs";
+export function createMessageLinkPreviewStore(options: {
+  load(references: LinkPreviewReference[]): Promise<MessageLinkPreviewsResponse>;
+  onChange?(): void; refreshDelayMs?: number;
+}): {
+  track(message: { id: string; references: LinkPreviewReference[] }): () => void;
+  get(messageId: string): MessageLinkPreview[];
+  refresh(): Promise<void>;
+  reset(): void;
+};

package/shared/message-link-preview-store.mjs

@@ -0,0 +1,77 @@
+import { LINK_PREVIEW_BATCH_LIMIT, linkPreviewKey } from "./message-link-previews.mjs";
+
+/** Separate from messages: one bounded read chain for the references rendered in a room. */
+export function createMessageLinkPreviewStore({ load, onChange, refreshDelayMs = 50 }) {
+  let epoch = 0;
+  let tracked = new Map();
+  let previews = new Map();
+  let timer = null;
+  let reading = null;
+  function schedule() {
+    if (timer !== null) return;
+    timer = setTimeout(() => { timer = null; void refresh(); }, refreshDelayMs);
+  }
+  function track(message) {
+    if (!message.references.length) return () => {};
+    const token = Symbol();
+    tracked.set(token, message);
+    onChange?.();
+    if (message.references.some((ref) => !previews.has(linkPreviewKey(ref)))) schedule();
+    return () => {
+      tracked.delete(token);
+      const used = new Set([...tracked.values()].flatMap((entry) => entry.references.map(linkPreviewKey)));
+      for (const key of previews.keys()) if (!used.has(key)) previews.delete(key);
+    };
+  }
+  function get(messageId) {
+    const message = [...tracked.values()].find((entry) => entry.id === messageId);
+    return (message?.references ?? []).flatMap((ref) => previews.get(linkPreviewKey(ref)) ?? []);
+  }
+  function refresh() {
+    if (timer !== null) clearTimeout(timer);
+    timer = null;
+    if (reading) { reading.again = true; return reading.promise; }
+    const startedIn = epoch;
+    const cycle = { again: false, promise: null };
+    reading = cycle;
+    cycle.promise = (async () => {
+      do {
+        cycle.again = false;
+        const unique = new Map([...tracked.values()].flatMap((entry) => entry.references.map((ref) => [linkPreviewKey(ref), ref])));
+        const references = [...unique.values()];
+        for (let i = 0; i < references.length; i += LINK_PREVIEW_BATCH_LIMIT) {
+          if (startedIn !== epoch) return;
+          const batch = references.slice(i, i + LINK_PREVIEW_BATCH_LIMIT);
+          try {
+            const result = await load(batch);
+            if (startedIn !== epoch) return;
+            const values = new Map(result.previews.map((preview) => [linkPreviewKey(preview), preview]));
+            let changed = false;
+            const used = new Set([...tracked.values()].flatMap((entry) => entry.references.map(linkPreviewKey)));
+            for (const ref of batch) {
+              const key = linkPreviewKey(ref);
+              if (!used.has(key)) continue;
+              const next = values.get(key) ?? null;
+              if (JSON.stringify(previews.get(key) ?? null) !== JSON.stringify(next)) changed = true;
+              previews.set(key, next);
+            }
+            if (changed) onChange?.();
+          } catch {
+            // Retry on the next stream update, reconnect or registration.
+          }
+        }
+      } while (cycle.again && startedIn === epoch);
+    })().finally(() => { if (reading === cycle) reading = null; });
+    return cycle.promise;
+  }
+  function reset() {
+    epoch++;
+    if (timer !== null) clearTimeout(timer);
+    timer = null;
+    reading = null;
+    tracked = new Map();
+    previews = new Map();
+    onChange?.();
+  }
+  return { track, get, refresh, reset };
+}

package/shared/message-link-previews.d.mts

@@ -0,0 +1,17 @@
+export const LINK_PREVIEW_BATCH_LIMIT: 50;
+export const LINK_PREVIEW_MESSAGE_LIMIT: 3;
+export interface LinkPreviewReference { kind: "pull" | "issue"; number: number }
+export interface GitHubLinkReference extends LinkPreviewReference { repository: string; url: string }
+export interface MessageLinkPreview extends GitHubLinkReference { title: string; state: "merged" | "closed" | "draft" | "open" }
+export interface MessageLinkPreviewsResponse { room_id: string; previews: MessageLinkPreview[]; available?: boolean }
+export function parseGitHubLinkReference(value: unknown): GitHubLinkReference | null;
+export function excludeGitHubEventLink(urls: readonly string[], eventUrl: string | null | undefined): string[];
+export function normalizePreviewRepository(value: unknown): string | null;
+export function linkPreviewKey(reference: LinkPreviewReference): string;
+export function parseLinkPreviewReferences(value: unknown): LinkPreviewReference[] | null;
+export function eligibleLinkPreviewReferences(urls: readonly string[], repository: string | null): LinkPreviewReference[];
+export function linkPreviewState(state: unknown, metadata?: { merged?: unknown; draft?: unknown } | null): MessageLinkPreview["state"] | null;
+export function linkPreviewPresentation(preview: MessageLinkPreview): {
+  kind: "pull-request" | "issue"; kindLabel: string; tone: "emerald" | "slate" | "amber" | "violet";
+  statusLabel: string; headline: string; detail: null; repository: string; taskId: null; url: string; urlLabel: string;
+};

package/shared/message-link-previews.mjs

@@ -0,0 +1,76 @@
+export const LINK_PREVIEW_BATCH_LIMIT = 50;
+export const LINK_PREVIEW_MESSAGE_LIMIT = 3;
+
+export function parseGitHubLinkReference(value) {
+  if (typeof value !== "string" || value.length > 2048) return null;
+  try {
+    const url = new URL(value);
+    if (url.protocol !== "https:" || url.hostname !== "github.com" || url.port || url.username || url.password) return null;
+    const match = /^\/([\w.-]+)\/([\w.-]+)\/(pull|issues)\/([1-9]\d*)\/?$/.exec(url.pathname);
+    if (!match) return null;
+    const number = Number(match[4]);
+    if (!Number.isSafeInteger(number)) return null;
+    const repository = `${match[1]}/${match[2]}`.toLowerCase();
+    const kind = match[3] === "pull" ? "pull" : "issue";
+    return { repository, kind, number, url: `https://github.com/${repository}/${match[3]}/${number}` };
+  } catch { return null; }
+}
+
+/** The event card already represents its main PR/issue; keep any other links. */
+export function excludeGitHubEventLink(urls, eventUrl) {
+  const represented = parseGitHubLinkReference(eventUrl);
+  return urls.filter(url => !represented || parseGitHubLinkReference(url)?.url !== represented.url);
+}
+
+export function normalizePreviewRepository(value) {
+  if (typeof value !== "string") return null;
+  const name = value.replace(/^https:\/\//i, "").replace(/^github\.com\//i, "").replace(/\/$/, "");
+  return /^[\w.-]+\/[\w.-]+$/.test(name) ? name.toLowerCase() : null;
+}
+
+export function linkPreviewKey(reference) { return `${reference.kind}:${reference.number}`; }
+
+export function parseLinkPreviewReferences(value) {
+  if (!Array.isArray(value) || value.length > LINK_PREVIEW_BATCH_LIMIT) return null;
+  const references = new Map();
+  for (const ref of value) {
+    if (!ref || typeof ref !== "object" || Object.keys(ref).length !== 2
+      || !["pull", "issue"].includes(ref.kind) || !Number.isSafeInteger(ref.number) || ref.number <= 0) return null;
+    references.set(linkPreviewKey(ref), { kind: ref.kind, number: ref.number });
+  }
+  return [...references.values()];
+}
+
+export function eligibleLinkPreviewReferences(urls, repository) {
+  const repo = normalizePreviewRepository(repository);
+  if (!repo) return [];
+  const refs = new Map();
+  for (const url of urls) {
+    const ref = parseGitHubLinkReference(url);
+    if (!ref || ref.repository !== repo) continue;
+    refs.set(linkPreviewKey(ref), { kind: ref.kind, number: ref.number });
+    if (refs.size === LINK_PREVIEW_MESSAGE_LIMIT) break;
+  }
+  return [...refs.values()];
+}
+
+/** State is a last-observed snapshot, never a request to GitHub. */
+export function linkPreviewState(state, metadata) {
+  if (state === "merged" || metadata?.merged === true) return "merged";
+  if (state === "closed") return "closed";
+  if (state === "draft" || state === "open" && metadata?.draft === true) return "draft";
+  return state === "open" ? "open" : null;
+}
+
+export function linkPreviewPresentation(preview) {
+  const pull = preview.kind === "pull";
+  return {
+    kind: pull ? "pull-request" : "issue",
+    kindLabel: pull ? "Pull request" : "Issue",
+    tone: preview.state === "merged" ? "emerald" : preview.state === "closed" ? "slate" : preview.state === "draft" ? "amber" : "violet",
+    statusLabel: preview.state,
+    headline: `#${preview.number} ${preview.title}`,
+    detail: null, repository: preview.repository, taskId: null,
+    url: preview.url, urlLabel: pull ? "Open pull request" : "Open issue",
+  };
+}

package/shared/message-pin-store.d.mts

@@ -0,0 +1,20 @@
+import type { MessagePin, MessagePinsResponse } from "./message-pins.mjs";
+export interface MessagePinState {
+  pins: MessagePin[];
+  available: boolean;
+  loading: boolean;
+  pending: string | null;
+  error: string | null;
+}
+export function createMessagePinStore<Context>(options: {
+  load(context: Context): Promise<MessagePinsResponse>;
+  mutate(context: Context, messageId: string, pinned: boolean): Promise<unknown>;
+  onChange?(state: MessagePinState): void;
+  onError?(message: string): void;
+}): {
+  readonly state: MessagePinState;
+  reset(context?: Context | null): void;
+  refresh(): Promise<unknown>;
+  setPinned(messageId: string, pinned: boolean): Promise<unknown>;
+  dispose(): void;
+};