@lostgradient/cinder 0.4.0 → 0.4.1

package/dist/server/index.server-kykvc153.js

@@ -0,0 +1,3393 @@
+import {
+  Selection_popover
+} from "./index.server-r30hm3ep.js";
+import {
+  Textarea
+} from "./index.server-41003crj.js";
+import {
+  Diff_statistics
+} from "./index.server-4p5znv15.js";
+import {
+  Diff_viewer
+} from "./index.server-fnj6xyr0.js";
+import {
+  Checkbox
+} from "./index.server-qjdkp02z.js";
+import {
+  Markdown_editor
+} from "./index.server-xjmx6rm8.js";
+import {
+  Segment
+} from "./index.server-qreadmdy.js";
+import {
+  Segmented_control
+} from "./index.server-nxx9ckb3.js";
+import {
+  Input
+} from "./index.server-8gakk9d5.js";
+import {
+  createCopyState,
+  stringifyOrNull
+} from "./index.server-nwjjp9t6.js";
+import {
+  Dropdown
+} from "./index.server-kjtb596w.js";
+import {
+  Dropdown_trigger
+} from "./index.server-77gpgvab.js";
+import {
+  Dropdown_item
+} from "./index.server-r0wzpqh7.js";
+import {
+  Dropdown_menu
+} from "./index.server-4jc5ny87.js";
+import {
+  createAnchoredOverlay
+} from "./index.server-94b7tjs5.js";
+import {
+  useReducedMotion
+} from "./index.server-8hdvr9bt.js";
+import {
+  Git_branch,
+  Message_square,
+  Plus,
+  Trash_2
+} from "./index.server-eq2ca4j4.js";
+import {
+  Ellipsis,
+  Pencil
+} from "./index.server-nav1z5d8.js";
+import {
+  X
+} from "./index.server-3fvz5gak.js";
+import {
+  Rotate_ccw
+} from "./index.server-e10j3s54.js";
+import {
+  File_code
+} from "./index.server-p78n7r6g.js";
+import {
+  File_text
+} from "./index.server-y16zcjfw.js";
+import {
+  Badge
+} from "./index.server-bkz7h7jx.js";
+import {
+  Copy
+} from "./index.server-ans2v9y9.js";
+import {
+  Check
+} from "./index.server-y0q949bm.js";
+import {
+  Button
+} from "./index.server-34p02y48.js";
+import {
+  devWarn
+} from "./index.server-nj8mebze.js";
+import {
+  classNames
+} from "./index.server-z7nvkz8v.js";
+
+// src/components/review-editor/review-editor.svelte
+import * as $11 from "svelte/internal/server";
+
+// src/components/review-editor/review-editor-impl.svelte
+import * as $10 from "svelte/internal/server";
+
+// src/components/review-editor/focus-navigation.ts
+var FOCUSABLE_SELECTOR = 'button, [href], input, select, textarea, [tabindex]:not([tabindex="-1"])';
+function createFocusRegionNavigator(regions, options = {}) {
+  const { isRegionActive, customFocusHandler } = options;
+  function getActiveRegions() {
+    if (!isRegionActive) {
+      return regions;
+    }
+    return regions.filter(isRegionActive);
+  }
+  function getFallbackRegion() {
+    const firstRegion = regions[0];
+    if (!firstRegion) {
+      throw new Error("createFocusRegionNavigator requires at least one focus region.");
+    }
+    return firstRegion;
+  }
+  function getCurrentRegion(container) {
+    const active = document.activeElement;
+    if (!active || !container.contains(active)) {
+      return null;
+    }
+    for (const region of regions) {
+      const element = container.querySelector(region.selector);
+      if (element?.contains(active)) {
+        return region;
+      }
+    }
+    return null;
+  }
+  function getNextRegion(current, reverse = false) {
+    const activeRegions = getActiveRegions();
+    if (activeRegions.length === 0) {
+      return getFallbackRegion();
+    }
+    if (!current) {
+      return activeRegions[0] ?? getFallbackRegion();
+    }
+    const currentIndex = activeRegions.findIndex((r) => r.id === current.id);
+    if (currentIndex === -1) {
+      return activeRegions[0] ?? getFallbackRegion();
+    }
+    const nextIndex = reverse ? (currentIndex - 1 + activeRegions.length) % activeRegions.length : (currentIndex + 1) % activeRegions.length;
+    return activeRegions[nextIndex] ?? getFallbackRegion();
+  }
+  function focusRegion(container, region) {
+    if (customFocusHandler?.(region, container)) {
+      return;
+    }
+    const element = container.querySelector(region.selector);
+    if (element instanceof HTMLElement) {
+      const focusable = element.querySelector(FOCUSABLE_SELECTOR);
+      (focusable ?? element).focus();
+    }
+  }
+  return {
+    getCurrentRegion,
+    getNextRegion,
+    focusRegion,
+    getActiveRegions
+  };
+}
+
+// src/utilities/change-tracker.svelte.ts
+import * as $ from "svelte/internal/server";
+import { contentEquals, contentEqualsWithFrontMatter } from "@lostgradient/cinder/markdown/pipeline";
+function simpleHash(str) {
+  let hash = 5381;
+  for (let i = 0;i < str.length; i++) {
+    hash = (hash << 5) + hash ^ str.charCodeAt(i);
+  }
+  return hash >>> 0;
+}
+function createChangeTracker(options = {}) {
+  const { debounceMs = 300, includeFrontMatter = false } = options;
+  let baseline = "";
+  let current = "";
+  let baselineHash = 0;
+  let currentHash = 0;
+  let isPending = false;
+  let semanticResult = null;
+  let verifyTimeout = null;
+  const isDirtyFast = $.derived(() => {
+    if (baseline === current)
+      return false;
+    if (baseline.length !== current.length)
+      return true;
+    return currentHash !== baselineHash;
+  });
+  const hasChanges = $.derived(() => {
+    if (!isDirtyFast())
+      return false;
+    if (semanticResult !== null)
+      return semanticResult;
+    return true;
+  });
+  function doSemanticVerification() {
+    const equals = includeFrontMatter ? contentEqualsWithFrontMatter(baseline, current) : contentEquals(baseline, current);
+    semanticResult = !equals;
+    isPending = false;
+  }
+  function scheduleVerification(base, curr, baseHash, currHash) {
+    if (verifyTimeout) {
+      clearTimeout(verifyTimeout);
+      verifyTimeout = null;
+    }
+    semanticResult = null;
+    if (base === curr) {
+      isPending = false;
+      return;
+    }
+    if (baseHash === currHash && base.length === curr.length) {
+      isPending = true;
+      verifyTimeout = setTimeout(doSemanticVerification, debounceMs);
+      return;
+    }
+    isPending = true;
+    verifyTimeout = setTimeout(doSemanticVerification, debounceMs);
+  }
+  return {
+    get hasChanges() {
+      return hasChanges();
+    },
+    get isPending() {
+      return isPending;
+    },
+    setBaseline(value) {
+      baseline = value;
+      baselineHash = simpleHash(value);
+      semanticResult = null;
+    },
+    setCurrent(value) {
+      current = value;
+      currentHash = simpleHash(value);
+      semanticResult = null;
+    },
+    verifyNow() {
+      if (verifyTimeout) {
+        clearTimeout(verifyTimeout);
+        verifyTimeout = null;
+      }
+      if (baseline === current) {
+        isPending = false;
+        semanticResult = false;
+        return false;
+      }
+      doSemanticVerification();
+      return semanticResult ?? false;
+    },
+    destroy() {
+      if (verifyTimeout) {
+        clearTimeout(verifyTimeout);
+        verifyTimeout = null;
+      }
+    }
+  };
+}
+
+// src/components/review-editor/review-editor-impl.svelte
+import { contentEquals as contentEquals2, normalize } from "@lostgradient/cinder/markdown/pipeline";
+import { textOffsetToProseMirrorPosition } from "@lostgradient/cinder/editor";
+import { createAnchorPlugin, anchorPluginKey } from "@lostgradient/cinder/commentary/anchor-decorations";
+import {
+  reanchorQuote,
+  ANCHOR_CONTEXT_LENGTH,
+  generateId,
+  extractMentions,
+  createDocumentAnchor
+} from "@lostgradient/cinder/commentary/comments";
+import { buildAnchorFromSelection } from "@lostgradient/cinder/commentary/anchoring";
+
+// src/components/review-editor/thread-popover.svelte
+import * as $4 from "svelte/internal/server";
+import { isDocumentAnchor } from "@lostgradient/cinder/commentary/comments";
+
+// src/components/review-editor/comment-list.svelte
+import * as $2 from "svelte/internal/server";
+
+// src/utilities/format-date.ts
+var MINUTE = 60000;
+var HOUR = 3600000;
+var DAY = 86400000;
+var WEEK = 604800000;
+var MONTH = 2592000000;
+function toDate(input) {
+  if (input instanceof Date)
+    return input;
+  if (typeof input === "number")
+    return new Date(input);
+  return new Date(input);
+}
+function formatRelativeTime(input) {
+  const date = toDate(input);
+  const now = Date.now();
+  const elapsed = now - date.getTime();
+  if (elapsed < MINUTE)
+    return "just now";
+  if (elapsed < HOUR)
+    return `${Math.floor(elapsed / MINUTE)}m ago`;
+  if (elapsed < DAY)
+    return `${Math.floor(elapsed / HOUR)}h ago`;
+  if (elapsed < WEEK)
+    return `${Math.floor(elapsed / DAY)}d ago`;
+  if (elapsed < MONTH)
+    return `${Math.floor(elapsed / WEEK)}w ago`;
+  return new Intl.DateTimeFormat("en-US", {
+    month: "short",
+    day: "numeric",
+    year: "numeric",
+    timeZone: "UTC"
+  }).format(date);
+}
+// src/components/review-editor/comment-list.svelte
+function Comment_list($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      comments,
+      currentUserId,
+      mode = "edit",
+      class: className,
+      onupdate,
+      ondelete
+    } = $$props;
+    const visibleComments = $2.derived(() => comments.filter((c) => !("deletedAt" in c) || !c.deletedAt));
+    let editingCommentId = null;
+    let editingBody = "";
+    function startEdit(comment) {
+      editingCommentId = comment.id;
+      editingBody = comment.body;
+    }
+    function cancelEdit() {
+      editingCommentId = null;
+      editingBody = "";
+    }
+    function saveEdit(commentId) {
+      if (editingBody.trim()) {
+        onupdate?.(commentId, editingBody.trim());
+      }
+      cancelEdit();
+    }
+    function handleEditKeyDown(event, commentId) {
+      if (event.key === "Escape") {
+        cancelEdit();
+      } else if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
+        event.preventDefault();
+        saveEdit(commentId);
+      }
+    }
+    function canEditComment(comment) {
+      return mode !== "readonly" && comment.authorId === currentUserId;
+    }
+    function canDeleteComment(comment) {
+      return mode !== "readonly" && comment.authorId === currentUserId;
+    }
+    $$renderer2.push(`<div${$2.attr_class($2.clsx(classNames("comment-list", className)), "svelte-11dydst")}><!--[-->`);
+    const each_array = $2.ensure_array_like(visibleComments());
+    for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+      let comment = each_array[$$index];
+      $$renderer2.push(`<article class="comment svelte-11dydst"${$2.attr("data-comment-id", comment.id)}><header class="comment-header svelte-11dydst"><div class="comment-author svelte-11dydst"><div class="comment-avatar svelte-11dydst" aria-hidden="true">${$2.escape(comment.authorId.charAt(0).toUpperCase())}</div> <span class="comment-author-name svelte-11dydst">${$2.escape(comment.authorId)}</span></div> <div class="comment-meta svelte-11dydst"><time class="comment-time svelte-11dydst"${$2.attr("datetime", comment.createdAt)}${$2.attr("title", comment.createdAt)}>${$2.escape(formatRelativeTime(comment.createdAt))}</time> `);
+      if ("editedAt" in comment && comment.editedAt) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<span class="comment-edited svelte-11dydst"${$2.attr("title", `Edited ${comment.editedAt}`)}>(edited)</span>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></div></header> `);
+      if (editingCommentId === comment.id) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="comment-edit svelte-11dydst"><label${$2.attr("for", `${$2.stringify(comment.id)}-edit`)} class="sr-only svelte-11dydst">Edit comment</label> <textarea${$2.attr("id", `${$2.stringify(comment.id)}-edit`)} class="comment-edit-textarea svelte-11dydst"${$2.attr("rows", 3)}>`);
+        const $$body = $2.escape(editingBody);
+        if ($$body) {
+          $$renderer2.push(`${$$body}`);
+        } else {}
+        $$renderer2.push(`</textarea> <div class="comment-edit-actions svelte-11dydst">`);
+        Button($$renderer2, {
+          variant: "ghost",
+          size: "xs",
+          onclick: cancelEdit,
+          children: ($$renderer3) => {
+            $$renderer3.push(`<!---->Cancel`);
+          },
+          $$slots: { default: true }
+        });
+        $$renderer2.push(`<!----> `);
+        Button($$renderer2, {
+          variant: "primary",
+          size: "xs",
+          onclick: () => saveEdit(comment.id),
+          disabled: !editingBody.trim(),
+          children: ($$renderer3) => {
+            $$renderer3.push(`<!---->Save`);
+          },
+          $$slots: { default: true }
+        });
+        $$renderer2.push(`<!----></div></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+        $$renderer2.push(`<div class="comment-body svelte-11dydst">${$2.escape(comment.body)}</div>`);
+      }
+      $$renderer2.push(`<!--]--> `);
+      if (mode !== "readonly" && editingCommentId !== comment.id) {
+        $$renderer2.push("<!--[0-->");
+        $$renderer2.push(`<div class="comment-actions svelte-11dydst">`);
+        if (canEditComment(comment)) {
+          $$renderer2.push("<!--[0-->");
+          $$renderer2.push(`<button type="button" class="comment-action svelte-11dydst" aria-label="Edit comment" title="Edit comment">`);
+          Pencil($$renderer2, { class: "icon-sm" });
+          $$renderer2.push(`<!----></button>`);
+        } else {
+          $$renderer2.push("<!--[-1-->");
+        }
+        $$renderer2.push(`<!--]--> `);
+        if (canDeleteComment(comment)) {
+          $$renderer2.push("<!--[0-->");
+          $$renderer2.push(`<button type="button" class="comment-action comment-action-danger svelte-11dydst" aria-label="Delete comment" title="Delete comment">`);
+          Trash_2($$renderer2, { class: "icon-sm" });
+          $$renderer2.push(`<!----></button>`);
+        } else {
+          $$renderer2.push("<!--[-1-->");
+        }
+        $$renderer2.push(`<!--]--></div>`);
+      } else {
+        $$renderer2.push("<!--[-1-->");
+      }
+      $$renderer2.push(`<!--]--></article>`);
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (visibleComments().length === 0) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p class="comment-list-empty svelte-11dydst">No comments yet.</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  });
+}
+
+// src/components/review-editor/comment-composer.svelte
+import * as $3 from "svelte/internal/server";
+function Comment_composer($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      value = "",
+      placeholder = "Write a comment...",
+      disabled = false,
+      loading = false,
+      error,
+      minRows = 3,
+      maxRows,
+      autoExpand = true,
+      class: className,
+      onsubmit,
+      oncancel,
+      actions,
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    let textareaElement = null;
+    const isMac = $3.derived(() => {
+      if (typeof navigator === "undefined")
+        return false;
+      if ("userAgentData" in navigator && navigator.userAgentData) {
+        return navigator.userAgentData.platform === "macOS";
+      }
+      return /Mac|iPhone|iPad|iPod/.test(navigator.userAgent);
+    });
+    const errorId = $3.derived(() => `${id}-error`);
+    const canSubmit = $3.derived(() => value.trim().length > 0 && !disabled && !loading);
+    const dynamicRows = $3.derived(() => {
+      if (!autoExpand)
+        return minRows;
+      const lineCount = (value.match(/\n/g) || []).length + 1;
+      let rows = Math.max(minRows, lineCount);
+      if (maxRows !== undefined) {
+        rows = Math.min(rows, maxRows);
+      }
+      return rows;
+    });
+    function handleSubmit(event) {
+      event.preventDefault();
+      if (!canSubmit())
+        return;
+      onsubmit?.(value.trim());
+      value = "";
+      textareaElement?.focus();
+    }
+    function handleKeyDown(event) {
+      if (event.key === "Enter" && (event.metaKey || event.ctrlKey)) {
+        event.preventDefault();
+        if (canSubmit()) {
+          onsubmit?.(value.trim());
+          value = "";
+          textareaElement?.focus();
+        }
+        return;
+      }
+      if (event.key === "Escape" && oncancel) {
+        event.preventDefault();
+        oncancel();
+      }
+    }
+    function focus() {
+      textareaElement?.focus();
+    }
+    function selectAll() {
+      textareaElement?.select();
+    }
+    function clear() {
+      value = "";
+      textareaElement?.focus();
+    }
+    $$renderer2.push(`<form${$3.attr_class($3.clsx(classNames("comment-composer", className)), "svelte-uu92gn")}><label${$3.attr("for", id)} class="sr-only svelte-uu92gn">Comment</label> <div class="comment-composer-textarea-container svelte-uu92gn"><textarea${$3.attributes({
+      id,
+      class: "comment-composer-textarea",
+      "data-has-error": !!error,
+      placeholder,
+      disabled: disabled || loading,
+      rows: dynamicRows(),
+      "aria-invalid": error ? "true" : undefined,
+      "aria-describedby": error ? errorId() : undefined,
+      "aria-busy": loading ? "true" : undefined,
+      ...rest
+    }, "svelte-uu92gn")}>`);
+    const $$body = $3.escape(value);
+    if ($$body) {
+      $$renderer2.push(`${$$body}`);
+    } else {}
+    $$renderer2.push(`</textarea> <div class="comment-composer-inline-submit svelte-uu92gn">`);
+    Button($$renderer2, {
+      type: "submit",
+      variant: "primary",
+      size: "xs",
+      disabled: !canSubmit(),
+      loading,
+      children: ($$renderer3) => {
+        $$renderer3.push(`<!---->${$3.escape(loading ? "Sending..." : "Comment")}`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----></div></div> `);
+    if (error) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<p${$3.attr("id", errorId())} class="comment-composer-error svelte-uu92gn" role="alert">${$3.escape(error)}</p>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <div class="comment-composer-footer svelte-uu92gn"><span class="comment-composer-hint svelte-uu92gn"><kbd class="svelte-uu92gn">${$3.escape(isMac() ? "⌘" : "Ctrl")}</kbd><kbd class="svelte-uu92gn">↵</kbd> to submit</span> <div class="comment-composer-actions svelte-uu92gn">`);
+    if (actions) {
+      $$renderer2.push("<!--[0-->");
+      actions($$renderer2);
+      $$renderer2.push(`<!---->`);
+    } else if (oncancel) {
+      $$renderer2.push("<!--[1-->");
+      Button($$renderer2, {
+        variant: "ghost",
+        size: "xs",
+        onclick: oncancel,
+        disabled: loading,
+        children: ($$renderer3) => {
+          $$renderer3.push(`<!---->Cancel`);
+        },
+        $$slots: { default: true }
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div></div></form>`);
+    $3.bind_props($$props, { value, focus, selectAll, clear });
+  });
+}
+
+// src/components/review-editor/thread-popover.svelte
+function Thread_popover($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      thread,
+      currentUserId,
+      mode = "edit",
+      position,
+      class: className,
+      onclose,
+      ondelete,
+      oncommentcreate,
+      oncommentupdate,
+      oncommentdelete
+    } = $$props;
+    const isReadonly = $4.derived(() => mode === "readonly");
+    let popoverElement = null;
+    const virtualAnchor = $4.derived(() => {
+      if (!position)
+        return null;
+      return {
+        getBoundingClientRect: () => ({
+          x: position.x,
+          y: position.y,
+          top: position.y,
+          left: position.x,
+          right: position.x,
+          bottom: position.y,
+          width: 0,
+          height: 0
+        })
+      };
+    });
+    const anchoredOverlay = createAnchoredOverlay({
+      open: () => Boolean(position),
+      anchor: () => virtualAnchor(),
+      panel: () => popoverElement,
+      placement: () => "right-start",
+      offset: () => 8,
+      widthMode: () => "content"
+    });
+    function handleKeyDown(event) {
+      if (event.key === "Escape" && !event.defaultPrevented) {
+        event.preventDefault();
+        onclose?.();
+      }
+    }
+    function handleDelete() {
+      ondelete?.(thread.id);
+    }
+    function handleCommentUpdate(commentId, body) {
+      oncommentupdate?.(thread.id, commentId, body);
+    }
+    function handleCommentDelete(commentId) {
+      oncommentdelete?.(thread.id, commentId);
+    }
+    function handleCommentCreate(body) {
+      oncommentcreate?.(thread.id, body);
+    }
+    const isDocumentComment = $4.derived(() => isDocumentAnchor(thread.anchor));
+    const displayTitle = $4.derived(() => {
+      if (isDocumentComment()) {
+        return null;
+      }
+      const quote = thread.anchor.quote;
+      return quote.length > 30 ? `${quote.slice(0, 30)}...` : quote;
+    });
+    $$renderer2.push(`<div${$4.attr("id", id)} role="dialog" aria-modal="true"${$4.attr("aria-labelledby", `${$4.stringify(id)}-title`)} tabindex="-1"${$4.attr_class($4.clsx(classNames("thread-popover", className)), "svelte-jqotwh")}${$4.attr_style(anchoredOverlay.positionStyle)}${$4.attr("data-position-ready", anchoredOverlay.positionReady)}${$4.attr("inert", !anchoredOverlay.positionReady ? true : undefined, true)}><header class="thread-popover-header svelte-jqotwh"><div class="thread-popover-title-row svelte-jqotwh"><h2${$4.attr("id", `${$4.stringify(id)}-title`)} class="thread-popover-title svelte-jqotwh">`);
+    if (isDocumentComment()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<span class="thread-popover-document-label svelte-jqotwh">`);
+      File_text($$renderer2, { class: "icon-xs" });
+      $$renderer2.push(`<!----> Document comment</span>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<span class="thread-popover-quote svelte-jqotwh"${$4.attr("title", thread.anchor.quote)}>"${$4.escape(displayTitle())}"</span>`);
+    }
+    $$renderer2.push(`<!--]--></h2> <div class="thread-popover-header-actions svelte-jqotwh">`);
+    if (!isReadonly()) {
+      $$renderer2.push("<!--[0-->");
+      Button($$renderer2, {
+        variant: "ghost",
+        size: "xs",
+        onclick: handleDelete,
+        disabled: !currentUserId,
+        "aria-label": "Delete thread",
+        children: ($$renderer3) => {
+          Trash_2($$renderer3, { class: "icon-sm" });
+        },
+        $$slots: { default: true }
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <button type="button" class="thread-popover-close svelte-jqotwh" aria-label="Close">`);
+    X($$renderer2, { class: "icon-sm" });
+    $$renderer2.push(`<!----></button></div></div></header> <div class="thread-popover-content svelte-jqotwh">`);
+    Comment_list($$renderer2, {
+      comments: thread.comments,
+      currentUserId,
+      mode,
+      onupdate: handleCommentUpdate,
+      ondelete: handleCommentDelete
+    });
+    $$renderer2.push(`<!----></div> `);
+    if (!isReadonly() && currentUserId) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="thread-popover-composer svelte-jqotwh">`);
+      Comment_composer($$renderer2, {
+        id: `${$4.stringify(id)}-composer`,
+        placeholder: "Reply...",
+        onsubmit: handleCommentCreate
+      });
+      $$renderer2.push(`<!----></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div>`);
+  });
+}
+
+// src/components/review-editor/live-region.svelte
+import * as $5 from "svelte/internal/server";
+function Live_region($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { class: className } = $$props;
+    let message = "";
+    let priority = "polite";
+    let clearTimeoutId = null;
+    let announceVersion = 0;
+    let isDestroyed = false;
+    function announce(text, announcePriority = "polite") {
+      if (isDestroyed)
+        return;
+      const version = ++announceVersion;
+      if (clearTimeoutId) {
+        clearTimeout(clearTimeoutId);
+        clearTimeoutId = null;
+      }
+      message = "";
+      priority = announcePriority;
+      queueMicrotask(() => {
+        if (isDestroyed || announceVersion !== version)
+          return;
+        message = text;
+        clearTimeoutId = setTimeout(() => {
+          if (isDestroyed || announceVersion !== version)
+            return;
+          message = "";
+          clearTimeoutId = null;
+        }, 1000);
+      });
+    }
+    if (priority === "polite") {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div role="status" aria-live="polite" aria-atomic="true"${$5.attr_class($5.clsx(classNames("sr-only", className)))}>${$5.escape(message)}</div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<div role="alert" aria-live="assertive" aria-atomic="true"${$5.attr_class($5.clsx(classNames("sr-only", className)))}>${$5.escape(message)}</div>`);
+    }
+    $$renderer2.push(`<!--]-->`);
+    $5.bind_props($$props, { announce });
+  });
+}
+
+// src/components/review-editor/export-actions.svelte
+import * as $6 from "svelte/internal/server";
+function Export_actions($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      onexportcontent,
+      onexportsummary,
+      onexportjson,
+      onexportdiff,
+      onexportcomments,
+      class: className
+    } = $$props;
+    const copyState = createCopyState();
+    async function handleCopy(format) {
+      let content;
+      switch (format) {
+        case "content":
+          if (!onexportcontent)
+            return;
+          content = onexportcontent();
+          break;
+        case "summary":
+          content = onexportsummary();
+          break;
+        case "json":
+          content = onexportjson();
+          break;
+        case "diff":
+          content = onexportdiff();
+          break;
+        case "comments":
+          if (!onexportcomments)
+            return;
+          content = onexportcomments();
+          break;
+      }
+      await copyState.trigger(format, content);
+    }
+    const formatLabels = {
+      content: "Content",
+      summary: "Summary (for LLM)",
+      json: "JSON",
+      diff: "Git Diff",
+      comments: "Comments"
+    };
+    $$renderer2.push(`<div${$6.attr_class($6.clsx(classNames("export-actions", className)), "svelte-1cj1bq5")}><div class="cinder-sr-only" aria-live="polite" aria-atomic="true">`);
+    if (copyState.copiedKey) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`Copied ${$6.escape(formatLabels[copyState.copiedKey])}`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div> `);
+    Dropdown($$renderer2, {
+      id,
+      children: ($$renderer3) => {
+        Dropdown_trigger($$renderer3, {
+          class: "export-trigger",
+          "aria-label": "Copy to clipboard",
+          showCaret: false,
+          children: ($$renderer4) => {
+            Copy($$renderer4, { class: "icon-sm" });
+            $$renderer4.push(`<!----> <span class="cinder-sr-only">Copy</span>`);
+          },
+          $$slots: { default: true }
+        });
+        $$renderer3.push(`<!----> `);
+        Dropdown_menu($$renderer3, {
+          children: ($$renderer4) => {
+            if (onexportcontent) {
+              $$renderer4.push("<!--[0-->");
+              Dropdown_item($$renderer4, {
+                onclick: () => handleCopy("content"),
+                children: ($$renderer5) => {
+                  if (copyState.copiedKey === "content") {
+                    $$renderer5.push("<!--[0-->");
+                    Check($$renderer5, { class: "icon-sm export-icon-success" });
+                  } else {
+                    $$renderer5.push("<!--[-1-->");
+                    File_text($$renderer5, { class: "icon-sm" });
+                  }
+                  $$renderer5.push(`<!--]--> <span>${$6.escape(formatLabels.content)}</span> `);
+                  if (copyState.copiedKey === "content") {
+                    $$renderer5.push("<!--[0-->");
+                    $$renderer5.push(`<span class="copied-label svelte-1cj1bq5">Copied!</span>`);
+                  } else {
+                    $$renderer5.push("<!--[-1-->");
+                  }
+                  $$renderer5.push(`<!--]-->`);
+                },
+                $$slots: { default: true }
+              });
+            } else {
+              $$renderer4.push("<!--[-1-->");
+            }
+            $$renderer4.push(`<!--]--> `);
+            Dropdown_item($$renderer4, {
+              onclick: () => handleCopy("summary"),
+              children: ($$renderer5) => {
+                if (copyState.copiedKey === "summary") {
+                  $$renderer5.push("<!--[0-->");
+                  Check($$renderer5, { class: "icon-sm export-icon-success" });
+                } else {
+                  $$renderer5.push("<!--[-1-->");
+                  File_text($$renderer5, { class: "icon-sm" });
+                }
+                $$renderer5.push(`<!--]--> <span>${$6.escape(formatLabels.summary)}</span> `);
+                if (copyState.copiedKey === "summary") {
+                  $$renderer5.push("<!--[0-->");
+                  $$renderer5.push(`<span class="copied-label svelte-1cj1bq5">Copied!</span>`);
+                } else {
+                  $$renderer5.push("<!--[-1-->");
+                }
+                $$renderer5.push(`<!--]-->`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer4.push(`<!----> `);
+            Dropdown_item($$renderer4, {
+              onclick: () => handleCopy("diff"),
+              children: ($$renderer5) => {
+                if (copyState.copiedKey === "diff") {
+                  $$renderer5.push("<!--[0-->");
+                  Check($$renderer5, { class: "icon-sm export-icon-success" });
+                } else {
+                  $$renderer5.push("<!--[-1-->");
+                  Git_branch($$renderer5, { class: "icon-sm" });
+                }
+                $$renderer5.push(`<!--]--> <span>${$6.escape(formatLabels.diff)}</span> `);
+                if (copyState.copiedKey === "diff") {
+                  $$renderer5.push("<!--[0-->");
+                  $$renderer5.push(`<span class="copied-label svelte-1cj1bq5">Copied!</span>`);
+                } else {
+                  $$renderer5.push("<!--[-1-->");
+                }
+                $$renderer5.push(`<!--]-->`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer4.push(`<!----> `);
+            if (onexportcomments) {
+              $$renderer4.push("<!--[0-->");
+              Dropdown_item($$renderer4, {
+                onclick: () => handleCopy("comments"),
+                children: ($$renderer5) => {
+                  if (copyState.copiedKey === "comments") {
+                    $$renderer5.push("<!--[0-->");
+                    Check($$renderer5, { class: "icon-sm export-icon-success" });
+                  } else {
+                    $$renderer5.push("<!--[-1-->");
+                    Message_square($$renderer5, { class: "icon-sm" });
+                  }
+                  $$renderer5.push(`<!--]--> <span>${$6.escape(formatLabels.comments)}</span> `);
+                  if (copyState.copiedKey === "comments") {
+                    $$renderer5.push("<!--[0-->");
+                    $$renderer5.push(`<span class="copied-label svelte-1cj1bq5">Copied!</span>`);
+                  } else {
+                    $$renderer5.push("<!--[-1-->");
+                  }
+                  $$renderer5.push(`<!--]-->`);
+                },
+                $$slots: { default: true }
+              });
+            } else {
+              $$renderer4.push("<!--[-1-->");
+            }
+            $$renderer4.push(`<!--]--> `);
+            Dropdown_item($$renderer4, {
+              onclick: () => handleCopy("json"),
+              children: ($$renderer5) => {
+                if (copyState.copiedKey === "json") {
+                  $$renderer5.push("<!--[0-->");
+                  Check($$renderer5, { class: "icon-sm export-icon-success" });
+                } else {
+                  $$renderer5.push("<!--[-1-->");
+                  File_code($$renderer5, { class: "icon-sm" });
+                }
+                $$renderer5.push(`<!--]--> <span>${$6.escape(formatLabels.json)}</span> `);
+                if (copyState.copiedKey === "json") {
+                  $$renderer5.push("<!--[0-->");
+                  $$renderer5.push(`<span class="copied-label svelte-1cj1bq5">Copied!</span>`);
+                } else {
+                  $$renderer5.push("<!--[-1-->");
+                }
+                $$renderer5.push(`<!--]-->`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer4.push(`<!---->`);
+          },
+          $$slots: { default: true }
+        });
+        $$renderer3.push(`<!---->`);
+      },
+      $$slots: { default: true }
+    });
+    $$renderer2.push(`<!----></div>`);
+  });
+}
+
+// src/components/review-editor/comment-sidebar.svelte
+import * as $7 from "svelte/internal/server";
+
+// src/utilities/truncate.ts
+function truncate(text, maxLength, ellipsis = "…") {
+  if (text.length <= maxLength)
+    return text;
+  if (maxLength <= ellipsis.length)
+    return text.slice(0, maxLength);
+  return text.slice(0, maxLength - ellipsis.length) + ellipsis;
+}
+// src/components/review-editor/comment-sidebar.svelte
+import { getVisibleComments, isDocumentAnchor as isDocumentAnchor2 } from "@lostgradient/cinder/commentary/comments";
+function Comment_sidebar($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      threads,
+      activeThreadId = null,
+      readonly = false,
+      onthreadselect,
+      onclearall,
+      onadddocumentcomment,
+      class: className
+    } = $$props;
+    let showConfirmClear = false;
+    let composingDocumentComment = false;
+    function handleStartDocumentComment() {
+      composingDocumentComment = true;
+    }
+    function handleCancelDocumentComment() {
+      composingDocumentComment = false;
+    }
+    function handleSubmitDocumentComment(body) {
+      onadddocumentcomment?.(body);
+      composingDocumentComment = false;
+    }
+    const $$d = $7.derived(() => {
+      const visible = threads.filter((thread) => getVisibleComments(thread).length > 0);
+      const docThreads = visible.filter((thread) => isDocumentAnchor2(thread.anchor));
+      const txtThreads = visible.filter((thread) => !isDocumentAnchor2(thread.anchor)).sort((a, b) => {
+        const posA = a.anchor.from ?? a.anchor.originalPosition?.offset ?? 0;
+        const posB = b.anchor.from ?? b.anchor.originalPosition?.offset ?? 0;
+        return posA - posB;
+      });
+      return { documentThreads: docThreads, textThreads: txtThreads };
+    }), documentThreads = $7.derived(() => $$d().documentThreads), textThreads = $7.derived(() => $$d().textThreads);
+    const visibleThreads = $7.derived(() => [...documentThreads(), ...textThreads()]);
+    function getPreview(thread) {
+      const comments = getVisibleComments(thread);
+      const firstComment = comments[0];
+      if (!firstComment)
+        return "";
+      return truncate(firstComment.body, 80);
+    }
+    function handleThreadClick(threadId) {
+      onthreadselect?.(threadId);
+    }
+    function handleClearAllClick() {
+      showConfirmClear = true;
+    }
+    function handleConfirmClear() {
+      onclearall?.();
+      showConfirmClear = false;
+    }
+    function handleCancelClear() {
+      showConfirmClear = false;
+    }
+    $$renderer2.push(`<aside${$7.attr("id", id)}${$7.attr_class($7.clsx(classNames("comment-sidebar", className)), "svelte-1g8l8sh")} aria-label="Comment threads"><div class="sidebar-header svelte-1g8l8sh">`);
+    Message_square($$renderer2, { class: "icon-sm" });
+    $$renderer2.push(`<!----> <h2 class="sidebar-title svelte-1g8l8sh">Comments</h2> <span class="thread-count svelte-1g8l8sh">${$7.escape(visibleThreads().length)}</span> `);
+    if (!readonly) {
+      $$renderer2.push("<!--[0-->");
+      Button($$renderer2, {
+        variant: "ghost",
+        size: "xs",
+        "aria-label": composingDocumentComment ? "Cancel document comment" : "Add document comment",
+        title: composingDocumentComment ? "Cancel adding document comment" : "Add comment about the entire document",
+        onclick: composingDocumentComment ? handleCancelDocumentComment : handleStartDocumentComment,
+        children: ($$renderer3) => {
+          if (composingDocumentComment) {
+            $$renderer3.push("<!--[0-->");
+            X($$renderer3, { class: "icon-sm" });
+          } else {
+            $$renderer3.push("<!--[-1-->");
+            Plus($$renderer3, { class: "icon-sm" });
+          }
+          $$renderer3.push(`<!--]-->`);
+        },
+        $$slots: { default: true }
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (!readonly && visibleThreads().length > 0) {
+      $$renderer2.push("<!--[0-->");
+      Dropdown($$renderer2, {
+        id: `${$7.stringify(id)}-actions`,
+        children: ($$renderer3) => {
+          Dropdown_trigger($$renderer3, {
+            class: "actions-trigger",
+            "aria-label": "Comment actions",
+            showCaret: false,
+            children: ($$renderer4) => {
+              Ellipsis($$renderer4, { class: "icon-sm" });
+            },
+            $$slots: { default: true }
+          });
+          $$renderer3.push(`<!----> `);
+          Dropdown_menu($$renderer3, {
+            children: ($$renderer4) => {
+              Dropdown_item($$renderer4, {
+                variant: "danger",
+                onclick: handleClearAllClick,
+                children: ($$renderer5) => {
+                  Trash_2($$renderer5, { class: "icon-sm" });
+                  $$renderer5.push(`<!----> Clear all comments`);
+                },
+                $$slots: { default: true }
+              });
+            },
+            $$slots: { default: true }
+          });
+          $$renderer3.push(`<!---->`);
+        },
+        $$slots: { default: true }
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--></div> `);
+    if (showConfirmClear) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="confirm-clear svelte-1g8l8sh" role="alertdialog"${$7.attr("aria-labelledby", `${$7.stringify(id)}-confirm-title`)}><p${$7.attr("id", `${$7.stringify(id)}-confirm-title`)} class="confirm-message svelte-1g8l8sh">Delete all ${$7.escape(visibleThreads().length)} comment threads?</p> <div class="confirm-actions svelte-1g8l8sh">`);
+      Button($$renderer2, {
+        variant: "secondary",
+        size: "xs",
+        onclick: handleCancelClear,
+        children: ($$renderer3) => {
+          $$renderer3.push(`<!---->Cancel`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer2.push(`<!----> `);
+      Button($$renderer2, {
+        variant: "danger",
+        size: "xs",
+        onclick: handleConfirmClear,
+        children: ($$renderer3) => {
+          $$renderer3.push(`<!---->Delete All`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer2.push(`<!----></div></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> `);
+    if (composingDocumentComment) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="document-comment-composer svelte-1g8l8sh"><div class="document-comment-header svelte-1g8l8sh">`);
+      File_text($$renderer2, { class: "icon-xs" });
+      $$renderer2.push(`<!----> <span>Document comment</span></div> `);
+      Comment_composer($$renderer2, {
+        id: `${$7.stringify(id)}-document-composer`,
+        placeholder: "Add a comment about the entire document...",
+        onsubmit: handleSubmitDocumentComment,
+        oncancel: handleCancelDocumentComment
+      });
+      $$renderer2.push(`<!----></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+    }
+    $$renderer2.push(`<!--]--> <div class="thread-list svelte-1g8l8sh">`);
+    if (visibleThreads().length === 0) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<div class="empty-state svelte-1g8l8sh"><p class="empty-message svelte-1g8l8sh">No comments yet</p> <p class="empty-hint svelte-1g8l8sh">Select text or click + to add a comment</p></div>`);
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<!--[-->`);
+      const each_array = $7.ensure_array_like(documentThreads());
+      for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+        let thread = each_array[$$index];
+        $$renderer2.push(`<button type="button" class="thread-item svelte-1g8l8sh" data-document="true"${$7.attr("data-active", activeThreadId === thread.id || undefined)}${$7.attr("aria-current", activeThreadId === thread.id ? "true" : undefined)}><div class="thread-document-label svelte-1g8l8sh">`);
+        File_text($$renderer2, { class: "icon-xs" });
+        $$renderer2.push(`<!----> <span>Document comment</span></div> <p class="thread-preview svelte-1g8l8sh">${$7.escape(getPreview(thread))}</p></button>`);
+      }
+      $$renderer2.push(`<!--]--> <!--[-->`);
+      const each_array_1 = $7.ensure_array_like(textThreads());
+      for (let $$index_1 = 0, $$length = each_array_1.length;$$index_1 < $$length; $$index_1++) {
+        let thread = each_array_1[$$index_1];
+        $$renderer2.push(`<button type="button" class="thread-item svelte-1g8l8sh"${$7.attr("data-active", activeThreadId === thread.id || undefined)}${$7.attr("aria-current", activeThreadId === thread.id ? "true" : undefined)}><blockquote class="thread-quote svelte-1g8l8sh">${$7.escape(truncate(thread.anchor.quote, 60))}</blockquote> <p class="thread-preview svelte-1g8l8sh">${$7.escape(getPreview(thread))}</p></button>`);
+      }
+      $$renderer2.push(`<!--]-->`);
+    }
+    $$renderer2.push(`<!--]--></div></aside>`);
+  });
+}
+
+// src/components/review-editor/front-matter-fields.svelte
+import * as $8 from "svelte/internal/server";
+import { untrack } from "svelte";
+import { parseFrontMatter as parseFrontMatter2, validateFrontMatter as validateFrontMatter2 } from "@lostgradient/cinder/markdown/pipeline";
+
+// src/components/review-editor/review-editor-front-matter.ts
+import {
+  parseFrontMatter,
+  serializeYaml,
+  stringifyFrontMatter,
+  validateFrontMatter
+} from "@lostgradient/cinder/markdown/pipeline";
+function parseReviewEditorFrontMatter(markdown) {
+  const parsed = parseFrontMatter(markdown);
+  const bodyOffset = parsed.hasFrontMatter ? markdown.length - parsed.body.length : 0;
+  return {
+    hasFrontMatter: parsed.hasFrontMatter,
+    data: parsed.data,
+    raw: parsed.hasFrontMatter ? parsed.raw ?? "" : null,
+    body: parsed.hasFrontMatter ? parsed.body : markdown,
+    bodyOffset
+  };
+}
+function reviewStateToMarkdown(state) {
+  if (parseReviewEditorFrontMatter(state.content).hasFrontMatter)
+    return state.content;
+  if (state.frontMatterRaw == null && state.frontMatter == null)
+    return state.content;
+  if (state.frontMatterRaw === undefined)
+    return state.content;
+  return stringifyFrontMatter(state.frontMatter ?? null, state.content, {
+    originalRaw: state.frontMatterRaw,
+    originalData: state.frontMatter ?? null,
+    preserveEmptyFrontMatter: true
+  });
+}
+function combineFrontMatterAndBody(frontMatter, body) {
+  if (!frontMatter.hasFrontMatter)
+    return body;
+  if (frontMatter.data === null && frontMatter.raw !== null && frontMatter.raw.trim() !== "") {
+    return `---
+${frontMatter.raw}
+---
+${body}`;
+  }
+  return stringifyFrontMatter(frontMatter.data, body, {
+    originalRaw: frontMatter.raw,
+    originalData: frontMatter.data,
+    preserveEmptyFrontMatter: true
+  });
+}
+function replaceFrontMatterData(markdown, data) {
+  const frontMatter = parseReviewEditorFrontMatter(markdown);
+  if (!frontMatter.hasFrontMatter)
+    return markdown;
+  return stringifyFrontMatter(data, frontMatter.body, {
+    originalRaw: frontMatter.raw,
+    originalData: frontMatter.data,
+    preserveEmptyFrontMatter: true
+  });
+}
+function serializeYamlFieldValue(value) {
+  const raw = serializeYaml({ value });
+  if (raw.startsWith(`value:
+`)) {
+    return raw.slice(`value:
+`.length).replace(/^  /gm, "");
+  }
+  return raw.replace(/^value:\s?/, "");
+}
+function parseYamlFieldValue(raw) {
+  const validation = validateFrontMatter(`value:
+${indentYaml(raw)}`);
+  if (!validation.valid) {
+    return { valid: false, error: validation.error ?? "Invalid YAML syntax" };
+  }
+  const parsed = parseFrontMatter(`---
+value:
+${indentYaml(raw)}
+---
+`);
+  return { valid: true, value: parsed.data?.["value"] };
+}
+function documentPositionToBodyPosition(position, bodyOffset) {
+  return Math.max(0, position - bodyOffset);
+}
+function bodyPositionToDocumentPosition(position, bodyOffset) {
+  return position + bodyOffset;
+}
+function documentAnchorToBodyAnchor(anchor, bodyOffset) {
+  return offsetAnchor(anchor, -bodyOffset);
+}
+function documentPersistedAnchorToBodyAnchor(anchor, bodyOffset) {
+  return offsetPersistedAnchor(anchor, -bodyOffset);
+}
+function bodyAnchorToDocumentAnchor(anchor, bodyOffset, documentText) {
+  return offsetAnchor(anchor, bodyOffset, documentText);
+}
+function remapDocumentAnchorBodyOffset(anchor, previousBodyOffset, nextBodyOffset, nextDocumentText) {
+  if (previousBodyOffset === nextBodyOffset)
+    return anchor;
+  return bodyAnchorToDocumentAnchor(documentAnchorToBodyAnchor(anchor, previousBodyOffset), nextBodyOffset, nextDocumentText);
+}
+function bodyAnchorUpdateToDocumentAnchorUpdate(update, bodyOffset) {
+  const documentUpdate = {
+    ...update,
+    from: bodyPositionToDocumentPosition(update.from, bodyOffset),
+    to: bodyPositionToDocumentPosition(update.to, bodyOffset)
+  };
+  if (update.lastKnownOffset !== undefined) {
+    documentUpdate.lastKnownOffset = bodyPositionToDocumentPosition(update.lastKnownOffset, bodyOffset);
+  }
+  return documentUpdate;
+}
+function offsetAnchor(anchor, offset, documentText) {
+  if (anchor.type === "document")
+    return anchor;
+  const originalPosition = anchor.originalPosition;
+  const originalPositionOffset = originalPosition === undefined ? undefined : Math.max(0, originalPosition.offset + offset);
+  return {
+    ...anchor,
+    from: Math.max(0, anchor.from + offset),
+    to: Math.max(0, anchor.to + offset),
+    lastKnownOffset: anchor.lastKnownOffset === undefined ? undefined : Math.max(0, anchor.lastKnownOffset + offset),
+    originalPosition: originalPosition === undefined || originalPositionOffset === undefined ? undefined : textOffsetToLineColumn(documentText, originalPositionOffset, originalPosition)
+  };
+}
+function offsetPersistedAnchor(anchor, offset) {
+  if (anchor.type === "document")
+    return anchor;
+  const originalPosition = anchor.originalPosition;
+  const originalPositionOffset = originalPosition === undefined ? undefined : Math.max(0, originalPosition.offset + offset);
+  return {
+    ...anchor,
+    lastKnownOffset: anchor.lastKnownOffset === undefined ? undefined : Math.max(0, anchor.lastKnownOffset + offset),
+    originalPosition: originalPosition === undefined || originalPositionOffset === undefined ? undefined : { ...originalPosition, offset: originalPositionOffset }
+  };
+}
+function indentYaml(raw) {
+  if (raw.trim() === "")
+    return "  null";
+  return raw.split(`
+`).map((line) => line.trim() === "" ? line : `  ${line}`).join(`
+`);
+}
+function textOffsetToLineColumn(documentText, offset, fallback) {
+  if (documentText === undefined) {
+    return { ...fallback, offset };
+  }
+  let line = 1;
+  let column = 1;
+  const clampedOffset = Math.max(0, Math.min(offset, documentText.length));
+  for (let index = 0;index < clampedOffset; index++) {
+    if (documentText[index] === `
+`) {
+      line++;
+      column = 1;
+    } else {
+      column++;
+    }
+  }
+  return { offset: clampedOffset, line, column };
+}
+
+// src/components/review-editor/front-matter-fields.svelte
+function Front_matter_fields($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let { id, data, raw, readonly = false, onchange } = $$props;
+    const entries = $8.derived(() => Object.entries(data ?? {}));
+    const hasParsedFields = $8.derived(() => data !== null && entries().length > 0);
+    const shouldShowRawYaml = $8.derived(() => !hasParsedFields() && raw !== null);
+    let rawDraft = untrack(() => raw) ?? "";
+    let rawError = undefined;
+    let lastRaw = null;
+    let complexDrafts = {};
+    let complexErrors = {};
+    let lastComplexKeys = "";
+    function patchField(name, value) {
+      if (readonly)
+        return;
+      onchange({ ...data ?? {}, [name]: value });
+    }
+    function handleNumberInput(name, rawValue) {
+      if (rawValue.trim() === "") {
+        patchField(name, null);
+        return;
+      }
+      const parsed = Number(rawValue);
+      if (!Number.isFinite(parsed))
+        return;
+      patchField(name, parsed);
+    }
+    function handleComplexInput(name, rawValue) {
+      complexDrafts = { ...complexDrafts, [name]: rawValue };
+      const parsed = parseYamlFieldValue(rawValue);
+      if (!parsed.valid) {
+        complexErrors = { ...complexErrors, [name]: parsed.error };
+        return;
+      }
+      const nextErrors = { ...complexErrors };
+      delete nextErrors[name];
+      complexErrors = nextErrors;
+      patchField(name, parsed.value);
+    }
+    function handleRawInput(rawValue) {
+      rawDraft = rawValue;
+      const validation = validateFrontMatter2(rawValue);
+      rawError = validation.error;
+      if (!validation.valid || readonly)
+        return;
+      const parsed = parseFrontMatter2(`---
+${rawValue}
+---
+`);
+      onchange(parsed.data);
+    }
+    function fieldId(name) {
+      return `${id}-${name.replace(/[^a-zA-Z0-9_-]/g, "-")}`;
+    }
+    function isComplexValue(value) {
+      return typeof value === "object" && value !== null;
+    }
+    $$renderer2.push(`<section class="review-editor-front-matter"${$8.attr("aria-labelledby", `${id}-heading`)}><div class="review-editor-front-matter__header"><h3${$8.attr("id", `${id}-heading`)} class="review-editor-front-matter__title">Front matter</h3></div> <div class="review-editor-front-matter__body">`);
+    if (hasParsedFields()) {
+      $$renderer2.push("<!--[0-->");
+      $$renderer2.push(`<!--[-->`);
+      const each_array = $8.ensure_array_like(entries());
+      for (let $$index = 0, $$length = each_array.length;$$index < $$length; $$index++) {
+        let [name, fieldValue] = each_array[$$index];
+        $$renderer2.push(`<div class="review-editor-front-matter__field">`);
+        if (typeof fieldValue === "boolean") {
+          $$renderer2.push("<!--[0-->");
+          Checkbox($$renderer2, {
+            id: fieldId(name),
+            label: name,
+            checked: fieldValue,
+            disabled: readonly,
+            onchange: (event) => patchField(name, event.currentTarget.checked)
+          });
+        } else if (typeof fieldValue === "number") {
+          $$renderer2.push("<!--[1-->");
+          Input($$renderer2, {
+            id: fieldId(name),
+            label: name,
+            value: String(fieldValue),
+            disabled: readonly,
+            oninput: (event) => handleNumberInput(name, event.currentTarget.value)
+          });
+        } else if (typeof fieldValue === "string") {
+          $$renderer2.push("<!--[2-->");
+          Input($$renderer2, {
+            id: fieldId(name),
+            label: name,
+            value: fieldValue,
+            disabled: readonly,
+            oninput: (event) => patchField(name, event.currentTarget.value)
+          });
+        } else if (isComplexValue(fieldValue)) {
+          $$renderer2.push("<!--[3-->");
+          Textarea($$renderer2, {
+            id: fieldId(name),
+            label: name,
+            value: complexDrafts[name] ?? serializeYamlFieldValue(fieldValue),
+            error: complexErrors[name] ?? "",
+            disabled: readonly,
+            rows: Math.max(3, (complexDrafts[name] ?? serializeYamlFieldValue(fieldValue)).split(`
+`).length),
+            oninput: (event) => handleComplexInput(name, event.currentTarget.value)
+          });
+        } else {
+          $$renderer2.push("<!--[-1-->");
+          Input($$renderer2, {
+            id: fieldId(name),
+            label: name,
+            value: fieldValue === null ? "null" : String(fieldValue),
+            disabled: readonly,
+            oninput: (event) => patchField(name, event.currentTarget.value)
+          });
+        }
+        $$renderer2.push(`<!--]--></div>`);
+      }
+      $$renderer2.push(`<!--]-->`);
+    } else if (shouldShowRawYaml()) {
+      $$renderer2.push("<!--[1-->");
+      Textarea($$renderer2, {
+        id: `${id}-raw`,
+        label: "YAML",
+        value: rawDraft,
+        error: rawError ?? "",
+        disabled: readonly,
+        rows: Math.max(3, rawDraft.split(`
+`).length),
+        oninput: (event) => handleRawInput(event.currentTarget.value)
+      });
+    } else {
+      $$renderer2.push("<!--[-1-->");
+      $$renderer2.push(`<p class="review-editor-front-matter__empty">No front matter fields.</p>`);
+    }
+    $$renderer2.push(`<!--]--></div></section>`);
+  });
+}
+
+// src/components/review-editor/review-editor-controls.svelte
+import * as $9 from "svelte/internal/server";
+function Review_editor_controls($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      id,
+      activeView,
+      viewPanelIds,
+      onViewChange,
+      showDiffTabs = true,
+      diffStats,
+      diffViewMode = "unified",
+      hasContentChanges = false,
+      readonly = false,
+      onRevertAll,
+      commentCount = 0,
+      sidebarOpen = false,
+      onSidebarToggle,
+      trailing,
+      class: className
+    } = $$props;
+    function handleViewChange(view) {
+      onViewChange?.(view);
+    }
+    const commentsToggleLabel = $9.derived(() => `${sidebarOpen ? "Close" : "Open"} comments sidebar (${commentCount} ${commentCount === 1 ? "comment" : "comments"})`);
+    let previousCommentCount = null;
+    let liveAnnouncementText = "";
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      $$renderer3.push(`<div${$9.attr("id", id)}${$9.attr_class($9.clsx(classNames("review-editor-controls", className)), "svelte-161pl7w")} role="toolbar" aria-label="Review editor controls"><div class="controls-leading svelte-161pl7w">`);
+      Segmented_control($$renderer3, {
+        id: `${$9.stringify(id)}-view-mode`,
+        label: "Review editor view",
+        hideLabel: true,
+        variant: "tablist",
+        size: "sm",
+        density: "toolbar",
+        value: activeView,
+        onchange: handleViewChange,
+        children: ($$renderer4) => {
+          {
+            let leading = function($$renderer5) {
+              Pencil($$renderer5, { class: "icon-xs" });
+            };
+            Segment($$renderer4, {
+              value: "editor",
+              controls: viewPanelIds?.editor,
+              leading,
+              children: ($$renderer5) => {
+                $$renderer5.push(`<!---->Editor`);
+              },
+              $$slots: { leading: true, default: true }
+            });
+          }
+          $$renderer4.push(`<!----> `);
+          if (showDiffTabs) {
+            $$renderer4.push("<!--[0-->");
+            {
+              let leading = function($$renderer5) {
+                Git_branch($$renderer5, { class: "icon-xs" });
+              };
+              Segment($$renderer4, {
+                value: "diff",
+                controls: viewPanelIds?.diff,
+                leading,
+                children: ($$renderer5) => {
+                  $$renderer5.push(`<!---->Diff`);
+                },
+                $$slots: { leading: true, default: true }
+              });
+            }
+            $$renderer4.push(`<!----> `);
+            {
+              let leading = function($$renderer5) {
+                File_text($$renderer5, { class: "icon-xs" });
+              };
+              Segment($$renderer4, {
+                value: "summary",
+                controls: viewPanelIds?.summary,
+                leading,
+                children: ($$renderer5) => {
+                  $$renderer5.push(`<!---->Summary`);
+                },
+                $$slots: { leading: true, default: true }
+              });
+            }
+            $$renderer4.push(`<!---->`);
+          } else {
+            $$renderer4.push("<!--[-1-->");
+          }
+          $$renderer4.push(`<!--]-->`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer3.push(`<!----> `);
+      if (diffStats && (diffStats.added > 0 || diffStats.removed > 0 || diffStats.modified > 0)) {
+        $$renderer3.push("<!--[0-->");
+        Diff_statistics($$renderer3, {
+          variant: "compact",
+          density: "toolbar",
+          added: diffStats.added,
+          removed: diffStats.removed,
+          modified: diffStats.modified,
+          hideZero: true
+        });
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (activeView === "diff") {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<div class="controls-separator svelte-161pl7w" aria-hidden="true"></div> `);
+        Segmented_control($$renderer3, {
+          id: `${$9.stringify(id)}-diff-view-mode`,
+          selectionMode: "single",
+          size: "sm",
+          density: "toolbar",
+          label: "Diff view mode",
+          hideLabel: true,
+          get value() {
+            return diffViewMode;
+          },
+          set value($$value) {
+            diffViewMode = $$value;
+            $$settled = false;
+          },
+          children: ($$renderer4) => {
+            Segment($$renderer4, {
+              value: "unified",
+              children: ($$renderer5) => {
+                $$renderer5.push(`<!---->Unified`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer4.push(`<!----> `);
+            Segment($$renderer4, {
+              value: "final",
+              children: ($$renderer5) => {
+                $$renderer5.push(`<!---->Final`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer4.push(`<!----> `);
+            Segment($$renderer4, {
+              value: "original",
+              children: ($$renderer5) => {
+                $$renderer5.push(`<!---->Original`);
+              },
+              $$slots: { default: true }
+            });
+            $$renderer4.push(`<!---->`);
+          },
+          $$slots: { default: true }
+        });
+        $$renderer3.push(`<!---->`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--></div> <div class="controls-trailing svelte-161pl7w">`);
+      if (activeView === "diff" && hasContentChanges && !readonly) {
+        $$renderer3.push("<!--[0-->");
+        Button($$renderer3, {
+          variant: "ghost",
+          size: "sm",
+          onclick: onRevertAll,
+          "aria-label": "Revert all changes",
+          title: "Revert all changes",
+          children: ($$renderer4) => {
+            Rotate_ccw($$renderer4, { class: "icon-sm" });
+            $$renderer4.push(`<!----> <span class="cinder-sr-only">Revert All</span>`);
+          },
+          $$slots: { default: true }
+        });
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> <div class="comments-toggle-wrapper svelte-161pl7w">`);
+      Button($$renderer3, {
+        variant: "ghost",
+        size: "sm",
+        onclick: onSidebarToggle,
+        "aria-expanded": sidebarOpen,
+        "aria-controls": `${$9.stringify(id)}-sidebar`,
+        "aria-label": commentsToggleLabel(),
+        title: sidebarOpen ? "Close comments sidebar" : "Open comments sidebar",
+        children: ($$renderer4) => {
+          Message_square($$renderer4, { class: "icon-sm" });
+          $$renderer4.push(`<!----> `);
+          Badge($$renderer4, {
+            "aria-hidden": "true",
+            size: "sm",
+            variant: "neutral",
+            children: ($$renderer5) => {
+              $$renderer5.push(`<!---->${$9.escape(commentCount)}`);
+            },
+            $$slots: { default: true }
+          });
+          $$renderer4.push(`<!---->`);
+        },
+        $$slots: { default: true }
+      });
+      $$renderer3.push(`<!----></div> `);
+      if (trailing) {
+        $$renderer3.push("<!--[0-->");
+        trailing($$renderer3);
+        $$renderer3.push(`<!---->`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--></div></div> <div role="status" aria-live="polite" aria-atomic="true" class="comments-count-announcer cinder-sr-only">${$9.escape(liveAnnouncementText)}</div>`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    $9.bind_props($$props, { diffViewMode });
+  });
+}
+
+// src/components/review-editor/review-editor-selection-geometry.ts
+function getSelectionAnchorRect(range) {
+  const rect = Array.from(range.getClientRects()).find((clientRect) => {
+    return clientRect.width > 0 && clientRect.height > 0;
+  }) ?? range.getBoundingClientRect();
+  if (rect.width === 0 && rect.height === 0)
+    return null;
+  return rect;
+}
+function getSelectionAnchorPosition(range) {
+  const rect = getSelectionAnchorRect(range);
+  if (!rect)
+    return null;
+  return {
+    x: rect.left + rect.width / 2,
+    y: rect.top,
+    height: rect.height
+  };
+}
+
+// src/components/review-editor/review-editor-impl.svelte
+import { computeLineDiff, getDiffStats } from "@lostgradient/cinder/markdown/diff/line-diff";
+import {
+  generateMarkdownSummary,
+  generateUnifiedDiff,
+  generateCommentsExport
+} from "@lostgradient/cinder/commentary/export";
+function Review_editor_impl($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    const reducedMotion = useReducedMotion();
+    let {
+      id,
+      original = "",
+      value = "",
+      threads = [],
+      mode = "edit",
+      currentUserId,
+      placeholder = "Start writing...",
+      name,
+      class: className,
+      onchange,
+      onthreadcreate,
+      onthreaddelete,
+      oncommentcreate,
+      oncommentupdate,
+      oncommentdelete,
+      snapshotMode = false
+    } = $$props;
+    let containerElement = null;
+    let editorRef = undefined;
+    let liveRegionRef = undefined;
+    let editorViewReady = false;
+    let currentSelection = null;
+    let popoverThreadId = null;
+    let popoverPosition = null;
+    let selectTimeoutId = null;
+    let activeThreadId = null;
+    let sidebarOpen = false;
+    const currentDocument = $10.derived(() => parseReviewEditorFrontMatter(value));
+    const editorValue = $10.derived(() => currentDocument().body);
+    const viewPanelIds = $10.derived(() => ({
+      editor: `${id}-editor-panel`,
+      diff: `${id}-diff-panel`,
+      summary: `${id}-summary-panel`
+    }));
+    let activeView = "editor";
+    let diffViewMode = "unified";
+    const diffStats = $10.derived(() => {
+      if (!original) {
+        return { added: 0, removed: 0, modified: 0 };
+      }
+      const normalizedOriginal = normalize(original);
+      const normalizedCurrent = normalize(value);
+      const lineDiffs = computeLineDiff(normalizedOriginal, normalizedCurrent);
+      return getDiffStats(lineDiffs);
+    });
+    const hasContentChanges = $10.derived(() => diffStats().added > 0 || diffStats().removed > 0 || diffStats().modified > 0);
+    const commentCount = $10.derived(() => threads.reduce((count, thread) => {
+      return count + thread.comments.filter((c) => !c.deletedAt).length;
+    }, 0));
+    const summaryContent = $10.derived(() => {
+      const result = exportMarkdownSummary();
+      return result.markdown.replace(/^# Review Summary\n+/, "");
+    });
+    let selectionPopoverPosition = null;
+    let capturedSelectionForPopover = null;
+    let selectionPopoverExpanded = false;
+    const showSelectionPopover = $10.derived(() => activeView === "editor" && mode === "edit" && currentUserId !== undefined && (selectionPopoverPosition !== null || selectionPopoverExpanded) && popoverThreadId === null);
+    const POSITION_DELAY_MS = 350;
+    function getScrollBehavior() {
+      return reducedMotion.current ? "instant" : "smooth";
+    }
+    function announce(message, priority = "polite") {
+      liveRegionRef?.announce(message, priority);
+    }
+    const popoverThread = $10.derived(() => {
+      if (!popoverThreadId)
+        return null;
+      return threads.find((t) => t.id === popoverThreadId) ?? null;
+    });
+    function scrollAnchorIntoView(threadId) {
+      const editorDom = editorRef?.getView()?.dom;
+      const anchorElement = editorDom?.querySelector(`[data-thread-id="${threadId}"]`);
+      if (anchorElement) {
+        anchorElement.scrollIntoView({ behavior: getScrollBehavior(), block: "center" });
+      }
+    }
+    function handlePopoverClose() {
+      if (selectTimeoutId !== null) {
+        clearTimeout(selectTimeoutId);
+        selectTimeoutId = null;
+      }
+      popoverThreadId = null;
+      popoverPosition = null;
+      activeThreadId = null;
+    }
+    function handlePopoverDelete(threadId) {
+      if (currentUserId) {
+        deleteThread(threadId);
+        handlePopoverClose();
+      }
+    }
+    function handlePopoverCommentUpdate(threadId, commentId, body) {
+      updateComment(threadId, commentId, body);
+    }
+    function handlePopoverCommentDelete(threadId, commentId) {
+      deleteComment(threadId, commentId);
+    }
+    function handlePopoverCommentCreate(threadId, body) {
+      if (currentUserId) {
+        createComment(threadId, body, currentUserId);
+      }
+    }
+    function calculateViewportPosition(from) {
+      const view = editorRef?.getView();
+      if (!view)
+        return null;
+      try {
+        const coords = view.coordsAtPos(documentPositionToBodyPosition(from, currentDocument().bodyOffset));
+        if (coords) {
+          return {
+            top: coords.top + 24,
+            left: Math.max(16, coords.left)
+          };
+        }
+      } catch {}
+      return null;
+    }
+    let lastSyncedFingerprint = null;
+    let pendingState = null;
+    function createSyncFingerprint(threadsToSync) {
+      return threadsToSync.map((t) => {
+        const a = t.anchor;
+        return `${t.id}:${a.from}:${a.to}:${a.quote}:${a.prefix}:${a.suffix}:${a.lastKnownOffset ?? ""}`;
+      }).join("|");
+    }
+    function createPluginSyncFingerprint(threadsToSync) {
+      return `${currentDocument().bodyOffset}|${createSyncFingerprint(threadsToSync)}`;
+    }
+    function handleAnchorsUpdate(updates) {
+      threads = threads.map((thread) => {
+        const update = updates.find((u) => u.threadId === thread.id);
+        if (update) {
+          const documentUpdate = bodyAnchorUpdateToDocumentAnchorUpdate(update, currentDocument().bodyOffset);
+          return {
+            ...thread,
+            anchor: {
+              ...thread.anchor,
+              from: documentUpdate.from,
+              to: documentUpdate.to,
+              quote: documentUpdate.quote,
+              prefix: documentUpdate.prefix,
+              suffix: documentUpdate.suffix,
+              lastKnownOffset: documentUpdate.lastKnownOffset
+            }
+          };
+        }
+        return thread;
+      });
+      lastSyncedFingerprint = createPluginSyncFingerprint(threads);
+    }
+    const anchorPlugin = createAnchorPlugin({
+      onAnchorsUpdate: handleAnchorsUpdate,
+      onAnchorClick: handleAnchorClick
+    });
+    function handleAnchorClick(threadId, event) {
+      if (selectTimeoutId !== null) {
+        clearTimeout(selectTimeoutId);
+        selectTimeoutId = null;
+      }
+      selectionPopoverPosition = null;
+      capturedSelectionForPopover = null;
+      selectionPopoverExpanded = false;
+      activeThreadId = threadId;
+      const thread = threads.find((t) => t.id === threadId);
+      if (thread) {
+        popoverPosition = { x: event.clientX + 16, y: event.clientY };
+        popoverThreadId = threadId;
+      }
+    }
+    function syncThreadsToPlugin(threadsToSync) {
+      const view = editorRef?.getView();
+      if (!view)
+        return;
+      const fingerprint = createPluginSyncFingerprint(threadsToSync);
+      if (fingerprint === lastSyncedFingerprint)
+        return;
+      lastSyncedFingerprint = fingerprint;
+      view.dispatch(view.state.tr.setMeta(anchorPluginKey, {
+        type: "sync",
+        threads: threadsToSync.map((thread) => ({
+          ...thread,
+          anchor: documentAnchorToBodyAnchor(thread.anchor, currentDocument().bodyOffset)
+        })),
+        source: "external"
+      }));
+    }
+    function attemptReanchoring() {
+      if (!pendingState)
+        return;
+      const view = editorRef?.getView();
+      if (!view)
+        return;
+      const currentMarkdown = editorRef?.getMarkdown() ?? "";
+      const pendingDocument = parseReviewEditorFrontMatter(pendingState.content);
+      const expectedMarkdown = pendingDocument.body;
+      if (!contentEquals2(currentMarkdown, expectedMarkdown)) {
+        return;
+      }
+      const state = pendingState;
+      pendingState = null;
+      const { doc } = view.state;
+      const documentText = doc.textBetween(0, doc.content.size, `
+`);
+      const reanchoredThreads = [];
+      for (const persistedThread of state.threads) {
+        const bodyPersistedAnchor = documentPersistedAnchorToBodyAnchor(persistedThread.anchor, pendingDocument.bodyOffset);
+        const result = reanchorQuote(documentText, bodyPersistedAnchor);
+        if (!result.found) {
+          onthreaddelete?.({ threadId: persistedThread.id });
+          continue;
+        }
+        const from = textOffsetToProseMirrorPosition(doc, result.from);
+        const to = textOffsetToProseMirrorPosition(doc, result.to);
+        if (from !== null && to !== null) {
+          const matchedQuote = documentText.slice(result.from, result.to);
+          const newPrefix = documentText.slice(Math.max(0, result.from - ANCHOR_CONTEXT_LENGTH), result.from);
+          const newSuffix = documentText.slice(result.to, Math.min(documentText.length, result.to + ANCHOR_CONTEXT_LENGTH));
+          reanchoredThreads.push({
+            ...persistedThread,
+            anchor: {
+              ...persistedThread.anchor,
+              from: from + pendingDocument.bodyOffset,
+              to: to + pendingDocument.bodyOffset,
+              quote: matchedQuote,
+              prefix: newPrefix,
+              suffix: newSuffix,
+              status: "anchored",
+              lastKnownOffset: result.from + pendingDocument.bodyOffset
+            }
+          });
+        }
+      }
+      threads = reanchoredThreads;
+      syncThreadsToPlugin(threads);
+    }
+    const isReadonly = $10.derived(() => mode === "readonly");
+    const changeTracker = createChangeTracker({ debounceMs: 300, includeFrontMatter: true });
+    let selectionTimeoutId = null;
+    const SELECTION_DEBOUNCE_MS = 20;
+    function handleSelectionChange(selection) {
+      if (!editorViewReady) {
+        editorViewReady = true;
+      }
+      currentSelection = selection;
+    }
+    function handleChange(newValue) {
+      value = newValue;
+      onchange?.(newValue);
+    }
+    function handleEditorBodyChange(newBody) {
+      handleChange(combineFrontMatterAndBody(currentDocument(), newBody));
+    }
+    function handleFrontMatterChange(data) {
+      const previousBodyOffset = currentDocument().bodyOffset;
+      const nextValue = replaceFrontMatterData(value, data);
+      const nextDocument = parseReviewEditorFrontMatter(nextValue);
+      if (previousBodyOffset !== nextDocument.bodyOffset) {
+        threads = threads.map((thread) => ({
+          ...thread,
+          anchor: remapDocumentAnchorBodyOffset(thread.anchor, previousBodyOffset, nextDocument.bodyOffset, nextValue)
+        }));
+      }
+      handleChange(nextValue);
+    }
+    function focus() {
+      editorRef?.focus();
+    }
+    function getMarkdown() {
+      const body = editorRef?.getMarkdown() ?? currentDocument().body;
+      return combineFrontMatterAndBody(currentDocument(), body);
+    }
+    function setMarkdown(content) {
+      value = content;
+      editorRef?.setMarkdown(parseReviewEditorFrontMatter(content).body);
+    }
+    function getAst() {
+      return editorRef?.getAst();
+    }
+    function getSelection() {
+      const selection = editorRef?.getSelection();
+      if (!selection)
+        return null;
+      return {
+        ...selection,
+        from: selection.from + currentDocument().bodyOffset,
+        to: selection.to + currentDocument().bodyOffset
+      };
+    }
+    function scrollToThread(threadId) {
+      const thread = threads.find((t) => t.id === threadId);
+      if (!thread)
+        return;
+      const view = editorRef?.getView();
+      if (view && thread.anchor.from !== undefined) {
+        const coords = view.coordsAtPos(documentPositionToBodyPosition(thread.anchor.from, currentDocument().bodyOffset));
+        if (coords) {
+          view.dom.scrollTo({
+            top: coords.top - 100,
+            behavior: getScrollBehavior()
+          });
+        }
+      }
+    }
+    function handleSidebarThreadSelect(threadId) {
+      const thread = threads.find((t) => t.id === threadId);
+      if (!thread)
+        return;
+      activeThreadId = threadId;
+      scrollToThread(threadId);
+      setTimeout(() => {
+        const view = editorRef?.getView();
+        if (view && thread.anchor.from !== undefined) {
+          const coords = view.coordsAtPos(documentPositionToBodyPosition(thread.anchor.from, currentDocument().bodyOffset));
+          if (coords) {
+            popoverPosition = { x: coords.left + 16, y: coords.top };
+            popoverThreadId = threadId;
+          }
+        }
+      }, POSITION_DELAY_MS);
+    }
+    function handleAddDocumentComment(body) {
+      if (!currentUserId) {
+        devWarn("Cannot add document comment: no currentUserId");
+        return;
+      }
+      createDocumentThread(body, currentUserId);
+    }
+    function getState() {
+      const persistedThreads = threads.map((thread) => ({
+        ...thread,
+        anchor: {
+          quote: thread.anchor.quote,
+          prefix: thread.anchor.prefix,
+          suffix: thread.anchor.suffix,
+          status: thread.anchor.status,
+          blockId: thread.anchor.blockId,
+          originalPosition: thread.anchor.originalPosition,
+          originalQuote: thread.anchor.originalQuote,
+          lastKnownOffset: thread.anchor.lastKnownOffset
+        }
+      }));
+      return {
+        schemaVersion: 4,
+        content: value,
+        original: original || undefined,
+        threads: persistedThreads,
+        reviewSession: undefined,
+        frontMatter: currentDocument().data,
+        frontMatterRaw: currentDocument().raw,
+        updatedAt: new Date().toISOString()
+      };
+    }
+    function setState(state) {
+      const nextValue = reviewStateToMarkdown(state);
+      value = nextValue;
+      if (state.original !== undefined) {
+        original = state.original;
+      }
+      pendingState = { ...state, content: nextValue };
+      attemptReanchoring();
+    }
+    function getView() {
+      return editorRef?.getView() ?? null;
+    }
+    function getEditor() {
+      return editorRef?.getEditor() ?? null;
+    }
+    function exportMarkdownSummary(options = undefined) {
+      return generateMarkdownSummary(getState(), options);
+    }
+    function exportUnifiedDiff(options = undefined) {
+      return generateUnifiedDiff(getState(), options);
+    }
+    function handleExportContent() {
+      return value;
+    }
+    function handleExportSummary() {
+      return exportMarkdownSummary().markdown;
+    }
+    function handleExportJSON() {
+      const json = stringifyOrNull(getState());
+      if (json === null) {
+        return '{"error": "Failed to serialize editor state"}';
+      }
+      return json;
+    }
+    function handleExportDiff() {
+      return exportUnifiedDiff().diff;
+    }
+    function handleExportComments() {
+      return generateCommentsExport(getState()).markdown;
+    }
+    function getFieldName(field) {
+      return name ? `${name}-${field}` : field;
+    }
+    const formOriginal = $10.derived(() => original);
+    const formCurrent = $10.derived(() => value);
+    const formComments = $10.derived(() => JSON.stringify(threads));
+    const formDiff = $10.derived(() => exportUnifiedDiff().diff);
+    const formSummary = $10.derived(() => exportMarkdownSummary().markdown);
+    function getFormData() {
+      return {
+        original: formOriginal(),
+        current: formCurrent(),
+        comments: formComments(),
+        diff: formDiff(),
+        summary: formSummary()
+      };
+    }
+    function reset() {
+      value = original;
+      onchange?.(original);
+      for (const thread of threads) {
+        onthreaddelete?.({ threadId: thread.id });
+      }
+      popoverThreadId = null;
+      popoverPosition = null;
+      activeThreadId = null;
+      activeView = "editor";
+      selectionPopoverPosition = null;
+      capturedSelectionForPopover = null;
+      selectionPopoverExpanded = false;
+      announce("Review reset");
+    }
+    function handleSelectionComment(body) {
+      function failWithMessage(message) {
+        devWarn(message);
+        selectionPopoverPosition = null;
+        capturedSelectionForPopover = null;
+        selectionPopoverExpanded = false;
+        announce("Could not add comment. Please try selecting text again.", "assertive");
+      }
+      if (!currentUserId) {
+        failWithMessage("Cannot create comment: no currentUserId set");
+        return;
+      }
+      if (!capturedSelectionForPopover) {
+        failWithMessage("Cannot create comment: no captured selection");
+        return;
+      }
+      if (mode === "readonly") {
+        failWithMessage("Cannot create thread: editor is readonly");
+        return;
+      }
+      const view = editorRef?.getView();
+      if (!view) {
+        failWithMessage("Cannot create thread: editor view not available");
+        return;
+      }
+      const { from, to } = capturedSelectionForPopover;
+      const docSize = view.state.doc.content.size;
+      if (from < 0 || to > docSize || from > to) {
+        failWithMessage("Cannot create thread: captured selection is out of bounds");
+        return;
+      }
+      const anchor = bodyAnchorToDocumentAnchor(buildAnchorFromSelection(view, from, to), currentDocument().bodyOffset, value);
+      const requestId = generateId();
+      const mentions = extractMentions(body);
+      const event = {
+        requestId,
+        anchor,
+        body,
+        authorId: currentUserId,
+        mentions: mentions.length > 0 ? mentions : undefined
+      };
+      onthreadcreate?.(event);
+      capturedSelectionForPopover = null;
+      selectionPopoverPosition = null;
+      selectionPopoverExpanded = false;
+      announce("Comment added");
+    }
+    function handleSelectionPopoverExpand() {
+      selectionPopoverExpanded = true;
+    }
+    function handleSelectionPopoverCancel() {
+      selectionPopoverExpanded = false;
+    }
+    function handleSelectionPopoverClose() {
+      selectionPopoverPosition = null;
+      capturedSelectionForPopover = null;
+      selectionPopoverExpanded = false;
+    }
+    function createThread(body, authorId) {
+      if (!currentSelection || currentSelection.isCollapsed) {
+        devWarn("Cannot create thread: no text selected");
+        return null;
+      }
+      if (mode === "readonly") {
+        devWarn("Cannot create thread: editor is readonly");
+        return null;
+      }
+      const view = editorRef?.getView();
+      if (!view) {
+        devWarn("Cannot create thread: editor view not available");
+        return null;
+      }
+      const { from, to } = currentSelection;
+      const anchor = bodyAnchorToDocumentAnchor(buildAnchorFromSelection(view, from, to), currentDocument().bodyOffset, value);
+      const mentions = extractMentions(body);
+      const requestId = generateId();
+      const event = {
+        requestId,
+        anchor,
+        body,
+        authorId,
+        mentions: mentions.length > 0 ? mentions : undefined
+      };
+      onthreadcreate?.(event);
+      announce("Comment added");
+      return requestId;
+    }
+    function createDocumentThread(body, authorId) {
+      if (mode === "readonly") {
+        devWarn("Cannot create thread: editor is readonly");
+        return null;
+      }
+      const anchor = createDocumentAnchor();
+      const mentions = extractMentions(body);
+      const requestId = generateId();
+      const event = {
+        requestId,
+        anchor,
+        body,
+        authorId,
+        mentions: mentions.length > 0 ? mentions : undefined
+      };
+      onthreadcreate?.(event);
+      announce("Document comment added");
+      return requestId;
+    }
+    function deleteThread(threadId) {
+      if (mode === "readonly")
+        return;
+      const thread = threads.find((t) => t.id === threadId);
+      if (!thread)
+        return;
+      onthreaddelete?.({ threadId });
+    }
+    function clearAllThreads() {
+      if (mode === "readonly")
+        return;
+      if (threads.length === 0)
+        return;
+      for (const thread of threads) {
+        onthreaddelete?.({ threadId: thread.id });
+      }
+      popoverThreadId = null;
+      popoverPosition = null;
+      activeThreadId = null;
+      announce("All comments cleared");
+    }
+    function createComment(threadId, body, authorId) {
+      if (mode === "readonly")
+        return null;
+      const thread = threads.find((t) => t.id === threadId);
+      if (!thread)
+        return null;
+      const mentions = extractMentions(body);
+      const requestId = generateId();
+      oncommentcreate?.({
+        requestId,
+        threadId,
+        body,
+        authorId,
+        mentions: mentions.length > 0 ? mentions : undefined
+      });
+      announce("Comment added");
+      return requestId;
+    }
+    function updateComment(threadId, commentId, body) {
+      if (mode === "readonly")
+        return;
+      const thread = threads.find((t) => t.id === threadId);
+      const comment = thread?.comments.find((c) => c.id === commentId);
+      if (!comment || comment.deletedAt)
+        return;
+      const mentions = extractMentions(body);
+      oncommentupdate?.({
+        threadId,
+        commentId,
+        body,
+        mentions: mentions.length > 0 ? mentions : undefined
+      });
+    }
+    function deleteComment(threadId, commentId, soft = true) {
+      if (mode === "readonly")
+        return;
+      const thread = threads.find((t) => t.id === threadId);
+      const comment = thread?.comments.find((c) => c.id === commentId);
+      if (!comment || soft && comment.deletedAt)
+        return;
+      oncommentdelete?.({ threadId, commentId, soft });
+      announce("Comment deleted");
+    }
+    function createBlockThread(body, authorId) {
+      if (mode === "readonly") {
+        devWarn("Cannot create block thread: editor is readonly");
+        return null;
+      }
+      const view = editorRef?.getView();
+      if (!view) {
+        devWarn("Cannot create block thread: editor view not available");
+        return null;
+      }
+      const { from } = view.state.selection;
+      const resolvedPos = view.state.doc.resolve(from);
+      for (let depth = resolvedPos.depth;depth > 0; depth--) {
+        const node = resolvedPos.node(depth);
+        if (!node.isBlock)
+          continue;
+        const blockFrom = resolvedPos.start(depth);
+        const blockTo = resolvedPos.end(depth);
+        const anchor = bodyAnchorToDocumentAnchor(buildAnchorFromSelection(view, blockFrom, blockTo), currentDocument().bodyOffset, value);
+        const mentions = extractMentions(body);
+        const requestId = generateId();
+        onthreadcreate?.({
+          requestId,
+          anchor,
+          body,
+          authorId,
+          mentions: mentions.length > 0 ? mentions : undefined
+        });
+        return requestId;
+      }
+      devWarn("Cannot create block thread: cursor not inside a block");
+      return null;
+    }
+    const focusRegions = [
+      {
+        id: "editor",
+        selector: ".review-editor-main",
+        label: "Editor"
+      },
+      { id: "popover", selector: ".thread-popover", label: "Thread" }
+    ];
+    const focusNavigator = createFocusRegionNavigator(focusRegions, {
+      isRegionActive: (region) => {
+        if (region.id === "popover") {
+          return popoverThread() !== null;
+        }
+        return true;
+      },
+      customFocusHandler: (region) => {
+        if (region.id === "editor") {
+          editorRef?.getView()?.focus();
+          return true;
+        }
+        return false;
+      }
+    });
+    function handleContainerKeyDown(event) {
+      if (event.key !== "F6")
+        return;
+      const container = event.currentTarget;
+      if (!(container instanceof HTMLElement))
+        return;
+      event.preventDefault();
+      const current = focusNavigator.getCurrentRegion(container);
+      const next = focusNavigator.getNextRegion(current, event.shiftKey);
+      focusNavigator.focusRegion(container, next);
+    }
+    function exportActionsSnippet($$renderer3) {
+      Export_actions($$renderer3, {
+        id: `${$10.stringify(id)}-export`,
+        onexportcontent: handleExportContent,
+        onexportsummary: handleExportSummary,
+        onexportjson: handleExportJSON,
+        onexportdiff: handleExportDiff,
+        onexportcomments: handleExportComments
+      });
+    }
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      $$renderer3.push(`<div data-testid="review-editor"${$10.attr_class($10.clsx(classNames("review-editor-container", className)), "svelte-1rnat08")}${$10.attr("data-mode", mode)}${$10.attr("data-view", activeView)}${$10.attr("data-ready", editorViewReady && !pendingState ? true : undefined)}${$10.attr("data-snapshot-mode", snapshotMode || undefined)}>`);
+      Live_region($$renderer3, {});
+      $$renderer3.push(`<!----> `);
+      if (name) {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<input type="hidden"${$10.attr("name", getFieldName("original"))}${$10.attr("value", formOriginal())} class="svelte-1rnat08"/> <input type="hidden"${$10.attr("name", getFieldName("current"))}${$10.attr("value", formCurrent())} class="svelte-1rnat08"/> <input type="hidden"${$10.attr("name", getFieldName("comments"))}${$10.attr("value", formComments())} class="svelte-1rnat08"/> <input type="hidden"${$10.attr("name", getFieldName("diff"))}${$10.attr("value", formDiff())} class="svelte-1rnat08"/> <input type="hidden"${$10.attr("name", getFieldName("summary"))}${$10.attr("value", formSummary())} class="svelte-1rnat08"/>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      Review_editor_controls($$renderer3, {
+        id: `${$10.stringify(id)}-controls`,
+        activeView,
+        viewPanelIds: viewPanelIds(),
+        onViewChange: (view) => {
+          if (view !== "editor") {
+            selectionPopoverPosition = null;
+            capturedSelectionForPopover = null;
+            selectionPopoverExpanded = false;
+          }
+          activeView = view;
+          announce(`Switched to ${view} view`);
+        },
+        showDiffTabs: !!original,
+        diffStats: diffStats(),
+        hasContentChanges: hasContentChanges(),
+        readonly: isReadonly(),
+        onRevertAll: () => {
+          value = original;
+          onchange?.(original);
+          announce("All changes reverted");
+        },
+        commentCount: commentCount(),
+        sidebarOpen,
+        onSidebarToggle: () => sidebarOpen = !sidebarOpen,
+        trailing: exportActionsSnippet,
+        get diffViewMode() {
+          return diffViewMode;
+        },
+        set diffViewMode($$value) {
+          diffViewMode = $$value;
+          $$settled = false;
+        }
+      });
+      $$renderer3.push(`<!----> <div class="review-editor-main svelte-1rnat08">`);
+      if (activeView === "editor") {
+        $$renderer3.push("<!--[0-->");
+        $$renderer3.push(`<div${$10.attr("id", viewPanelIds().editor)} class="review-editor-view-panel svelte-1rnat08" role="tabpanel" aria-label="Editor view">`);
+        if (currentDocument().hasFrontMatter) {
+          $$renderer3.push("<!--[0-->");
+          Front_matter_fields($$renderer3, {
+            id: `${id}-front-matter`,
+            data: currentDocument().data,
+            raw: currentDocument().raw,
+            readonly: isReadonly(),
+            onchange: handleFrontMatterChange
+          });
+        } else {
+          $$renderer3.push("<!--[-1-->");
+        }
+        $$renderer3.push(`<!--]--> `);
+        Markdown_editor($$renderer3, {
+          id,
+          value: editorValue(),
+          mode: "wysiwyg",
+          readonly: isReadonly(),
+          placeholder,
+          plugins: [anchorPlugin],
+          snapshotMode,
+          onchange: handleEditorBodyChange,
+          onready: () => {
+            if (!editorViewReady) {
+              editorViewReady = true;
+            }
+          },
+          onselectionchange: handleSelectionChange
+        });
+        $$renderer3.push(`<!----></div>`);
+      } else if (activeView === "diff") {
+        $$renderer3.push("<!--[1-->");
+        $$renderer3.push(`<div${$10.attr("id", viewPanelIds().diff)} class="review-editor-view-panel svelte-1rnat08" role="tabpanel" aria-label="Diff view">`);
+        {
+          let toolbar = function($$renderer4) {};
+          Diff_viewer($$renderer3, {
+            original,
+            current: value,
+            readonly: isReadonly(),
+            get viewMode() {
+              return diffViewMode;
+            },
+            set viewMode($$value) {
+              diffViewMode = $$value;
+              $$settled = false;
+            },
+            toolbar,
+            $$slots: { toolbar: true }
+          });
+        }
+        $$renderer3.push(`<!----></div>`);
+      } else {
+        $$renderer3.push("<!--[-1-->");
+        $$renderer3.push(`<div${$10.attr("id", viewPanelIds().summary)} class="review-editor-view-panel svelte-1rnat08" role="tabpanel" aria-label="Summary view">`);
+        if (hasContentChanges() || threads.length > 0) {
+          $$renderer3.push("<!--[0-->");
+          Markdown_editor($$renderer3, {
+            id: `${$10.stringify(id)}-summary`,
+            value: summaryContent(),
+            mode: "wysiwyg",
+            readonly: true,
+            showToolbar: false,
+            placeholder: ""
+          });
+        } else {
+          $$renderer3.push("<!--[-1-->");
+          $$renderer3.push(`<div class="summary-view svelte-1rnat08" role="region" aria-label="Review summary"><div class="summary-empty svelte-1rnat08"><p class="svelte-1rnat08">No changes or comments to summarize.</p> <p class="summary-hint svelte-1rnat08">Edit the document or add comments to generate a summary.</p></div></div>`);
+        }
+        $$renderer3.push(`<!--]--></div>`);
+      }
+      $$renderer3.push(`<!--]--></div> `);
+      if (sidebarOpen) {
+        $$renderer3.push("<!--[0-->");
+        Comment_sidebar($$renderer3, {
+          id: `${$10.stringify(id)}-sidebar`,
+          threads,
+          activeThreadId,
+          readonly: isReadonly(),
+          onthreadselect: handleSidebarThreadSelect,
+          onclearall: clearAllThreads,
+          onadddocumentcomment: handleAddDocumentComment
+        });
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (popoverThread() && popoverPosition) {
+        $$renderer3.push("<!--[0-->");
+        Thread_popover($$renderer3, {
+          id: `${$10.stringify(id)}-thread-popover`,
+          thread: popoverThread(),
+          currentUserId,
+          mode,
+          position: popoverPosition,
+          onclose: handlePopoverClose,
+          ondelete: handlePopoverDelete,
+          oncommentcreate: handlePopoverCommentCreate,
+          oncommentupdate: handlePopoverCommentUpdate,
+          oncommentdelete: handlePopoverCommentDelete
+        });
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--> `);
+      if (showSelectionPopover()) {
+        $$renderer3.push("<!--[0-->");
+        Selection_popover($$renderer3, {
+          id: `${$10.stringify(id)}-selection-popover`,
+          position: selectionPopoverPosition,
+          open: showSelectionPopover(),
+          oncommentsubmit: handleSelectionComment,
+          onexpand: handleSelectionPopoverExpand,
+          oncancel: handleSelectionPopoverCancel,
+          onclose: handleSelectionPopoverClose
+        });
+      } else {
+        $$renderer3.push("<!--[-1-->");
+      }
+      $$renderer3.push(`<!--]--></div>`);
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    $10.bind_props($$props, {
+      original,
+      value,
+      threads,
+      focus,
+      getMarkdown,
+      setMarkdown,
+      getAst,
+      getSelection,
+      scrollToThread,
+      getState,
+      setState,
+      getView,
+      getEditor,
+      exportMarkdownSummary,
+      exportUnifiedDiff,
+      getFormData,
+      reset,
+      createThread,
+      createDocumentThread,
+      deleteThread,
+      clearAllThreads,
+      createComment,
+      updateComment,
+      deleteComment,
+      createBlockThread
+    });
+  });
+}
+
+// src/components/review-editor/review-editor.svelte
+function Review_editor($$renderer, $$props) {
+  $$renderer.component(($$renderer2) => {
+    let {
+      class: customClassName,
+      original = "",
+      value = "",
+      threads = [],
+      $$slots,
+      $$events,
+      ...rest
+    } = $$props;
+    const mergedClassName = $11.derived(() => classNames(customClassName));
+    let $$settled = true;
+    let $$inner_renderer;
+    function $$render_inner($$renderer3) {
+      Review_editor_impl($$renderer3, $11.spread_props([
+        { class: mergedClassName() },
+        rest,
+        {
+          get original() {
+            return original;
+          },
+          set original($$value) {
+            original = $$value;
+            $$settled = false;
+          },
+          get value() {
+            return value;
+          },
+          set value($$value) {
+            value = $$value;
+            $$settled = false;
+          },
+          get threads() {
+            return threads;
+          },
+          set threads($$value) {
+            threads = $$value;
+            $$settled = false;
+          }
+        }
+      ]));
+    }
+    do {
+      $$settled = true;
+      $$inner_renderer = $$renderer2.copy();
+      $$render_inner($$inner_renderer);
+    } while (!$$settled);
+    $$renderer2.subsume($$inner_renderer);
+    $11.bind_props($$props, { original, value, threads });
+  });
+}
+
+// src/components/review-editor/review-editor-state.svelte.ts
+import * as $12 from "svelte/internal/server";
+import { generateMarkdownSummary as generateMarkdownSummary2 } from "@lostgradient/cinder/commentary/export";
+import { computeLineDiff as computeLineDiff2, getDiffStats as getDiffStats2 } from "@lostgradient/cinder/markdown/diff/line-diff";
+import { normalize as normalize2 } from "@lostgradient/cinder/markdown/pipeline";
+function createReviewEditorState(options) {
+  const { getOriginal, getValue, getThreads } = options;
+  let activeView = "editor";
+  let diffViewMode = "unified";
+  const diffStats = $12.derived(() => {
+    const original = getOriginal();
+    if (!original) {
+      return { added: 0, removed: 0, modified: 0 };
+    }
+    const normalizedOriginal = normalize2(original);
+    const normalizedCurrent = normalize2(getValue());
+    const lineDiffs = computeLineDiff2(normalizedOriginal, normalizedCurrent);
+    return getDiffStats2(lineDiffs);
+  });
+  const hasContentChanges = $12.derived(() => diffStats().added > 0 || diffStats().removed > 0 || diffStats().modified > 0);
+  const commentCount = $12.derived(() => {
+    const threads = getThreads();
+    return threads.reduce((count, thread) => {
+      return count + thread.comments.filter((c) => !c.deletedAt).length;
+    }, 0);
+  });
+  const summaryContent = $12.derived(() => {
+    const threads = getThreads();
+    const state = {
+      schemaVersion: 4,
+      content: getValue(),
+      original: getOriginal() || undefined,
+      threads: threads.map((t) => ({
+        ...t,
+        anchor: {
+          quote: t.anchor.quote,
+          prefix: t.anchor.prefix,
+          suffix: t.anchor.suffix,
+          status: t.anchor.status,
+          blockId: t.anchor.blockId,
+          originalPosition: t.anchor.originalPosition,
+          originalQuote: t.anchor.originalQuote,
+          lastKnownOffset: t.anchor.lastKnownOffset
+        }
+      })),
+      updatedAt: ""
+    };
+    const result = generateMarkdownSummary2(state);
+    return result.markdown.replace(/^# Review Summary\n+/, "");
+  });
+  return {
+    get activeView() {
+      return activeView;
+    },
+    setActiveView(view) {
+      activeView = view;
+    },
+    get diffViewMode() {
+      return diffViewMode;
+    },
+    setDiffViewMode(mode) {
+      diffViewMode = mode;
+    },
+    get diffStats() {
+      return diffStats();
+    },
+    get hasContentChanges() {
+      return hasContentChanges();
+    },
+    get commentCount() {
+      return commentCount();
+    },
+    get summaryContent() {
+      return summaryContent();
+    }
+  };
+}
+// src/components/review-editor/review-editor-threads.svelte.ts
+import * as $13 from "svelte/internal/server";
+import { buildAnchorFromSelection as buildAnchorFromSelection2 } from "@lostgradient/cinder/commentary/anchoring";
+import { createDocumentAnchor as createDocumentAnchor2, extractMentions as extractMentions2, generateId as generateId2 } from "@lostgradient/cinder/commentary/comments";
+var POSITION_DELAY_MS = 350;
+function createThreadManager(options) {
+  const {
+    getThreads,
+    getEditorView,
+    getMode,
+    getCurrentUserId,
+    getScrollBehavior,
+    announce,
+    onthreadcreate,
+    onthreaddelete,
+    oncommentcreate,
+    oncommentupdate,
+    oncommentdelete,
+    onBeforePopoverOpen
+  } = options;
+  let popoverThreadId = null;
+  let popoverPosition = null;
+  let activeThreadId = null;
+  let selectTimeoutId = null;
+  const popoverThread = $13.derived(() => {
+    if (!popoverThreadId)
+      return null;
+    return getThreads().find((t) => t.id === popoverThreadId) ?? null;
+  });
+  function calculateViewportPosition(from) {
+    const view = getEditorView();
+    if (!view)
+      return null;
+    try {
+      const coords = view.coordsAtPos(from);
+      if (coords) {
+        return { x: Math.max(16, coords.left), y: coords.top + 24 };
+      }
+    } catch {}
+    return null;
+  }
+  function scrollAnchorIntoView(threadId) {
+    const editorDom = getEditorView()?.dom;
+    const anchorElement = editorDom?.querySelector(`[data-thread-id="${threadId}"]`);
+    if (anchorElement) {
+      anchorElement.scrollIntoView({ behavior: getScrollBehavior(), block: "center" });
+    }
+  }
+  function scrollToThread(threadId) {
+    const thread = getThreads().find((t) => t.id === threadId);
+    if (!thread)
+      return;
+    const view = getEditorView();
+    if (view && thread.anchor.from !== undefined) {
+      const coords = view.coordsAtPos(thread.anchor.from);
+      if (coords) {
+        view.dom.scrollTo({ top: coords.top - 100, behavior: getScrollBehavior() });
+      }
+    }
+  }
+  function openPopover(threadId, position) {
+    popoverThreadId = threadId;
+    popoverPosition = position;
+    activeThreadId = threadId;
+  }
+  function closePopover() {
+    if (selectTimeoutId !== null) {
+      clearTimeout(selectTimeoutId);
+      selectTimeoutId = null;
+    }
+    popoverThreadId = null;
+    popoverPosition = null;
+    activeThreadId = null;
+  }
+  function handleAnchorClick(threadId, event) {
+    if (selectTimeoutId !== null) {
+      clearTimeout(selectTimeoutId);
+      selectTimeoutId = null;
+    }
+    onBeforePopoverOpen?.();
+    activeThreadId = threadId;
+    const thread = getThreads().find((t) => t.id === threadId);
+    if (thread) {
+      popoverPosition = { x: event.clientX + 16, y: event.clientY };
+      popoverThreadId = threadId;
+    }
+  }
+  function handleSidebarThreadSelect(threadId) {
+    const thread = getThreads().find((t) => t.id === threadId);
+    if (!thread)
+      return;
+    onBeforePopoverOpen?.();
+    activeThreadId = threadId;
+    scrollToThread(threadId);
+    selectTimeoutId = setTimeout(() => {
+      selectTimeoutId = null;
+      const view = getEditorView();
+      if (view && thread.anchor.from !== undefined) {
+        const coords = view.coordsAtPos(thread.anchor.from);
+        if (coords) {
+          popoverPosition = { x: coords.left + 16, y: coords.top };
+          popoverThreadId = threadId;
+        }
+      }
+    }, POSITION_DELAY_MS);
+  }
+  function createThread(body, authorId, selection) {
+    if (!selection || selection.from === selection.to) {
+      devWarn("Cannot create thread: no text selected");
+      return null;
+    }
+    if (getMode() === "readonly") {
+      devWarn("Cannot create thread: editor is readonly");
+      return null;
+    }
+    const view = getEditorView();
+    if (!view) {
+      devWarn("Cannot create thread: editor view not available");
+      return null;
+    }
+    const { from, to } = selection;
+    const anchor = buildAnchorFromSelection2(view, from, to);
+    const mentions = extractMentions2(body);
+    const requestId = generateId2();
+    const event = {
+      requestId,
+      anchor,
+      body,
+      authorId,
+      mentions: mentions.length > 0 ? mentions : undefined
+    };
+    onthreadcreate?.(event);
+    announce("Comment added");
+    return requestId;
+  }
+  function createDocumentThread(body, authorId) {
+    if (getMode() === "readonly") {
+      devWarn("Cannot create thread: editor is readonly");
+      return null;
+    }
+    const anchor = createDocumentAnchor2();
+    const mentions = extractMentions2(body);
+    const requestId = generateId2();
+    const event = {
+      requestId,
+      anchor,
+      body,
+      authorId,
+      mentions: mentions.length > 0 ? mentions : undefined
+    };
+    onthreadcreate?.(event);
+    announce("Document comment added");
+    return requestId;
+  }
+  function createBlockThread(body, authorId) {
+    if (getMode() === "readonly") {
+      devWarn("Cannot create block thread: editor is readonly");
+      return null;
+    }
+    const view = getEditorView();
+    if (!view) {
+      devWarn("Cannot create block thread: editor view not available");
+      return null;
+    }
+    const { from } = view.state.selection;
+    const resolvedPos = view.state.doc.resolve(from);
+    for (let depth = resolvedPos.depth;depth > 0; depth--) {
+      const node = resolvedPos.node(depth);
+      if (!node.isBlock)
+        continue;
+      const blockFrom = resolvedPos.start(depth);
+      const blockTo = resolvedPos.end(depth);
+      const anchor = buildAnchorFromSelection2(view, blockFrom, blockTo);
+      const mentions = extractMentions2(body);
+      const requestId = generateId2();
+      onthreadcreate?.({
+        requestId,
+        anchor,
+        body,
+        authorId,
+        mentions: mentions.length > 0 ? mentions : undefined
+      });
+      return requestId;
+    }
+    devWarn("Cannot create block thread: cursor not inside a block");
+    return null;
+  }
+  function deleteThread(threadId) {
+    if (getMode() === "readonly")
+      return;
+    const thread = getThreads().find((t) => t.id === threadId);
+    if (!thread)
+      return;
+    onthreaddelete?.({ threadId });
+  }
+  function clearAllThreads() {
+    if (getMode() === "readonly")
+      return;
+    const threads = getThreads();
+    if (threads.length === 0)
+      return;
+    for (const thread of threads) {
+      onthreaddelete?.({ threadId: thread.id });
+    }
+    popoverThreadId = null;
+    popoverPosition = null;
+    activeThreadId = null;
+    announce("All comments cleared");
+  }
+  function createComment(threadId, body, authorId) {
+    if (getMode() === "readonly")
+      return null;
+    const thread = getThreads().find((t) => t.id === threadId);
+    if (!thread)
+      return null;
+    const mentions = extractMentions2(body);
+    const requestId = generateId2();
+    oncommentcreate?.({
+      requestId,
+      threadId,
+      body,
+      authorId,
+      mentions: mentions.length > 0 ? mentions : undefined
+    });
+    announce("Comment added");
+    return requestId;
+  }
+  function updateComment(threadId, commentId, body) {
+    if (getMode() === "readonly")
+      return;
+    const thread = getThreads().find((t) => t.id === threadId);
+    const comment = thread?.comments.find((c) => c.id === commentId);
+    if (!comment || comment.deletedAt)
+      return;
+    const mentions = extractMentions2(body);
+    oncommentupdate?.({
+      threadId,
+      commentId,
+      body,
+      mentions: mentions.length > 0 ? mentions : undefined
+    });
+  }
+  function deleteComment(threadId, commentId, soft = true) {
+    if (getMode() === "readonly")
+      return;
+    const thread = getThreads().find((t) => t.id === threadId);
+    const comment = thread?.comments.find((c) => c.id === commentId);
+    if (!comment || soft && comment.deletedAt)
+      return;
+    oncommentdelete?.({ threadId, commentId, soft });
+    announce("Comment deleted");
+  }
+  function handlePopoverClose() {
+    closePopover();
+  }
+  function handlePopoverDelete(threadId) {
+    const currentUserId = getCurrentUserId();
+    if (currentUserId) {
+      deleteThread(threadId);
+      closePopover();
+    }
+  }
+  function handlePopoverCommentCreate(threadId, body) {
+    const currentUserId = getCurrentUserId();
+    if (currentUserId) {
+      createComment(threadId, body, currentUserId);
+    }
+  }
+  function handlePopoverCommentUpdate(threadId, commentId, body) {
+    updateComment(threadId, commentId, body);
+  }
+  function handlePopoverCommentDelete(threadId, commentId) {
+    deleteComment(threadId, commentId);
+  }
+  function destroy() {
+    if (selectTimeoutId !== null) {
+      clearTimeout(selectTimeoutId);
+      selectTimeoutId = null;
+    }
+  }
+  return {
+    get popoverThreadId() {
+      return popoverThreadId;
+    },
+    get popoverPosition() {
+      return popoverPosition;
+    },
+    get popoverThread() {
+      return popoverThread();
+    },
+    get activeThreadId() {
+      return activeThreadId;
+    },
+    openPopover,
+    closePopover,
+    handleAnchorClick,
+    handleSidebarThreadSelect,
+    createThread,
+    createDocumentThread,
+    createBlockThread,
+    deleteThread,
+    clearAllThreads,
+    createComment,
+    updateComment,
+    deleteComment,
+    handlePopoverClose,
+    handlePopoverDelete,
+    handlePopoverCommentCreate,
+    handlePopoverCommentUpdate,
+    handlePopoverCommentDelete,
+    scrollAnchorIntoView,
+    scrollToThread,
+    calculateViewportPosition,
+    destroy
+  };
+}
+// src/components/review-editor/review-editor-selection.svelte.ts
+import * as $14 from "svelte/internal/server";
+import { buildAnchorFromSelection as buildAnchorFromSelection3 } from "@lostgradient/cinder/commentary/anchoring";
+import { extractMentions as extractMentions3, generateId as generateId3 } from "@lostgradient/cinder/commentary/comments";
+var SELECTION_DEBOUNCE_MS = 20;
+function createSelectionPopover(options) {
+  const {
+    getId,
+    getMainRef,
+    getEditorView,
+    getMode,
+    getActiveView,
+    getCurrentUserId,
+    isThreadPopoverOpen,
+    announce,
+    onthreadcreate
+  } = options;
+  let position = null;
+  let capturedSelection = null;
+  let expanded = false;
+  let selectionTimeoutId = null;
+  let isListening = false;
+  let computeVersion = 0;
+  const visible = $14.derived(() => {
+    return getActiveView() === "editor" && getMode() === "edit" && getCurrentUserId() !== undefined && (position !== null || expanded) && !isThreadPopoverOpen();
+  });
+  function clearTimeouts() {
+    if (selectionTimeoutId !== null) {
+      clearTimeout(selectionTimeoutId);
+      selectionTimeoutId = null;
+    }
+  }
+  function clear() {
+    clearTimeouts();
+    position = null;
+    capturedSelection = null;
+    expanded = false;
+    computeVersion++;
+  }
+  function close() {
+    clear();
+  }
+  function handleExpand() {
+    expanded = true;
+  }
+  function handleCancel() {
+    expanded = false;
+  }
+  function handleComment(body) {
+    function failWithMessage(message) {
+      devWarn(message);
+      clear();
+      announce("Could not add comment. Please try selecting text again.", "assertive");
+    }
+    const currentUserId = getCurrentUserId();
+    if (!currentUserId) {
+      failWithMessage("Cannot create comment: no currentUserId set");
+      return;
+    }
+    if (!capturedSelection) {
+      failWithMessage("Cannot create comment: no captured selection");
+      return;
+    }
+    if (getMode() === "readonly") {
+      failWithMessage("Cannot create thread: editor is readonly");
+      return;
+    }
+    const view = getEditorView();
+    if (!view) {
+      failWithMessage("Cannot create thread: editor view not available");
+      return;
+    }
+    const { from, to } = capturedSelection;
+    const docSize = view.state.doc.content.size;
+    if (from < 0 || to > docSize || from > to) {
+      failWithMessage("Cannot create thread: captured selection is out of bounds");
+      return;
+    }
+    const anchor = buildAnchorFromSelection3(view, from, to);
+    const requestId = generateId3();
+    const mentions = extractMentions3(body);
+    const event = {
+      requestId,
+      anchor,
+      body,
+      authorId: currentUserId,
+      mentions: mentions.length > 0 ? mentions : undefined
+    };
+    onthreadcreate?.(event);
+    clear();
+    announce("Comment added");
+  }
+  function handleBrowserSelectionChange() {
+    clearTimeouts();
+    if (getMode() !== "edit") {
+      position = null;
+      capturedSelection = null;
+      return;
+    }
+    const selectionPopoverElement = document.getElementById(`${getId()}-selection-popover`);
+    if (selectionPopoverElement?.contains(document.activeElement)) {
+      return;
+    }
+    if (expanded) {
+      return;
+    }
+    const browserSelection = window.getSelection();
+    if (!browserSelection || browserSelection.isCollapsed) {
+      position = null;
+      capturedSelection = null;
+      expanded = false;
+      return;
+    }
+    const mainRef = getMainRef();
+    const anchorNode = browserSelection.anchorNode;
+    if (!mainRef || !anchorNode || !mainRef.contains(anchorNode)) {
+      position = null;
+      capturedSelection = null;
+      expanded = false;
+      return;
+    }
+    const version = ++computeVersion;
+    selectionTimeoutId = setTimeout(() => {
+      selectionTimeoutId = null;
+      if (computeVersion !== version)
+        return;
+      const sel = window.getSelection();
+      if (!sel || sel.isCollapsed) {
+        position = null;
+        capturedSelection = null;
+        return;
+      }
+      const range = sel.getRangeAt(0);
+      const anchorPosition = getSelectionAnchorPosition(range);
+      if (anchorPosition) {
+        const view = getEditorView();
+        if (view) {
+          const { from, to } = view.state.selection;
+          if (from !== to) {
+            capturedSelection = { from, to };
+            position = anchorPosition;
+          }
+        }
+      }
+    }, SELECTION_DEBOUNCE_MS);
+  }
+  function startListening() {
+    if (isListening || typeof document === "undefined")
+      return;
+    document.addEventListener("selectionchange", handleBrowserSelectionChange);
+    isListening = true;
+  }
+  function stopListening() {
+    if (!isListening || typeof document === "undefined")
+      return;
+    document.removeEventListener("selectionchange", handleBrowserSelectionChange);
+    isListening = false;
+  }
+  function destroy() {
+    stopListening();
+    clearTimeouts();
+  }
+  return {
+    get position() {
+      return position;
+    },
+    get capturedSelection() {
+      return capturedSelection;
+    },
+    get expanded() {
+      return expanded;
+    },
+    get visible() {
+      return visible();
+    },
+    handleComment,
+    handleExpand,
+    handleCancel,
+    close,
+    clear,
+    startListening,
+    stopListening,
+    destroy
+  };
+}
+// src/components/review-editor/review-editor-anchors.svelte.ts
+import * as $15 from "svelte/internal/server";
+import { anchorPluginKey as anchorPluginKey2, createAnchorPlugin as createAnchorPlugin2 } from "@lostgradient/cinder/commentary/anchor-decorations";
+import { ANCHOR_CONTEXT_LENGTH as ANCHOR_CONTEXT_LENGTH2, reanchorQuote as reanchorQuote2 } from "@lostgradient/cinder/commentary/comments";
+import { textOffsetToProseMirrorPosition as textOffsetToProseMirrorPosition2 } from "@lostgradient/cinder/editor";
+import { contentEquals as contentEquals3 } from "@lostgradient/cinder/markdown/pipeline";
+function createSyncFingerprint(threads) {
+  return threads.map((thread) => {
+    const anchor = thread.anchor;
+    return `${thread.id}:${anchor.from}:${anchor.to}:${anchor.quote}:${anchor.prefix}:${anchor.suffix}:${anchor.lastKnownOffset ?? ""}`;
+  }).join("|");
+}
+function createAnchorManager(options) {
+  const {
+    getThreads,
+    setThreads,
+    getEditorView,
+    getMarkdown,
+    getValue,
+    onAnchorClick,
+    onthreaddelete
+  } = options;
+  let lastSyncedFingerprint = null;
+  let pendingState = null;
+  function handleAnchorsUpdate(updates) {
+    const threads = getThreads();
+    const updatedThreads = threads.map((thread) => {
+      const update = updates.find((u) => u.threadId === thread.id);
+      if (update) {
+        return {
+          ...thread,
+          anchor: {
+            ...thread.anchor,
+            from: update.from,
+            to: update.to,
+            quote: update.quote,
+            prefix: update.prefix,
+            suffix: update.suffix,
+            lastKnownOffset: update.lastKnownOffset
+          }
+        };
+      }
+      return thread;
+    });
+    setThreads(updatedThreads);
+    lastSyncedFingerprint = createSyncFingerprint(updatedThreads);
+  }
+  const plugin = createAnchorPlugin2({ onAnchorsUpdate: handleAnchorsUpdate, onAnchorClick });
+  function syncThreadsToPlugin(threads) {
+    const view = getEditorView();
+    if (!view)
+      return;
+    const fingerprint = createSyncFingerprint(threads);
+    if (fingerprint === lastSyncedFingerprint)
+      return;
+    lastSyncedFingerprint = fingerprint;
+    view.dispatch(view.state.tr.setMeta(anchorPluginKey2, { type: "sync", threads, source: "external" }));
+  }
+  function attemptReanchoring() {
+    if (!pendingState)
+      return;
+    const view = getEditorView();
+    if (!view)
+      return;
+    const currentMarkdown = getMarkdown();
+    const expectedMarkdown = pendingState.content;
+    if (!contentEquals3(currentMarkdown, expectedMarkdown)) {
+      return;
+    }
+    const state = pendingState;
+    pendingState = null;
+    const { doc } = view.state;
+    const documentText = doc.textBetween(0, doc.content.size, `
+`);
+    const reanchoredThreads = [];
+    for (const persistedThread of state.threads) {
+      const result = reanchorQuote2(documentText, persistedThread.anchor);
+      if (!result.found) {
+        onthreaddelete?.({ threadId: persistedThread.id });
+        continue;
+      }
+      const from = textOffsetToProseMirrorPosition2(doc, result.from);
+      const to = textOffsetToProseMirrorPosition2(doc, result.to);
+      if (from !== null && to !== null) {
+        const matchedQuote = documentText.slice(result.from, result.to);
+        const newPrefix = documentText.slice(Math.max(0, result.from - ANCHOR_CONTEXT_LENGTH2), result.from);
+        const newSuffix = documentText.slice(result.to, Math.min(documentText.length, result.to + ANCHOR_CONTEXT_LENGTH2));
+        reanchoredThreads.push({
+          ...persistedThread,
+          anchor: {
+            ...persistedThread.anchor,
+            from,
+            to,
+            quote: matchedQuote,
+            prefix: newPrefix,
+            suffix: newSuffix,
+            status: "anchored",
+            lastKnownOffset: result.from
+          }
+        });
+      }
+    }
+    setThreads(reanchoredThreads);
+    syncThreadsToPlugin(reanchoredThreads);
+  }
+  return {
+    get plugin() {
+      return plugin;
+    },
+    get pendingState() {
+      return pendingState;
+    },
+    setPendingState(state) {
+      pendingState = state;
+    },
+    attemptReanchoring,
+    syncThreadsToPlugin,
+    createSyncFingerprint,
+    handleAnchorsUpdate
+  };
+}
+function toPersistedThreads(threads) {
+  return threads.map((thread) => ({
+    ...thread,
+    anchor: {
+      quote: thread.anchor.quote,
+      prefix: thread.anchor.prefix,
+      suffix: thread.anchor.suffix,
+      status: thread.anchor.status,
+      blockId: thread.anchor.blockId,
+      originalPosition: thread.anchor.originalPosition,
+      originalQuote: thread.anchor.originalQuote,
+      lastKnownOffset: thread.anchor.lastKnownOffset
+    }
+  }));
+}
+// src/components/review-editor/review-editor-exports.ts
+import {
+  generateCommentsExport as generateCommentsExport2,
+  generateMarkdownSummary as generateMarkdownSummary3,
+  generateUnifiedDiff as generateUnifiedDiff2
+} from "@lostgradient/cinder/commentary/export";
+function buildFormData(state) {
+  return {
+    original: state.original ?? "",
+    current: state.content,
+    comments: JSON.stringify(state.threads),
+    diff: generateUnifiedDiff2(state).diff,
+    summary: generateMarkdownSummary3(state).markdown
+  };
+}
+function buildFormDataFromValues(original, current, threads) {
+  const state = {
+    schemaVersion: 4,
+    content: current,
+    original,
+    threads: threads.map((t) => ({
+      ...t,
+      anchor: {
+        quote: t.anchor.quote,
+        prefix: t.anchor.prefix,
+        suffix: t.anchor.suffix,
+        status: t.anchor.status,
+        blockId: t.anchor.blockId,
+        originalPosition: t.anchor.originalPosition,
+        originalQuote: t.anchor.originalQuote,
+        lastKnownOffset: t.anchor.lastKnownOffset
+      }
+    })),
+    updatedAt: new Date().toISOString()
+  };
+  return buildFormData(state);
+}
+function exportMarkdownSummary(state, options) {
+  return generateMarkdownSummary3(state, options);
+}
+function exportUnifiedDiff(state, options) {
+  return generateUnifiedDiff2(state, options);
+}
+function exportCommentsMarkdown(state) {
+  return generateCommentsExport2(state).markdown;
+}
+function getSummaryContentWithoutHeading(state) {
+  const result = generateMarkdownSummary3(state);
+  return result.markdown.replace(/^# Review Summary\n+/, "");
+}
+
+// src/components/review-editor/index.ts
+var review_editor_default = Review_editor;
+export { Comment_list, Comment_composer, Thread_popover, Export_actions, Review_editor, createReviewEditorState, createThreadManager, createSelectionPopover, createAnchorManager, toPersistedThreads, buildFormData, buildFormDataFromValues, exportMarkdownSummary, exportUnifiedDiff, exportCommentsMarkdown, getSummaryContentWithoutHeading, review_editor_default };
+
+//# debugId=07F3B0BEC63F9CCF64756E2164756E21