@beyondwork/docx-react-component 1.0.1 → 1.0.3

package/src/ui-tailwind/toolbar/tw-toolbar.tsx

@@ -0,0 +1,231 @@
+import React from "react";
+
+import * as Popover from "@radix-ui/react-popover";
+import * as Toggle from "@radix-ui/react-toggle";
+import * as ToggleGroup from "@radix-ui/react-toggle-group";
+import * as Tooltip from "@radix-ui/react-tooltip";
+import {
+  Download,
+  Eye,
+  EyeOff,
+  FileText,
+  MessageSquare,
+  Monitor,
+  Redo2,
+  ShieldAlert,
+  ShieldCheck,
+  Undo2,
+} from "lucide-react";
+
+import type { CompatibilityPanelSnapshot, EditorWarning } from "../../api/public-types";
+import type { SessionCapabilities } from "../../runtime/session-capabilities";
+import { TwHealthPanel } from "../review/tw-health-panel";
+import { TwToolbarIconButton } from "./tw-toolbar-icon-button";
+
+export type ViewMode = "canvas" | "document";
+
+export interface TwToolbarProps {
+  sourceLabel?: string;
+  capabilities?: SessionCapabilities;
+  compatibility?: CompatibilityPanelSnapshot;
+  warnings?: EditorWarning[];
+  viewMode: ViewMode;
+  /** Display toggle for tracked change decorations (not a runtime mutation toggle). */
+  showTrackedChanges: boolean;
+  onUndo: () => void;
+  onRedo: () => void;
+  onAddComment: () => void;
+  onExport: () => void;
+  onViewModeChange: (value: ViewMode) => void;
+  onShowTrackedChangesChange: (show: boolean) => void;
+}
+
+const focusRingClass =
+  "focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-accent focus-visible:ring-offset-2 focus-visible:ring-offset-canvas";
+
+export function TwToolbar(props: TwToolbarProps) {
+  const caps = props.capabilities;
+
+  return (
+    <header className="flex h-10 shrink-0 items-center gap-1 border-b border-border px-2">
+      {/* Left cluster: undo/redo + formatting */}
+      <div className="flex items-center gap-0.5">
+        <TwToolbarIconButton
+          icon={Undo2}
+          label="Undo"
+          disabled={caps ? !caps.canUndo : true}
+          onClick={props.onUndo}
+        />
+        <TwToolbarIconButton
+          icon={Redo2}
+          label="Redo"
+          disabled={caps ? !caps.canRedo : true}
+          onClick={props.onRedo}
+        />
+        <div className="mx-1 h-4 w-px bg-border" />
+
+        {/* Paragraph style selector and B/I/U removed — not yet supported */}
+      </div>
+
+      {/* Center: document title */}
+      <div className="flex-1 text-center min-w-0">
+        <span className="text-sm font-medium truncate block">
+          {props.sourceLabel ?? "Untitled"}
+        </span>
+      </div>
+
+      {/* Right cluster: comment, track changes, markup, view, export */}
+      <div className="flex items-center gap-0.5">
+        <TwToolbarIconButton
+          icon={MessageSquare}
+          label="Add comment"
+          disabled={caps ? !caps.canAddComment : true}
+          emphasis
+          onClick={props.onAddComment}
+        />
+
+        <Tooltip.Root>
+          <Tooltip.Trigger asChild>
+            <Toggle.Root
+              pressed={props.showTrackedChanges}
+              onPressedChange={props.onShowTrackedChangesChange}
+              disabled={caps ? !caps.trackChangesSupported : false}
+              className={`inline-flex h-7 w-7 items-center justify-center rounded-md text-secondary transition-colors hover:bg-surface data-[state=on]:bg-accent-soft data-[state=on]:text-accent outline-none disabled:opacity-40 ${focusRingClass}`}
+            >
+              {props.showTrackedChanges ? <Eye className="h-4 w-4" /> : <EyeOff className="h-4 w-4" />}
+            </Toggle.Root>
+          </Tooltip.Trigger>
+          <Tooltip.Portal>
+            <Tooltip.Content
+              className="rounded-md bg-primary px-2 py-1 text-xs text-white shadow-md z-50"
+              sideOffset={6}
+            >
+              {props.showTrackedChanges ? "Hide tracked changes" : "Show tracked changes"}
+            </Tooltip.Content>
+          </Tooltip.Portal>
+        </Tooltip.Root>
+
+        <div className="mx-1 h-4 w-px bg-border" />
+
+        {/* View mode toggle group: Canvas (clean, flowing) / Document (paged, markup) */}
+        <ToggleGroup.Root
+          type="single"
+          value={props.viewMode}
+          onValueChange={(v: string) => {
+            if (v) props.onViewModeChange(v as ViewMode);
+          }}
+          className="flex items-center gap-0.5"
+        >
+          <Tooltip.Root>
+            <Tooltip.Trigger asChild>
+              <ToggleGroup.Item
+                value="canvas"
+                className={`inline-flex h-7 w-7 items-center justify-center rounded-md text-secondary transition-colors hover:bg-surface data-[state=on]:bg-accent-soft data-[state=on]:text-accent outline-none ${focusRingClass}`}
+              >
+                <Monitor className="h-3.5 w-3.5" />
+              </ToggleGroup.Item>
+            </Tooltip.Trigger>
+            <Tooltip.Portal>
+              <Tooltip.Content className="rounded-md bg-primary px-2 py-1 text-xs text-white shadow-md z-50" sideOffset={6}>
+                Canvas — clean flowing text
+              </Tooltip.Content>
+            </Tooltip.Portal>
+          </Tooltip.Root>
+          <Tooltip.Root>
+            <Tooltip.Trigger asChild>
+              <ToggleGroup.Item
+                value="document"
+                className={`inline-flex h-7 w-7 items-center justify-center rounded-md text-secondary transition-colors hover:bg-surface data-[state=on]:bg-accent-soft data-[state=on]:text-accent outline-none ${focusRingClass}`}
+              >
+                <FileText className="h-3.5 w-3.5" />
+              </ToggleGroup.Item>
+            </Tooltip.Trigger>
+            <Tooltip.Portal>
+              <Tooltip.Content className="rounded-md bg-primary px-2 py-1 text-xs text-white shadow-md z-50" sideOffset={6}>
+                Document — paged with markup
+              </Tooltip.Content>
+            </Tooltip.Portal>
+          </Tooltip.Root>
+        </ToggleGroup.Root>
+
+        {/* Health indicator */}
+        {props.compatibility && props.warnings ? (
+          <Popover.Root>
+            <Tooltip.Root>
+              <Tooltip.Trigger asChild>
+                <Popover.Trigger asChild>
+                  <button
+                    type="button"
+                    className={`relative inline-flex h-7 w-7 items-center justify-center rounded-md transition-colors hover:bg-surface hover:text-primary outline-none ${focusRingClass} ${
+                      (caps?.healthIssueCount ?? 0) > 0 ? "text-secondary" : "text-secondary"
+                    }`}
+                  >
+                    {(caps?.healthIssueCount ?? 0) > 0
+                      ? <ShieldAlert className="h-4 w-4" />
+                      : <ShieldCheck className="h-4 w-4" />
+                    }
+                    {(caps?.healthIssueCount ?? 0) > 0 ? (
+                      <span className="absolute -top-0.5 -right-0.5 flex h-3 min-w-[12px] items-center justify-center rounded-full bg-tertiary text-[8px] font-medium text-white">
+                        {caps?.healthIssueCount}
+                      </span>
+                    ) : null}
+                  </button>
+                </Popover.Trigger>
+              </Tooltip.Trigger>
+              <Tooltip.Portal>
+                <Tooltip.Content className="rounded-md bg-primary px-2 py-1 text-xs text-white shadow-md z-50" sideOffset={6}>
+                  {(caps?.healthIssueCount ?? 0) > 0
+                    ? `Document health — ${caps?.healthIssueCount} issue${(caps?.healthIssueCount ?? 0) !== 1 ? "s" : ""}`
+                    : "Document health — no issues"
+                  }
+                </Tooltip.Content>
+              </Tooltip.Portal>
+            </Tooltip.Root>
+            <Popover.Portal>
+              <Popover.Content
+                className="w-[360px] max-h-[480px] overflow-y-auto rounded-lg bg-canvas shadow-lg ring-1 ring-border p-3 z-50"
+                sideOffset={8}
+                align="end"
+              >
+                <TwHealthPanel
+                  compatibility={props.compatibility}
+                  warnings={props.warnings}
+                />
+              </Popover.Content>
+            </Popover.Portal>
+          </Popover.Root>
+        ) : null}
+
+        <div className="mx-1 h-4 w-px bg-border" />
+
+        {/* Export button */}
+        <Tooltip.Root>
+          <Tooltip.Trigger asChild>
+            <button
+              type="button"
+              disabled={caps ? !caps.canExport : true}
+              className={[
+                "inline-flex h-7 items-center gap-1.5 rounded-md px-2.5 text-xs font-semibold transition-colors outline-none",
+                focusRingClass,
+                caps?.exportBlocked
+                  ? "cursor-not-allowed text-danger opacity-50"
+                  : "text-accent hover:bg-accent-soft",
+              ].join(" ")}
+              onClick={props.onExport}
+            >
+              <Download className="h-3.5 w-3.5" />
+              Export
+            </button>
+          </Tooltip.Trigger>
+          <Tooltip.Portal>
+            <Tooltip.Content className="rounded-md bg-primary px-2 py-1 text-xs text-white shadow-md z-50" sideOffset={6}>
+              {caps?.exportBlocked
+                ? "Export blocked by unsupported content"
+                : "Export document"}
+            </Tooltip.Content>
+          </Tooltip.Portal>
+        </Tooltip.Root>
+      </div>
+    </header>
+  );
+}

