@beyondwork/docx-react-component 1.0.66 → 1.0.69

package/src/model/layout/page-layout-snapshot.ts

@@ -0,0 +1,105 @@
+/**
+ * Layer 02 · layout data shapes used across api / runtime / session.
+ *
+ * Pass 2 of the L04/L02 `src/model/layout/` seam (see
+ * `docs/plans/cross-layer-coord-04.md §1.12`). Previously these three
+ * types lived in `src/api/public-types.ts`; relocating them here lets
+ * the runtime-owned layout graph (`RuntimePageGraph`) reference them
+ * from a location that does not forbid transit by session / stateless
+ * services. `src/api/public-types.ts` continues to re-export these
+ * shapes so every consumer's import path remains `@beyondwork/...api`.
+ *
+ * These are pure data: no methods, no higher-layer imports. The
+ * acceptance rule at `src/model/layout/index.ts` applies.
+ */
+
+/**
+ * Runtime-derived description of page layout, projected from
+ * `CanonicalDocument` `SectionProperties` + ambient defaults.
+ */
+export interface PageLayoutSnapshot {
+  sectionIndex: number;
+  sectionType?: "continuous" | "nextPage" | "evenPage" | "oddPage" | "nextColumn";
+  pageWidth: number;
+  pageHeight: number;
+  marginTop: number;
+  marginBottom: number;
+  marginLeft: number;
+  marginRight: number;
+  headerMargin: number;
+  footerMargin: number;
+  gutter: number;
+  orientation: "portrait" | "landscape";
+  columns: number;
+  differentFirstPage: boolean;
+  differentOddEvenPages: boolean;
+  pageNumbering?: {
+    format?: string;
+    start?: number;
+    chapterStyle?: string;
+    chapterSeparator?: string;
+  };
+  lineNumbering?: {
+    countBy?: number;
+    start?: number;
+    distance?: number;
+    restart?: "newPage" | "newSection" | "continuous";
+  };
+  pageBorders?: {
+    top?: { value?: string; size?: number; space?: number; color?: string };
+    left?: { value?: string; size?: number; space?: number; color?: string };
+    bottom?: { value?: string; size?: number; space?: number; color?: string };
+    right?: { value?: string; size?: number; space?: number; color?: string };
+    offsetFrom?: "page" | "text";
+    display?: "allPages" | "firstPage" | "notFirstPage";
+    zOrder?: "front" | "back";
+  };
+  documentGrid?: {
+    type?: "default" | "lines" | "linesAndChars" | "snapToChars";
+    linePitch?: number;
+    charSpace?: number;
+  };
+  columnDefinitions: Array<{ width: number; space?: number }>;
+  equalWidthColumns: boolean;
+  columnSeparator: boolean;
+  headerVariants: Array<{ variant: "default" | "first" | "even"; relationshipId: string }>;
+  footerVariants: Array<{ variant: "default" | "first" | "even"; relationshipId: string }>;
+}
+
+/**
+ * Identifies which story / surface a read or edit addresses.
+ */
+export type EditorStoryTarget =
+  | { kind: "main" }
+  | {
+      kind: "header";
+      relationshipId: string;
+      variant: "default" | "first" | "even";
+      sectionIndex?: number;
+    }
+  | {
+      kind: "footer";
+      relationshipId: string;
+      variant: "default" | "first" | "even";
+      sectionIndex?: number;
+    }
+  | { kind: "footnote"; noteId: string }
+  | { kind: "endnote"; noteId: string };
+
+/**
+ * Runtime-derived descriptor for a single logical page.
+ */
+export interface DocumentPageSnapshot {
+  /** Zero-based page index within the whole document. */
+  pageIndex: number;
+  /** Section that owns this page (zero-based). */
+  sectionIndex: number;
+  /** Zero-based page index within its owning section. */
+  pageInSection: number;
+  /** Estimated character offset where the page begins in the main story. */
+  startOffset: number;
+  /** Estimated character offset where the page ends in the main story. */
+  endOffset: number;
+  /** Page layout properties inherited from the section. */
+  layout: PageLayoutSnapshot;
+}

package/src/model/layout/resolved-layout-types.ts

