@dev.fast/whiteboard 0.0.0-stage → 0.2.1-preview.20261005.98

package/dist/sharing/index.d.ts

@@ -0,0 +1,1977 @@
+import { z } from "zod";
+import { watch } from "node:fs";
+import { DatabaseSync } from "node:sqlite";
+//#region ../json/src/json.d.ts
+/**
+ * JSON values as they come off the wire or out of a file. Parse into one of
+ * these at the I/O boundary, then narrow into a domain type; never carry an
+ * `unknown`-valued dictionary past the boundary.
+ */
+type JsonPrimitive = string | number | boolean | null;
+type JsonValue = JsonPrimitive | JsonArray | JsonObject;
+type JsonArray = JsonValue[];
+type JsonObject = {
+  [key: string]: JsonValue;
+};
+//#endregion
+//#region ../review-share-protocol/src/index.d.ts
+declare const shareManifestSchema: z.ZodObject<{
+  format: z.ZodLiteral<"review-share/1">;
+  reviewId: z.ZodString;
+  version: z.ZodNumber;
+  title: z.ZodString;
+  snapshot: z.ZodString;
+  presentation: z.ZodString;
+  objects: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    size: z.ZodNumber;
+    sha256: z.ZodString;
+  }, z.core.$strict>>;
+  resources: z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    kind: z.ZodEnum<{
+      map: "map";
+      image: "image";
+      trace: "trace";
+    }>;
+    mimeType: z.ZodEnum<{
+      "image/png": "image/png";
+      "application/json": "application/json";
+    }>;
+    object: z.ZodString;
+  }, z.core.$strict>>;
+  repository: z.ZodOptional<z.ZodObject<{
+    cloneUrl: z.ZodString;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type ShareManifest = z.infer<typeof shareManifestSchema>;
+//#endregion
+//#region ../local-vcs/src/vcs.d.ts
+interface LocalVcsDiffFileSummary {
+  path: string;
+  previousPath?: string;
+  status: "added" | "modified" | "deleted" | "renamed";
+  additions: number;
+  deletions: number;
+  /** Git reports no line counts for this file's contents. */
+  binary?: true;
+}
+interface LocalVcsCommitSummary {
+  commit: string;
+  parentCommit: string;
+  subject: string;
+  author: string;
+  authoredAt: string;
+  fileCount: number;
+  additions: number;
+  deletions: number;
+}
+//#endregion
+//#region ../../node_modules/@dev.fast/diffr/dist/contract.d.ts
+/** A pairing always has at least one side; additions/deletions omit the other. */
+type StructuralPairing<T> = {
+  lhs: T;
+  rhs: T;
+} | {
+  lhs: T;
+  rhs?: never;
+} | {
+  rhs: T;
+  lhs?: never;
+};
+type StructuralDiffEvent = {
+  type: "start";
+  version: number;
+  lhs: StructuralSnapshot;
+  rhs: StructuralSnapshot;
+  files: StructuralFileChange[];
+} | ({
+  type: "file";
+  file: StructuralPairing<StructuralFileRef>;
+  visibility?: StructuralVisibility;
+} & StructuralOutcome) | {
+  type: "annotations";
+  file: StructuralPairing<StructuralFileRef>;
+  annotations: {
+    region_id: number;
+    label: string;
+  }[];
+  error?: StructuralProblem;
+} | {
+  type: "complete";
+  succeeded: number;
+  failed: number;
+  aborted?: StructuralProblem;
+};
+/** A file record contains exactly one result or error. */
+type StructuralOutcome = {
+  diff: StructuralDiff;
+  error?: never;
+} | {
+  error: StructuralProblem;
+  diff?: never;
+};
+type StructuralSnapshot = {
+  type: "revision";
+  rev: string;
+} | {
+  type: "index";
+} | {
+  type: "working_tree";
+} | {
+  type: "empty_tree";
+} | {
+  type: "path";
+  path: string;
+};
+type StructuralProblem = {
+  code: string;
+  message: string;
+};
+type StructuralFileChange = {
+  file: StructuralPairing<StructuralFileRef>;
+  status: StructuralFileStatus;
+  tags?: string[];
+};
+type StructuralFileStatus = "added" | "deleted" | "modified" | "renamed" | "copied" | "type_changed";
+type StructuralFileRef = {
+  path: string;
+  oid: string;
+  mode: string;
+};
+type StructuralVisibility = {
+  collapsed?: boolean;
+  label?: string;
+};
+/** Structural changed lines, independent of presentation and fold state. */
+type StructuralChanges = {
+  base: [number, number][];
+  head: [number, number][];
+};
+type StructuralDiff = ({
+  type: "text";
+  stats: StructuralStats;
+  structural_changes: StructuralChanges;
+} & StructuralPairing<StructuralSource>) | ({
+  type: "binary";
+} & StructuralPairing<StructuralBinaryRef>);
+type StructuralSource = {
+  text: string;
+  syntax?: StructuralSyntaxSpan[];
+  regions?: StructuralRegion[];
+};
+type StructuralBinaryRef = {
+  size: number;
+};
+type StructuralSyntaxSpan = {
+  line: number;
+  start_column: number;
+  end_column: number;
+  capture: string;
+};
+/** Region identity, collapse identity, and leaf alignment identity are distinct. */
+type StructuralRegion = {
+  id: number;
+  fold_state_id: number;
+  tags?: string[];
+  visibility?: StructuralVisibility;
+} & StructuralSourceRange & StructuralNode;
+type StructuralNode = {
+  kind: "leaf";
+  alignment_id: number;
+  changed?: StructuralSpan[];
+} | {
+  kind: "fold";
+  children: StructuralRegion[];
+};
+type StructuralSpan = {
+  line: number;
+  start_column: number;
+  end_column: number;
+};
+type StructuralSourceRange = {
+  start: StructuralPos;
+  end: StructuralPos;
+};
+type StructuralPos = {
+  line: number;
+  column: number;
+};
+type StructuralStats = {
+  textual: StructuralLineCounts;
+  visible: StructuralLineCounts;
+  fallback?: StructuralProblem;
+};
+type StructuralLineCounts = {
+  added: number;
+  removed: number;
+};
+//#endregion
+//#region ../review-protocol/src/review-api-client.d.ts
+/** List metadata for the authenticated local catalog; document contents stay in snapshots. */
+interface ReviewApiSummary {
+  reviewId: string;
+  version: number;
+  title: string;
+  /** Absent for a review. The one scratchpad has no pins or lifecycle. */
+  kind?: "scratchpad";
+  /** What is on the scratchpad, for its Home card; absent for a review. */
+  contents?: {
+    blocks: number;
+    diagrams: number;
+  };
+  /** Absent for a document whose references all carry their own pins. */
+  pins?: {
+    repositoryId: string;
+    base: string;
+    head: string;
+    worktreeRevision?: string;
+  };
+  target?: {
+    kind: "worktree";
+    repositoryId: string;
+    base?: string;
+  } | {
+    kind: "commits";
+    repositoryId: string;
+    head: string;
+    base?: string;
+  };
+  createdAt: string;
+  /** Timestamp of the earliest retained review version, when known. */
+  firstCreatedAt?: string;
+  /** Present on reviews imported from the legacy MDX store. */
+  origin?: {
+    branch?: string;
+    baseRef?: string;
+    pullRequestNumber?: number;
+    pullRequestUrl?: string;
+    revision?: string;
+  };
+  /** Shared imports have separate local checkouts but retain their remote identity. */
+  shared?: {
+    cloneUrl?: string;
+  };
+  /** Display grouping only; source pins remain bound to their own checkout. */
+  repositoryGroup?: {
+    key: string;
+    label: string;
+  };
+  repositoryName: string;
+  repositoryPath?: string;
+  diffStats?: {
+    fileCount: number;
+    additions: number;
+    deletions: number;
+  } | null;
+  viewedAt: string | null;
+  dismissedAt: string | null;
+  /** An agent holds a live lease; absent on shared reviews. */
+  working?: boolean;
+}
+interface ReviewSourceEntry {
+  path: string;
+  kind: "file" | "directory";
+}
+//#endregion
+//#region ../review-protocol/src/contracts.d.ts
+/** Workspace attachment identity is independent of the displayed source generation. */
+interface ReviewLanguageEnvironment {
+  /** Absent for a caller on another machine. */
+  readonly rootPath?: string | null;
+  readonly identity: string;
+  /** Present only when the language checkout is unavailable, not while preparing. */
+  readonly issue?: string;
+}
+//#endregion
+//#region src/source.d.ts
+/** The repository and commits one source reference was read from. A
+ * reference without pins resolves against its document's pins; one with
+ * pins names them itself, so a document can quote several repositories or
+ * commits. `base` is only needed by references to the base side. */
+declare const sourcePinsSchema: z.ZodObject<{
+  repositoryId: z.ZodString;
+  head: z.ZodString;
+  base: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type SourcePins = z.infer<typeof sourcePinsSchema>;
+/** Internal coordinates for reading one revision or storing resolved coverage.
+ * Authored document attachments use DiffSelection instead. */
+declare const fileLineRangeSchema: z.ZodObject<{
+  side: z.ZodDefault<z.ZodEnum<{
+    head: "head";
+    base: "base";
+  }>>;
+  file: z.ZodString;
+  fromLine: z.ZodNumber;
+  toLine: z.ZodNumber;
+  pins: z.ZodOptional<z.ZodObject<{
+    repositoryId: z.ZodString;
+    head: z.ZodString;
+    base: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type FileLineRange = z.infer<typeof fileLineRangeSchema>;
+//#endregion
+//#region src/lens-selection.d.ts
+type AlignmentRow$1 = readonly [number | null, number | null];
+//#endregion
+//#region src/viewed-coverage.d.ts
+/** Zero-based, half-open intervals; always normalized at the storage boundary. */
+type LineInterval = [number, number];
+interface Coverage {
+  base: LineInterval[];
+  head: LineInterval[];
+}
+interface CoverageFile$1 {
+  path: string;
+  previousPath?: string;
+  fingerprint: string;
+  changed: Coverage;
+  /** The changed lines diffr folds by default: every changed line of a file
+   * it hides, or those under a region that starts collapsed. Absent without
+   * structural data, where every changed line is left to read. */
+  folded?: Coverage;
+  viewed: Coverage;
+}
+//#endregion
+//#region src/review-api/blocks/flow_diagram.d.ts
+/** Nodes and edges are the diagram's children: each is its own edit target,
+ * so an agent can draw a diagram one unit at a time. Edges still name nodes
+ * by their diagram-local key. */
+declare const flowNodeSchema: z.ZodObject<{
+  type: z.ZodDefault<z.ZodLiteral<"flow_node">>;
+  key: z.ZodString;
+  label: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  kind: z.ZodOptional<z.ZodEnum<{
+    process: "process";
+    decision: "decision";
+    terminal: "terminal";
+  }>>;
+  attachments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    label: z.ZodString;
+    sources: z.ZodArray<any>;
+    pins: any;
+  }, z.core.$strict>>>;
+  id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+declare const flowEdgeSchema: z.ZodObject<{
+  type: z.ZodDefault<z.ZodLiteral<"flow_edge">>;
+  from: z.ZodString;
+  to: z.ZodString;
+  label: z.ZodOptional<z.ZodString>;
+  style: z.ZodOptional<z.ZodEnum<{
+    solid: "solid";
+    dashed: "dashed";
+  }>>;
+  id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type FlowDiagramNode = z.infer<typeof flowNodeSchema>;
+type FlowDiagramEdge = z.infer<typeof flowEdgeSchema>;
+//#endregion
+//#region src/review-api/blocks/database_lens.d.ts
+interface DatabaseField {
+  label: string;
+  dataType: string;
+  nullable?: boolean;
+  primaryKey?: boolean;
+  references?: {
+    store: string;
+    collection: string;
+    field: string;
+  };
+  /** An illustrative value shown beside the field. */
+  example?: JsonValue;
+  /** Nested fields of a document-store object field. */
+  fields?: Record<string, DatabaseField>;
+}
+//#endregion
+//#region src/review-api/blocks/sequence.d.ts
+declare const stepSchema: z.ZodObject<{
+  type: z.ZodDefault<z.ZodLiteral<"step">>;
+  from: z.ZodString;
+  to: z.ZodString;
+  label: z.ZodString;
+  style: z.ZodDefault<z.ZodEnum<{
+    call: "call";
+    return: "return";
+    async: "async";
+  }>>;
+  source: any;
+  pins: any;
+  explanation: z.ZodOptional<z.ZodString>;
+  code: z.ZodOptional<z.ZodObject<{
+    language: z.ZodDefault<z.ZodString>;
+    text: z.ZodString;
+  }, z.core.$strict>>;
+  id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type Step = z.infer<typeof stepSchema>;
+//#endregion
+//#region src/review-api/blocks/callout.d.ts
+interface CalloutBlock {
+  id?: string;
+  type: "callout";
+  title?: string;
+  tone: "info" | "warning" | "danger" | "success";
+  children: Block[];
+}
+//#endregion
+//#region src/review-api/blocks/section.d.ts
+interface SectionBlock {
+  id?: string;
+  type: "section";
+  title: string;
+  defaultCollapsed?: boolean;
+  children: Block[];
+}
+//#endregion
+//#region src/tutorial-conversation.d.ts
+declare const tutorialAuthoringConversationSchema: z.ZodObject<{
+  version: z.ZodLiteral<1>;
+  title: z.ZodString;
+  messages: z.ZodArray<z.ZodObject<{
+    role: z.ZodEnum<{
+      user: "user";
+      assistant: "assistant";
+    }>;
+    body: z.ZodString;
+  }, z.core.$strict>>;
+}, z.core.$strict>;
+type TutorialAuthoringConversation = z.infer<typeof tutorialAuthoringConversationSchema>;
+//#endregion
+//#region src/review-api/blocks/tutorial.d.ts
+type TutorialContent = {
+  kind: "keymap";
+} | {
+  kind: "conversation";
+  conversation: TutorialAuthoringConversation;
+} | {
+  kind: "view";
+  view: "review" | "commits" | "diff" | "map";
+  label: string;
+} | {
+  kind: "feature";
+  feature: "softwareMap";
+  children: Block[];
+};
+type TutorialBlock = {
+  id?: string;
+  type: "tutorial";
+} & TutorialContent;
+//#endregion
+//#region src/review-api/blocks/index.d.ts
+/** Leaf kinds share one discriminated union so unknown types read as they always have. */
+declare const leafSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  type: z.ZodLiteral<"markdown">;
+  id: z.ZodOptional<z.ZodString>;
+  markdown: z.ZodString;
+  pins: any;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"code">;
+  id: z.ZodOptional<z.ZodString>;
+  caption: z.ZodOptional<z.ZodString>;
+  language: z.ZodDefault<z.ZodString>;
+  text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"divider">;
+  id: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"code_peek">;
+  id: z.ZodOptional<z.ZodString>;
+  source: any;
+  pins: any;
+  caption: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"sequence">;
+  id: z.ZodOptional<z.ZodString>;
+  title: z.ZodString;
+  actors: z.ZodRecord<z.ZodString, z.ZodString>;
+  steps: z.ZodArray<z.ZodObject<{
+    type: z.ZodDefault<z.ZodLiteral<"step">>;
+    from: z.ZodString;
+    to: z.ZodString;
+    label: z.ZodString;
+    style: z.ZodDefault<z.ZodEnum<{
+      call: "call";
+      return: "return";
+      async: "async";
+    }>>;
+    source: any;
+    pins: any;
+    explanation: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodObject<{
+      language: z.ZodDefault<z.ZodString>;
+      text: z.ZodString;
+    }, z.core.$strict>>;
+    id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  pins: any;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"call_stack_diff">;
+  id: z.ZodOptional<z.ZodString>;
+  title: z.ZodString;
+  base: z.ZodArray<z.ZodObject<{
+    key: z.ZodOptional<z.ZodString>;
+    parentKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    callSite: any;
+    source: any;
+    contextSources: z.ZodOptional<z.ZodArray<any>>;
+    label: z.ZodOptional<z.ZodString>;
+    pins: any;
+    via: z.ZodOptional<z.ZodObject<{
+      kind: z.ZodEnum<{
+        call: "call";
+        queue: "queue";
+        callback: "callback";
+        rpc: "rpc";
+      }>;
+      reason: z.ZodString;
+    }, z.core.$strict>>;
+    id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  head: z.ZodArray<z.ZodObject<{
+    key: z.ZodOptional<z.ZodString>;
+    parentKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    callSite: any;
+    source: any;
+    contextSources: z.ZodOptional<z.ZodArray<any>>;
+    label: z.ZodOptional<z.ZodString>;
+    pins: any;
+    via: z.ZodOptional<z.ZodObject<{
+      kind: z.ZodEnum<{
+        call: "call";
+        queue: "queue";
+        callback: "callback";
+        rpc: "rpc";
+      }>;
+      reason: z.ZodString;
+    }, z.core.$strict>>;
+    id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  pins: any;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"database_lens">;
+  id: z.ZodOptional<z.ZodString>;
+  title: z.ZodString;
+  actors: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    label: z.ZodString;
+    softwareMapPath: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>]>>;
+  stores: z.ZodRecord<z.ZodString, z.ZodObject<{
+    label: z.ZodString;
+    storage: z.ZodEnum<{
+      document: "document";
+      relational: "relational";
+    }>;
+    dataStoreKind: z.ZodOptional<z.ZodEnum<{
+      database: "database";
+      objectStore: "objectStore";
+      bucket: "bucket";
+      artifactStore: "artifactStore";
+      fileStore: "fileStore";
+    }>>;
+    softwareMapPath: z.ZodOptional<z.ZodString>;
+    collections: z.ZodRecord<z.ZodString, z.ZodObject<{
+      label: z.ZodString;
+      key: z.ZodOptional<z.ZodString>;
+      fields: z.ZodRecord<z.ZodString, z.ZodType<DatabaseField, unknown, z.core.$ZodTypeInternals<DatabaseField, unknown>>>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>>;
+  useCases: z.ZodArray<z.ZodObject<{
+    label: z.ZodString;
+    summary: z.ZodOptional<z.ZodString>;
+    operations: z.ZodArray<z.ZodObject<{
+      kind: z.ZodEnum<{
+        read: "read";
+        write: "write";
+      }>;
+      store: z.ZodString;
+      collection: z.ZodString;
+      field: z.ZodOptional<z.ZodString>;
+      actor: z.ZodString;
+      label: z.ZodString;
+      detail: z.ZodOptional<z.ZodString>;
+      source: any;
+      pins: any;
+      id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  pins: any;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"image">;
+  id: z.ZodOptional<z.ZodString>;
+  assetId: z.ZodString;
+  alt: z.ZodString;
+  caption: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"trace_quote">;
+  id: z.ZodOptional<z.ZodString>;
+  traceId: z.ZodString;
+  eventId: z.ZodString;
+  text: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"software_map">;
+  id: z.ZodOptional<z.ZodString>;
+  mapVersionId: z.ZodString;
+  focusElementId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"flow_diagram">;
+  id: z.ZodOptional<z.ZodString>;
+  title: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+  direction: z.ZodOptional<z.ZodEnum<{
+    right: "right";
+    down: "down";
+  }>>;
+  nodes: z.ZodArray<z.ZodObject<{
+    type: z.ZodDefault<z.ZodLiteral<"flow_node">>;
+    key: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+      process: "process";
+      decision: "decision";
+      terminal: "terminal";
+    }>>;
+    attachments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      label: z.ZodString;
+      sources: z.ZodArray<any>;
+      pins: any;
+    }, z.core.$strict>>>;
+    id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  edges: z.ZodArray<z.ZodObject<{
+    type: z.ZodDefault<z.ZodLiteral<"flow_edge">>;
+    from: z.ZodString;
+    to: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodEnum<{
+      solid: "solid";
+      dashed: "dashed";
+    }>>;
+    id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>>;
+  pins: any;
+}, z.core.$strict>], "type">;
+type LeafBlock = z.infer<typeof leafSchema>;
+type Block = LeafBlock | SectionBlock | CalloutBlock | TutorialBlock;
+//#endregion
+//#region src/review-api/diff-lenses.d.ts
+declare const lensSchema: z.ZodObject<{
+  id: z.ZodString;
+  title: z.ZodString;
+  targets: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"files">;
+    patterns: z.ZodArray<z.ZodString>;
+  }, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"ranges">;
+    sources: z.ZodArray<any>;
+  }, z.core.$strict>], "kind">>;
+}, z.core.$strict>;
+type Lens = z.infer<typeof lensSchema>;
+//#endregion
+//#region src/review-api/document.d.ts
+declare const pinsSchema: z.ZodObject<{
+  repositoryId: z.ZodString;
+  base: z.ZodString;
+  head: z.ZodString;
+}, z.core.$strict>;
+/** Source identity retained internally for a saved worktree generation. */
+/** worktreeRevision is a refresh token, never an address for stored source. */
+type Pins = z.infer<typeof pinsSchema> & {
+  worktreeRevision?: string;
+};
+declare const reviewTargetSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"worktree">;
+  repositoryId: z.ZodString;
+  base: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+  kind: z.ZodLiteral<"commits">;
+  repositoryId: z.ZodString;
+  head: z.ZodString;
+  base: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>], "kind">;
+type ReviewTarget = z.infer<typeof reviewTargetSchema>;
+/** Everything with an id: blocks, and the units diagrams are drawn from. */
+type Element = Block | Step | FlowDiagramNode | FlowDiagramEdge;
+/** A diagram unit: addressed on its own, but only ever inside its diagram. */
+type Unit = Step | FlowDiagramNode | FlowDiagramEdge;
+declare const editSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  parentId: z.ZodOptional<z.ZodString>;
+  afterId: z.ZodOptional<z.ZodString>;
+  type: z.ZodLiteral<"insert">;
+  content: z.ZodDiscriminatedUnion<[z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"markdown">;
+    id: z.ZodOptional<z.ZodString>;
+    markdown: z.ZodString;
+    pins: any;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"code">;
+    id: z.ZodOptional<z.ZodString>;
+    caption: z.ZodOptional<z.ZodString>;
+    language: z.ZodDefault<z.ZodString>;
+    text: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"divider">;
+    id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"code_peek">;
+    id: z.ZodOptional<z.ZodString>;
+    source: any;
+    pins: any;
+    caption: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"sequence">;
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    actors: z.ZodRecord<z.ZodString, z.ZodString>;
+    steps: z.ZodArray<z.ZodObject<{
+      type: z.ZodDefault<z.ZodLiteral<"step">>;
+      from: z.ZodString;
+      to: z.ZodString;
+      label: z.ZodString;
+      style: z.ZodDefault<z.ZodEnum<{
+        call: "call";
+        return: "return";
+        async: "async";
+      }>>;
+      source: any;
+      pins: any;
+      explanation: z.ZodOptional<z.ZodString>;
+      code: z.ZodOptional<z.ZodObject<{
+        language: z.ZodDefault<z.ZodString>;
+        text: z.ZodString;
+      }, z.core.$strict>>;
+      id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    pins: any;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"call_stack_diff">;
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    base: z.ZodArray<z.ZodObject<{
+      key: z.ZodOptional<z.ZodString>;
+      parentKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      callSite: any;
+      source: any;
+      contextSources: z.ZodOptional<z.ZodArray<any>>;
+      label: z.ZodOptional<z.ZodString>;
+      pins: any;
+      via: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+          call: "call";
+          queue: "queue";
+          callback: "callback";
+          rpc: "rpc";
+        }>;
+        reason: z.ZodString;
+      }, z.core.$strict>>;
+      id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    head: z.ZodArray<z.ZodObject<{
+      key: z.ZodOptional<z.ZodString>;
+      parentKey: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+      callSite: any;
+      source: any;
+      contextSources: z.ZodOptional<z.ZodArray<any>>;
+      label: z.ZodOptional<z.ZodString>;
+      pins: any;
+      via: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+          call: "call";
+          queue: "queue";
+          callback: "callback";
+          rpc: "rpc";
+        }>;
+        reason: z.ZodString;
+      }, z.core.$strict>>;
+      id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    pins: any;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"database_lens">;
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    actors: z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+      label: z.ZodString;
+      softwareMapPath: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>]>>;
+    stores: z.ZodRecord<z.ZodString, z.ZodObject<{
+      label: z.ZodString;
+      storage: z.ZodEnum<{
+        document: "document";
+        relational: "relational";
+      }>;
+      dataStoreKind: z.ZodOptional<z.ZodEnum<{
+        database: "database";
+        objectStore: "objectStore";
+        bucket: "bucket";
+        artifactStore: "artifactStore";
+        fileStore: "fileStore";
+      }>>;
+      softwareMapPath: z.ZodOptional<z.ZodString>;
+      collections: z.ZodRecord<z.ZodString, z.ZodObject<{
+        label: z.ZodString;
+        key: z.ZodOptional<z.ZodString>;
+        fields: z.ZodRecord<z.ZodString, z.ZodType<DatabaseField, unknown, z.core.$ZodTypeInternals<DatabaseField, unknown>>>;
+      }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    useCases: z.ZodArray<z.ZodObject<{
+      label: z.ZodString;
+      summary: z.ZodOptional<z.ZodString>;
+      operations: z.ZodArray<z.ZodObject<{
+        kind: z.ZodEnum<{
+          read: "read";
+          write: "write";
+        }>;
+        store: z.ZodString;
+        collection: z.ZodString;
+        field: z.ZodOptional<z.ZodString>;
+        actor: z.ZodString;
+        label: z.ZodString;
+        detail: z.ZodOptional<z.ZodString>;
+        source: any;
+        pins: any;
+        id: z.ZodOptional<z.ZodString>;
+      }, z.core.$strict>>;
+      id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    pins: any;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    id: z.ZodOptional<z.ZodString>;
+    assetId: z.ZodString;
+    alt: z.ZodString;
+    caption: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"trace_quote">;
+    id: z.ZodOptional<z.ZodString>;
+    traceId: z.ZodString;
+    eventId: z.ZodString;
+    text: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"software_map">;
+    id: z.ZodOptional<z.ZodString>;
+    mapVersionId: z.ZodString;
+    focusElementId: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"flow_diagram">;
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    direction: z.ZodOptional<z.ZodEnum<{
+      right: "right";
+      down: "down";
+    }>>;
+    nodes: z.ZodArray<z.ZodObject<{
+      type: z.ZodDefault<z.ZodLiteral<"flow_node">>;
+      key: z.ZodString;
+      label: z.ZodString;
+      description: z.ZodOptional<z.ZodString>;
+      kind: z.ZodOptional<z.ZodEnum<{
+        process: "process";
+        decision: "decision";
+        terminal: "terminal";
+      }>>;
+      attachments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        sources: z.ZodArray<any>;
+        pins: any;
+      }, z.core.$strict>>>;
+      id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    edges: z.ZodArray<z.ZodObject<{
+      type: z.ZodDefault<z.ZodLiteral<"flow_edge">>;
+      from: z.ZodString;
+      to: z.ZodString;
+      label: z.ZodOptional<z.ZodString>;
+      style: z.ZodOptional<z.ZodEnum<{
+        solid: "solid";
+        dashed: "dashed";
+      }>>;
+      id: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+    pins: any;
+  }, z.core.$strict>], "type">, z.ZodObject<{
+    type: z.ZodLiteral<"section">;
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodString;
+    defaultCollapsed: z.ZodOptional<z.ZodBoolean>;
+    children: z.ZodArray<z.ZodLazy<z.ZodType<Block, unknown, z.core.$ZodTypeInternals<Block, unknown>>>>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"callout">;
+    id: z.ZodOptional<z.ZodString>;
+    title: z.ZodOptional<z.ZodString>;
+    tone: z.ZodDefault<z.ZodEnum<{
+      success: "success";
+      info: "info";
+      warning: "warning";
+      danger: "danger";
+    }>>;
+    children: z.ZodArray<z.ZodLazy<z.ZodType<Block, unknown, z.core.$ZodTypeInternals<Block, unknown>>>>;
+  }, z.core.$strict>, z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"tutorial">;
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"keymap">;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"tutorial">;
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"conversation">;
+    conversation: any;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"tutorial">;
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"view">;
+    view: z.ZodEnum<{
+      map: "map";
+      commits: "commits";
+      review: "review";
+      diff: "diff";
+    }>;
+    label: z.ZodString;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodLiteral<"tutorial">;
+    id: z.ZodOptional<z.ZodString>;
+    kind: z.ZodLiteral<"feature">;
+    feature: z.ZodLiteral<"softwareMap">;
+    children: z.ZodArray<z.ZodLazy<z.ZodType<Block, unknown, z.core.$ZodTypeInternals<Block, unknown>>>>;
+  }, z.core.$strict>], "kind">, z.ZodObject<{
+    type: z.ZodDefault<z.ZodLiteral<"step">>;
+    from: z.ZodString;
+    to: z.ZodString;
+    label: z.ZodString;
+    style: z.ZodDefault<z.ZodEnum<{
+      call: "call";
+      return: "return";
+      async: "async";
+    }>>;
+    source: any;
+    pins: any;
+    explanation: z.ZodOptional<z.ZodString>;
+    code: z.ZodOptional<z.ZodObject<{
+      language: z.ZodDefault<z.ZodString>;
+      text: z.ZodString;
+    }, z.core.$strict>>;
+    id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodDefault<z.ZodLiteral<"flow_node">>;
+    key: z.ZodString;
+    label: z.ZodString;
+    description: z.ZodOptional<z.ZodString>;
+    kind: z.ZodOptional<z.ZodEnum<{
+      process: "process";
+      decision: "decision";
+      terminal: "terminal";
+    }>>;
+    attachments: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      label: z.ZodString;
+      sources: z.ZodArray<any>;
+      pins: any;
+    }, z.core.$strict>>>;
+    id: z.ZodOptional<z.ZodString>;
+    link: z.ZodOptional<z.ZodObject<{
+      from: z.ZodOptional<z.ZodString>;
+      to: z.ZodOptional<z.ZodString>;
+      label: z.ZodOptional<z.ZodString>;
+      style: z.ZodOptional<z.ZodEnum<{
+        solid: "solid";
+        dashed: "dashed";
+      }>>;
+    }, z.core.$strict>>;
+  }, z.core.$strict>, z.ZodObject<{
+    type: z.ZodDefault<z.ZodLiteral<"flow_edge">>;
+    from: z.ZodString;
+    to: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodEnum<{
+      solid: "solid";
+      dashed: "dashed";
+    }>>;
+    id: z.ZodOptional<z.ZodString>;
+  }, z.core.$strict>], "type">;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"replace">;
+  targetId: z.ZodString;
+  content: z.ZodType<Block, unknown, z.core.$ZodTypeInternals<Block, unknown>>;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"update">;
+  targetId: z.ZodString;
+  changes: z.ZodRecord<z.ZodString, z.ZodJSONSchema>;
+}, z.core.$strict>, z.ZodObject<{
+  parentId: z.ZodOptional<z.ZodString>;
+  afterId: z.ZodOptional<z.ZodString>;
+  type: z.ZodLiteral<"move">;
+  targetId: z.ZodString;
+}, z.core.$strict>, z.ZodObject<{
+  type: z.ZodLiteral<"remove">;
+  targetId: z.ZodString;
+}, z.core.$strict>], "type">;
+type Edit = z.infer<typeof editSchema>;
+/**
+ * What one saved version did, for a canvas drawing the document as the
+ * agent writes it: the edit's kind, the element it landed on, and the block
+ * that element belongs to (itself, for a block; its diagram, for a unit).
+ */
+interface EditSummary {
+  type: Edit["type"];
+  targetId: string;
+  /** For a lens, the lens itself. */
+  blockId: string;
+  /** What the target is: a block type, a unit type, or a Diff-view lens. */
+  kind: Element["type"] | "lens";
+  unit?: Unit["type"];
+  /** The edge a new flow node arrived with, drawn right after the node. */
+  linkId?: string;
+  /** An update's patched fields, so the canvas can draw only what changed. */
+  fields?: string[];
+  /** A diagram written whole: its units in the order a hand would draw
+   * them, so the canvas can trace the whole diagram in one quick pass. */
+  units?: string[];
+  /** The agent whose courier draws this edit, when the host could tell. */
+  activityId?: string;
+}
+/** A component an edit wrote, named so the author can address it. */
+interface WrittenComponent {
+  id: string;
+  type: Element["type"];
+}
+//#endregion
+//#region src/review-api/comparison-coverage.d.ts
+type CoverageMode = "structural" | "textual";
+interface ComparisonCoverage {
+  files: CoverageFile$1[];
+  fileSources: Map<string, FileLineRange[]>;
+  alignments: Map<string, readonly AlignmentRow$1[]>;
+}
+//#endregion
+//#region src/review-api/pull-request.d.ts
+/** Runs one subprocess and resolves its stdout; rejects on failure or timeout. */
+type RunCommand = (file: string, args: string[], options: {
+  cwd?: string;
+  timeoutMs: number;
+}) => Promise<string>;
+interface PullRequestDeps {
+  run: RunCommand;
+  fetch: typeof fetch;
+}
+//#endregion
+//#region src/review-api/activity.d.ts
+declare const focusSchema: z.ZodObject<{
+  description: z.ZodString;
+  targetId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** Which page an agent last wrote on, so the app knows where its courier is. */
+type ActivitySurface = "document" | "lenses";
+type ActivityFocus = z.infer<typeof focusSchema>;
+/** One agent working on a review. */
+interface ActivityPresence {
+  activityId: string;
+  /** The agent's color: the lowest slot free when it began, kept until it ends. */
+  slot: number;
+  focus?: ActivityFocus;
+  /** Where it last wrote; absent until its first attributed write. */
+  surface?: ActivitySurface;
+}
+interface ActivitySnapshot {
+  /** Live presences. */
+  workingCount: number;
+  /** The latest expiry among live presences. */
+  expiresAt: number | null;
+  /** Each live presence, in the order they began. */
+  activities?: ActivityPresence[];
+}
+declare class ReviewActivity {
+  private readonly db;
+  private readonly assertReview?;
+  private readonly timers;
+  private readonly listeners;
+  private readonly working;
+  private readonly workingListeners;
+  constructor(db: DatabaseSync, assertReview?: ((reviewId: string) => void) | undefined);
+  subscribe(listener: (reviewId: string) => void): () => void;
+  /** Fires only when a review starts or stops being authored, never on
+   * renewals or focus changes. */
+  subscribeWorking(listener: () => void): () => void;
+  isWorking(reviewId: string): boolean;
+  private changed;
+  private live;
+  read(reviewId: string): ActivitySnapshot;
+  /** Inside the caller's write transaction: the presence a write belongs to,
+   * renewed and moved to the write's surface. The named one if it is live;
+   * otherwise, with none named, the review's only presence. A write is never
+   * refused for this. Call `extended` once the transaction commits. */
+  attribute(reviewId: string, surface: ActivitySurface, activityId?: string): string | undefined;
+  /** Move the expiry timer after a committed `attribute`. */
+  extended(reviewId: string): void;
+  update(reviewId: string, value: unknown): ActivitySnapshot & {
+    activityId?: string;
+  };
+  /** One timer per review, for its soonest-expiring presence. */
+  private scheduleExpiry;
+  /** Called when another database connection commits session changes. */
+  refresh(): void;
+  /** The store deletes the session atomically with its review before notifying. */
+  deleted(reviewId: string): void;
+  close(): void;
+}
+//#endregion
+//#region src/ask/thread-state.d.ts
+declare const askAgentIds: readonly ["claude", "codex", "cursor", "opencode", "pi"];
+type AskAgentId = (typeof askAgentIds)[number];
+declare const askEntrySchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  kind: z.ZodLiteral<"user">;
+  id: z.ZodString;
+  text: z.ZodString;
+  at: z.ZodOptional<z.ZodNumber>;
+  attachments: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    kind: z.ZodLiteral<"file">;
+    path: z.ZodString;
+  }, z.core.$strip>, z.ZodObject<{
+    kind: z.ZodLiteral<"image">;
+    name: z.ZodString;
+  }, z.core.$strip>], "kind">>>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"agent">;
+  id: z.ZodString;
+  text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"tool">;
+  id: z.ZodString;
+  title: z.ZodString;
+  toolKind: z.ZodString;
+  status: z.ZodEnum<{
+    pending: "pending";
+    in_progress: "in_progress";
+    completed: "completed";
+    failed: "failed";
+  }>;
+  input: z.ZodOptional<z.ZodString>;
+  summary: z.ZodOptional<z.ZodString>;
+  output: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"permission">;
+  id: z.ZodString;
+  title: z.ZodString;
+  toolKind: z.ZodString;
+  input: z.ZodOptional<z.ZodString>;
+  options: z.ZodArray<z.ZodObject<{
+    optionId: z.ZodString;
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+      allow_once: "allow_once";
+      allow_always: "allow_always";
+      reject_once: "reject_once";
+      reject_always: "reject_always";
+    }>;
+  }, z.core.$strip>>;
+  outcome: z.ZodOptional<z.ZodString>;
+  automatic: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>, z.ZodObject<{
+  kind: z.ZodLiteral<"notice">;
+  id: z.ZodString;
+  severity: z.ZodString;
+  title: z.ZodString;
+  description: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "kind">;
+/** What an agent offers before anything is asked of it, as it last said. */
+declare const askOfferSchema: z.ZodObject<{
+  choices: z.ZodObject<{
+    model: z.ZodOptional<z.ZodObject<{
+      current: z.ZodString;
+      options: z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+    effort: z.ZodOptional<z.ZodObject<{
+      current: z.ZodString;
+      options: z.ZodArray<z.ZodObject<{
+        value: z.ZodString;
+        name: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+      }, z.core.$strip>>;
+    }, z.core.$strip>>;
+  }, z.core.$strip>;
+  commands: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    hint: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  accepts: z.ZodOptional<z.ZodObject<{
+    image: z.ZodBoolean;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type AskOffer = z.infer<typeof askOfferSchema>;
+type AskEntry = z.infer<typeof askEntrySchema>;
+/** A saved conversation, as the history list shows it. The transcript stays
+ * with the agent; Whiteboard keeps what it needs to find and reopen it. */
+declare const askHistoryEntrySchema: z.ZodObject<{
+  id: z.ZodString;
+  agent: z.ZodEnum<{
+    claude: "claude";
+    codex: "codex";
+    cursor: "cursor";
+    opencode: "opencode";
+    pi: "pi";
+  }>;
+  title: z.ZodString;
+  question: z.ZodOptional<z.ZodString>;
+  selection: any;
+  head: z.ZodString;
+  createdAt: z.ZodString;
+  updatedAt: z.ZodString;
+}, z.core.$strip>;
+type AskHistoryEntry = z.infer<typeof askHistoryEntrySchema>;
+//#endregion
+//#region src/review-api/ask-history.d.ts
+/** A saved Ask conversation: its history entry, and how to reopen it. */
+declare const askRecordSchema: any;
+type AskRecord = z.infer<typeof askRecordSchema>;
+/** Saved Ask conversations, per review. Shared reviews are not in
+ * `reviews`, so there is no foreign key; deleting a review deletes its rows. */
+declare class AskHistory {
+  private readonly db;
+  constructor(db: DatabaseSync);
+  save(record: AskRecord): void;
+  /** Whether reopening the conversation bypasses permissions. */
+  setBypass(id: string, bypass: boolean): void;
+  /** Points a conversation at a new session, when its agent could not
+   * reopen the one it had. */
+  updateSession(id: string, sessionId: string): void;
+  /** Keeps what the panel shows, so a reopen need not wait on the agent. */
+  saveEntries(id: string, entries: AskEntry[]): void;
+  /** The agent's name for the conversation, which the list shows. */
+  rename(id: string, title: string): void;
+  saveOffer(agent: AskAgentId, offer: AskOffer): void;
+  /** Keeps what the agent offers with the offer's model, without making
+   * it what the agent offered last. */
+  saveModelOffer(agent: AskAgentId, offer: AskOffer): void;
+  /** What the agent offered last, or last with the model given. */
+  offer(agent: AskAgentId, model?: string): AskOffer | undefined;
+  touch(id: string, at?: string): void;
+  /** Newest first. */
+  list(reviewId: string): AskHistoryEntry[];
+  get(id: string): AskRecord | undefined;
+  delete(id: string): void;
+}
+//#endregion
+//#region src/review-api/store.d.ts
+/** Source identity displayed in the review header and Home, alongside immutable pins. */
+interface SnapshotOrigin {
+  /** Managed tutorial; readable by ID but excluded from the user catalog. */
+  tutorial?: boolean;
+  branch?: string;
+  baseRef?: string;
+  pullRequestNumber?: number;
+  pullRequestUrl?: string;
+  /** The legacy review revision this version was imported from. */
+  revision?: string;
+}
+interface Snapshot {
+  shared?: {
+    login?: string;
+    sharedAt?: number;
+    cloneUrl?: string;
+  };
+  reviewId: string;
+  version: number;
+  title: string;
+  /** Absent for a review. The scratchpad has no pins, target or lifecycle. */
+  kind?: "scratchpad";
+  /** The default pins for references that name none. A document whose
+   * references all carry their own pins has neither pins nor target. */
+  pins?: Pins;
+  target?: ReviewTarget;
+  staleSources?: string[];
+  sourceUnavailable?: boolean;
+  document: Block[];
+  /** The Diff view's lenses, beside the document and versioned with it.
+   * Absent on a version with none. */
+  lenses?: Lens[];
+  createdAt: string;
+  origin?: SnapshotOrigin;
+  /** The edit that produced this version, when one did; absent for a
+   * rename, set_target, restore or import, which the canvas does not draw. */
+  lastEdit?: EditSummary;
+}
+interface Result {
+  /** Create only: false when an existing review for the same PR came back. */
+  created?: boolean;
+  /** Why an existing review came back, and what to do next, in words. */
+  note?: string;
+  reviewId: string;
+  version: number;
+  /** The existing review's stored target; the requested one is not applied. */
+  target?: ReviewTarget;
+  /** The requested head differs from the existing review's. */
+  headMoved?: boolean;
+  /** An agent is working on the existing review. */
+  working?: boolean;
+  /** Older reviews that also name the PR, newest first. */
+  otherReviewIds?: string[];
+  /** The component an edit landed on, its type, and — for an insert or
+   * replace — its first-level children with their fresh IDs. */
+  targetId?: string;
+  type?: Element["type"] | "lens";
+  children?: WrittenComponent[];
+  attention?: true;
+  deleted?: true;
+  warnings?: string[];
+}
+/** A PR's current comparison: GitHub's head and diff base, fetched locally. */
+interface ResolvedPullRequest {
+  target: ReviewTarget;
+  pins: Pins;
+  title: string;
+}
+interface ReviewProviders {
+  headBranch?(pins: Pins, headRef?: string): Promise<string | undefined>;
+  projectSource?(snapshot: Snapshot, pins: Pins): Promise<Snapshot>;
+  /** Fetch a PR into a registered checkout: the named one, else the first
+   * preferred one that still matches, else any whose remote is the PR's. */
+  resolvePullRequest?(url: string, repository: {
+    id?: string;
+    preferred?: string;
+  }): Promise<ResolvedPullRequest>;
+  resolveTarget?(target: ReviewTarget, pinned?: Pins): Promise<{
+    target: ReviewTarget;
+    pins: Pins;
+  }>;
+  /** Rejects with a 404 ReviewInputError when the snapshot's checkout is gone.
+   * Resolves undefined for a document without default pins. */
+  sourcePins?(snapshot: Snapshot): Promise<Pins | undefined>;
+  /** Ids of references whose own pins no longer name a usable checkout. */
+  unavailableAnchors?(snapshot: Snapshot): Promise<string[]>;
+  validatePins(pins: Pins): Promise<void>;
+  /** The files each side's commit changed from one set of pins to another,
+   * or undefined when they can't be diffed commit to commit. */
+  filesChangedBetween?(from: Pins, to: Pins): Promise<{
+    base: Set<string>;
+    head: Set<string>;
+  } | undefined>;
+  validateSource(pins: Pins, source: FileLineRange, options: {
+    peek: boolean;
+  }): Promise<void>;
+  validateResource(pins: Pins | undefined, block: Block): Promise<void>;
+}
+/** One instance owned by the desktop server. All writers go through execute().
+ * The queue includes async validation; SQLite transactions contain only writes.
+ * This prototype uses a new, explicitly supplied database, never an existing profile.
+ */
+declare class ReviewStore {
+  private readonly providers;
+  readonly activity: ReviewActivity;
+  readonly askHistory: AskHistory;
+  private readonly db;
+  private pending;
+  private closing;
+  private readonly liveSources;
+  private refreshTimer?;
+  private refreshSubscribers;
+  watchWorktrees(): () => void;
+  private projectLiveSource;
+  private refreshPending;
+  /** Refresh source state without writing authored document versions. Serialized with edits. */
+  refreshWorktrees(): Promise<void>;
+  private readonly listeners;
+  private readonly catalogListeners;
+  private readonly externalChanges;
+  private observedDataVersion;
+  private observedVersions;
+  subscribeCatalog(listener: () => void): () => void;
+  /** For a host whose listing changed without the store: a preference flip. */
+  invalidateCatalog(): void;
+  subscribe(listener: (result: Result) => void): () => void;
+  constructor(databasePath: string, providers: ReviewProviders);
+  private dataVersion;
+  private currentVersions;
+  private refreshExternalChanges;
+  /** Reader progress never creates a document version or authoring event. */
+  viewedCoverage(reviewId: string): Map<string, {
+    fingerprint: string;
+    coverage: Coverage;
+  }>;
+  updateViewedCoverage(reviewId: string, files: {
+    path: string;
+    fingerprint: string;
+    scope: Coverage;
+  }[], viewed: boolean): void;
+  private readonly repositoryGroups;
+  private repositoryGroup;
+  registerRepository(root: string): {
+    id: string;
+    name: string;
+  };
+  unregisterRepository(id: string): void;
+  /** Registered checkouts, oldest registration first. */
+  repositories(): {
+    id: string;
+    path: string;
+  }[];
+  repositoryPath(id: string): string;
+  putResource(id: string, repositoryId: string, kind: string, mimeType: string, data: Uint8Array): {
+    id: string;
+    kind: string;
+    mimeType: string;
+  };
+  resource(id: string): {
+    id: string;
+    repositoryId: string;
+    kind: string;
+    mimeType: string;
+    data: Uint8Array;
+  };
+  close(): Promise<void>;
+  /** Stable across restarts; the first host on a new store chooses it. */
+  serverId(): string;
+  resetServerId(): string;
+  /** The 404 check alone, without loading a snapshot. */
+  assertExists(id: string): void;
+  read(id: string, version?: number): Snapshot;
+  setDiffStats(pins: Pins, stats: NonNullable<ReviewApiSummary["diffStats"]>, mode?: "structural" | "textual"): void;
+  /** Managed records are discoverable even if their preparation stamp was lost. */
+  tutorialIds(): string[];
+  list(mode?: "structural" | "textual"): ReviewApiSummary[];
+  /** One review's catalog entry, as review_list shows it. */
+  summary(id: string): ReviewApiSummary | undefined;
+  private summaries;
+  /** Local and imported summaries use the same persisted, mode-specific counts. */
+  withDiffStats<T extends ReviewApiSummary>(reviews: T[], mode?: "structural" | "textual"): T[];
+  /** What the pad holds, for its Home card: blocks, and the diagrams among them. */
+  private scratchpadContents;
+  /** The one scratchpad, made on first use. A host that loses the race to
+   * another on the same home finds it made. */
+  ensureScratchpad(): Promise<void>;
+  history(id: string): {
+    version: number;
+    title: string;
+    createdAt: string;
+  }[];
+  inspect(id: string, targetId?: string, version?: number): Element | {
+    id: string | undefined;
+    type: "image" | "code" | "markdown" | "divider" | "code_peek" | "sequence" | "step" | "call_stack_diff" | "database_lens" | "trace_quote" | "software_map" | "flow_diagram" | "flow_node" | "flow_edge" | "section" | "callout" | "tutorial";
+    label: any;
+  }[];
+  /** The host can seed a managed document; transport callers only supply a command. */
+  execute(input: unknown, initial?: {
+    document: Block[];
+    origin: SnapshotOrigin;
+  }): Promise<Result>;
+  /** Resolve a target-less PR create before it queues, when it will need it. */
+  private startPullRequest;
+  /** Reviews whose PR is this one, newest version first. Summaries only. */
+  private reviewsForPullRequest;
+  /** The answer to a create that found its PR's review. Its target stays:
+   * moving it would silently point existing links at different code. */
+  private existingReview;
+  private commitCommand;
+  private assertMutation;
+  private notify;
+  /** Dismissed reviews, as Home lists them; only a restore clears it, not a view. */
+  dismissedIds(): string[];
+  has(reviewId: string): boolean;
+  private validateExternal;
+}
+//#endregion
+//#region src/review-api/workspaces.d.ts
+interface WorkspaceStatus {
+  id: string;
+  commit: string;
+  rootPath: string | null;
+  generation: string;
+  state: "pending" | "preparing" | "ready" | "unconfigured" | "failed" | "cleanup-failed";
+  log: string;
+  /** Acquisition failed; this can be transient. Optional setup failures are not issues. */
+  issue?: string;
+}
+/** Local lifecycle only: source and authored history never depend on preparation.
+ * Status/queue/process lifecycle follows #334, retaining the legacy prepare config
+ * and per-review managed checkout layout instead of a new settings system.
+ */
+declare class ReviewWorkspaces {
+  private readonly store;
+  private readonly db;
+  private readonly requests;
+  private readonly jobs;
+  private readonly stop;
+  private cleanup;
+  private closed;
+  private readonly ownerId;
+  constructor(databasePath: string, store: ReviewStore);
+  private dismissed?;
+  private readonly releasing;
+  /**
+   * Frees a newly dismissed review's checkouts to save disk. The review itself
+   * stays; reopening it rebuilds them. Checkouts rebuilt by peeking at a
+   * dismissed review are kept until the next startup or dismissal, since
+   * the Desktop's canvas tabs and source windows may still show them.
+   */
+  private releaseDismissed;
+  private repositoryDirs;
+  /** Resolves once no release of the review is pending, so an ensure cannot race it. */
+  released(reviewId: string): Promise<void>;
+  private release;
+  private releaseCheckouts;
+  private external?;
+  private stopExternal?;
+  attachExternalReviews(source: {
+    has(id: string): boolean;
+    subscribe(listener: () => void): () => void;
+  }): void;
+  private hasReview;
+  private assertReview;
+  remove(reviewId: string): Promise<void>;
+  private lease;
+  private leasedElsewhere;
+  /** Takes the review's lease unless another live Desktop holds it. */
+  private claim;
+  private all;
+  private get;
+  private save;
+  private status;
+  list(reviewId: string): WorkspaceStatus[];
+  failures(): WorkspaceStatus[];
+  retryCleanup(id: string): Promise<void>;
+  open(reviewId: string, pins: Pins): Promise<void>;
+  source(reviewId: string, pins: Pins, side: "base" | "head", retryFailed?: boolean): Promise<WorkspaceStatus>;
+  private acquire;
+  private prepare;
+  retry(reviewId: string, id: string): Promise<WorkspaceStatus>;
+  private collect;
+  idle(): Promise<void>;
+  private closing?;
+  close(): Promise<void>;
+  private closeAll;
+}
+//#endregion
+//#region src/review-api/local-data.d.ts
+/** Local source/resource boundary, including Desktop-only local language context. */
+declare class LocalReviewData {
+  private readonly store;
+  private readonly options;
+  private readonly workspaceManager?;
+  get workspaces(): ReviewWorkspaces;
+  currentEnvironmentIssues(snapshot: Snapshot): {
+    side: string;
+    message: string;
+  }[];
+  environmentIssues(snapshot: Snapshot, retryFailed?: boolean): Promise<{
+    side: "base" | "head";
+    message: string;
+  }[]>;
+  private readonly untrackedCounts;
+  /**
+   * Untracked files a live worktree review leaves out; undefined otherwise.
+   * Counted once per worktree revision, never by the revision poll, so a
+   * checkout with many untracked files pays for the walk only when read.
+   */
+  untrackedFiles(pins: Pins): Promise<number | undefined>;
+  /** Local checkout context for live worktree targets only. */
+  /** Desktop language services borrow the registered checkout, never create one. */
+  liveFile(repositoryId: string, file: string, text: string): Promise<{
+    localPath: string;
+    localRoot: string;
+  } | undefined>;
+  /** Source bytes and the language workspace have independent lifetimes. */
+  languageEnvironment(snapshot: Snapshot, side: "base" | "head", commit?: string, retryFailed?: boolean, anchor?: SourcePins): Promise<ReviewLanguageEnvironment>;
+  /** Resolve source coordinates after selecting a local or imported snapshot.
+   * `anchor` reads at a reference's own pins instead of the document's;
+   * `commit` narrows the document comparison to one of its commits. */
+  resolveSource(snapshot: Snapshot, commit?: string, anchor?: SourcePins): Promise<{
+    snapshot: Snapshot;
+    pins: Pins;
+  }>;
+  /** Where an Ask agent reads source: the Review's own head checkout, or the
+   * registered checkout for a live worktree target, as the navigator does. */
+  agentCheckout(snapshot: Snapshot): Promise<{
+    rootPath: string;
+    head: string;
+    live: boolean;
+  }>;
+  /** Resolve a native workspace without replacing the selected source with today's HEAD. */
+  navigatorWorkspace(snapshot: Snapshot, source?: {
+    side?: "base" | "head";
+    file?: string;
+    empty?: boolean;
+    commit?: string;
+    anchor?: SourcePins;
+  }): Promise<{
+    workspacePath: string;
+    filePath?: string;
+  }>;
+  /** A document read that needs default pins; 409 when the document has none. */
+  documentPins(snapshot: Snapshot): Promise<Pins>;
+  /** Pins a reference names itself, checked against the registered checkout. */
+  anchorSourcePins(anchor: SourcePins): Promise<Pins>;
+  /** References whose own repository is unregistered or gone from disk. */
+  unavailableAnchors(snapshot: Snapshot): Promise<string[]>;
+  private readonly trackedFiles;
+  private readonly repositories;
+  private readonly readers;
+  private readonly commitRanges;
+  constructor(store: ReviewStore, options?: {
+    blobReaderIdleTimeoutMs?: number;
+    workspaceDatabase?: string;
+    manageWorkspaces?: boolean;
+    watch?: typeof watch;
+    /** gh, git and GitHub API access for pull request targets. */
+    pullRequests?: PullRequestDeps;
+  });
+  structuralChanges({ reviewId, pins, signal, file }: {
+    reviewId: string;
+    pins: Pins;
+    signal: AbortSignal;
+    file?: string;
+  }): AsyncGenerator<StructuralDiffEvent>;
+  private readonly structuralComparisons;
+  private closed;
+  private readonly worktrees;
+  private forgetWorktree;
+  private worktreeState;
+  close(): Promise<void>;
+  /** Detected once; dropped when the root vanishes or detection found nothing. */
+  private vcs;
+  /** None once closed: a read suspended across close() gets its own process. */
+  private reader;
+  private closeReader;
+  forgetRepository(repositoryId: string): Promise<void>;
+  private vcsTarget;
+  register(root: string): Promise<{
+    id: string;
+    name: string;
+  }>;
+  projectSource(snapshot: Snapshot, pins: Pins): Promise<Snapshot>;
+  /** Throws 404 when the checkout behind the snapshot is gone. Undefined
+   * for a document without default pins. */
+  sourcePins(snapshot: Snapshot): Promise<Pins | undefined>;
+  /** Capture a label only when its ref still resolves to these exact pins. */
+  headBranch(pins: Pins, headRef?: string): Promise<string | undefined>;
+  /** `pinned` refreshes a stored target: a worktree base ref resolves to its
+   * current fork point, and keeps the pinned one if the ref is gone. */
+  resolveTarget(target: ReviewTarget, pinned?: Pins): Promise<{
+    target: ReviewTarget;
+    pins: Pins;
+  }>;
+  /** The fork point from `ref`, by default the repository's default branch. */
+  private worktreeBase;
+  /** The PR's current comparison, fetched into a registered checkout of its repository. */
+  resolvePullRequest(url: string, repository: {
+    id?: string;
+    preferred?: string;
+  }): Promise<ResolvedPullRequest>;
+  /** A registered checkout with a remote for host/owner/repo, and that remote. */
+  private pullRequestCheckout;
+  resolvePins(repositoryId: string, base: string, head: string): Promise<Pins>;
+  /** Files each side's commit changed from one set of pins to another, under
+   * both names for a rename. A worktree has no commit to diff from. */
+  filesChangedBetween(from: Pins, to: Pins): Promise<{
+    base: Set<string>;
+    head: Set<string>;
+  } | undefined>;
+  validatePins(pins: Pins): Promise<void>;
+  file(pins: Pins, side: "base" | "head", file: string, allowBinary?: boolean): Promise<{
+    file: string;
+    side: "base" | "head";
+    commit: string;
+    text: string;
+  }>;
+  tree(pins: Pins, side: "base" | "head", directory: string): Promise<ReviewSourceEntry[]>;
+  private trackedFilesAt;
+  validateSources(pins: Pins, sources: FileLineRange[]): Promise<void>;
+  quote(pins: Pins, source: FileLineRange): Promise<any>;
+  /** Every source reference must exist at the pins; only code peeks must also
+   * show something. */
+  validateSource(pins: Pins, source: FileLineRange, options: {
+    peek: boolean;
+  }): Promise<void>;
+  private readonly coverageCache;
+  private readonly coverageAbort;
+  private readonly coverageListeners;
+  coverageRevision: number;
+  subscribeCoverage(listener: () => void): () => void;
+  /** Start shared coverage work without occupying an HTTP request until it completes. */
+  coveragePending(reviewId: string, pins: Pins, mode: CoverageMode): boolean;
+  coverageSnapshot(reviewId: string, pins: Pins, mode: CoverageMode): {
+    pending: boolean;
+    comparison: ComparisonCoverage | {
+      files: never[];
+      fileSources: Map<any, any>;
+      alignments: Map<any, any>;
+    };
+  };
+  private coverageNotification;
+  private notifyCoverage;
+  coverage(reviewId: string, pins: Pins, mode: CoverageMode): Promise<{
+    files: CoverageFile[];
+    fileSources: Map<string, FileLineRange[]>;
+    alignments: Map<string, readonly AlignmentRow[]>;
+  }>;
+  changes(pins: Pins): Promise<LocalVcsDiffFileSummary[]>;
+  changes(pins: Pins, file: string): Promise<string>;
+  changes(pins: Pins, file?: string): Promise<LocalVcsDiffFileSummary[] | string>;
+  private summaries;
+  /** Raw Git patch text for exact filenames, or every change. */
+  private rawPatch;
+  private worktreeInput;
+  commits(pins: Pins): Promise<LocalVcsCommitSummary[]>;
+  private readCommitRange;
+  comparison(pins: Pins, commit?: string): Promise<Pins>;
+  map(documentPins: Pins | undefined, resourceId: string): Promise<{
+    countsByElementPath: any;
+    unmappedByElementPath: any;
+    elements: NormalizedSoftwareModel;
+    relationships: NormalizedSoftwareModel;
+    side: "base" | "head";
+    commit: string;
+  }>;
+  upload(value: unknown): Promise<{
+    id: string;
+    kind: string;
+    mimeType: string;
+  }>;
+  /** A resource must belong to the document's repository when it has one;
+   * a document without pins may use any registered repository's resources. */
+  validateResource(pins: Pins | undefined, block: Block): Promise<void>;
+}
+//#endregion
+//#region src/sharing/export.d.ts
+interface ShareBundle {
+  manifest: ShareManifest;
+  objects: Map<string, Uint8Array>;
+  attribution?: {
+    login: string;
+    sharedAt: number;
+  };
+}
+type ShareExportStore = Pick<ReviewStore, "read" | "resource">;
+type ShareExportData = Pick<LocalReviewData, "map" | "validateResource" | "validateSource">;
+/** Freeze one stored version before any asynchronous source reads. */
+declare function exportShare(input: {
+  store: ShareExportStore;
+  data: ShareExportData;
+  reviewId: string;
+  version?: number;
+  repository?: ShareManifest["repository"];
+}): Promise<ShareBundle>;
+//#endregion
+//#region src/sharing/client.d.ts
+/** Account tokens go only to the configured API origin, never to object storage. */
+declare class ShareClient {
+  private readonly token?;
+  private readonly send;
+  private readonly origin;
+  constructor(origin: string, token?: string | undefined, send?: typeof fetch);
+  private api;
+  private upload;
+  create(bundle: ShareBundle, requestId?: string, beforeUpload?: () => Promise<void>): Promise<{
+    shareId: string;
+    url: string;
+  }>;
+  list(cursor?: string): Promise<JsonValue>;
+  recoverLink(shareId: string): Promise<{
+    shareId: string;
+    url: string;
+  }>;
+  revoke(shareId: string): Promise<JsonValue>;
+  download(shareId: string, capability: string): Promise<ShareBundle>;
+}
+//#endregion
+//#region src/sharing/repository.d.ts
+/** Recipients need complete history; publication only checks that the commits exist. */
+declare function fetchPinnedRepository(root: string, url: string, pins: Pick<Pins, "base" | "head">, publishing?: boolean): Promise<void>;
+declare function verifyShareRepository(root: string, pins: Pins, repository?: {
+  cloneUrl: string;
+}): Promise<{
+  cloneUrl: string;
+}>;
+//#endregion
+//#region src/sharing/import.d.ts
+declare function validateShareBundle(bundle: ShareBundle): {
+  manifest: {
+    format: "review-share/1";
+    reviewId: string;
+    version: number;
+    title: string;
+    snapshot: string;
+    presentation: string;
+    objects: {
+      id: string;
+      size: number;
+      sha256: string;
+    }[];
+    resources: {
+      id: string;
+      kind: "map" | "image" | "trace";
+      mimeType: "application/json" | "image/png";
+      object: string;
+    }[];
+    repository?: {
+      cloneUrl: string;
+    } | undefined;
+  };
+  snapshot: {
+    [x: string]: any;
+    reviewId: string;
+    version: number;
+    title: string;
+    createdAt: string;
+    lenses?: any[] | undefined;
+    origin?: {
+      branch?: string | undefined;
+      baseRef?: string | undefined;
+      pullRequestNumber?: number | undefined;
+      pullRequestUrl?: string | undefined;
+      revision?: string | undefined;
+    } | undefined;
+  };
+  presentation: {
+    maps: Record<string, {
+      commit: string;
+      side: "base" | "head";
+      elements: any[];
+      relationships: any[];
+      countsByElementPath: Record<string, {
+        additions: number;
+        deletions: number;
+      }>;
+      unmappedByElementPath: Record<string, {
+        additions: number;
+        deletions: number;
+        files: {
+          additions: number;
+          deletions: number;
+          file: string;
+          hunks: {
+            startLine: number;
+            lines: {
+              kind: "add" | "remove";
+              oldLine: number | null;
+              newLine: number | null;
+              text: string;
+            }[];
+          }[];
+        }[];
+      }>;
+    }>;
+  };
+};
+declare function sharedReviewId(origin: string, shareId: string): string;
+/** Separate immutable directory tree; authoring mutation handlers cannot write it. */
+declare class SharedReviewStore {
+  readonly root: string;
+  private readonly fetchRepository;
+  private readonly loaded;
+  private readonly validated;
+  private readonly attention;
+  private readonly listeners;
+  private catalogLoaded;
+  private readonly downloads;
+  trackImport(job: Promise<void>): void;
+  close(): Promise<void>;
+  private local?;
+  private readonly repositories;
+  private readonly jobs;
+  private readonly states;
+  constructor(root: string, fetchRepository?: typeof fetchPinnedRepository);
+  connect(store: ReviewStore, data: LocalReviewData): void;
+  has(id: string): boolean;
+  status(id: string): {
+    stage: "downloading" | "fetching" | "validating" | "ready" | "error";
+    error?: string;
+  };
+  setStatus(id: string, stage: "downloading" | "fetching" | "validating" | "ready" | "error", error?: string): void;
+  repositoryRoot(id: string): string;
+  prepare(id: string): Promise<void>;
+  private prepareRepository;
+  assertReady(id: string): Promise<void>;
+  subscribe(listener: () => void): () => void;
+  load(): Promise<void>;
+  get(id: string): {
+    snapshot: {
+      reviewId: string;
+      pins: any;
+      target: any;
+      shared: {
+        cloneUrl: string | undefined;
+        login?: string | undefined;
+        sharedAt?: number | undefined;
+      };
+      version: number;
+      title: string;
+      createdAt: string;
+      lenses?: any[] | undefined;
+      origin?: {
+        branch?: string | undefined;
+        baseRef?: string | undefined;
+        pullRequestNumber?: number | undefined;
+        pullRequestUrl?: string | undefined;
+        revision?: string | undefined;
+      } | undefined;
+    };
+    manifest: {
+      format: "review-share/1";
+      reviewId: string;
+      version: number;
+      title: string;
+      snapshot: string;
+      presentation: string;
+      objects: {
+        id: string;
+        size: number;
+        sha256: string;
+      }[];
+      resources: {
+        id: string;
+        kind: "map" | "image" | "trace";
+        mimeType: "application/json" | "image/png";
+        object: string;
+      }[];
+      repository?: {
+        cloneUrl: string;
+      } | undefined;
+    };
+    presentation: {
+      maps: Record<string, {
+        commit: string;
+        side: "base" | "head";
+        elements: any[];
+        relationships: any[];
+        countsByElementPath: Record<string, {
+          additions: number;
+          deletions: number;
+        }>;
+        unmappedByElementPath: Record<string, {
+          additions: number;
+          deletions: number;
+          files: {
+            additions: number;
+            deletions: number;
+            file: string;
+            hunks: {
+              startLine: number;
+              lines: {
+                kind: "add" | "remove";
+                oldLine: number | null;
+                newLine: number | null;
+                text: string;
+              }[];
+            }[];
+          }[];
+        }>;
+      }>;
+    };
+  };
+  list(mode?: "structural" | "textual"): any;
+  readObject(id: string, objectId: string): Promise<NonSharedBuffer>;
+  removeLocal(id: string): Promise<void>;
+  setAttention(id: string, action: "view" | "dismiss" | "restore"): Promise<void>;
+  import(origin: string, shareId: string, bundle: ShareBundle): Promise<string>;
+  read(id: string): Promise<ShareBundle>;
+  private readValidated;
+}
+//#endregion
+export { type ShareBundle, ShareClient, type ShareExportData, type ShareExportStore, SharedReviewStore, exportShare, sharedReviewId, validateShareBundle, verifyShareRepository };