@fabrika/canvas-kernel 0.1.44

package/src/client/generateMarkdown.ts

@@ -0,0 +1,250 @@
+// The canvas document format: revisions, responses, required fields, sections.
+// Rendering one annotation is host-agnostic and lives in ./annotationMarkdown.
+import type { Annotation, PlanResponse, FeedbackEntry } from "./AnnotationProvider";
+import { renderAnnotation } from "./annotationMarkdown";
+import { RESPONSE_ANNOTATION_PATH } from "./utils";
+
+/**
+ * Drop answers whose question is not in this revision's canvas. A draft carried
+ * forward by carryUnsubmittedDraft() can hold an answer to a question the new
+ * revision removed; submitting that would report an answer the author was never
+ * asked for.
+ *
+ * `seenResponseIds` must be the sticky set of controls that have mounted at any
+ * point in this draft, never the currently-mounted ones — see canPruneResponses.
+ */
+export function pruneStaleResponses(
+  responses: Map<string, PlanResponse>,
+  seenResponseIds: ReadonlySet<string>,
+): Map<string, PlanResponse> {
+  const out = new Map<string, PlanResponse>();
+  for (const [id, r] of responses) {
+    if (seenResponseIds.has(id)) out.set(id, r);
+  }
+  return out;
+}
+
+/**
+ * Whether the set of seen response ids is complete enough to prune against.
+ *
+ * An id is only evidence of absence once every canvas that could host it has
+ * rendered. Until then "not seen" means "not looked at yet" — the host opens
+ * multi-canvas sessions on the overview, where no canvas is mounted at all, so
+ * pruning early would throw away every answer the author gave.
+ */
+export function canPruneResponses(
+  canvasFiles: readonly string[] | undefined,
+  renderedCanvases: ReadonlySet<string>,
+): boolean {
+  if (!canvasFiles || canvasFiles.length === 0) return false;
+  return canvasFiles.every((filename) => renderedCanvases.has(filename));
+}
+
+/**
+ * Generate human-readable markdown feedback from annotations and responses.
+ */
+export function generateMarkdown(
+  annotations: Annotation[],
+  generalNote: string,
+  responses?: Map<string, PlanResponse>,
+  feedbackEntries?: Map<string, FeedbackEntry>,
+  includedRemoteIds?: Set<string>,
+): string {
+  const parts: string[] = [];
+  const included = annotations.filter((a) =>
+    a.source !== "remote" || (includedRemoteIds && includedRemoteIds.has(a.id))
+  );
+  const responseAnns = included.filter((a) => a.filePath === RESPONSE_ANNOTATION_PATH);
+  const canvasAnns = included.filter((a) => !a.filePath);
+  const fileAnns = included.filter((a) => a.filePath && a.filePath !== RESPONSE_ANNOTATION_PATH);
+  const resps = responses ? Array.from(responses.values()).filter((r) => hasValue(r)) : [];
+  const fbEntries = feedbackEntries
+    ? Array.from(feedbackEntries.values()).filter((e) => e.markdown.trim())
+    : [];
+
+  // Responses section
+  const hasResponseSection = resps.length > 0 || fbEntries.length > 0;
+  if (hasResponseSection) {
+    parts.push("## Responses");
+    parts.push("");
+    for (const r of resps) {
+      parts.push(renderResponse(r));
+    }
+    for (const entry of fbEntries) {
+      parts.push(entry.markdown.trim());
+      parts.push("");
+    }
+  }
+
+  // Response annotations (on agent response banner)
+  if (responseAnns.length > 0) {
+    parts.push("## Annotations on agent response");
+    parts.push("");
+    for (const ann of responseAnns) {
+      parts.push(renderAnnotation(ann));
+    }
+  }
+
+  // Canvas annotations grouped by canvas file, then hierarchy
+  if (canvasAnns.length > 0) {
+    parts.push("## Canvas annotations");
+    parts.push("");
+
+    // Group by canvasFile
+    const byCanvas = new Map<string, Annotation[]>();
+    for (const ann of canvasAnns) {
+      const key = ann.canvasFile || "";
+      if (!byCanvas.has(key)) byCanvas.set(key, []);
+      byCanvas.get(key)!.push(ann);
+    }
+
+    const canvasKeys = [...byCanvas.keys()].sort();
+    const multipleCanvases = canvasKeys.length > 1 || (canvasKeys.length === 1 && canvasKeys[0] !== "");
+
+    for (const canvasKey of canvasKeys) {
+      const anns = byCanvas.get(canvasKey)!;
+      if (multipleCanvases && canvasKey) {
+        parts.push(`### ${canvasKey.replace(/\.jsx$/, "")}`);
+        parts.push("");
+      }
+      const grouped = groupByHierarchy(anns);
+      parts.push(renderHierarchyGroup(grouped));
+    }
+  }
+
+  // File annotations grouped by path
+  if (fileAnns.length > 0) {
+    const groups: Record<string, Annotation[]> = {};
+    for (const ann of fileAnns) {
+      const key = ann.filePath!;
+      if (!groups[key]) groups[key] = [];
+      groups[key].push(ann);
+    }
+    parts.push("## File annotations");
+    parts.push("");
+    for (const [filePath, anns] of Object.entries(groups)) {
+      parts.push(`### ${filePath}`);
+      parts.push("");
+      for (const ann of anns) {
+        parts.push(renderAnnotation(ann));
+      }
+    }
+  }
+
+  // General notes
+  if (generalNote.trim()) {
+    parts.push("## General notes");
+    parts.push("");
+    parts.push(generalNote.trim());
+    parts.push("");
+  }
+
+  return parts.join("\n").trim() + "\n";
+}
+
+export function hasValue(r: PlanResponse): boolean {
+  if (r.note?.trim()) return true;
+  if (r.value === null || r.value === undefined) return false;
+  if (r.type === "text" && !(r.value as string).trim()) return false;
+  if (r.type === "checkbox" && (r.value as string[]).length === 0) return false;
+  return true;
+}
+
+export function getMissingRequired(responses: Map<string, PlanResponse>): PlanResponse[] {
+  const missing: PlanResponse[] = [];
+  for (const r of responses.values()) {
+    if (!r.required) continue;
+    if (r.value === null || r.value === undefined) { missing.push(r); continue; }
+    if (r.type === "text" && !(r.value as string).trim()) { missing.push(r); continue; }
+    if (r.type === "checkbox" && (r.value as string[]).length === 0) { missing.push(r); continue; }
+  }
+  return missing;
+}
+
+export function getMissingRequiredFeedback(entries: Map<string, FeedbackEntry>): FeedbackEntry[] {
+  const missing: FeedbackEntry[] = [];
+  for (const entry of entries.values()) {
+    if (entry.required && !entry.markdown.trim()) {
+      missing.push(entry);
+    }
+  }
+  return missing;
+}
+
+/** Returns list of missing required field labels, or empty if all valid */
+export function getMissingRequiredLabels(responses: Map<string, PlanResponse>, feedbackEntries: Map<string, FeedbackEntry>): string[] {
+  const missingResponses = getMissingRequired(responses);
+  const missingFeedback = getMissingRequiredFeedback(feedbackEntries);
+  return [
+    ...missingResponses.map((r) => r.label),
+    ...missingFeedback.map((e) => e.label || e.id),
+  ];
+}
+
+function renderResponse(r: PlanResponse): string {
+  const lines: string[] = [];
+  lines.push(`**${r.label}**`);
+
+  switch (r.type) {
+    case "radio":
+    case "select":
+      lines.push(`Answer: ${r.value}`);
+      break;
+    case "checkbox":
+      for (const v of r.value as string[]) {
+        lines.push(`- [x] ${v}`);
+      }
+      break;
+    case "text":
+      lines.push("");
+      lines.push((r.value as string).trim());
+      break;
+    case "range":
+      lines.push(`Answer: ${r.value}`);
+      break;
+  }
+
+  if (r.note?.trim()) {
+    lines.push("");
+    lines.push(`Note: ${r.note.trim()}`);
+  }
+
+  lines.push("");
+  return lines.join("\n");
+}
+
+interface HierarchyNode {
+  label: string;
+  annotations: Annotation[];
+  children: Map<string, HierarchyNode>;
+}
+
+function groupByHierarchy(annotations: Annotation[]): HierarchyNode {
+  const root: HierarchyNode = { label: "", annotations: [], children: new Map() };
+  for (const ann of annotations) {
+    const path = ann.context?.hierarchy || [];
+    let current = root;
+    for (const segment of path) {
+      if (!current.children.has(segment)) {
+        current.children.set(segment, { label: segment, annotations: [], children: new Map() });
+      }
+      current = current.children.get(segment)!;
+    }
+    current.annotations.push(ann);
+  }
+  return root;
+}
+
+function renderHierarchyGroup(node: HierarchyNode, depth: number = 0): string {
+  const parts: string[] = [];
+  for (const ann of node.annotations) {
+    parts.push(renderAnnotation(ann));
+  }
+  for (const [, child] of node.children) {
+    const prefix = depth === 0 ? "###" : "####";
+    parts.push(`${prefix} ${child.label}`);
+    parts.push("");
+    parts.push(renderHierarchyGroup(child, depth + 1));
+  }
+  return parts.join("\n");
+}