@@ -0,0 +1,47 @@
+/**
+ * Layer 02 · resolved-layout data shapes.
+ *
+ * Pass 2 (2026-04-22) — these two types moved out of
+ * `src/runtime/layout/page-story-resolver.ts` and
+ * `src/runtime/document-layout.ts` respectively. Both are pure data
+ * shapes: no methods, no runtime-only imports. Living in the model
+ * tree lets `RuntimePageGraph` (next step) live here as well, which
+ * in turn lets `CacheEnvelope` drop its transit through
+ * `src/runtime/**` (per `docs/plans/cross-layer-coord-04.md §1.12`
+ * and Layer 01's §1 ask).
+ *
+ * The resolver function and section builder remain in their runtime
+ * homes; only the type definitions move, and those files continue to
+ * re-export them so existing consumer imports remain stable.
+ */
+
+import type { SectionProperties } from "../canonical-document.ts";
+import type { EditorStoryTarget } from "./page-layout-snapshot.ts";
+
+/**
+ * Per-page story resolution — which header/footer variant applies on
+ * this page, and what the effective page number is.
+ */
+export interface ResolvedPageStories {
+  /** Header story target for this page, if any. */
+  header?: EditorStoryTarget;
+  /** Footer story target for this page, if any. */
+  footer?: EditorStoryTarget;
+  /** Whether this is a "first page" in its section (title page behavior). */
+  isFirstPage: boolean;
+  /** Whether this is an even-numbered page (1-indexed for display). */
+  isEvenPage: boolean;
+  /** The effective page number for display (accounting for page numbering settings). */
+  displayPageNumber: number;
+}
+
+/**
+ * Resolved section metadata — where a section begins and ends in the
+ * flattened offset space, plus the section-properties payload.
+ */
+export interface ResolvedDocumentSection {
+  index: number;
+  start: number;
+  end: number;
+  properties?: SectionProperties;
+}

package/src/model/layout/runtime-page-graph-types.ts

@@ -0,0 +1,102 @@
+/**
+ * Layer 02 · runtime page-graph types.
+ *
+ * Pass 2 (2026-04-22) — `RuntimePageGraph`, `RuntimePageNode`, and
+ * `BuildPageGraphInput` moved out of `src/runtime/layout/page-graph.ts`
+ * per `docs/plans/cross-layer-coord-04.md §1.12`. Relocation unblocks
+ * Layer 01's `CacheEnvelope` transit (the type chain from
+ * `CacheEnvelope → RuntimePageGraph → PageLayoutSnapshot / ...` no
+ * longer routes through `src/runtime/**`).
+ *
+ * These are pure data shapes: no methods, no runtime-only imports.
+ * The graph's construction functions (`buildPageGraph`, `spliceGraph`)
+ * and the `graphRevision` module-local counter remain in the runtime
+ * layer (`src/runtime/layout/page-graph.ts`).
+ */
+
+import type {
+  RuntimeBlockFragment,
+  RuntimeLineBox,
+  RuntimeNoteAllocation,
+  RuntimePageAnchor,
+  RuntimePageRegions,
+} from "./page-graph-types.ts";
+import type {
+  DocumentPageSnapshot,
+  PageLayoutSnapshot,
+} from "./page-layout-snapshot.ts";
+import type {
+  ResolvedDocumentSection,
+  ResolvedPageStories,
+} from "./resolved-layout-types.ts";
+
+/**
+ * A stable, inspectable representation of the document's paginated
+ * structure. Produced by the `PaginatedLayoutEngine` from canonical
+ * document state. External read models such as
+ * `DocumentNavigationSnapshot` and `PageLayoutSnapshot` are derived
+ * from it.
+ */
+export interface RuntimePageGraph {
+  /** Monotonically increasing revision stamp. */
+  revision: number;
+  /** Ordered page nodes. */
+  pages: RuntimePageNode[];
+  /** Flat list of every block fragment produced during pagination. */
+  fragments: RuntimeBlockFragment[];
+  /** Per-offset anchor index for O(log n) lookup. */
+  anchors: RuntimePageAnchor[];
+  /** Section metadata. */
+  sections: ResolvedDocumentSection[];
+  /** Total non-blank page count. */
+  contentPageCount: number;
+}
+
+export interface RuntimePageNode {
+  pageId: string;
+  pageIndex: number;
+  sectionIndex: number;
+  pageInSection: number;
+  startOffset: number;
+  endOffset: number;
+  layout: PageLayoutSnapshot;
+  stories: ResolvedPageStories;
+  /** Sub-regions on the page. */
+  regions: RuntimePageRegions;
+  /** Line boxes rendered in the body region. */
+  lineBoxes: RuntimeLineBox[];
+  /** Footnote allocations reserved at the bottom of the page. */
+  noteAllocations: RuntimeNoteAllocation[];
+  /** Whether this page is a blank filler (from even/odd page breaks). */
+  isBlankFiller: boolean;
+}
+
+export interface BuildPageGraphInput {
+  pages: readonly DocumentPageSnapshot[];
+  sections: readonly ResolvedDocumentSection[];
+  stories: readonly ResolvedPageStories[];
+  /** Optional block fragments pre-computed by pagination; when omitted the
+   *  graph produces one fragment per page spanning its entire offset range. */
+  fragments?: readonly RuntimeBlockFragment[];
+  /**
+   * Optional block fragments keyed by pageIndex with the `pageId` omitted.
+   * `buildPageGraph` fills in the pageId using the graph's fresh revision
+   * stamp. Use this when the caller wants to emit per-block fragments but
+   * cannot know the pageId in advance.
+   */
+  fragmentsByPageIndex?: ReadonlyMap<
+    number,
+    ReadonlyArray<Omit<RuntimeBlockFragment, "pageId">>
+  >;
+  /** Optional per-page line boxes. */
+  lineBoxes?: ReadonlyMap<string, RuntimeLineBox[]>;
+  /** Optional per-page note allocations keyed by graph-assigned pageId. */
+  noteAllocations?: ReadonlyMap<string, RuntimeNoteAllocation[]>;
+  /**
+   * P8 — per-page note allocations keyed by pageIndex (0-based).
+   * Parallel to `fragmentsByPageIndex`; `buildPageGraph` uses the index to
+   * look up allocations without requiring callers to know the graph-internal
+   * `page-${revision}-${index}` pageId in advance.
+   */
+  noteAllocationsByPageIndex?: ReadonlyMap<number, RuntimeNoteAllocation[]>;
+}

