@beyondwork/docx-react-component 1.0.52 → 1.0.54

package/src/runtime/collab/runtime-collab-sync.ts

@@ -11,6 +11,7 @@ import type { BlockNode } from "../../model/canonical-document.ts";
 import type {
   CommandAppliedMeta,
   DocumentRuntime,
+  RemoteCommandEnvelope,
   Unsubscribe,
 } from "../document-runtime.ts";
 import {
@@ -21,7 +22,7 @@ import {
   type CommandEvent,
 } from "./event-types.ts";
 import { computeBaseDocFingerprint } from "./base-doc-fingerprint.ts";
-import type { Checkpoint } from "./checkpoint-store.ts";
+import { CHECKPOINTS_KEY, type Checkpoint } from "./checkpoint-store.ts";
 import { createWorkflowShared, type WorkflowSharedHandle } from "./workflow-shared.ts";
 
 /** Shared Y.Map key — {@link SHARED_META_MAP_KEY}. */
@@ -29,7 +30,6 @@ const SHARED_META_MAP_KEY = "meta";
 const META_BASE_DOC_HASH_KEY = "baseDocHash";
 const META_SCHEMA_VERSION_KEY = "schemaVersion";
 const META_CREATED_AT_KEY = "createdAt";
-const CHECKPOINTS_KEY = "checkpoints";
 
 /**
  * Lifecycle + correctness events surfaced by a
@@ -200,6 +200,30 @@ export interface RuntimeCollabSyncOptions {
    * - `"observer"`: all writes refused with `collab_observer_readonly`.
    */
   role?: "author" | "reviewer" | "observer";
+  /**
+   * R1 — coalesce inbound remote-replay events into one commit per
+   * animation frame. When `true` (default), N events arriving within a
+   * single rAF tick (or `setTimeout(0)` in non-DOM contexts) drain via
+   * one `runtime.applyRemoteCommandBatch(...)` call → one
+   * `refreshRenderSnapshot` / one `notify`. Observer semantics change:
+   * subscribers see one `DocumentRuntimeEvent` per burst rather than
+   * one per event. Hosts that depend on per-event semantics (rare —
+   * counted-event tests, granular per-comment-add observers) opt out
+   * with `false`. The whole batch is atomic: any per-command effect
+   * collision falls back to per-event replay automatically.
+   *
+   * Defaults to `true` in both DOM and Node contexts so tests exercise
+   * the coalesced path without ceremony.
+   */
+  coalesceRemoteReplay?: boolean;
+  /**
+   * R1 hook point for R3 idle-priority plumbing. Invoked once per
+   * scheduled drain (NOT per queued event). R3's future implementation
+   * will use this to abort any in-flight idle prerender task on
+   * `src/io/load-scheduler.ts` so the upcoming commit doesn't compete
+   * with idle work. Safe to omit; R1 functions identically without it.
+   */
+  onRemoteReplayScheduled?: () => void;
 }
 
 export interface RuntimeCollabSyncHandle {
@@ -268,6 +292,48 @@ export function createRuntimeCollabSync(
   let readOnly = false;
   let baseDocFingerprint: string | null = null;
 
+  // R1 — coalesced remote-replay scheduler. Default: ON in both DOM and
+  // Node contexts. Falls back to setTimeout(0) when requestAnimationFrame
+  // is missing so tests and non-DOM hosts exercise the same drain path.
+  const useCoalescing = options.coalesceRemoteReplay !== false;
+  const replayQueue: CommandEvent[] = [];
+  let rafHandle: number | null = null;
+  let timeoutHandle: ReturnType<typeof setTimeout> | null = null;
+
+  function scheduleDrain(): void {
+    if (rafHandle !== null || timeoutHandle !== null) return;
+    options.onRemoteReplayScheduled?.();
+    if (typeof requestAnimationFrame === "function") {
+      rafHandle = requestAnimationFrame(() => {
+        rafHandle = null;
+        drainReplayQueue();
+      });
+    } else {
+      timeoutHandle = setTimeout(() => {
+        timeoutHandle = null;
+        drainReplayQueue();
+      }, 0);
+    }
+  }
+
+  function drainReplayQueue(): void {
+    if (replayQueue.length === 0) return;
+    const batch = replayQueue.splice(0, replayQueue.length);
+    const envelopes = batch.map(eventToEnvelope);
+    runtime.applyRemoteCommandBatch(envelopes);
+  }
+
+  function cancelPendingDrain(): void {
+    if (rafHandle !== null) {
+      if (typeof cancelAnimationFrame === "function") cancelAnimationFrame(rafHandle);
+      rafHandle = null;
+    }
+    if (timeoutHandle !== null) {
+      clearTimeout(timeoutHandle);
+      timeoutHandle = null;
+    }
+  }
+
   // Events emitted before any subscriber exists are buffered and flushed
   // to the first subscriber. This lets hosts react to the attach-path
   // base-doc mismatch and schema-version mismatch for pre-existing
@@ -494,6 +560,10 @@ export function createRuntimeCollabSync(
 
   return {
     destroy() {
+      // R1 — drain any queued replay events synchronously before tearing
+      // down so callers don't lose remote events on an early unmount.
+      cancelPendingDrain();
+      drainReplayQueue();
       unsubscribeCommandApplied();
       yEvents.unobserve(onYEventsChange);
       yMeta.unobserve(checkFingerprintAgainstMeta);
@@ -607,19 +677,29 @@ export function createRuntimeCollabSync(
     return true;
   }
 
-  function applyEventToRuntime(event: CommandEvent): void {
-    runtime.applyRemoteCommand(
-      event.command,
-      {
+  function eventToEnvelope(event: CommandEvent): RemoteCommandEnvelope {
+    return {
+      command: event.command,
+      context: {
         timestamp: event.timestamp,
         documentMode: event.context.documentMode,
         defaultAuthorId: event.context.defaultAuthorId ?? event.authorId,
       },
-      {
+      meta: {
         preSelection: event.context.preSelection,
         activeStory: event.context.activeStory,
       },
-    );
+    };
+  }
+
+  function applyEventToRuntime(event: CommandEvent): void {
+    if (useCoalescing) {
+      replayQueue.push(event);
+      scheduleDrain();
+      return;
+    }
+    const env = eventToEnvelope(event);
+    runtime.applyRemoteCommand(env.command, env.context, env.meta);
   }
 }
 

package/src/runtime/document-runtime.ts

@@ -160,6 +160,7 @@ import {
   createDocumentSectionSnapshots,
   createSectionLocations,
   createTocSnapshot,
+  findBookmarkNameForOffset,
   findDocumentSectionSnapshot,
 } from "./document-outline.ts";
 import {
@@ -209,6 +210,7 @@ import type {
   BlockNode,
   FieldNode,
   FieldRefreshStatus,
+  HyperlinkNode,
   InlineNode,
   PageMargins,
   ParagraphNode,
@@ -298,6 +300,27 @@ export interface DocumentRuntime {
     context: CommandExecutionContext,
     meta?: Partial<CommandAppliedMeta>,
   ): void;
+  /**
+   * R1 — coalesced remote-replay entry point. Applies N envelopes as ONE
+   * commit: per-command transactions are chained (`replayState = txN.nextState`),
+   * mapping steps concatenated, `markDirty` ORed, and a single `commitRemote`
+   * call drives `finalizeState` / `invalidate` / `refreshRenderSnapshot` /
+   * `notify` exactly once. Per-command `meta.activeStory` isolation is
+   * preserved (the remote story scopes its own replay; the local cursor
+   * stays put). Behavior matches `applyRemoteCommand` invoked N times for
+   * a single envelope; for empty arrays it's a no-op.
+   *
+   * Singular effect collisions (≥2 envelopes both emitting `commentAdded` /
+   * `changeAccepted` / etc.) fall back to per-envelope replay so observers
+   * still see every effect — typical text-burst replay (all warnings-only
+   * effects) takes the fast path.
+   *
+   * History commands (`history.undo` / `history.redo`) and runtime overlay
+   * commands (`workflow.set-overlay`, etc.) inside a batch are processed
+   * individually as in the per-event path; they don't participate in the
+   * chained commit.
+   */
+  applyRemoteCommandBatch(envelopes: ReadonlyArray<RemoteCommandEnvelope>): void;
   emitBlockedCommand(command: string, reasons: WorkflowBlockedCommandReason[]): void;
   undo(): void;
   redo(): void;
@@ -433,6 +456,17 @@ export interface CommandAppliedMeta {
   priorDocument: CanonicalDocumentEnvelope;
 }
 
+/**
+ * Single envelope shape consumed by {@link DocumentRuntime.applyRemoteCommandBatch}.
+ * Mirrors the `applyRemoteCommand(command, context, meta)` signature so
+ * batch and per-event paths stay schema-compatible.
+ */
+export interface RemoteCommandEnvelope {
+  command: EditorCommand;
+  context: CommandExecutionContext;
+  meta?: Partial<CommandAppliedMeta>;
+}
+
 export interface CreateDocumentRuntimeOptions {
   documentId: string;
   initialSessionState?: EditorSessionState;
@@ -2264,6 +2298,133 @@ export function createDocumentRuntime(
         emitError(toRuntimeError(error));
       }
     },
+    applyRemoteCommandBatch(envelopes) {
+      if (envelopes.length === 0) return;
+      if (envelopes.length === 1) {
+        const e = envelopes[0]!;
+        this.applyRemoteCommand(e.command, e.context, e.meta);
+        return;
+      }
+
+      try {
+        // Chain per-command transactions before ONE commitRemote at the end.
+        // Each command runs through executeEditorCommand on the replayed
+        // state; resulting nextState becomes the input to the next command.
+        // History/overlay commands are processed individually as in the
+        // per-event path (they don't participate in the chained commit).
+        let replayState: typeof state = state;
+        const stepsAccumulator: import("../core/selection/mapping.ts").MappingStep[] = [];
+        let anyDirty = false;
+        let lastNextState: typeof state | null = null;
+        let lastCrossStoryReplay = false;
+        const warningsAdded: import("../core/state/editor-state.ts").EditorWarning[] = [];
+        const warningsCleared: Array<{ warningId: string; code: import("../core/state/editor-state.ts").EditorWarning["code"] }> = [];
+        const SINGULAR_EFFECT_KEYS = [
+          "commentAdded",
+          "commentResolved",
+          "commentReopened",
+          "commentReplyAdded",
+          "commentBodyEdited",
+          "changeAccepted",
+          "changeRejected",
+          "revisionAuthored",
+          "commandBlocked",
+        ] as const;
+        const singularEffectsCounts = new Map<string, number>();
+        const aggregatedSingular: Record<string, unknown> = {};
+
+        for (const env of envelopes) {
+          const { command, context, meta } = env;
+          if (command.type === "history.undo" || command.type === "history.redo") {
+            // Match per-event path: silently skipped on remote replay.
+            continue;
+          }
+          if (isRuntimeStateOverlayCommand(command)) {
+            // Overlays bypass commitRemote in the per-event path; mirror that
+            // here without disturbing the chained replayState.
+            applyRuntimeStateOverlayCommand(command);
+            continue;
+          }
+          const replayStory = meta?.activeStory ?? activeStory;
+          const crossStoryReplay = Boolean(
+            meta?.activeStory && !storyTargetsEqual(meta.activeStory, activeStory),
+          );
+          let stateForCommand: typeof state;
+          let snapshotForCommand: typeof cachedRenderSnapshot;
+          if (meta?.preSelection) {
+            // Reuse the R5 scratch (avoids per-command allocation across the
+            // burst). Seed from the CURRENT chain state so each command sees
+            // the prior command's nextState as its starting point.
+            Object.assign(r5ScratchReplayState, replayState);
+            r5ScratchReplayState.selection = meta.preSelection;
+            Object.assign(r5ScratchReplaySnapshot, cachedRenderSnapshot);
+            r5ScratchReplaySnapshot.selection = toPublicSelectionSnapshot(meta.preSelection, replayStory);
+            stateForCommand = r5ScratchReplayState;
+            snapshotForCommand = r5ScratchReplaySnapshot;
+          } else {
+            stateForCommand = replayState;
+            snapshotForCommand = cachedRenderSnapshot;
+          }
+          const replayContext = {
+            ...context,
+            renderSnapshot: snapshotForCommand,
+          };
+          const transaction = executeEditorCommand(stateForCommand, command, replayContext);
+          replayState = transaction.nextState;
+          stepsAccumulator.push(...transaction.mapping.steps);
+          anyDirty = anyDirty || transaction.markDirty;
+          warningsAdded.push(...transaction.effects.warningsAdded);
+          warningsCleared.push(...transaction.effects.warningsCleared);
+          for (const key of SINGULAR_EFFECT_KEYS) {
+            const v = (transaction.effects as unknown as Record<string, unknown>)[key];
+            if (v !== undefined) {
+              singularEffectsCounts.set(key, (singularEffectsCounts.get(key) ?? 0) + 1);
+              aggregatedSingular[key] = v;
+            }
+          }
+          lastNextState = transaction.nextState;
+          lastCrossStoryReplay = crossStoryReplay;
+        }
+
+        // Singular-effect collision (≥2 envelopes both setting the same
+        // singular field): fall back to per-envelope replay so observers
+        // see every effect. Common burst (all text.insert with empty
+        // effects) takes the fast path above.
+        let singularCollision = false;
+        for (const count of singularEffectsCounts.values()) {
+          if (count > 1) {
+            singularCollision = true;
+            break;
+          }
+        }
+        if (singularCollision) {
+          for (const env of envelopes) {
+            this.applyRemoteCommand(env.command, env.context, env.meta);
+          }
+          return;
+        }
+        if (lastNextState === null) {
+          // All envelopes were skip/overlay — nothing to commit.
+          return;
+        }
+        const consolidated = {
+          nextState: lastCrossStoryReplay
+            ? { ...lastNextState, selection: state.selection }
+            : lastNextState,
+          mapping: { steps: stepsAccumulator },
+          effects: {
+            warningsAdded,
+            warningsCleared,
+            ...aggregatedSingular,
+          } as import("../core/commands/index.ts").TransactionEffects,
+          historyBoundary: "skip" as const,
+          markDirty: anyDirty,
+        };
+        commitRemote(consolidated);
+      } catch (error) {
+        emitError(toRuntimeError(error));
+      }
+    },
     undo() {
       this.dispatch({
         type: "history.undo",
@@ -5038,7 +5199,7 @@ function refreshDocumentTableOfContents(
 } {
   const navigation = createDocumentNavigationSnapshot(document, selectionHead, activeStory);
   let changed = false;
-  let resultEntries: Array<{ level: number; text: string; pageIndex: number }> = [];
+  let resultEntries: Array<{ level: number; text: string; pageIndex: number; bookmarkName?: string }> = [];
   let changedFrom: number | undefined;
   let changedTo: number | undefined;
   const nextChildren = refreshBlocksWithCursor(document.content.children, (field, range) => {
@@ -5050,11 +5211,15 @@ function refreshDocumentTableOfContents(
       : parseTocLevelRange(field.instruction);
     const entries = navigation.headings
       .filter((heading) => heading.level >= levelRange.from && heading.level <= levelRange.to)
-      .map((heading) => ({
-        level: heading.level,
-        text: heading.text,
-        pageIndex: heading.pageIndex,
-      }));
+      .map((heading) => {
+        const bookmarkName = findBookmarkNameForOffset(document, heading.offset);
+        return {
+          level: heading.level,
+          text: heading.text,
+          pageIndex: heading.pageIndex,
+          ...(bookmarkName ? { bookmarkName } : {}),
+        };
+      });
     if (resultEntries.length === 0) {
       resultEntries = entries;
     }
@@ -5251,12 +5416,20 @@ function buildInlineNodesFromDisplayText(text: string): InlineNode[] {
  * resolver, falls back to the raw `pageIndex + 1` (pre-P5 behavior).
  */
 function buildTocInlineNodes(
-  entries: ReadonlyArray<{ level: number; text: string; pageIndex: number }>,
+  entries: ReadonlyArray<{ level: number; text: string; pageIndex: number; bookmarkName?: string }>,
   resolveDisplayPageNumber?: (pageIndex: number) => number | null,
 ): InlineNode[] {
   const children: InlineNode[] = [];
   entries.forEach((entry, index) => {
-    children.push({ type: "text", text: entry.text });
+    if (entry.bookmarkName) {
+      children.push({
+        type: "hyperlink",
+        href: `#${entry.bookmarkName}`,
+        children: [{ type: "text", text: entry.text }],
+      } as HyperlinkNode);
+    } else {
+      children.push({ type: "text", text: entry.text });
+    }
     children.push({ type: "tab" });
     const displayed = resolveDisplayPageNumber?.(entry.pageIndex);
     children.push({
@@ -5272,7 +5445,7 @@ function buildTocInlineNodes(
 
 /** Test-only export of `buildTocInlineNodes` (P5 unit tests). */
 export function __buildTocInlineNodes(
-  entries: ReadonlyArray<{ level: number; text: string; pageIndex: number }>,
+  entries: ReadonlyArray<{ level: number; text: string; pageIndex: number; bookmarkName?: string }>,
   resolveDisplayPageNumber?: (pageIndex: number) => number | null,
 ): InlineNode[] {
   return buildTocInlineNodes(entries, resolveDisplayPageNumber);

package/src/runtime/layout/inert-layout-facet.ts

@@ -59,6 +59,7 @@ export function createInertLayoutFacet(): WordReviewEditorLayoutFacet {
     swapMeasurementProvider: () => undefined,
     invalidateMeasurementCache: () => undefined,
     getTableRenderPlan: () => null,
+    getTableBodyYOffsetOnPage: () => null,
     getDirtyFieldFamilies: () => [],
     getFieldDirtinessReport: () => emptyReport,
     setVisibleBlockRange: () => undefined,

package/src/runtime/layout/layout-engine-version.ts

@@ -93,8 +93,94 @@
  *       pixel-geometry change; cache envelopes from v9 invalidate
  *       because page-node identity semantics on bounded splices
  *       changed.
+ *  11 — Lane 3a P10 Phase B2. `toPublicPageNode` memoizes its
+ *       `RuntimePageNode → PublicPageNode` projection via WeakMap so
+ *       Phase D1's stable runtime-node references cascade into stable
+ *       public-facet return values. `facet.getPage(pageIndex)` now
+ *       returns reference-equal `PublicPageNode`s across bounded
+ *       relayouts where the underlying runtime node was reused.
+ *       Cascades into downstream consumers (React.memo-gated page
+ *       subtrees, per-page test hooks) and closes the Phase B → D1
+ *       stable-reference chain. No pixel-geometry change; cache
+ *       envelopes from v10 invalidate because the public-facet
+ *       contract changed from "fresh object per call" to "stable ref
+ *       per underlying runtime node".
+ *  12 — Lane 3a R3 table row-split: `getTableRenderPlan` now derives
+ *       `isContinuationPage` from the page graph's fragment slice
+ *       metadata (`kind === "table-slice" && tableRowRange.from > 0`)
+ *       and passes it to `buildTableRenderPlan`. Tables split across
+ *       pages now carry non-empty `repeatedHeaderRows` on continuation
+ *       pages so chrome can prepend header rows visually. No
+ *       pixel-geometry change; cache envelopes from v11 invalidate
+ *       because the table-render-plan contract changed.
+ *  13 — Lane 6d.U2 canvas-seam pill polish: the canvas-posture page-break
+ *       widget's "N / M" badge is promoted from transparent text over the
+ *       dotted seam to a true pill with `--radius-pill` geometry, hairline
+ *       `--color-border-default` border, and `--shadow-soft`. Widget DOM
+ *       shape changed (new `data-variant="pill"` attribute; additional
+ *       inline style declarations on the badge). Cache envelopes from v12
+ *       invalidate because the decoration's cacheable DOM shape changed.
+ *  13 — Lane 3a P14.c: render-kernel gains a single-slot `DecorationIndex`
+ *       cache keyed on (revision, activeStory.kind, zoom.pxPerTwip, and
+ *       reference equality on each decoration source). When layout
+ *       changes but decoration sources are unchanged, `resolveDecorationIndex`
+ *       is skipped and the prior result is reused. The frame-level cache
+ *       already handles repeat reads; this slot targets the post-invalidate
+ *       rebuild path (on every keystroke that triggers a layout event).
+ *       No pixel-geometry change; cache envelopes from v12 invalidate
+ *       because the render-kernel source changed.
+ *  14 — Lane 3a Slice 5: `RuntimeBlockFragment` gains `resolvedStyleChainRef`
+ *       (block's styleId) and `numberingInstanceId` (block's list-instance id).
+ *       `analyzeInvalidation` for `styles-change` (when `dirtyStyleIds` is
+ *       supplied) and `numbering-change` (when `numberingInstanceId` is
+ *       supplied) now return `scope: "bounded"` starting from the first page
+ *       whose fragments reference the dirty style / instance. Fallback to
+ *       `scope: "full"` when payload is absent or no match found. No
+ *       pixel-geometry change; cache envelopes from v13 invalidate because
+ *       the fragment shape and invalidation-scope contract changed.
+ *  15 — Bug fixes: `pageNodesStructurallyEqual` now compares
+ *       `lineBoxes.length` and `noteAllocations.length` as structural
+ *       proxies to prevent stale-node reuse when line geometry changes
+ *       with stable fragment IDs (L1). `analyzeSectionChange` normalizes
+ *       `dirtySectionRange` to guarantee from ≤ to for all graph states
+ *       including empty-sections fallback (L2).
+ *  16 — Bug fixes: `diffRenderFrames` now flags pages whose physical frame
+ *       changed (but block regions are stable) with `pageFrameChanged: true`
+ *       in `changedPages` so consumers can re-project without a block-region
+ *       signal (R1). Chrome reservation changes (`railLaneTwips`,
+ *       `balloonLaneTwips`, `footnoteAreaTwips`, `pageFrameWidthPx`,
+ *       `pageFrameHeightPx`) now trigger `changedPages` so overlay
+ *       re-projection is not silently skipped (R2).
+ *  17 — Lane 3a Slice 2 + R4: `WordReviewEditorLayoutFacet` gains
+ *       `getTableBodyYOffsetOnPage(blockId, pageIndex)` which returns the
+ *       Y offset (in twips from body top) of the table's first fragment on
+ *       a given page by summing prior body-fragment heights. Used by the
+ *       new `TwTableContinuationHeader` chrome overlay to position repeated
+ *       header rows on continuation pages of multi-page tables — no DOM
+ *       measurement, layout-engine fragment heights only. No cached-geometry
+ *       change; cache envelopes from v16 invalidate because the facet
+ *       interface changed.
+ *  18 — Lane 3a Slice 6: `buildPageStackFromWithSplits` no longer discards
+ *       `resumeAt.startOffset`. When `startOffset > 0` and no block
+ *       straddles the dirty section boundary, only sections at and after
+ *       the first dirty section are paginated; the resulting page indices
+ *       are shifted by `startPageIndex` so they align with the global graph.
+ *       Full-paginate + tail-slice fallback used when a block straddles the
+ *       section boundary (safety guard). This eliminates re-paginating
+ *       settled head sections on every bounded-invalidation relayout.
+ *       No pixel-geometry change; cache envelopes from v17 invalidate
+ *       because `buildPageStackFromWithSplits` output contract changed.
+ *  19 — Slice 5 bug-fix: `analyzeNumberingChange` now honors its own
+ *       "Fallback to full rebuild when absent or no match" contract. When
+ *       `numberingInstanceId` is supplied but no materialized fragment
+ *       matches it, the analyzer returns `scope: "full"` +
+ *       `requiresFullRecompute: true` instead of the prior "bounded over
+ *       full range" shortcut, which bypassed the safety guard and could
+ *       leak stale field-family projections. No pixel-geometry change;
+ *       cache envelopes from v18 invalidate because the invalidation
+ *       classifier's contract corrected.
  */
-export const LAYOUT_ENGINE_VERSION = 10 as const;
+export const LAYOUT_ENGINE_VERSION = 19 as const;
 
 /**
  * Serialization schema version for the LayCache payload (the cache envelope
@@ -113,5 +199,14 @@ export const LAYOUT_ENGINE_VERSION = 10 as const;
  *       correctly invalidates. v1 envelopes are rejected on load under v2 —
  *       no corruption path exists because schemaVersion is the top-level
  *       discriminator.
+ *   3 — L7 Phase 2 Finale C3: adds optional `compatibilityReport` field so
+ *       the warm-Plan-B short-circuit can skip `buildCompatibilityReport`
+ *       (~60–100 ms on extra-large). `generatedAt` inside the cached report
+ *       is pinned to a fixed sentinel (`"__cache_normalized__"`) at
+ *       prerender write time so two sequential prerenders produce
+ *       byte-identical envelopes. The field is optional — v3 envelopes
+ *       written without the report are still valid; readers fall through
+ *       to the live `buildCompatibilityReport` call. v2 envelopes are
+ *       rejected cleanly on v3 readers (schemaVersion mismatch).
  */
-export const LAYCACHE_SCHEMA_VERSION = 2 as const;
+export const LAYCACHE_SCHEMA_VERSION = 3 as const;