package/src/ui-tailwind/tw-review-workspace.tsx

@@ -0,0 +1,140 @@
+import React, { type ReactNode, useState } from "react";
+
+import * as Tooltip from "@radix-ui/react-tooltip";
+
+import type {
+  CommentSidebarThreadSnapshot,
+  RuntimeRenderSnapshot,
+  TrackedChangeEntrySnapshot,
+} from "../api/public-types";
+import type { SessionCapabilities } from "../runtime/session-capabilities";
+import type { MarkupDisplay } from "../ui/headless/comment-decoration-model";
+import { TwAlertBanner } from "./chrome/tw-alert-banner";
+import { TwSelectionToolbar } from "./chrome/tw-selection-toolbar";
+import { TwReviewRail, type ReviewRailTab } from "./review/tw-review-rail";
+import { TwStatusBar } from "./status/tw-status-bar";
+import { TwToolbar, type ViewMode } from "./toolbar/tw-toolbar";
+
+export interface TwReviewWorkspaceProps {
+  snapshot: RuntimeRenderSnapshot;
+  currentUserId?: string;
+  capabilities?: SessionCapabilities;
+  reviewMode?: "editing" | "review";
+  document: ReactNode;
+  viewMode: ViewMode;
+  activeRailTab: ReviewRailTab;
+  activeCommentId?: string;
+  activeRevisionId?: string;
+  showTrackedChanges: boolean;
+  selectionPreview?: string | null;
+  onViewModeChange: (value: ViewMode) => void;
+  onActiveRailTabChange: (value: ReviewRailTab) => void;
+  onShowTrackedChangesChange: (show: boolean) => void;
+  onUndo: () => void;
+  onRedo: () => void;
+  onAddComment: () => void;
+  onExport: () => void;
+  onOpenComment: (thread: CommentSidebarThreadSnapshot) => void;
+  onResolveComment: (commentId: string) => void;
+  onReopenComment?: (commentId: string) => void;
+  onAddReply?: (commentId: string, body: string) => void;
+  onEditBody?: (commentId: string, body: string) => void;
+  onOpenRevision: (revision: TrackedChangeEntrySnapshot) => void;
+  onAcceptRevision: (revisionId: string) => void;
+  onRejectRevision: (revisionId: string) => void;
+  onAcceptAllChanges: () => void;
+  onRejectAllChanges: () => void;
+}
+
+export function TwReviewWorkspace(props: TwReviewWorkspaceProps) {
+  const { snapshot } = props;
+  const caps = props.capabilities;
+  const markupDisplay: MarkupDisplay = props.viewMode === "document" ? "all" : "clean";
+  const preserveOnlyCount = caps?.preserveOnlyCount ??
+    snapshot.compatibility.featureEntries.filter(
+      (entry) => entry.featureClass === "preserve-only",
+    ).length;
+  const showReviewRail = caps?.reviewRailVisible ?? true;
+
+  return (
+    <Tooltip.Provider delayDuration={400}>
+      <div className="flex h-full flex-col bg-canvas text-primary">
+        <TwToolbar
+          sourceLabel={snapshot.sourceLabel}
+          capabilities={caps}
+          compatibility={snapshot.compatibility}
+          warnings={snapshot.warnings}
+          viewMode={props.viewMode}
+          showTrackedChanges={props.showTrackedChanges}
+          onUndo={props.onUndo}
+          onRedo={props.onRedo}
+          onAddComment={props.onAddComment}
+          onExport={props.onExport}
+          onViewModeChange={props.onViewModeChange}
+          onShowTrackedChangesChange={props.onShowTrackedChangesChange}
+        />
+
+        <TwAlertBanner snapshot={snapshot} preserveOnlyCount={preserveOnlyCount} />
+
+        <div className="flex flex-1 min-h-0">
+          {/* Document column */}
+          <div className="flex flex-1 flex-col min-w-0">
+            <div className={`flex-1 overflow-y-auto ${props.viewMode === "document" ? "bg-surface" : "bg-canvas"}`}>
+              <div
+                className={`mx-auto min-h-full ${
+                  props.viewMode === "document"
+                    ? "max-w-[780px] my-8 rounded-xl ring-1 ring-border shadow-sm bg-canvas"
+                    : "bg-canvas"
+                }`}
+              >
+                {props.selectionPreview ? (
+                  <div className="flex justify-center pt-4 px-4">
+                    <TwSelectionToolbar
+                      selectionPreview={props.selectionPreview}
+                      readOnly={snapshot.readOnly}
+                      onAddComment={props.onAddComment}
+                    />
+                  </div>
+                ) : null}
+                {props.document}
+              </div>
+            </div>
+
+            <TwStatusBar
+              isDirty={snapshot.isDirty}
+              isExportBlocked={snapshot.compatibility.blockExport}
+              preserveOnlyCount={preserveOnlyCount}
+              commentCount={snapshot.comments.totalCount}
+              changeCount={snapshot.trackedChanges.totalCount}
+              sessionId={snapshot.sessionId}
+            />
+          </div>
+
+          {/* Review rail — hidden in editing mode unless toggled */}
+          {showReviewRail ? <TwReviewRail
+            activeTab={props.activeRailTab}
+            currentUserId={props.currentUserId}
+            comments={snapshot.comments}
+            trackedChanges={snapshot.trackedChanges}
+            compatibility={snapshot.compatibility}
+            warnings={snapshot.warnings}
+            markupDisplay={markupDisplay}
+            activeCommentId={props.activeCommentId}
+            activeRevisionId={props.activeRevisionId}
+            onActiveTabChange={props.onActiveRailTabChange}
+            onOpenComment={props.onOpenComment}
+            onResolveComment={props.onResolveComment}
+            onReopenComment={props.onReopenComment}
+            onAddReply={props.onAddReply}
+            onEditBody={props.onEditBody}
+            onOpenRevision={props.onOpenRevision}
+            onAcceptRevision={props.onAcceptRevision}
+            onRejectRevision={props.onRejectRevision}
+            onAcceptAllChanges={props.onAcceptAllChanges}
+            onRejectAllChanges={props.onRejectAllChanges}
+          /> : null}
+        </div>
+      </div>
+    </Tooltip.Provider>
+  );
+}