package/src/model/paragraph-scope-ids.ts

@@ -0,0 +1,72 @@
+/**
+ * Paragraph scope-id minting — neutral home shared by L06 (workflow /
+ * metadata writer) and L08 (semantic scope enumerator).
+ *
+ * The enumerator at `src/runtime/scopes/enumerate-scopes.ts` and the
+ * derived-scope resolver at `src/runtime/workflow/derived-scope-resolver.ts`
+ * must produce identical scopeIds for the same (paragraph, blockIndex)
+ * pair — the enumerator mints them for the outward surface, the
+ * resolver matches them on the inverse path for metadata writes. Both
+ * lanes' files sit in W9-purity-guarded trees, so the logic lives here
+ * (in L02's neutral `src/model/` home) to keep both imports legal.
+ *
+ * Rules are purely shape-derived from `ParagraphNode` — no runtime,
+ * no overlay, no layout. Safe to import from anywhere.
+ */
+
+import type { ParagraphNode } from "./canonical-document.ts";
+
+/**
+ * Classify a paragraph as `paragraph` / `heading` / `list-item` using
+ * outlineLevel → heading style → numbering precedence. The enumerator
+ * and the derived-scope resolver both call this so their scopeIds
+ * agree on kind.
+ */
+export function detectParagraphKind(
+  paragraph: ParagraphNode,
+): "paragraph" | "heading" | "list-item" {
+  if (
+    typeof paragraph.outlineLevel === "number" &&
+    paragraph.outlineLevel >= 0 &&
+    paragraph.outlineLevel <= 8
+  ) {
+    return "heading";
+  }
+  if (
+    typeof paragraph.styleId === "string" &&
+    /^heading\d$/i.test(paragraph.styleId)
+  ) {
+    return "heading";
+  }
+  if (paragraph.numbering) {
+    return "list-item";
+  }
+  return "paragraph";
+}
+
+/**
+ * Mint the derived scopeId for a paragraph. `wordExtensionIds.paraId`
+ * (the w14:paraId attribute) wins when present — it's stable across
+ * reopen but carries no kind information, so the kind prefix
+ * disambiguates. Kind-less bare paraIds would collide with
+ * marker-backed overlay scopeIds; the prefix prevents that.
+ */
+export function buildParagraphScopeId(
+  kind: "paragraph" | "heading" | "list-item",
+  blockIndex: number,
+  paragraph: ParagraphNode,
+): string {
+  const paraId = paragraph.wordExtensionIds?.paraId;
+  if (kind === "heading") {
+    if (paraId) return `heading:${paraId}`;
+    return `heading:${paragraph.outlineLevel ?? 0}:${blockIndex}`;
+  }
+  if (kind === "list-item") {
+    if (paraId) return `li:${paraId}`;
+    const inst = paragraph.numbering?.numberingInstanceId ?? "u";
+    const lvl = paragraph.numbering?.level ?? 0;
+    return `li:${inst}:${lvl}:${blockIndex}`;
+  }
+  if (paraId) return `para:${paraId}`;
+  return `para:${blockIndex}`;
+}

