@beyondwork/docx-react-component 1.0.28 → 1.0.29

package/dist/chunk-2FJS5GZM.js

@@ -0,0 +1,763 @@
+import {
+  describeOpaqueFragment,
+  listOpaqueFragments,
+  listPreservedPackageParts
+} from "./chunk-SWKWQZXM.js";
+import {
+  createRangeAnchor,
+  mapAnchor,
+  normalizeRange
+} from "./chunk-EBI3BX6U.js";
+
+// src/api/session-state.ts
+var EDITOR_SESSION_STATE_VERSION = "editor-session-state/1";
+function cloneStructuredValue(value) {
+  return structuredClone(value);
+}
+function createEditorSessionState(input) {
+  return cloneStructuredValue({
+    sessionVersion: EDITOR_SESSION_STATE_VERSION,
+    ...input
+  });
+}
+function editorSessionStateFromPersistedSnapshot(snapshot) {
+  return createEditorSessionState({
+    schemaVersion: snapshot.schemaVersion,
+    documentId: snapshot.documentId,
+    docId: snapshot.docId,
+    createdAt: snapshot.createdAt,
+    updatedAt: snapshot.updatedAt,
+    editorBuild: snapshot.editorBuild,
+    canonicalDocument: snapshot.canonicalDocument,
+    compatibility: snapshot.compatibility,
+    warningLog: snapshot.warningLog,
+    protectionSnapshot: snapshot.protectionSnapshot,
+    sourcePackage: snapshot.sourcePackage
+  });
+}
+function persistedSnapshotFromEditorSessionState(sessionState, options) {
+  return cloneStructuredValue({
+    snapshotVersion: "persisted-editor-snapshot/2",
+    schemaVersion: sessionState.schemaVersion,
+    documentId: sessionState.documentId,
+    docId: sessionState.docId,
+    createdAt: sessionState.createdAt,
+    updatedAt: sessionState.updatedAt,
+    savedAt: options.savedAt,
+    editorBuild: sessionState.editorBuild,
+    canonicalDocument: sessionState.canonicalDocument,
+    compatibility: sessionState.compatibility,
+    warningLog: sessionState.warningLog,
+    protectionSnapshot: sessionState.protectionSnapshot,
+    sourcePackage: sessionState.sourcePackage
+  });
+}
+
+// src/review/store/revision-types.ts
+function createRevisionRangeAnchor(from, to = from, assoc) {
+  return createRangeAnchor(from, to, assoc);
+}
+function remapRevisionAnchor(anchor, mapping) {
+  return mapAnchor(anchor, mapping);
+}
+function isDetachedRevisionAnchor(anchor) {
+  return anchor.kind === "detached";
+}
+function summarizeRevisionAnchor(anchor) {
+  if (anchor.kind === "range") {
+    return {
+      anchor,
+      state: "active",
+      range: normalizeRange(anchor.range)
+    };
+  }
+  if (anchor.kind === "node") {
+    return {
+      anchor,
+      state: "active",
+      range: {
+        from: anchor.at,
+        to: anchor.at
+      }
+    };
+  }
+  return {
+    anchor,
+    state: "detached",
+    range: normalizeRange(anchor.lastKnownRange)
+  };
+}
+function getRevisionActionability(revision) {
+  if (typeof revision !== "string" && typeof revision.metadata.preserveOnlyReason === "string" && revision.metadata.preserveOnlyReason.length > 0) {
+    return "preserve-only";
+  }
+  const kind = typeof revision === "string" ? revision : revision.kind;
+  switch (kind) {
+    case "insertion":
+    case "deletion":
+    case "property-change":
+      return "actionable";
+    case "formatting":
+    case "move":
+      return "preserve-only";
+  }
+}
+function isRevisionActionable(record) {
+  return getRevisionActionability(record) === "actionable" && record.status === "active";
+}
+function describeRevisionKind(kind) {
+  switch (kind) {
+    case "insertion":
+      return "Insertion";
+    case "deletion":
+      return "Deletion";
+    case "formatting":
+      return "Formatting change";
+    case "move":
+      return "Move";
+    case "property-change":
+      return "Property change";
+  }
+}
+
+// src/review/store/revision-store.ts
+function createRevisionStore(revisions = {}) {
+  return {
+    version: "revision-store/1",
+    revisions
+  };
+}
+function createRevisionRecord(params) {
+  return normalizeRevisionRecord({
+    revisionId: params.revisionId,
+    kind: params.kind,
+    anchor: params.anchor,
+    authorId: params.authorId,
+    createdAt: params.createdAt,
+    status: params.status ?? "active",
+    warningIds: [...params.warningIds ?? []],
+    metadata: {
+      source: params.metadata?.source ?? "runtime",
+      storyTarget: params.metadata?.storyTarget,
+      preserveOnlyReason: params.metadata?.preserveOnlyReason ?? (getRevisionActionability(params.kind) === "preserve-only" ? "Imported preserve-only revision." : void 0),
+      importedRevisionForm: params.metadata?.importedRevisionForm,
+      originalRevisionType: params.metadata?.originalRevisionType,
+      ooxmlRevisionId: params.metadata?.ooxmlRevisionId,
+      propertyChangeData: params.metadata?.propertyChangeData,
+      moveData: params.metadata?.moveData
+    }
+  });
+}
+function upsertRevisionRecord(store, revision) {
+  return {
+    ...store,
+    revisions: {
+      ...store.revisions,
+      [revision.revisionId]: normalizeRevisionRecord(revision)
+    }
+  };
+}
+function setRevisionStatus(store, revisionId, status) {
+  const existing = store.revisions[revisionId];
+  if (!existing) {
+    return store;
+  }
+  if (existing.status === "detached") {
+    return store;
+  }
+  if ((status === "accepted" || status === "rejected") && getRevisionActionability(existing) !== "actionable") {
+    return store;
+  }
+  return upsertRevisionRecord(store, {
+    ...existing,
+    status
+  });
+}
+function remapRevisionStore(store, mapping) {
+  return createRevisionStore(
+    Object.fromEntries(
+      Object.entries(store.revisions).map(([revisionId, revision]) => {
+        const anchor = remapRevisionAnchor(revision.anchor, mapping);
+        const status = anchor.kind === "detached" ? "detached" : revision.status === "accepted" || revision.status === "rejected" ? revision.status : "active";
+        return [
+          revisionId,
+          normalizeRevisionRecord({
+            ...revision,
+            anchor,
+            status
+          })
+        ];
+      })
+    )
+  );
+}
+function createRevisionSidebarProjection(store) {
+  const revisions = Object.values(store.revisions).map(toSidebarEntry).sort(compareRevisionEntries);
+  return {
+    totalCount: revisions.length,
+    activeRevisionIds: revisions.filter((revision) => revision.status === "active").map((revision) => revision.revisionId),
+    acceptedRevisionIds: revisions.filter((revision) => revision.status === "accepted").map((revision) => revision.revisionId),
+    rejectedRevisionIds: revisions.filter((revision) => revision.status === "rejected").map((revision) => revision.revisionId),
+    detachedRevisionIds: revisions.filter((revision) => revision.status === "detached").map((revision) => revision.revisionId),
+    actionableRevisionIds: revisions.filter((revision) => revision.actionability === "actionable").map((revision) => revision.revisionId),
+    preserveOnlyRevisionIds: revisions.filter((revision) => revision.actionability === "preserve-only").map((revision) => revision.revisionId),
+    revisions
+  };
+}
+function toSidebarEntry(revision) {
+  const anchorSummary = summarizeRevisionAnchor(revision.anchor);
+  const actionability = getRevisionActionability(revision);
+  const moveData = revision.metadata.moveData;
+  return {
+    revisionId: revision.revisionId,
+    kind: revision.kind,
+    label: describeRevisionKind(revision.kind),
+    status: revision.status,
+    actionability,
+    anchorLabel: anchorSummary.state === "detached" ? `Detached ${anchorSummary.range.from}-${anchorSummary.range.to}` : `Range ${anchorSummary.range.from}-${anchorSummary.range.to}`,
+    createdAt: revision.createdAt,
+    authorId: revision.authorId,
+    warningCount: revision.warningIds.length,
+    canAccept: isRevisionActionable(revision),
+    canReject: isRevisionActionable(revision),
+    preserveOnlyReason: revision.metadata.preserveOnlyReason,
+    linkedMoveRevisionId: moveData?.linkedRevisionId,
+    moveDirection: moveData?.direction
+  };
+}
+function normalizeRevisionRecord(revision) {
+  const actionability = getRevisionActionability(revision);
+  if (isDetachedRevisionAnchor(revision.anchor)) {
+    return {
+      ...revision,
+      status: "detached",
+      metadata: {
+        ...revision.metadata,
+        preserveOnlyReason: revision.metadata.preserveOnlyReason ?? (actionability === "preserve-only" ? "Imported preserve-only revision." : void 0)
+      }
+    };
+  }
+  if (actionability === "preserve-only" && revision.status !== "detached") {
+    return {
+      ...revision,
+      status: revision.status === "accepted" || revision.status === "rejected" ? "active" : revision.status,
+      metadata: {
+        ...revision.metadata,
+        preserveOnlyReason: revision.metadata.preserveOnlyReason ?? "Imported preserve-only revision."
+      }
+    };
+  }
+  return revision;
+}
+function compareRevisionEntries(left, right) {
+  const statusDelta = priorityForStatus(left.status) - priorityForStatus(right.status);
+  if (statusDelta !== 0) {
+    return statusDelta;
+  }
+  const actionabilityDelta = priorityForActionability(left.actionability) - priorityForActionability(right.actionability);
+  if (actionabilityDelta !== 0) {
+    return actionabilityDelta;
+  }
+  return left.createdAt.localeCompare(right.createdAt);
+}
+function priorityForStatus(status) {
+  switch (status) {
+    case "active":
+      return 0;
+    case "detached":
+      return 1;
+    case "accepted":
+      return 2;
+    case "rejected":
+      return 3;
+  }
+}
+function priorityForActionability(actionability) {
+  switch (actionability) {
+    case "actionable":
+      return 0;
+    case "preserve-only":
+      return 1;
+  }
+}
+
+// src/validation/compatibility-engine.ts
+function buildCompatibilityReport(input) {
+  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 = [
+    ...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) {
+  return Object.values(comments).some((comment) => comment.anchor.kind !== "detached");
+}
+function normalizeDocumentRoot(content) {
+  if (content && typeof content === "object" && content.type === "doc") {
+    return content;
+  }
+  if (Array.isArray(content)) {
+    return {
+      type: "doc",
+      children: content.filter(
+        (value) => Boolean(value) && typeof value === "object" && (value.type === "paragraph" || value.type === "opaque_block")
+      )
+    };
+  }
+  return {
+    type: "doc",
+    children: [{ type: "paragraph", children: [] }]
+  };
+}
+function collectContentFeatures(content) {
+  const flags = {
+    paragraphs: false,
+    runs: false,
+    whitespace: false,
+    headings: false,
+    lists: false,
+    hyperlinks: false,
+    images: false,
+    tables: false,
+    sections: false,
+    contentControls: false
+  };
+  for (let index = 0; index < content.children.length; index += 1) {
+    measureBlock(content.children[index], flags);
+  }
+  const entries = [];
+  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."));
+  }
+  if (flags.tables) {
+    entries.push(
+      supportedEntry(
+        "tables",
+        "Structured tables keep cell topology and common visual properties through runtime editing and export."
+      )
+    );
+  }
+  if (flags.sections) {
+    entries.push(
+      supportedEntry(
+        "sections",
+        "Section boundaries and page-layout properties remain structured and export-safe."
+      )
+    );
+  }
+  if (flags.contentControls) {
+    entries.push(
+      supportedEntry(
+        "content-controls",
+        "Common content controls render through structured SDT state and round-trip without flattening to opaque placeholders."
+      )
+    );
+  }
+  return entries;
+}
+function measureBlock(block, flags) {
+  switch (block.type) {
+    case "paragraph":
+      flags.paragraphs = true;
+      if (block.styleId?.toLowerCase().startsWith("heading")) {
+        flags.headings = true;
+      }
+      if (block.numbering) {
+        flags.lists = true;
+      }
+      return measureParagraph(block, flags);
+    case "table":
+      flags.tables = true;
+      return block.rows.reduce(
+        (size, row) => size + row.cells.reduce(
+          (cellSize, cell) => cellSize + cell.children.reduce((childSize, child) => childSize + measureBlock(child, flags), 0),
+          0
+        ),
+        0
+      );
+    case "sdt":
+      flags.contentControls = true;
+      return block.children.reduce((size, child) => size + measureBlock(child, flags), 0);
+    case "custom_xml":
+      return block.children.reduce((size, child) => size + measureBlock(child, flags), 0);
+    case "section_break":
+      flags.sections = true;
+      return 1;
+    default:
+      return 0;
+  }
+}
+function measureParagraph(paragraph, flags) {
+  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, flags) {
+  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;
+    case "column_break":
+    case "symbol":
+    case "field":
+    case "bookmark_start":
+    case "bookmark_end":
+    case "footnote_ref":
+    case "chart_preview":
+    case "smartart_preview":
+    case "shape":
+    case "wordart":
+    case "vml_shape":
+    default:
+      flags.runs = true;
+      return 1;
+  }
+}
+function collectPreservationFeatures(document) {
+  const entries = [];
+  const structuredSubPartPaths = collectStructuredSubPartPaths(document);
+  entries.push(...collectSubPartFeatures(document));
+  for (const fragment of listOpaqueFragments(document.preservation)) {
+    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)) {
+    if (structuredSubPartPaths.has(packagePart.packagePartName)) {
+      continue;
+    }
+    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 collectStructuredSubPartPaths(document) {
+  const subParts = document.subParts;
+  if (!subParts) {
+    return /* @__PURE__ */ new Set();
+  }
+  const paths = /* @__PURE__ */ new Set();
+  for (const header of subParts.headers ?? []) {
+    paths.add(header.partPath);
+  }
+  for (const footer of subParts.footers ?? []) {
+    paths.add(footer.partPath);
+  }
+  if (subParts.footnoteCollection) {
+    paths.add("/word/footnotes.xml");
+    paths.add("/word/endnotes.xml");
+  }
+  if (subParts.theme) {
+    paths.add("/word/theme/theme1.xml");
+  }
+  return paths;
+}
+function collectSubPartFeatures(document) {
+  const subParts = document.subParts;
+  if (!subParts) {
+    return [];
+  }
+  const entries = collectLossySubPartFeatures(subParts);
+  const hasHeaderFooterContent = (subParts.headers?.length ?? 0) > 0 || (subParts.footers?.length ?? 0) > 0;
+  const noteCount = Object.keys(subParts.footnoteCollection?.footnotes ?? {}).length + Object.keys(subParts.footnoteCollection?.endnotes ?? {}).length;
+  if (hasHeaderFooterContent && !entries.some((entry) => entry.featureKey === "headers-footers-lossy")) {
+    entries.push({
+      featureEntryId: "feature:subparts:headers-footers",
+      featureKey: "headers-footers",
+      featureClass: "supported-roundtrip",
+      message: "Headers and footers resolve as structured secondary stories with export-safe ownership.",
+      details: {
+        headerCount: subParts.headers?.length ?? 0,
+        footerCount: subParts.footers?.length ?? 0
+      }
+    });
+  }
+  if (noteCount > 0 && !entries.some((entry) => entry.featureKey === "notes-lossy")) {
+    entries.push({
+      featureEntryId: "feature:subparts:notes",
+      featureKey: "notes",
+      featureClass: "supported-roundtrip",
+      message: "Footnotes and endnotes resolve as structured secondary stories with export-safe ownership.",
+      details: {
+        footnoteCount: Object.keys(subParts.footnoteCollection?.footnotes ?? {}).length,
+        endnoteCount: Object.keys(subParts.footnoteCollection?.endnotes ?? {}).length
+      }
+    });
+  }
+  if (subParts.theme) {
+    entries.push({
+      featureEntryId: "feature:subparts:theme",
+      featureKey: "unknown-package-parts",
+      featureClass: "preserve-only",
+      message: "Theme metadata is preserved through structured sub-part ownership.",
+      details: {
+        surface: "theme-subpart",
+        themeName: subParts.theme.name
+      }
+    });
+  }
+  return entries;
+}
+function collectLossySubPartFeatures(subParts) {
+  const entries = [];
+  const headerFooterLossy = [
+    ...(subParts.headers ?? []).flatMap(
+      (header) => collectLossyBlocks(header.blocks, `header:${header.partPath}`)
+    ),
+    ...(subParts.footers ?? []).flatMap(
+      (footer) => collectLossyBlocks(footer.blocks, `footer:${footer.partPath}`)
+    )
+  ];
+  if (headerFooterLossy.length > 0) {
+    entries.push({
+      featureEntryId: "feature:subparts:headers-footers-lossy",
+      featureKey: "headers-footers-lossy",
+      featureClass: "unsupported-fatal",
+      message: "Headers or footers contain content the current sub-part serializer cannot re-emit safely.",
+      details: {
+        issues: headerFooterLossy
+      }
+    });
+  }
+  const noteLossy = [
+    ...Object.values(subParts.footnoteCollection?.footnotes ?? {}).flatMap(
+      (note) => collectLossyBlocks(note.blocks, `footnote:${note.noteId}`)
+    ),
+    ...Object.values(subParts.footnoteCollection?.endnotes ?? {}).flatMap(
+      (note) => collectLossyBlocks(note.blocks, `endnote:${note.noteId}`)
+    )
+  ];
+  if (noteLossy.length > 0) {
+    entries.push({
+      featureEntryId: "feature:subparts:notes-lossy",
+      featureKey: "notes-lossy",
+      featureClass: "unsupported-fatal",
+      message: "Footnotes or endnotes contain content the current sub-part serializer cannot re-emit safely.",
+      details: {
+        issues: noteLossy
+      }
+    });
+  }
+  return entries;
+}
+function collectLossyBlocks(blocks, surface) {
+  const issues = [];
+  for (const block of blocks) {
+    if (block.type === "table") {
+      for (const row of block.rows) {
+        for (const cell of row.cells) {
+          issues.push(...collectLossyBlocks(cell.children, `${surface}:table-cell`));
+        }
+      }
+      continue;
+    }
+    if (block.type !== "paragraph") {
+      issues.push(`${surface}:${block.type}`);
+      continue;
+    }
+    if (block.numbering !== void 0 || block.keepNext !== void 0 || block.keepLines !== void 0 || block.outlineLevel !== void 0 || block.pageBreakBefore !== void 0 || block.widowControl !== void 0 || block.borders !== void 0 || block.shading !== void 0 || block.bidi !== void 0 || block.suppressLineNumbers !== void 0 || block.cnfStyle !== void 0) {
+      issues.push(`${surface}:paragraph-properties`);
+    }
+    for (const child of block.children) {
+      issues.push(...collectLossyInlineContent(child, surface));
+    }
+  }
+  return [...new Set(issues)];
+}
+function collectLossyInlineContent(node, surface) {
+  switch (node.type) {
+    case "text": {
+      const allowSecondaryStoryColorMarks = surface.startsWith("header:") || surface.startsWith("footer:");
+      const unsupportedMarks = (node.marks ?? []).filter(
+        (mark) => mark.type !== "bold" && mark.type !== "italic" && mark.type !== "underline" && mark.type !== "strikethrough" && mark.type !== "doubleStrikethrough" && mark.type !== "fontFamily" && mark.type !== "fontSize" && mark.type !== "textColor" && (!allowSecondaryStoryColorMarks || mark.type !== "backgroundColor") && (!allowSecondaryStoryColorMarks || mark.type !== "highlight") && mark.type !== "smallCaps" && mark.type !== "allCaps"
+      ).map((mark) => `${surface}:mark:${mark.type}`);
+      return unsupportedMarks;
+    }
+    case "tab":
+    case "hard_break":
+    case "footnote_ref":
+    case "field":
+    case "bookmark_start":
+    case "bookmark_end":
+    case "shape":
+    case "wordart":
+    case "vml_shape":
+    case "chart_preview":
+    case "smartart_preview":
+      return [];
+    default:
+      return [`${surface}:${node.type}`];
+  }
+}
+function collectDiagnosticWarnings(document) {
+  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) {
+  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, message) {
+  return {
+    featureEntryId: `feature:${featureKey}`,
+    featureKey,
+    featureClass: "supported-roundtrip",
+    message
+  };
+}
+function dedupeWarnings(warnings) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const warning of warnings) {
+    byId.set(warning.warningId, warning);
+  }
+  return [...byId.values()];
+}
+function dedupeErrors(errors) {
+  const byId = /* @__PURE__ */ new Map();
+  for (const error of errors) {
+    byId.set(error.errorId, error);
+  }
+  return [...byId.values()];
+}
+
+// src/validation/diagnostics.ts
+var EXPORT_BLOCKING_ERROR_CODES = /* @__PURE__ */ new Set([
+  "import_failed",
+  "export_failed",
+  "package_corrupt",
+  "validation_failed"
+]);
+function createDiagnostics(input = {}) {
+  return {
+    featureEntries: freezeArray(input.featureEntries ?? []),
+    warnings: freezeArray(input.warnings ?? []),
+    errors: freezeArray(input.errors ?? [])
+  };
+}
+function diagnosticsBlockExport(diagnostics, explicitBlockExport = false) {
+  if (explicitBlockExport) {
+    return true;
+  }
+  return diagnostics.featureEntries.some(
+    (entry) => entry.featureClass === "unsupported-fatal"
+  ) || diagnostics.errors.some(
+    (error) => error.isFatal || EXPORT_BLOCKING_ERROR_CODES.has(error.code)
+  );
+}
+function freezeArray(items) {
+  return Object.freeze([...items]);
+}
+
+export {
+  EDITOR_SESSION_STATE_VERSION,
+  createEditorSessionState,
+  editorSessionStateFromPersistedSnapshot,
+  persistedSnapshotFromEditorSessionState,
+  createRevisionRangeAnchor,
+  getRevisionActionability,
+  createRevisionRecord,
+  setRevisionStatus,
+  remapRevisionStore,
+  createRevisionSidebarProjection,
+  buildCompatibilityReport,
+  createDiagnostics,
+  diagnosticsBlockExport
+};
+//# sourceMappingURL=chunk-2FJS5GZM.js.map