package/src/client/highlightRange.ts

@@ -0,0 +1,262 @@
+/**
+ * Wraps the current browser Range in <mark> elements with the given annotation ID.
+ * Works for multiline / cross-element selections.
+ */
+export function wrapRangeWithMark(range: Range, annotationId: string): HTMLElement[] {
+  const marks: HTMLElement[] = [];
+
+  // Collect all text nodes within the range
+  const textNodes = getTextNodesInRange(range);
+
+  for (const tn of textNodes) {
+    const nodeRange = document.createRange();
+    nodeRange.selectNodeContents(tn);
+
+    // Clamp to the actual selection range
+    if (tn === range.startContainer) {
+      nodeRange.setStart(tn, range.startOffset);
+    }
+    if (tn === range.endContainer) {
+      nodeRange.setEnd(tn, range.endOffset);
+    }
+
+    const text = nodeRange.toString();
+    if (!text || !text.trim()) continue;
+
+    // Wrap this portion in a <mark>
+    const mark = document.createElement("mark");
+    mark.setAttribute("data-annotation-id", annotationId);
+
+    try {
+      nodeRange.surroundContents(mark);
+    } catch {
+      // surroundContents fails if range crosses element boundaries within a single text node
+      // (shouldn't happen for a single text node, but handle gracefully)
+      const fragment = nodeRange.extractContents();
+      mark.appendChild(fragment);
+      nodeRange.insertNode(mark);
+    }
+
+    marks.push(mark);
+  }
+
+  return marks;
+}
+
+/**
+ * Whether the annotation index carries this text. Line-number gutters and text
+ * that already belongs to another annotation are outside it. Everything that
+ * records a snippet or its context is matched back against that index later, so
+ * all of them have to skip exactly the same runs.
+ */
+export function isIndexedText(node: Text): boolean {
+  const parent = node.parentElement;
+  if (parent?.classList.contains("select-none")) return false;
+  if (parent?.closest("[data-annotation-id]")) return false;
+  return true;
+}
+
+function getTextNodesInRange(range: Range): Text[] {
+  const nodes: Text[] = [];
+  const ancestor = range.commonAncestorContainer;
+
+  if (ancestor.nodeType === Node.TEXT_NODE) {
+    nodes.push(ancestor as Text);
+    return nodes;
+  }
+
+  const walker = document.createTreeWalker(ancestor, NodeFilter.SHOW_TEXT);
+  let node: Text | null;
+  while ((node = walker.nextNode() as Text | null)) {
+    if (!isIndexedText(node)) continue;
+    if (range.intersectsNode(node)) {
+      nodes.push(node);
+    }
+  }
+
+  return nodes;
+}
+
+/** The part of a text node that falls inside the range. */
+function clampToRange(node: Text, range: Range): string {
+  const nodeRange = document.createRange();
+  nodeRange.selectNodeContents(node);
+  if (node === range.startContainer) nodeRange.setStart(node, range.startOffset);
+  if (node === range.endContainer) nodeRange.setEnd(node, range.endOffset);
+  return nodeRange.toString();
+}
+
+/**
+ * A selection's text as the annotation index will read it back. The raw
+ * selection is not that: it carries the gutter and any text already inside
+ * another annotation, none of which the index holds — so a snippet taken from
+ * it names something that cannot be found again.
+ */
+export function rangeIndexText(range: Range): string {
+  let text = "";
+  for (const node of getTextNodesInRange(range)) {
+    text += clampToRange(node, range);
+  }
+  return text;
+}
+
+/**
+ * Update the visual state of marks for a given annotation ID.
+ */
+export function setMarkActive(annotationId: string, active: boolean) {
+  const marks = document.querySelectorAll(`[data-annotation-id="${annotationId}"]`);
+  for (const mark of marks) {
+    (mark as HTMLElement).classList.toggle("mark-active", active);
+  }
+}
+
+/**
+ * Update active state for annotation marks.
+ * Only touches marks for the previous and current active IDs to avoid full DOM scans.
+ */
+export function updateAllMarkStates(activeId: string | null, prevActiveId?: string | null) {
+  if (prevActiveId != null && prevActiveId !== activeId) {
+    setMarkActive(prevActiveId, false);
+  }
+  if (activeId != null) {
+    setMarkActive(activeId, true);
+  }
+}
+
+/**
+ * Rename annotation ID on existing marks (e.g. temp → real ID).
+ */
+export function renameMarkId(oldId: string, newId: string) {
+  const marks = document.querySelectorAll(`[data-annotation-id="${oldId}"]`);
+  for (const mark of marks) {
+    mark.setAttribute("data-annotation-id", newId);
+  }
+}
+
+/**
+ * Restore marks for persisted annotations by finding their snippet text in the DOM.
+ * Uses before/after context for disambiguation when the same text appears multiple times.
+ */
+export function restoreMarks(
+  container: HTMLElement,
+  annotations: { id: string; snippet: string; filePath?: string; context?: { before: string; after: string; hierarchy: string[] } }[]
+) {
+  for (const ann of annotations) {
+    // A canvas can be rendered more than once (overview, compare, hidden
+    // source panes), so restore decisions must be scoped to this container.
+    if (container.querySelector(`[data-annotation-id="${ann.id}"]`)) continue;
+
+    const snippet = ann.snippet;
+    if (!snippet) continue;
+
+    // Rebuild after every inserted mark. Wrapping text splits and moves text
+    // nodes, so a cached offset map can point at stale DOM after the first hit.
+    const { fullText, textNodes } = buildTextIndex(container);
+
+    // Find all occurrences of the snippet in the full text
+    const occurrences: number[] = [];
+    let searchFrom = 0;
+    while (true) {
+      const idx = fullText.indexOf(snippet, searchFrom);
+      if (idx === -1) break;
+      occurrences.push(idx);
+      searchFrom = idx + 1;
+    }
+
+    const [firstOccurrence] = occurrences;
+    if (firstOccurrence === undefined) continue;
+
+    // Pick the best occurrence using context
+    let bestIdx = firstOccurrence;
+    if (occurrences.length > 1 && ann.context) {
+      let bestScore = -1;
+      for (const idx of occurrences) {
+        let score = 0;
+        if (ann.context.before) {
+          const preceding = fullText.slice(Math.max(0, idx - 80), idx);
+          if (preceding.includes(ann.context.before)) score += 2;
+          else if (ann.context.before.length > 10 && preceding.includes(ann.context.before.slice(-10))) score += 1;
+        }
+        if (ann.context.after) {
+          const following = fullText.slice(idx + snippet.length, idx + snippet.length + 80);
+          if (following.includes(ann.context.after)) score += 2;
+          else if (ann.context.after.length > 10 && following.includes(ann.context.after.slice(0, 10))) score += 1;
+        }
+        if (score > bestScore) {
+          bestScore = score;
+          bestIdx = idx;
+        }
+      }
+    }
+
+    // Map text offsets to DOM positions
+    const startOffset = bestIdx;
+    const endOffset = bestIdx + snippet.length;
+
+    const startPos = offsetToNode(textNodes, startOffset);
+    const endPos = offsetToNode(textNodes, endOffset);
+    if (!startPos || !endPos) continue;
+
+    try {
+      const range = document.createRange();
+      range.setStart(startPos.node, startPos.offset);
+      range.setEnd(endPos.node, endPos.offset);
+      wrapRangeWithMark(range, ann.id);
+    } catch {}
+  }
+}
+
+function buildTextIndex(container: HTMLElement): {
+  fullText: string;
+  textNodes: { node: Text; start: number }[];
+} {
+  const textNodes: { node: Text; start: number }[] = [];
+  let fullText = "";
+  const walker = document.createTreeWalker(container, NodeFilter.SHOW_TEXT);
+  let tn: Text | null;
+  while ((tn = walker.nextNode() as Text | null)) {
+    if (!isIndexedText(tn)) continue;
+    textNodes.push({ node: tn, start: fullText.length });
+    fullText += tn.textContent || "";
+  }
+  return { fullText, textNodes };
+}
+
+function offsetToNode(
+  textNodes: { node: Text; start: number }[],
+  offset: number
+): { node: Text; offset: number } | null {
+  for (let i = textNodes.length - 1; i >= 0; i--) {
+    const entry = textNodes[i];
+    if (!entry || entry.start > offset) continue;
+    const localOffset = offset - entry.start;
+    const nodeLen = entry.node.textContent?.length ?? 0;
+    if (localOffset <= nodeLen) {
+      return { node: entry.node, offset: localOffset };
+    }
+  }
+  return null;
+}
+
+/**
+ * Remove the decoration for a given annotation ID, restoring the original text
+ * nodes an inline mark wrapped.
+ */
+export function unwrapMarks(annotationId: string) {
+  const marks = document.querySelectorAll(`[data-annotation-id="${annotationId}"]`);
+  for (const mark of marks) {
+    const parent = mark.parentNode;
+    if (!parent) continue;
+    // Decoration that is not an inline mark — a region overlay — wraps no text
+    // and is simply taken out.
+    if (mark.tagName !== "MARK") {
+      parent.removeChild(mark);
+      continue;
+    }
+    while (mark.firstChild) {
+      parent.insertBefore(mark.firstChild, mark);
+    }
+    parent.removeChild(mark);
+    parent.normalize();
+  }
+}

