@beyondwork/docx-react-component 1.0.71 → 1.0.73

package/src/api/v3/ai/outline.ts

@@ -0,0 +1,140 @@
+/**
+ * @endStateApi v3 — `ai.getDocumentOutline`.
+ *
+ * Composes the layer-04/07 navigation snapshot with the layer-07 outline
+ * builder to return a heading tree an agent can surface for "jump to
+ * section" / "summarize this section" flows.
+ *
+ * Each entry carries `headingId`, `level`, `text`, `offset`, `pageIndex`,
+ * `sectionIndex`, and `parentHeadingIds` (top-level headings have an
+ * empty array). `activeHeadingId` points at the heading containing the
+ * current selection head, if any.
+ *
+ * Read-family; no audit emission.
+ */
+
+import type { RuntimeApiHandle } from "../_runtime-handle.ts";
+import type { ApiV3FnMetadata } from "../_layer-metadata.ts";
+import type {
+  DocumentOutlineHeadingSnapshot,
+  DocumentOutlineSnapshot,
+} from "../../public-types.ts";
+import { createDocumentNavigationSnapshot } from "../../../runtime/document-navigation.ts";
+import { createDocumentOutlineSnapshot } from "../../../runtime/document-outline.ts";
+import {
+  computeBlockPositions,
+  createScopeCompilerService,
+} from "../../../runtime/scopes/index.ts";
+
+/**
+ * Gap B (coord-08 post-Slice-7 integration) — v3 extension of
+ * `DocumentOutlineHeadingSnapshot` that carries the L08 scope
+ * compiler's `scopeId` for each heading. Agents use it directly with
+ * `ai.applyReplacementScope` / `ai.attachExplanation` / etc. without a
+ * separate `ai.listScopes({kind:"heading"})` lookup + offset match.
+ *
+ * The field is populated when the compiler's heading enumeration has
+ * a matching entry by block-range start; omitted when no match is
+ * found (e.g. a heading outside the `main` story). Empty-docs /
+ * no-heading docs return `headings: []` — the enrichment is a no-op.
+ */
+export type GetDocumentOutlineHeadingEntry = DocumentOutlineHeadingSnapshot & {
+  readonly scopeId?: string;
+};
+
+export type GetDocumentOutlineResult = Omit<
+  DocumentOutlineSnapshot,
+  "headings"
+> & {
+  readonly headings: readonly GetDocumentOutlineHeadingEntry[];
+};
+
+export const getDocumentOutlineMetadata: ApiV3FnMetadata = {
+  name: "ai.getDocumentOutline",
+  status: "live-with-adapter",
+  sourceLayer: "workflow-review",
+  liveEvidence: {
+    runnerTest: "test/api/v3/ai/ai-document-read.test.ts",
+    commit: "refactor-09-post-closure-document-read",
+  },
+  uxIntent: { uiVisible: false, expectsUxResponse: "none" },
+  agentMetadata: {
+    readOrMutate: "read",
+    boundedScope: "document",
+    auditCategory: "document-outline-read",
+    contextPromptShape:
+      "Hierarchical heading outline — {headingId, level, text, offset, pageIndex, sectionIndex, parentHeadingIds} per entry, plus activeHeadingId when selection lives under a heading.",
+  },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  rwdReference:
+    "§AI API § ai.getDocumentOutline. Composes createDocumentNavigationSnapshot (L04/07) with createDocumentOutlineSnapshot (L07) to surface the heading tree. Read-only; no audit emission.",
+};
+
+export function createOutlineFamily(runtime: RuntimeApiHandle) {
+  const compiler = createScopeCompilerService(runtime);
+  return {
+    getDocumentOutline(): GetDocumentOutlineResult {
+      // @endStateApi — live-with-adapter. Composes L04/07 navigation
+      // snapshot with L07 outline builder to surface heading tree;
+      // enriches each heading entry with the L08 compiler's `scopeId`
+      // (Gap B, coord-08 post-Slice-7 integration).
+      const snapshot = runtime.getRenderSnapshot();
+      const document = runtime.getCanonicalDocument();
+      const selectionHead = snapshot.selection.head;
+      const navigation = createDocumentNavigationSnapshot(
+        document,
+        selectionHead,
+        snapshot.activeStory,
+      );
+      const outline = createDocumentOutlineSnapshot({
+        navigation,
+        activeStory: snapshot.activeStory,
+        selectionHead,
+      });
+
+      // Gap B enrichment — build an offset → scopeId map over the
+      // heading enumeration and join onto each outline entry. The
+      // offset-based join uses `computeBlockPositions` to translate
+      // the compiler's `blockIndex` (on the enumerated scope's
+      // `semanticPath`) back into a character offset equal to the
+      // outline's `offset` field.
+      const headingScopes = compiler
+        .compileAllScopes()
+        .filter((s) => s.kind === "heading");
+      const blockPositions = computeBlockPositions(document);
+      const blockOffsetByIndex = new Map<number, number>();
+      for (const entry of blockPositions) {
+        blockOffsetByIndex.set(entry.blockIndex, entry.from);
+      }
+      const scopeIdByOffset = new Map<number, string>();
+      for (const scope of headingScopes) {
+        // `semanticPath` is ["body", "heading", <level>, <blockIndex>]
+        // — the blockIndex is the last segment. Numeric parse + offset
+        // lookup gives us the heading paragraph's character offset.
+        const path = scope.handle.semanticPath;
+        const lastSegment = path[path.length - 1];
+        if (typeof lastSegment !== "string") continue;
+        const blockIndex = Number.parseInt(lastSegment, 10);
+        if (!Number.isFinite(blockIndex)) continue;
+        const offset = blockOffsetByIndex.get(blockIndex);
+        if (typeof offset === "number") {
+          scopeIdByOffset.set(offset, scope.handle.scopeId);
+        }
+      }
+
+      const enrichedHeadings: GetDocumentOutlineHeadingEntry[] =
+        outline.headings.map((heading) => {
+          const scopeId = scopeIdByOffset.get(heading.offset);
+          return scopeId ? { ...heading, scopeId } : heading;
+        });
+
+      return {
+        ...(outline.activeHeadingId
+          ? { activeHeadingId: outline.activeHeadingId }
+          : {}),
+        headings: enrichedHeadings,
+      };
+    },
+  };
+}