package/src/validation/README.md

@@ -0,0 +1,3 @@
+# Validation
+
+Compatibility checks, round-trip validation, support classification, and Word reopen evidence helpers belong here.

package/src/validation/compatibility-engine.ts

@@ -0,0 +1,317 @@
+import { createRangeAnchor } from "../core/selection/mapping.ts";
+import type {
+  CanonicalDocumentEnvelope,
+  CompatibilityFeatureEntry,
+  CompatibilityReport,
+  EditorError,
+  EditorWarning,
+} from "../core/state/editor-state.ts";
+import type {
+  DocumentRootNode,
+  InlineNode,
+  ParagraphNode,
+} from "../model/canonical-document.ts";
+import {
+  describeOpaqueFragment,
+  listOpaqueFragments,
+  listPreservedPackageParts,
+} from "../preservation/store.ts";
+
+export interface BuildCompatibilityReportInput {
+  document: CanonicalDocumentEnvelope;
+  warnings?: readonly EditorWarning[];
+  fatalError?: EditorError;
+  generatedAt: string;
+}
+
+export function buildCompatibilityReport(
+  input: BuildCompatibilityReportInput,
+): CompatibilityReport {
+  const content = normalizeDocumentRoot(input.document.content);
+  const contentFeatures = collectContentFeatures(content);
+  if (hasSupportedRuntimeComments(input.document.review.comments)) {
+    contentFeatures.push(
+      supportedEntry(
+        "comments-single-paragraph",
+        "Single-paragraph review comments stay mappable through runtime selections.",
+      ),
+    );
+  }
+  const featureEntries: CompatibilityFeatureEntry[] = [
+    ...contentFeatures,
+    ...collectPreservationFeatures(input.document),
+  ];
+  const warnings = dedupeWarnings([
+    ...(input.warnings ?? []),
+    ...collectDiagnosticWarnings(input.document),
+  ]);
+  const errors = dedupeErrors([
+    ...collectDiagnosticErrors(input.document),
+    ...(input.fatalError ? [input.fatalError] : []),
+  ]);
+
+  return {
+    reportVersion: "compatibility-report/1",
+    generatedAt: input.generatedAt,
+    blockExport:
+      featureEntries.some((entry) => entry.featureClass === "unsupported-fatal") ||
+      errors.some((error) => error.isFatal),
+    featureEntries,
+    warnings,
+    errors,
+  };
+}
+
+function hasSupportedRuntimeComments(
+  comments: CanonicalDocumentEnvelope["review"]["comments"],
+): boolean {
+  return Object.values(comments).some((comment) => comment.anchor.kind !== "detached");
+}
+
+function normalizeDocumentRoot(content: unknown): DocumentRootNode {
+  if (content && typeof content === "object" && (content as { type?: string }).type === "doc") {
+    return content as DocumentRootNode;
+  }
+
+  if (Array.isArray(content)) {
+    return {
+      type: "doc",
+      children: content.filter(
+        (value): value is DocumentRootNode["children"][number] =>
+          Boolean(value) &&
+          typeof value === "object" &&
+          ((value as { type?: string }).type === "paragraph" ||
+            (value as { type?: string }).type === "opaque_block"),
+      ),
+    };
+  }
+
+  return {
+    type: "doc",
+    children: [{ type: "paragraph", children: [] }],
+  };
+}
+
+function collectContentFeatures(
+  content: DocumentRootNode,
+): CompatibilityFeatureEntry[] {
+  const flags = {
+    paragraphs: false,
+    runs: false,
+    whitespace: false,
+    headings: false,
+    lists: false,
+    hyperlinks: false,
+    images: false,
+  };
+
+  for (let index = 0; index < content.children.length; index += 1) {
+    const block = content.children[index];
+    if (block.type !== "paragraph") {
+      continue;
+    }
+
+    flags.paragraphs = true;
+    if (block.styleId?.toLowerCase().startsWith("heading")) {
+      flags.headings = true;
+    }
+    if (block.numbering) {
+      flags.lists = true;
+    }
+
+    measureParagraph(block, flags);
+  }
+
+  const entries: CompatibilityFeatureEntry[] = [];
+  if (flags.paragraphs) {
+    entries.push(supportedEntry("paragraphs", "Paragraph structure is editable and round-trippable."));
+  }
+  if (flags.runs) {
+    entries.push(supportedEntry("runs", "Runs and inline text are editable through runtime commands."));
+  }
+  if (flags.whitespace) {
+    entries.push(supportedEntry("whitespace", "Whitespace-sensitive text units stay explicit in the runtime model."));
+  }
+  if (flags.headings) {
+    entries.push(supportedEntry("headings", "Heading styles remain attached to paragraph structure."));
+  }
+  if (flags.lists) {
+    entries.push(supportedEntry("lists", "Numbering metadata stays attached to paragraph blocks."));
+  }
+  if (flags.hyperlinks) {
+    entries.push(supportedEntry("hyperlinks", "Hyperlink relationships are preserved and re-serialized."));
+  }
+  if (flags.images) {
+    entries.push(supportedEntry("inline-images", "Inline image placements stay attached to preserved media parts."));
+  }
+  return entries;
+}
+
+function measureParagraph(
+  paragraph: ParagraphNode,
+  flags: {
+    runs: boolean;
+    whitespace: boolean;
+    hyperlinks: boolean;
+    images: boolean;
+  },
+): number {
+  let size = 0;
+  const children = Array.isArray(paragraph.children) ? paragraph.children : [];
+
+  for (const child of children) {
+    size += measureInlineNode(child, flags);
+  }
+
+  return size;
+}
+
+function measureInlineNode(
+  node: InlineNode,
+  flags: {
+    runs: boolean;
+    whitespace: boolean;
+    hyperlinks: boolean;
+    images: boolean;
+  },
+): number {
+  switch (node.type) {
+    case "text":
+      flags.runs = flags.runs || node.text.length > 0;
+      flags.whitespace =
+        flags.whitespace ||
+        /^\s/u.test(node.text) ||
+        /\s$/u.test(node.text) ||
+        node.text.includes("  ");
+      return Array.from(node.text).length;
+    case "tab":
+    case "hard_break":
+      flags.runs = true;
+      flags.whitespace = true;
+      return 1;
+    case "hyperlink":
+      flags.runs = true;
+      flags.hyperlinks = true;
+      return node.children.reduce((size, child) => size + measureInlineNode(child, flags), 0);
+    case "image":
+      flags.images = true;
+      flags.runs = true;
+      return 1;
+    case "opaque_inline":
+      flags.runs = true;
+      return 1;
+  }
+}
+
+function collectPreservationFeatures(
+  document: CanonicalDocumentEnvelope,
+): CompatibilityFeatureEntry[] {
+  const entries: CompatibilityFeatureEntry[] = [];
+
+  for (const fragment of listOpaqueFragments(document.preservation as never)) {
+    const descriptor = describeOpaqueFragment(fragment);
+    entries.push({
+      featureEntryId: `feature:${fragment.fragmentId}`,
+      featureKey: descriptor.featureKey,
+      featureClass: "preserve-only",
+      message: descriptor.label,
+      affectedAnchor: createRangeAnchor(
+        fragment.lastKnownRange.from,
+        fragment.lastKnownRange.to,
+      ),
+      details: {
+        fragmentId: fragment.fragmentId,
+        warningId: fragment.warningId,
+        detail: descriptor.detail,
+      },
+    });
+  }
+
+  for (const packagePart of listPreservedPackageParts(document.preservation as never)) {
+    entries.push({
+      featureEntryId: `feature:package:${packagePart.packagePartName}`,
+      featureKey: "unknown-package-parts",
+      featureClass: "preserve-only",
+      message: `Preserved package part ${packagePart.packagePartName}.`,
+      details: {
+        packagePartName: packagePart.packagePartName,
+        contentType: packagePart.contentType,
+        relationshipIds: packagePart.relationshipIds,
+      },
+    });
+  }
+
+  return entries;
+}
+
+function collectDiagnosticWarnings(
+  document: CanonicalDocumentEnvelope,
+): EditorWarning[] {
+  const diagnostics = Array.isArray(document.diagnostics?.warnings)
+    ? document.diagnostics.warnings
+    : [];
+
+  return diagnostics.map((warning) => ({
+    warningId: warning.warningId,
+    code:
+      warning.source === "validation" || warning.source === "export"
+        ? "export_roundtrip_risk"
+        : warning.source === "preservation"
+          ? "unsupported_ooxml_preserved"
+          : "import_normalized",
+    severity: "warning",
+    message: warning.message,
+    source: warning.source,
+  }));
+}
+
+function collectDiagnosticErrors(
+  document: CanonicalDocumentEnvelope,
+): EditorError[] {
+  const diagnostics = Array.isArray(document.diagnostics?.errors)
+    ? document.diagnostics.errors
+    : [];
+
+  return diagnostics.map((error) => ({
+    errorId: error.diagnosticId,
+    code:
+      error.code === "load_failed"
+        ? "import_failed"
+        : error.code,
+    message: error.message,
+    isFatal: error.isFatal,
+    source: error.source,
+  }));
+}
+
+function supportedEntry(
+  featureKey: CompatibilityFeatureEntry["featureKey"],
+  message: string,
+): CompatibilityFeatureEntry {
+  return {
+    featureEntryId: `feature:${featureKey}`,
+    featureKey,
+    featureClass: "supported-roundtrip",
+    message,
+  };
+}
+
+function dedupeWarnings(warnings: EditorWarning[]): EditorWarning[] {
+  const byId = new Map<string, EditorWarning>();
+
+  for (const warning of warnings) {
+    byId.set(warning.warningId, warning);
+  }
+
+  return [...byId.values()];
+}
+
+function dedupeErrors(errors: EditorError[]): EditorError[] {
+  const byId = new Map<string, EditorError>();
+
+  for (const error of errors) {
+    byId.set(error.errorId, error);
+  }
+
+  return [...byId.values()];
+}