package/src/client/hostContext.tsx

@@ -0,0 +1,55 @@
+import { createContext, useContext } from "react";
+
+/**
+ * What the annotation surface needs from the host serving it.
+ *
+ * The kernel ships a local-daemon implementation, so a host that serves
+ * canvases straight off its own daemon needs no provider. Hosts with extra
+ * delivery modes (agent-canvas also serves read-only encrypted share links)
+ * provide their own.
+ */
+export interface CanvasHost {
+  /** Session the canvas belongs to. */
+  sessionId: string;
+  /** Read-only share view — local-only affordances stay hidden. */
+  isShared: boolean;
+  /** Host can read project files (feedback bodies, file browser). */
+  fsAvailable: boolean;
+  /** Endpoint accepting annotation image uploads, or `null` for a host that
+   *  has none — the attach affordances then stay hidden rather than posting
+   *  into the void. Required, not optional, so no host can be silent about it. */
+  uploadUrl: (() => string) | null;
+  /** Fetch and `import()` a compiled canvas module. */
+  loadCanvasModule: (filename: string, revision?: number) => Promise<any>;
+}
+
+/** Local mode carries the session id as the `/s/:id` path suffix. */
+function localSessionId(): string {
+  if (typeof window === "undefined") return "";
+  return window.location.pathname.replace("/s/", "");
+}
+
+export const localCanvasHost: CanvasHost = {
+  get sessionId() {
+    return localSessionId();
+  },
+  isShared: false,
+  fsAvailable: true,
+  // No endpoint by default. The only hosts that reach this fallback are the
+  // ones that configured nothing, which are exactly the ones least likely to
+  // serve an upload route — claiming one on their behalf is how every host got
+  // a paperclip that posts into the void. A host with uploads names its own.
+  uploadUrl: null,
+  loadCanvasModule: (filename, revision) => {
+    const jsName = filename.replace(/\.jsx$/, ".js");
+    const query = revision ? `?rev=${revision}&t=${Date.now()}` : `?t=${Date.now()}`;
+    const url = `/api/session/${localSessionId()}/canvas/${encodeURIComponent(jsName)}${query}`;
+    return import(/* @vite-ignore */ url);
+  },
+};
+
+export const CanvasHostContext = createContext<CanvasHost>(localCanvasHost);
+
+export function useCanvasHost(): CanvasHost {
+  return useContext(CanvasHostContext);
+}