package/src/model/review/comment-types.ts

@@ -0,0 +1,112 @@
+/**
+ * Pure shapes for comment threads on a CanonicalDocument.
+ *
+ * Like the revision types next door, these describe what exists on the
+ * document, not the store operations that mutate them. The review layer's
+ * `src/review/store/comment-store.ts` used to own these definitions; it
+ * now re-exports from here so the session layer can consume them via the
+ * model without crossing the P6 boundary.
+ *
+ * Store constructors (`createCommentStore`, `upsertCommentThread`, ...),
+ * the remap engine, and the sidebar projection all remain in
+ * `src/review/store/comment-store.ts` — they are runtime-state operations.
+ */
+
+import type { EditorAnchorProjection } from "../anchor.ts";
+
+export type CommentAnchor = EditorAnchorProjection;
+export type CommentAnchorState = "active" | "detached";
+
+export interface CommentAnchorSummary {
+  anchor: CommentAnchor;
+  state: CommentAnchorState;
+  range: import("../anchor.ts").DocRange;
+}
+
+export interface CommentEntry {
+  entryId: string;
+  authorId: string;
+  body: string;
+  createdAt: string;
+  metadata?: CommentEntryMetadata;
+}
+
+export interface CommentEntryMetadata {
+  ooxmlCommentId?: string;
+  paraId?: string;
+  parentParaId?: string;
+  durableId?: string;
+  initials?: string;
+}
+
+export interface CommentResolution {
+  resolvedAt: string;
+  resolvedBy: string;
+}
+
+export type CommentThreadStatus = "open" | "resolved" | "detached";
+
+export interface CommentThread {
+  commentId: string;
+  anchor: CommentAnchor;
+  status: CommentThreadStatus;
+  entries: CommentEntry[];
+  createdBy: string;
+  createdAt: string;
+  resolution?: CommentResolution;
+  warningIds: string[];
+  metadata?: CommentThreadMetadata;
+}
+
+export interface CommentThreadMetadata {
+  source?: "runtime" | "import";
+  rootOoxmlCommentId?: string;
+  rootParaId?: string;
+  detachedReason?: "incomplete-markers" | "multi-paragraph" | "opaque-region" | "revision-overlap";
+  actionabilityNote?: string;
+}
+
+export interface CommentStore {
+  version: "comment-store/1";
+  threads: Record<string, CommentThread>;
+}
+
+/**
+ * Pure projection from the canonical-document's loose `CommentThread`
+ * shape (src/model/canonical-document.ts — optional entries / createdBy
+ * / body fields, status uncorrelated with anchor.kind) to the review-layer
+ * strict `CommentThread` shape defined above (required entries + status
+ * correlated with a detached anchor).
+ *
+ * Mirrors the runtime-comment-store `toCommentThread` defaults without
+ * importing from core. Session-layer code paths consume this directly so
+ * they can produce review-shape threads without reaching into
+ * `src/review/store/**`.
+ */
+export function toReviewCommentThread(
+  source: import("../canonical-document.ts").CommentThread,
+): CommentThread {
+  const status: CommentThreadStatus =
+    source.anchor.kind === "detached"
+      ? "detached"
+      : source.status === "resolved"
+        ? "resolved"
+        : "open";
+  return {
+    commentId: source.commentId,
+    anchor: source.anchor,
+    status,
+    entries: source.entries ?? [],
+    createdBy: source.createdBy ?? source.authorId ?? "unknown",
+    createdAt: source.createdAt,
+    resolution: source.resolution,
+    warningIds: [...(source.warningIds ?? [])],
+    metadata: source.metadata,
+  };
+}
+
+export function commentRecordsToReviewThreads(
+  comments: Record<string, import("../canonical-document.ts").CommentThread>,
+): CommentThread[] {
+  return Object.values(comments).map(toReviewCommentThread);
+}