package/src/api/v3/ai/policy.ts

@@ -38,6 +38,30 @@ export interface GetPolicyInput {
 
 export type GetPolicyResult = AIActionPolicy | readonly AIActionPolicy[];
 
+export type ListAIActionsResult = readonly AIAction[];
+
+export const listAIActionsMetadata: ApiV3FnMetadata = {
+  name: "ai.listAIActions",
+  status: "live-with-adapter",
+  sourceLayer: "workflow-review",
+  liveEvidence: {
+    runnerTest: "test/api/v3/ai/ai-list-actions.test.ts",
+    commit: "refactor-09-post-closure-ki-p5",
+  },
+  uxIntent: { uiVisible: false, expectsUxResponse: "none" },
+  agentMetadata: {
+    readOrMutate: "read",
+    boundedScope: "document",
+    auditCategory: "policy-list",
+    contextPromptShape:
+      "Discovery: returns the AIAction vocabulary with policy entries. Use before calling getPolicy/evaluateAction so ids aren't guessed (closes KI-P5).",
+  },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  rwdReference:
+    "§AI API § ai.listAIActions. Read-only adapter over AI_ACTION_POLICIES — returns every AIAction id with a shipped policy entry. Closes KI-P5 (AIAction discoverability) by giving agents a runtime-discoverable vocabulary.",
+};
+
 export const getPolicyMetadata: ApiV3FnMetadata = {
   name: "ai.getPolicy",
   status: "live-with-adapter",
@@ -62,6 +86,13 @@ export const getPolicyMetadata: ApiV3FnMetadata = {
 
 export function createPolicyFamily(_runtime: RuntimeApiHandle) {
   return {
+    listAIActions(): ListAIActionsResult {
+      // @endStateApi — live-with-adapter. Projects AI_ACTION_POLICIES[]
+      // to the action-id list; every entry is guaranteed policy-backed
+      // (getPolicy on these ids returns support != 'unsupported').
+      return Object.freeze(AI_ACTION_POLICIES.map((p) => p.action));
+    },
+
     getPolicy(input?: GetPolicyInput): GetPolicyResult {
       // @endStateApi — live-with-adapter. Delegates to Layer-06's
       // getAIActionPolicy(action) for single-action lookups or returns

package/src/api/v3/ai/replacement.ts

@@ -121,6 +121,13 @@ export interface ApplyResult {
   readonly reason?: string;
   readonly blockers?: readonly string[];
   readonly auditHint?: string;
+  /**
+   * Gap A (post-Slice-7 integration) — revision IDs authored during
+   * the apply. Populated for suggest-mode (tracked insert + delete);
+   * empty for direct-edit. Agents chain into `ai.acceptRevision` /
+   * `ai.rejectRevision` with each id to land or discard the proposal.
+   */
+  readonly authoredRevisionIds: readonly string[];
 }
 
 export interface ApplyReplacementScopeInput {
@@ -331,6 +338,7 @@ export function createReplacementFamily(runtime: RuntimeApiHandle) {
           ? { blockers: Object.freeze([...result.validation.blockedReasons]) }
           : {}),
         ...(result.audit ? { auditHint: result.audit.actionId } : {}),
+        authoredRevisionIds: result.authoredRevisionIds,
       };
     },
   };

package/src/api/v3/ai/review.ts

@@ -0,0 +1,342 @@
+/**
+ * @endStateApi v3 — `ai` review-workflow family.
+ *
+ * acceptRevision / rejectRevision / resolveCommentThread.
+ *
+ * Thin adapters over Layer-06 review-workflow primitives exposed on
+ * `RuntimeApiHandle`:
+ *
+ *   - `runtime.acceptChange(revisionId)` — dispatches `change.accept`
+ *     through the /06 coordinator.
+ *   - `runtime.rejectChange(revisionId)` — dispatches `change.reject`.
+ *   - `runtime.resolveComment(commentId)` — dispatches `comment.resolve`.
+ *
+ * Refusal contract: when the id doesn't resolve (revision already
+ * accepted/rejected/detached, or unknown), the adapter returns
+ * `{accepted|rejected|resolved: false, reason: "<kind>-not-found:<id>" |
+ * "<kind>-not-actionable:<id>"}`. Success path is verified post-dispatch
+ * by re-reading `runtime.getRenderSnapshot().trackedChanges` /
+ * `.comments` and confirming the target entry transitioned.
+ *
+ * Architecture A4: these mutations emit exactly one `ScopeActionAudit`
+ * on the `scope` telemetry channel when the target carries a resolvable
+ * scope anchor. When no scope is resolvable (e.g. the revision anchors
+ * to a region that isn't an enumerable scope), the audit is skipped
+ * silently — mirrors `attach.ts`'s pre-scope-null arm. The mutation
+ * still commits; the contract is "at most one audit per mutation", and
+ * review-workflow mutations on non-scoped regions remain traceable via
+ * the primitive's own `change.*` dispatch records on the `command`
+ * telemetry channel.
+ */
+
+import type { RuntimeApiHandle } from "../_runtime-handle.ts";
+import type { ApiV3FnMetadata } from "../_layer-metadata.ts";
+import { emitUxResponse } from "../_ux-response.ts";
+import {
+  captureScopeSnapshot,
+  emitScopeMetadataAudit,
+  snapshotDocumentHash,
+} from "./_metadata-audit.ts";
+
+export interface AcceptRevisionInput {
+  readonly revisionId: string;
+  /**
+   * Optional audit-target hint. When provided and resolvable, the A4
+   * `ScopeActionAudit` is emitted against this scope. Omitting it still
+   * accepts the revision; the audit is skipped silently.
+   */
+  readonly scopeId?: string;
+}
+
+export interface AcceptRevisionResult {
+  readonly revisionId: string;
+  readonly accepted: boolean;
+  readonly reason?: string;
+}
+
+export interface RejectRevisionInput {
+  readonly revisionId: string;
+  readonly scopeId?: string;
+}
+
+export interface RejectRevisionResult {
+  readonly revisionId: string;
+  readonly rejected: boolean;
+  readonly reason?: string;
+}
+
+export interface ResolveCommentThreadInput {
+  readonly threadId: string;
+  readonly scopeId?: string;
+}
+
+export interface ResolveCommentThreadResult {
+  readonly threadId: string;
+  readonly resolved: boolean;
+  readonly reason?: string;
+}
+
+export const acceptRevisionMetadata: ApiV3FnMetadata = {
+  name: "ai.acceptRevision",
+  status: "live-with-adapter",
+  sourceLayer: "workflow-review",
+  liveEvidence: {
+    runnerTest: "test/api/v3/ai/ai-review-workflow.test.ts",
+    commit: "refactor-09-post-closure-review-workflow",
+  },
+  uxIntent: {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "tracked-change accepted; revision removed from pending list",
+  },
+  agentMetadata: {
+    readOrMutate: "mutate",
+    boundedScope: "document",
+    auditCategory: "revision-accept",
+    contextPromptShape:
+      "Accept a single tracked-change revision by revisionId. Optional scopeId hint binds the audit to a scope target.",
+  },
+  stateClass: "A-canonical",
+  persistsTo: "customXml",
+  broadcastsVia: "crdt",
+  rwdReference:
+    "§AI API § ai.acceptRevision. Adapter over runtime.acceptChange (Layer-06 review-workflow). A4 audit emitted when scopeId hint resolves; otherwise the primitive's /06 dispatch record on the command channel carries the trace.",
+};
+
+export const rejectRevisionMetadata: ApiV3FnMetadata = {
+  name: "ai.rejectRevision",
+  status: "live-with-adapter",
+  sourceLayer: "workflow-review",
+  liveEvidence: {
+    runnerTest: "test/api/v3/ai/ai-review-workflow.test.ts",
+    commit: "refactor-09-post-closure-review-workflow",
+  },
+  uxIntent: {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "tracked-change rejected; revision removed from pending list",
+  },
+  agentMetadata: {
+    readOrMutate: "mutate",
+    boundedScope: "document",
+    auditCategory: "revision-reject",
+    contextPromptShape:
+      "Reject a single tracked-change revision by revisionId. Optional scopeId hint binds the audit to a scope target.",
+  },
+  stateClass: "A-canonical",
+  persistsTo: "customXml",
+  broadcastsVia: "crdt",
+  rwdReference:
+    "§AI API § ai.rejectRevision. Adapter over runtime.rejectChange (Layer-06 review-workflow). A4 audit emitted when scopeId hint resolves.",
+};
+
+export const resolveCommentThreadMetadata: ApiV3FnMetadata = {
+  name: "ai.resolveCommentThread",
+  status: "live-with-adapter",
+  sourceLayer: "workflow-review",
+  liveEvidence: {
+    runnerTest: "test/api/v3/ai/ai-review-workflow.test.ts",
+    commit: "refactor-09-post-closure-review-workflow",
+  },
+  uxIntent: {
+    uiVisible: true,
+    expectsUxResponse: "inline-change",
+    expectedDelta: "comment thread marked resolved; thread moves out of open list",
+  },
+  agentMetadata: {
+    readOrMutate: "mutate",
+    boundedScope: "document",
+    auditCategory: "comment-resolve",
+    contextPromptShape:
+      "Resolve an open comment thread by threadId. Optional scopeId hint binds the audit to the anchored scope.",
+  },
+  stateClass: "A-canonical",
+  persistsTo: "customXml",
+  broadcastsVia: "crdt",
+  rwdReference:
+    "§AI API § ai.resolveCommentThread. Adapter over runtime.resolveComment (Layer-06 review-workflow). A4 audit emitted when scopeId hint resolves.",
+};
+
+export function createReviewFamily(runtime: RuntimeApiHandle) {
+  return {
+    acceptRevision(input: AcceptRevisionInput): AcceptRevisionResult {
+      // @endStateApi — live-with-adapter. Routes through Layer-06's
+      // runtime.acceptChange() dispatch; A4 audit emitted on success when
+      // caller supplied a resolvable scopeId hint.
+      const { revisionId } = input;
+      const before = runtime.getRenderSnapshot().trackedChanges;
+      const target = before.revisions.find((r) => r.revisionId === revisionId);
+      if (!target) {
+        return {
+          revisionId,
+          accepted: false,
+          reason: `revision-not-found:${revisionId}`,
+        };
+      }
+      if (!target.canAccept || target.status !== "active") {
+        return {
+          revisionId,
+          accepted: false,
+          reason: `revision-not-actionable:${revisionId}`,
+        };
+      }
+      const preScope = input.scopeId
+        ? captureScopeSnapshot(runtime, input.scopeId)
+        : null;
+      const documentHashBefore = snapshotDocumentHash(runtime);
+      runtime.acceptChange(revisionId);
+      const after = runtime.getRenderSnapshot().trackedChanges;
+      const accepted = !after.pendingChangeIds.includes(revisionId);
+      if (accepted && preScope && input.scopeId) {
+        emitScopeMetadataAudit({
+          runtime,
+          actionId: acceptRevisionMetadata.name,
+          scopeId: input.scopeId,
+          targetScopeSnapshot: preScope,
+          proposedContent: {
+            kind: "explanation",
+            payload: { revisionId, intent: "accept" },
+          },
+          compiledOperationKind: "metadata-attach-explanation",
+          compiledOperationSummary: `accept revision ${revisionId}`,
+          emittedAtUtc: new Date(0).toISOString(),
+          documentHashBefore,
+        });
+      }
+      emitUxResponse(runtime, {
+        apiFn: acceptRevisionMetadata.name,
+        intent: acceptRevisionMetadata.uxIntent.expectedDelta ?? "",
+        mockOrLive: "live",
+        uiVisible: true,
+        expectedDelta: acceptRevisionMetadata.uxIntent.expectedDelta,
+      });
+      return accepted
+        ? { revisionId, accepted: true }
+        : {
+            revisionId,
+            accepted: false,
+            reason: `revision-not-actionable:${revisionId}`,
+          };
+    },
+
+    rejectRevision(input: RejectRevisionInput): RejectRevisionResult {
+      // @endStateApi — live-with-adapter. Routes through Layer-06's
+      // runtime.rejectChange() dispatch.
+      const { revisionId } = input;
+      const before = runtime.getRenderSnapshot().trackedChanges;
+      const target = before.revisions.find((r) => r.revisionId === revisionId);
+      if (!target) {
+        return {
+          revisionId,
+          rejected: false,
+          reason: `revision-not-found:${revisionId}`,
+        };
+      }
+      if (!target.canReject || target.status !== "active") {
+        return {
+          revisionId,
+          rejected: false,
+          reason: `revision-not-actionable:${revisionId}`,
+        };
+      }
+      const preScope = input.scopeId
+        ? captureScopeSnapshot(runtime, input.scopeId)
+        : null;
+      const documentHashBefore = snapshotDocumentHash(runtime);
+      runtime.rejectChange(revisionId);
+      const after = runtime.getRenderSnapshot().trackedChanges;
+      const rejected = !after.pendingChangeIds.includes(revisionId);
+      if (rejected && preScope && input.scopeId) {
+        emitScopeMetadataAudit({
+          runtime,
+          actionId: rejectRevisionMetadata.name,
+          scopeId: input.scopeId,
+          targetScopeSnapshot: preScope,
+          proposedContent: {
+            kind: "explanation",
+            payload: { revisionId, intent: "reject" },
+          },
+          compiledOperationKind: "metadata-attach-explanation",
+          compiledOperationSummary: `reject revision ${revisionId}`,
+          emittedAtUtc: new Date(0).toISOString(),
+          documentHashBefore,
+        });
+      }
+      emitUxResponse(runtime, {
+        apiFn: rejectRevisionMetadata.name,
+        intent: rejectRevisionMetadata.uxIntent.expectedDelta ?? "",
+        mockOrLive: "live",
+        uiVisible: true,
+        expectedDelta: rejectRevisionMetadata.uxIntent.expectedDelta,
+      });
+      return rejected
+        ? { revisionId, rejected: true }
+        : {
+            revisionId,
+            rejected: false,
+            reason: `revision-not-actionable:${revisionId}`,
+          };
+    },
+
+    resolveCommentThread(
+      input: ResolveCommentThreadInput,
+    ): ResolveCommentThreadResult {
+      // @endStateApi — live-with-adapter. Routes through Layer-06's
+      // runtime.resolveComment() dispatch.
+      const { threadId } = input;
+      const before = runtime.getRenderSnapshot().comments;
+      const target = before.threads.find((t) => t.commentId === threadId);
+      if (!target) {
+        return {
+          threadId,
+          resolved: false,
+          reason: `thread-not-found:${threadId}`,
+        };
+      }
+      if (target.status !== "open") {
+        return {
+          threadId,
+          resolved: false,
+          reason: `thread-not-open:${threadId}`,
+        };
+      }
+      const preScope = input.scopeId
+        ? captureScopeSnapshot(runtime, input.scopeId)
+        : null;
+      const documentHashBefore = snapshotDocumentHash(runtime);
+      runtime.resolveComment(threadId);
+      const after = runtime.getRenderSnapshot().comments;
+      const resolved = after.resolvedCommentIds.includes(threadId);
+      if (resolved && preScope && input.scopeId) {
+        emitScopeMetadataAudit({
+          runtime,
+          actionId: resolveCommentThreadMetadata.name,
+          scopeId: input.scopeId,
+          targetScopeSnapshot: preScope,
+          proposedContent: {
+            kind: "explanation",
+            payload: { threadId, intent: "resolve-comment" },
+          },
+          compiledOperationKind: "metadata-attach-explanation",
+          compiledOperationSummary: `resolve comment thread ${threadId}`,
+          emittedAtUtc: new Date(0).toISOString(),
+          documentHashBefore,
+        });
+      }
+      emitUxResponse(runtime, {
+        apiFn: resolveCommentThreadMetadata.name,
+        intent: resolveCommentThreadMetadata.uxIntent.expectedDelta ?? "",
+        mockOrLive: "live",
+        uiVisible: true,
+        expectedDelta: resolveCommentThreadMetadata.uxIntent.expectedDelta,
+      });
+      return resolved
+        ? { threadId, resolved: true }
+        : {
+            threadId,
+            resolved: false,
+            reason: `thread-not-resolvable:${threadId}`,
+          };
+    },
+  };
+}

package/src/api/v3/ai/stats.ts

@@ -0,0 +1,62 @@
+/**
+ * @endStateApi v3 — `ai.getDocumentStatistics`.
+ *
+ * Passes `DocumentStats` derived inside the runtime through to agents.
+ * Counts: paragraphs, words, characters, comments, revisions.
+ *
+ * Read-family; no audit emission. Complements `ai.inspectDocument`
+ * (which reports scope-level counts) with flat document-level counts
+ * an agent can surface directly.
+ */
+
+import type { RuntimeApiHandle } from "../_runtime-handle.ts";
+import type { ApiV3FnMetadata } from "../_layer-metadata.ts";
+import { deriveDocumentStats } from "../../../core/state/editor-state.ts";
+
+export interface DocumentStatisticsResult {
+  readonly paragraphCount: number;
+  readonly wordCount: number;
+  readonly characterCount: number;
+  readonly commentCount: number;
+  readonly revisionCount: number;
+}
+
+export const getDocumentStatisticsMetadata: ApiV3FnMetadata = {
+  name: "ai.getDocumentStatistics",
+  status: "live-with-adapter",
+  sourceLayer: "canonical",
+  liveEvidence: {
+    runnerTest: "test/api/v3/ai/ai-document-read.test.ts",
+    commit: "refactor-09-post-closure-document-read",
+  },
+  uxIntent: { uiVisible: false, expectsUxResponse: "none" },
+  agentMetadata: {
+    readOrMutate: "read",
+    boundedScope: "document",
+    auditCategory: "document-stats-read",
+    contextPromptShape:
+      "Flat document counts: paragraphs, words, characters, comments, revisions.",
+  },
+  stateClass: "A-canonical",
+  persistsTo: "canonical",
+  rwdReference:
+    "§AI API § ai.getDocumentStatistics. Read-through of the DocumentStats record derived from the canonical document. Complements ai.inspectDocument's scope-level counts.",
+};
+
+export function createStatsFamily(runtime: RuntimeApiHandle) {
+  return {
+    getDocumentStatistics(): DocumentStatisticsResult {
+      // @endStateApi — live-with-adapter. Passes deriveDocumentStats
+      // through the canonical document for agent-facing counts.
+      const document = runtime.getCanonicalDocument();
+      const stats = deriveDocumentStats({ document });
+      return {
+        paragraphCount: stats.paragraphCount,
+        wordCount: stats.wordCount,
+        characterCount: stats.characterCount,
+        commentCount: stats.commentCount,
+        revisionCount: stats.revisionCount,
+      };
+    },
+  };
+}