package/src/client/index.ts

@@ -0,0 +1,128 @@
+// @fabrika/canvas-kernel/client — the reusable annotation surface.
+//
+// Everything a host needs to render a compiled canvas and collect feedback on
+// it, minus the app shell (navigation, file browser, revision chrome), which
+// each host builds itself.
+
+// --- Annotation state ------------------------------------------------------
+// Everything that lives in runtime.ts is re-exported through `#canvas/runtime`,
+// never through a relative path. The runtime holds the React contexts and ships
+// as its own bundle shared with the compiled canvas; importing it relatively
+// would bundle a second copy, and the provider and its consumers would then be
+// writing to and reading from different contexts.
+export { AnnotationProvider } from "./AnnotationProvider";
+export type { PersistedState } from "./AnnotationProvider";
+export {
+  useAnnotations,
+  useFeedback,
+  useCanvasFile,
+  useResponseRegistration,
+  AnnotationCtx,
+  SessionContext,
+  ActiveViewCtx,
+  CanvasFileCtx,
+} from "#canvas/runtime";
+export type {
+  Annotation,
+  AnnotationAttachment,
+  AnnotationAuthor,
+  AnnotationContext,
+  AnnotationContextValue,
+  ActiveView,
+  FeedbackEntry,
+  PlanResponse,
+} from "#canvas/runtime";
+
+// --- Surface ---------------------------------------------------------------
+export { AnnotationSidebar } from "./AnnotationSidebar";
+// The sidebar's reusable halves. Grouping stayed with the sidebar — what an
+// annotation belongs to is the host's taxonomy, so the host slices the list.
+export { AnnotationList } from "./AnnotationList";
+export type { AnnotationListProps } from "./AnnotationList";
+export { AnnotationDraftFooter } from "./AnnotationDraftFooter";
+export type { AnnotationDraftFooterProps } from "./AnnotationDraftFooter";
+export { AnnotationEditor, imageToUrl } from "./AnnotationEditor";
+export { PlanRenderer } from "./PlanRenderer";
+export { Popover, AnnotationPopover, AnnotationCreatePopover, AnnotationEditPopover } from "./Popover";
+export { ResponsePreview, MarkdownPreview } from "./ResponsePreview";
+export { FileIcon } from "./FileIcon";
+
+/** The kernel component set, as a namespace for hosts that inject it wholesale. */
+export * as components from "./components";
+export { useTextAnnotation } from "./useTextAnnotation";
+export { useRegionAnnotation } from "./useRegionAnnotation";
+
+// --- Host-provided context -------------------------------------------------
+export { CanvasHostContext, localCanvasHost, useCanvasHost } from "./hostContext";
+export type { CanvasHost } from "./hostContext";
+export { ActiveViewContext, RevisionContext } from "./appContext";
+export type { CanvasFileInfo, RevisionInfo } from "./appContext";
+export { RenderErrorContext } from "./RenderErrorContext";
+export type { CanvasRenderError } from "./RenderErrorContext";
+
+// --- Annotation plumbing ---------------------------------------------------
+export { extractContext, formatSnippetInContext } from "./annotationContext";
+export {
+  ANNOTATION_TARGETS,
+  ANNOTATABLE_SELECTOR,
+  BLOCK_SELECTOR,
+  describeSnippet,
+  findAnnotationElement,
+  findSnippetElement,
+  getBlockSnippet,
+  restoreAnnotationTargets,
+  scrollToAnnotation,
+} from "./annotationDom";
+
+// --- Locator strategies ----------------------------------------------------
+// What a snippet points at is the one thing in an annotation that is domain
+// specific. A host that needs to annotate something the kernel has no target
+// for writes one of these; nothing else has to change.
+export { sealTarget } from "./annotationTarget";
+export type { AnnotationTarget, SealedAnnotationTarget, TargetAnnotation } from "./annotationTarget";
+export { blockTarget } from "./blockTarget";
+export type { BlockLocator } from "./blockTarget";
+export { textTarget } from "./textTarget";
+export type { TextLocator } from "./textTarget";
+export {
+  createRegionOverlay,
+  describeRegion,
+  findRegionHost,
+  isDrawableRegion,
+  regionBetween,
+  regionPointIn,
+  regionStyle,
+  regionTarget,
+  REGION_HOST_ATTR,
+  REGION_UNITS,
+} from "./regionTarget";
+export type { RegionBox, RegionLocator, RegionPoint, RegionShape } from "./regionTarget";
+export {
+  annotationDraftKey,
+  carryUnsubmittedDraft,
+  clearPersistedDraft,
+} from "./annotationDraft";
+export type { AnnotationDraftPhase } from "./annotationDraft";
+export {
+  restoreMarks,
+  renameMarkId,
+  setMarkActive,
+  unwrapMarks,
+  updateAllMarkStates,
+  wrapRangeWithMark,
+} from "./highlightRange";
+// One annotation as markdown — the half of feedback that belongs to no
+// particular document format. `generateMarkdown` below is the canvas format
+// built on it; a host with its own headings calls this directly.
+export { renderAnnotation } from "./annotationMarkdown";
+export type { RenderableAnnotation } from "./annotationMarkdown";
+export {
+  canPruneResponses,
+  generateMarkdown,
+  getMissingRequired,
+  getMissingRequiredFeedback,
+  getMissingRequiredLabels,
+  hasValue,
+  pruneStaleResponses,
+} from "./generateMarkdown";
+export { autoResizeTextarea, fileAnnotationPath, generateAnnotationId, hostAcceptsUploads, RESPONSE_ANNOTATION_PATH } from "./utils";