package/src/model/review/index.ts

@@ -0,0 +1,2 @@
+export * from "./revision-types.ts";
+export * from "./comment-types.ts";

package/src/model/review/revision-types.ts

@@ -0,0 +1,215 @@
+/**
+ * Pure shapes for tracked-change revisions on a CanonicalDocument.
+ *
+ * Revisions are model-level data (what exists on the document), not
+ * runtime state (what the review store does with them). The review
+ * layer's store at `src/review/store/revision-types.ts` used to own
+ * these types; it now re-exports from here so the session layer (which
+ * cannot import from `src/review/**`) can consume the types via the
+ * model layer.
+ *
+ * Anchor-constructor helpers (`createRevisionRangeAnchor`, `remapRevisionAnchor`,
+ * etc.) + store-oriented predicates that cross into mapping mechanics
+ * remain in review/store. Pure classifiers (`getRevisionActionability`,
+ * `isRevisionActionable`, `describeRevisionKind`) live here — they only
+ * inspect data.
+ */
+
+import type { EditorAnchorProjection } from "../anchor.ts";
+import type { RevisionStoryTargetRecord } from "../canonical-document.ts";
+
+export type RevisionAnchor = EditorAnchorProjection;
+
+export type SupportedRevisionKind = "insertion" | "deletion" | "property-change";
+export type PreserveOnlyRevisionKind = "formatting" | "move";
+export type RevisionKind = SupportedRevisionKind | PreserveOnlyRevisionKind;
+
+export type RevisionStatus = "active" | "accepted" | "rejected" | "detached";
+export type RevisionActionability = "actionable" | "preserve-only";
+export type RevisionAnchorState = "active" | "detached";
+
+export interface PropertyChangeData {
+  xmlTag: "pPrChange" | "sectPrChange" | "tblPrChange" | "rPrChange";
+  beforeXml: string;
+}
+
+export interface MoveData {
+  moveId: string;
+  direction: "from" | "to";
+  linkedRevisionId?: string;
+}
+
+/**
+ * Payload for `w:cellMerge` revisions. `direction` is the `w:vMerge`
+ * attribute on the marker:
+ *   `"rest"` — this cell begins a vertical merge span (restart cell).
+ *   `"cont"` — this cell continues a vertical merge span.
+ *
+ * Accept commits `TableCellNode.verticalMerge` to the matching state;
+ * reject clears `verticalMerge` to undefined. No row topology changes
+ * (mirrors LibreOffice's treatment — vMerge is a rendering property, not
+ * a structural mutation).
+ */
+export interface CellMergeData {
+  direction: "rest" | "cont";
+}
+
+/**
+ * Ordinal coordinates of a structural table revision within the canonical
+ * document tree.
+ *
+ * Lane 7b row-insertion revisions (`<w:trPr><w:ins/></w:trPr>`) point at an
+ * entire row, not a text range — the runtime anchor position alone can't
+ * identify which row to remove on reject. This envelope carries the table's
+ * ordinal (the Nth `<w:tbl>` in the body) and the row's index within that
+ * table, both fixed at parse time. Accept/reject resolves these to a
+ * canonical-document `tableBlockIndex` by walking `doc.content.children[]`
+ * at action time.
+ */
+export interface TableRevisionCoordinates {
+  tableOrdinal: number;
+  rowIndex: number;
+  /**
+   * Cell index within `row.cells[]`. Present on cell-level structural
+   * revisions (`cellIns` / `cellDel` / `cellMerge`); `undefined` on
+   * row-level records (`row-ins` / `row-del`).
+   */
+  cellIndex?: number;
+  /**
+   * For revisions inside nested tables (a `<w:tbl>` inside a cell), this
+   * carries the full ordinal path so `resolveCanonicalTableRow` can
+   * tree-walk the canonical document:
+   *   `[bodyTableOrdinal, nestedTableIndex, ...]`
+   * Body-level revisions omit this field and use the flat `tableOrdinal`.
+   * Lane 7b Phase Q.
+   */
+  tableOrdinalPath?: readonly number[];
+}
+
+export interface RevisionMetadataEnvelope {
+  source: "runtime" | "import";
+  storyTarget?: RevisionStoryTargetRecord;
+  preserveOnlyReason?: string;
+  suggestionId?: string;
+  semanticKind?:
+    | "insertion"
+    | "deletion"
+    | "replacement"
+    | "formatting-change"
+    | "paragraph-property-change"
+    | "structural-change"
+    | "object-change";
+  linkedRevisionIds?: string[];
+  predecessorSuggestionId?: string;
+  importedRevisionForm?:
+    | "run-insertion"
+    | "run-deletion"
+    | "paragraph-insertion"
+    | "paragraph-deletion";
+  originalRevisionType?: string;
+  ooxmlRevisionId?: string;
+  propertyChangeData?: PropertyChangeData;
+  moveData?: MoveData;
+  cellMergeData?: CellMergeData;
+  tableRevisionCoordinates?: TableRevisionCoordinates;
+}
+
+export type PropertyChangeRevision = RevisionRecord & {
+  kind: "property-change";
+  metadata: RevisionMetadataEnvelope & { propertyChangeData: PropertyChangeData };
+};
+
+export type MoveRevision = RevisionRecord & {
+  kind: "move";
+  metadata: RevisionMetadataEnvelope & { moveData: MoveData };
+};
+
+export interface RevisionRecord {
+  revisionId: string;
+  kind: RevisionKind;
+  anchor: RevisionAnchor;
+  authorId: string;
+  createdAt: string;
+  status: RevisionStatus;
+  warningIds: string[];
+  metadata: RevisionMetadataEnvelope;
+}
+
+export interface RevisionAnchorSummary {
+  anchor: RevisionAnchor;
+  state: RevisionAnchorState;
+  range: import("../anchor.ts").DocRange;
+}
+
+export function getRevisionActionability(
+  revision:
+    | RevisionKind
+    | Pick<RevisionRecord, "kind" | "metadata">,
+): RevisionActionability {
+  // Lane 7b promotions run BEFORE the preserveOnlyReason check on purpose:
+  // `createRevisionRecord` injects a default "Imported preserve-only revision."
+  // reason for any kind that `getRevisionActionability(kind)` returns as
+  // preserve-only (see revision-store.ts), which covers both `kind: "move"`
+  // and `kind: "formatting"`. The overrides below flip the default back to
+  // actionable for the specific shapes that Lane 7b promoted: cellIns
+  // structural-table revisions, and linked-pair move revisions. Do not add a
+  // `&& !preserveOnlyReason` guard here — that would re-lock these shapes
+  // against the injected default and regress 7b.
+  if (
+    typeof revision !== "string" &&
+    (revision.metadata.originalRevisionType === "cellIns" ||
+      revision.metadata.originalRevisionType === "cellDel" ||
+      revision.metadata.originalRevisionType === "cellMerge")
+  ) {
+    return "actionable";
+  }
+
+  if (
+    typeof revision !== "string" &&
+    revision.kind === "move" &&
+    typeof revision.metadata.moveData?.linkedRevisionId === "string" &&
+    revision.metadata.moveData.linkedRevisionId.length > 0
+  ) {
+    return "actionable";
+  }
+
+  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";
+  }
+}
+
+export function isRevisionActionable(
+  record: Pick<RevisionRecord, "kind" | "metadata" | "status">,
+): boolean {
+  return getRevisionActionability(record) === "actionable" && record.status === "active";
+}
+
+export function describeRevisionKind(kind: RevisionKind): string {
+  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";
+  }
+}