@beyondwork/docx-react-component 1.0.134 → 1.0.136

package/dist/index.cjs

@@ -12983,10 +12983,16 @@ var FormattingContextImpl = class {
   // surface-projection calls `resolveParagraphCascade` on the same
   // paragraph via `resolveParagraph` + numbering resolve + marker-rPr;
   // each of those re-walked the style catalog before.
-  paragraphCascadeCache = /* @__PURE__ */ new WeakMap();
+  //
+  // Defaults to a per-context instance, but the runtime can supply a
+  // persistent `WeakMap` via `FormattingContextOptions.paragraphCascadeCache`
+  // so unchanged paragraphs don't re-cascade on every keystroke. See the
+  // contract on the option for invalidation semantics.
+  paragraphCascadeCache;
   constructor(doc, opts) {
     this.doc = doc;
     this.opts = opts;
+    this.paragraphCascadeCache = opts.paragraphCascadeCache ?? /* @__PURE__ */ new WeakMap();
     const canonicalTheme = doc.subParts?.canonicalTheme;
     this.theme = opts.themeResolver ?? (canonicalTheme ? new ThemeColorResolver(canonicalTheme) : void 0);
     this.numbering = opts.numberingPrefixResolver ?? createNumberingPrefixResolver(doc.numbering);
@@ -13552,7 +13558,8 @@ function createEditorSurfaceSnapshot(document2, _selection, activeStory = { kind
   const formattingContext = createFormattingContext(document2, {
     ...options.revisionMarkupMode ? { revisionMarkupMode: options.revisionMarkupMode } : {},
     ...options.getEffectiveMarkupMode ? { getEffectiveMarkupMode: options.getEffectiveMarkupMode } : {},
-    ...options.authorColorPalette ? { authorColorPalette: options.authorColorPalette } : {}
+    ...options.authorColorPalette ? { authorColorPalette: options.authorColorPalette } : {},
+    ...options.paragraphCascadeCache ? { paragraphCascadeCache: options.paragraphCascadeCache } : {}
   });
   const editableTargetsByBlockPath = options.editableTargetsByBlockPath ?? indexEditableTargetsByBlockPath(document2);
   const layoutIdentitiesByBlockPath = options.layoutIdentitiesByBlockPath;
@@ -22575,6 +22582,8 @@ function buildSearchPattern(query, options = {}) {
 function findSearchMatches(text, query, options = {}) {
   const pattern = buildSearchPattern(query, options);
   if (!pattern) return [];
+  const limit = normalizeSearchLimit(options.limit);
+  if (limit === 0) return [];
   const results = [];
   let match;
   pattern.lastIndex = 0;
@@ -22585,12 +22594,21 @@ function findSearchMatches(text, query, options = {}) {
       text: match[0],
       index: results.length
     });
+    if (results.length >= limit) {
+      break;
+    }
     if (match[0].length === 0) {
       pattern.lastIndex += 1;
     }
   }
   return results;
 }
+function normalizeSearchLimit(limit) {
+  if (limit === void 0 || !Number.isFinite(limit)) {
+    return Number.POSITIVE_INFINITY;
+  }
+  return Math.max(0, Math.floor(limit));
+}
 function createSearchExcerpt(text, from, to, radius = 24) {
   const safeFrom = Math.max(0, Math.min(from, text.length));
   const safeTo = Math.max(safeFrom, Math.min(to, text.length));
@@ -24362,6 +24380,106 @@ function setStartOverride(catalog, numberingInstanceId, level, startAt) {
     overrides: mergeOverride(instance.overrides, { level, startAt })
   };
 }
+function mergeFragmentNumberingCatalog(target, fragment) {
+  const catalog = cloneNumberingCatalog(target);
+  const abstractIdMap = /* @__PURE__ */ new Map();
+  const instanceIdMap = /* @__PURE__ */ new Map();
+  const picBulletIdMap = /* @__PURE__ */ new Map();
+  if (!fragment) {
+    return { catalog, abstractIdMap, instanceIdMap, picBulletIdMap };
+  }
+  for (const [picBulletId, entry] of Object.entries(fragment.numPicBullets ?? {})) {
+    const mappedId = mapPicBulletId(catalog, picBulletId, entry);
+    picBulletIdMap.set(picBulletId, mappedId);
+  }
+  for (const [abstractId, definition] of Object.entries(fragment.abstractDefinitions)) {
+    const mappedId = mapAbstractDefinition(catalog, definition, picBulletIdMap);
+    abstractIdMap.set(abstractId, mappedId);
+  }
+  for (const [instanceId, instance] of Object.entries(fragment.instances)) {
+    const mappedAbstractId = abstractIdMap.get(instance.abstractNumberingId) ?? instance.abstractNumberingId;
+    const mappedId = mapNumberingInstance(
+      catalog,
+      instance,
+      mappedAbstractId,
+      picBulletIdMap
+    );
+    instanceIdMap.set(instanceId, mappedId);
+  }
+  return { catalog, abstractIdMap, instanceIdMap, picBulletIdMap };
+}
+function mapPicBulletId(catalog, picBulletId, entry) {
+  const existing = catalog.numPicBullets?.[picBulletId];
+  if (existing && existing.rawXml === entry.rawXml) return picBulletId;
+  const mappedId = existing ? nextNumericString(Object.keys(catalog.numPicBullets ?? {})) : picBulletId;
+  const numPicBullets = { ...catalog.numPicBullets ?? {} };
+  numPicBullets[mappedId] = {
+    ...stripSourceRef(structuredClone(entry)),
+    numPicBulletId: mappedId
+  };
+  catalog.numPicBullets = numPicBullets;
+  return mappedId;
+}
+function mapAbstractDefinition(catalog, definition, picBulletIdMap) {
+  const existing = catalog.abstractDefinitions[definition.abstractNumberingId];
+  if (existing && sameJson(comparableAbstract(existing), comparableAbstract(definition))) {
+    return definition.abstractNumberingId;
+  }
+  const mappedId = existing ? nextCanonicalNumericId("abstract-num:", Object.keys(catalog.abstractDefinitions)) : definition.abstractNumberingId;
+  catalog.abstractDefinitions[mappedId] = {
+    ...stripSourceRef(structuredClone(definition)),
+    abstractNumberingId: mappedId,
+    nsid: freshLongHex(catalog, mappedId, "nsid"),
+    tplc: freshLongHex(catalog, mappedId, "tmpl"),
+    levels: definition.levels.map((level) => remapLevelPicBullet(level, picBulletIdMap))
+  };
+  return mappedId;
+}
+function mapNumberingInstance(catalog, instance, abstractNumberingId, picBulletIdMap) {
+  const existing = catalog.instances[instance.numberingInstanceId];
+  const candidate = {
+    ...instance,
+    abstractNumberingId,
+    overrides: instance.overrides.map(
+      (override) => remapOverridePicBullet(override, picBulletIdMap)
+    )
+  };
+  if (existing && sameJson(comparableInstance(existing), comparableInstance(candidate))) {
+    return instance.numberingInstanceId;
+  }
+  const mappedId = existing ? nextCanonicalNumericId("num:", Object.keys(catalog.instances)) : instance.numberingInstanceId;
+  catalog.instances[mappedId] = {
+    ...stripSourceRef(structuredClone(instance)),
+    overrides: candidate.overrides.map((override) => stripOverrideSourceRefs(override)),
+    numberingInstanceId: mappedId,
+    abstractNumberingId
+  };
+  return mappedId;
+}
+function remapLevelPicBullet(level, picBulletIdMap) {
+  const cloned = stripSourceRef(structuredClone(level));
+  if (!level.picBulletId) return cloned;
+  return {
+    ...cloned,
+    picBulletId: picBulletIdMap.get(level.picBulletId) ?? level.picBulletId
+  };
+}
+function remapOverridePicBullet(override, picBulletIdMap) {
+  const cloned = stripOverrideSourceRefs(structuredClone(override));
+  if (!override.levelDefinition) return cloned;
+  return {
+    ...cloned,
+    levelDefinition: remapLevelPicBullet(override.levelDefinition, picBulletIdMap)
+  };
+}
+function stripOverrideSourceRefs(override) {
+  const cloned = stripSourceRef(override);
+  if (!override.levelDefinition) return cloned;
+  return {
+    ...cloned,
+    levelDefinition: stripSourceRef(override.levelDefinition)
+  };
+}
 function mergeOverride(overrides, nextOverride) {
   return [
     ...overrides.filter((override) => override.level !== nextOverride.level),
@@ -24433,6 +24551,28 @@ function hashLongHex(input) {
   }
   return hash.toString(16).toUpperCase().padStart(8, "0").slice(-8);
 }
+function stripSourceRef(value) {
+  const { sourceRef: _sourceRef, ...rest } = value;
+  return rest;
+}
+function comparableAbstract(definition) {
+  return {
+    ...stripSourceRef(definition),
+    levels: definition.levels.map((level) => stripSourceRef(level))
+  };
+}
+function comparableInstance(instance) {
+  return {
+    ...stripSourceRef(instance),
+    overrides: instance.overrides.map((override) => ({
+      ...stripSourceRef(override),
+      ...override.levelDefinition ? { levelDefinition: stripSourceRef(override.levelDefinition) } : {}
+    }))
+  };
+}
+function sameJson(left, right) {
+  return JSON.stringify(left) === JSON.stringify(right);
+}
 
 // src/core/commands/list-commands.ts
 function toggleNumberedList(document2, paragraphIndexes, context, options = {}) {
@@ -24480,7 +24620,7 @@ function splitListParagraph(document2, paragraphIndex, paragraphIsEmpty, context
       action: "split"
     };
   }
-  const target = paragraphs[resolvedParagraphIndex];
+  const target = paragraphs[resolvedParagraphIndex]?.paragraph;
   if (!target?.numbering) {
     return {
       document: working,
@@ -24532,7 +24672,7 @@ function backspaceAtListStart(document2, paragraphIndex, context, options = {})
       handled: false
     };
   }
-  const target = paragraphs[resolvedParagraphIndex];
+  const target = paragraphs[resolvedParagraphIndex]?.paragraph;
   if (!target?.numbering) {
     return {
       document: working,
@@ -24578,7 +24718,7 @@ function restartNumbering(document2, paragraphIndex, context, startAt = 1, optio
       affectedParagraphIndexes: []
     };
   }
-  const target = paragraphs[resolvedParagraphIndex];
+  const target = paragraphs[resolvedParagraphIndex]?.paragraph;
   if (!target?.numbering) {
     return {
       document: working,
@@ -24600,8 +24740,13 @@ function restartNumbering(document2, paragraphIndex, context, startAt = 1, optio
   );
   setStartOverride(catalog, numberingInstanceId, target.numbering.level, startAt);
   const affectedParagraphIndexes = [];
+  const targetStoryKey = paragraphs[resolvedParagraphIndex]?.storyKey;
   for (let index = resolvedParagraphIndex; index < paragraphs.length; index += 1) {
-    const paragraph = paragraphs[index];
+    const entry = paragraphs[index];
+    if (entry?.storyKey !== targetStoryKey) {
+      break;
+    }
+    const paragraph = entry.paragraph;
     if (!paragraph?.numbering) {
       break;
     }
@@ -24645,7 +24790,7 @@ function continueNumbering(document2, paragraphIndex, context, options = {}) {
       affectedParagraphIndexes: []
     };
   }
-  const target = paragraphs[resolvedParagraphIndex];
+  const target = paragraphs[resolvedParagraphIndex]?.paragraph;
   if (!target?.numbering) {
     return {
       document: working,
@@ -24674,8 +24819,13 @@ function continueNumbering(document2, paragraphIndex, context, options = {}) {
     };
   }
   const affectedParagraphIndexes = [];
+  const targetStoryKey = paragraphs[resolvedParagraphIndex]?.storyKey;
   for (let index = resolvedParagraphIndex; index < paragraphs.length; index += 1) {
-    const paragraph = paragraphs[index];
+    const entry = paragraphs[index];
+    if (entry?.storyKey !== targetStoryKey) {
+      break;
+    }
+    const paragraph = entry.paragraph;
     if (!paragraph?.numbering) {
       break;
     }
@@ -24721,12 +24871,13 @@ function toggleListKind(document2, paragraphIndexes, kind, context, options) {
   }
   const catalog = cloneNumberingCatalog(working.numbering);
   const allAlreadyKind = normalizedIndexes.every((index) => {
-    const paragraph = paragraphs[index];
-    return paragraph.numbering ? getListKind(catalog, paragraph.numbering.numberingInstanceId) === kind : false;
+    const paragraph = paragraphs[index]?.paragraph;
+    return paragraph?.numbering ? getListKind(catalog, paragraph.numbering.numberingInstanceId) === kind : false;
   });
   if (allAlreadyKind) {
     for (const index of normalizedIndexes) {
-      delete paragraphs[index].numbering;
+      const paragraph = paragraphs[index]?.paragraph;
+      if (paragraph) delete paragraph.numbering;
     }
     working.numbering = catalog;
     return {
@@ -24736,7 +24887,8 @@ function toggleListKind(document2, paragraphIndexes, kind, context, options) {
   }
   const numberingInstanceId = findAdjacentCompatibleInstance(paragraphs, catalog, normalizedIndexes[0], kind) ?? ensureDefaultListInstance(catalog, kind);
   for (const index of normalizedIndexes) {
-    const paragraph = paragraphs[index];
+    const paragraph = paragraphs[index]?.paragraph;
+    if (!paragraph) continue;
     paragraph.numbering = {
       numberingInstanceId,
       level: clampLevel(paragraph.numbering?.level ?? 0)
@@ -24767,10 +24919,11 @@ function adjustListLevels(document2, paragraphIndexes, delta, context, options)
     };
   }
   const affectedParagraphIndexes = resolved.paragraphIndexes.filter(
-    (index) => Boolean(paragraphs[index]?.numbering)
+    (index) => Boolean(paragraphs[index]?.paragraph.numbering)
   );
   for (const index of affectedParagraphIndexes) {
-    const paragraph = paragraphs[index];
+    const paragraph = paragraphs[index]?.paragraph;
+    if (!paragraph) continue;
     if (!paragraph.numbering) {
       continue;
     }
@@ -24790,17 +24943,21 @@ function normalizeListCommandTargets(options) {
 }
 function resolveListCommandParagraphIndexes(document2, paragraphs, paragraphIndexes, context, editableTargets) {
   if (editableTargets.length === 0) {
-    return { paragraphIndexes: normalizeParagraphIndexes(paragraphs, paragraphIndexes) };
+    return {
+      paragraphIndexes: normalizeParagraphIndexesForStory(
+        paragraphs,
+        paragraphIndexes,
+        context.activeStoryKey
+      )
+    };
   }
   const currentTargets = collectEditableTargetRefs(document2, context.editableTargetCache);
-  const paragraphIndexByTargetKey = /* @__PURE__ */ new Map();
-  let paragraphIndex = 0;
-  for (const target of currentTargets) {
-    if (!isParagraphTextTarget(target)) continue;
-    if (!paragraphIndexByTargetKey.has(target.targetKey)) {
-      paragraphIndexByTargetKey.set(target.targetKey, paragraphIndex);
-      paragraphIndex += 1;
-    }
+  const paragraphIndexByAddress = /* @__PURE__ */ new Map();
+  for (let index = 0; index < paragraphs.length; index += 1) {
+    const entry = paragraphs[index];
+    if (!entry) continue;
+    paragraphIndexByAddress.set(`${entry.storyKey}
+${entry.blockPath}`, index);
   }
   const resolvedIndexes = [];
   for (const target of editableTargets) {
@@ -24825,7 +24982,8 @@ function resolveListCommandParagraphIndexes(document2, paragraphs, paragraphInde
         }
       };
     }
-    const currentIndex = paragraphIndexByTargetKey.get(current.targetKey);
+    const currentIndex = paragraphIndexByAddress.get(`${current.storyKey}
+${current.blockPath}`);
     if (currentIndex === void 0) {
       return {
         paragraphIndexes: [],
@@ -24900,18 +25058,28 @@ function sortJson(value) {
   return value;
 }
 function findAdjacentCompatibleInstance(paragraphs, catalog, fromIndex, kind) {
+  const current = paragraphs[fromIndex];
   const previous = paragraphs[fromIndex - 1];
-  if (previous?.numbering) {
-    const previousKind = getListKind(catalog, previous.numbering.numberingInstanceId);
+  if (previous?.storyKey !== current?.storyKey) {
+    return void 0;
+  }
+  const previousParagraph = previous?.paragraph;
+  if (previousParagraph?.numbering) {
+    const previousKind = getListKind(catalog, previousParagraph.numbering.numberingInstanceId);
     if (previousKind === kind) {
-      return previous.numbering.numberingInstanceId;
+      return previousParagraph.numbering.numberingInstanceId;
     }
   }
   return void 0;
 }
 function findPreviousCompatibleInstance(paragraphs, catalog, fromIndex, kind) {
+  const storyKey2 = paragraphs[fromIndex]?.storyKey;
   for (let index = fromIndex - 1; index >= 0; index -= 1) {
-    const paragraph = paragraphs[index];
+    const entry = paragraphs[index];
+    if (entry?.storyKey !== storyKey2) {
+      break;
+    }
+    const paragraph = entry.paragraph;
     if (!paragraph?.numbering) {
       continue;
     }
@@ -24930,7 +25098,14 @@ function cloneEnvelope(document2, timestamp) {
 function captureEditableParagraphs(document2) {
   if (isDocumentRoot(document2.content)) {
     const paragraphs = [];
-    collectEditableParagraphs(document2.content.children, paragraphs);
+    for (const context of collectStoryBlockContexts(document2)) {
+      collectEditableParagraphs(
+        context.blocks,
+        paragraphs,
+        context.storyKey,
+        context.basePath
+      );
+    }
     return paragraphs;
   }
   const fallback = {
@@ -24938,23 +25113,39 @@ function captureEditableParagraphs(document2) {
     children: [{ type: "paragraph", children: [] }]
   };
   document2.content = fallback;
-  return fallback.children;
+  return [{
+    paragraph: fallback.children[0],
+    storyKey: "main",
+    blockPath: "main/block[0]"
+  }];
 }
-function collectEditableParagraphs(blocks, output) {
-  for (const block of blocks) {
+function collectEditableParagraphs(blocks, output, storyKey2, basePath) {
+  for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
+    const block = blocks[blockIndex];
+    if (!block) continue;
+    const blockPath = `${basePath}/block[${blockIndex}]`;
     switch (block.type) {
       case "paragraph":
-        output.push(block);
+        output.push({ paragraph: block, storyKey: storyKey2, blockPath });
         break;
       case "table":
-        for (const row2 of block.rows) {
-          for (const cell of row2.cells) {
-            collectEditableParagraphs(cell.children, output);
+        for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
+          const row2 = block.rows[rowIndex];
+          if (!row2) continue;
+          for (let cellIndex = 0; cellIndex < row2.cells.length; cellIndex += 1) {
+            const cell = row2.cells[cellIndex];
+            if (!cell) continue;
+            collectEditableParagraphs(
+              cell.children,
+              output,
+              storyKey2,
+              `${blockPath}/row[${rowIndex}]/cell[${cellIndex}]`
+            );
           }
         }
         break;
       case "sdt":
-        collectEditableParagraphs(block.children, output);
+        collectEditableParagraphs(block.children, output, storyKey2, blockPath);
         break;
       case "custom_xml":
         break;
@@ -24966,6 +25157,18 @@ function collectEditableParagraphs(blocks, output) {
 function normalizeParagraphIndexes(paragraphs, paragraphIndexes) {
   return [...new Set(paragraphIndexes)].filter((index) => Number.isInteger(index) && index >= 0 && index < paragraphs.length).sort((left, right) => left - right);
 }
+function normalizeParagraphIndexesForStory(paragraphs, paragraphIndexes, storyKey2) {
+  if (storyKey2 === void 0) {
+    return normalizeParagraphIndexes(paragraphs, paragraphIndexes);
+  }
+  const storyParagraphIndexes = [];
+  for (let index = 0; index < paragraphs.length; index += 1) {
+    if (paragraphs[index]?.storyKey === storyKey2) {
+      storyParagraphIndexes.push(index);
+    }
+  }
+  return [...new Set(paragraphIndexes)].filter((index) => Number.isInteger(index) && index >= 0 && index < storyParagraphIndexes.length).map((index) => storyParagraphIndexes[index]).sort((left, right) => left - right);
+}
 function clampLevel(level) {
   return Math.max(0, Math.min(8, level));
 }
@@ -31261,9 +31464,9 @@ function findTableStructureTargetForSelection(document2, descriptor, operation2,
   if (descriptor.editability === "non-editable" && descriptor.nonEditableReason !== "nested-table-not-editable") {
     return null;
   }
-  const activeStoryKey = editableTargetStoryKey(activeStory);
+  const activeStoryKey2 = editableTargetStoryKey(activeStory);
   const targets = collectEditableTargetRefs(document2).filter(
-    (target) => target.commandFamily === "table-structure" && target.table !== void 0 && target.storyKey === activeStoryKey && tableStructureTargetMatchesDescriptor2(target, descriptor)
+    (target) => target.commandFamily === "table-structure" && target.table !== void 0 && target.storyKey === activeStoryKey2 && tableStructureTargetMatchesDescriptor2(target, descriptor)
   );
   const scope = preferredTableStructureScope(operation2);
   return targets.find((target) => {
@@ -36526,8 +36729,9 @@ function applyFragmentInsert(document2, selection, fragment, context) {
     workingDocument = collapseResult.document;
     workingSelection = collapseResult.selection;
     if (context.textTarget?.kind === "table-paragraph" || context.textTarget?.kind === "text-leaf") {
+      const { precomputedSurface: _precomputedSurface, ...contextWithoutPrecomputedSurface } = context;
       workingContext = {
-        ...context,
+        ...contextWithoutPrecomputedSurface,
         textTarget: {
           ...context.textTarget,
           paragraphEnd: Math.max(
@@ -36539,7 +36743,11 @@ function applyFragmentInsert(document2, selection, fragment, context) {
     }
   }
   const splitResult = splitParagraph(workingDocument, workingSelection, workingContext);
-  const splitRoot = splitResult.document.content;
+  const preparedFragment = prepareFragmentNumberingForInsertion(
+    splitResult.document,
+    fragment
+  );
+  const splitRoot = preparedFragment.document.content;
   if (!splitRoot || splitRoot.type !== "doc") {
     return {
       changed: false,
@@ -36550,9 +36758,9 @@ function applyFragmentInsert(document2, selection, fragment, context) {
   const targetedBlockPath = workingContext.textTarget?.kind === "table-paragraph" || workingContext.textTarget?.kind === "text-leaf" ? workingContext.textTarget.blockPath : void 0;
   if (targetedBlockPath) {
     const targeted = insertFragmentBlocksAfterPath(
-      splitResult.document,
+      preparedFragment.document,
       targetedBlockPath,
-      fragment.blocks
+      preparedFragment.blocks
     );
     if (targeted) {
       return {
@@ -36584,7 +36792,7 @@ function applyFragmentInsert(document2, selection, fragment, context) {
   const rightHalfIndex = scope.blockIndex + 1;
   const splicedChildren = [
     ...splitRoot.children.slice(0, rightHalfIndex),
-    ...fragment.blocks.map((block) => cloneBlock(block)),
+    ...preparedFragment.blocks.map((block) => cloneBlock(block)),
     ...splitRoot.children.slice(rightHalfIndex)
   ];
   const nextRoot = {
@@ -36592,7 +36800,7 @@ function applyFragmentInsert(document2, selection, fragment, context) {
     children: splicedChildren
   };
   const nextDocument = {
-    ...splitResult.document,
+    ...preparedFragment.document,
     updatedAt: context.timestamp,
     content: nextRoot
   };
@@ -36604,14 +36812,47 @@ function applyFragmentInsert(document2, selection, fragment, context) {
     mapping: createEmptyMapping()
   };
 }
-function cloneBlock(block) {
-  if (block.type === "paragraph") {
-    return {
-      ...block,
-      children: block.children.map((child) => ({ ...child }))
+function prepareFragmentNumberingForInsertion(document2, fragment) {
+  if (!fragment.numbering) {
+    return { document: document2, blocks: fragment.blocks };
+  }
+  const merged = mergeFragmentNumberingCatalog(document2.numbering, fragment.numbering);
+  return {
+    document: {
+      ...document2,
+      numbering: merged.catalog
+    },
+    blocks: fragment.blocks.map((block) => cloneBlock(block, merged.instanceIdMap))
+  };
+}
+function cloneBlock(block, numberingInstanceIdMap) {
+  const cloned = structuredClone(block);
+  remapNumberingReferences(cloned, numberingInstanceIdMap);
+  return cloned;
+}
+function remapNumberingReferences(value, numberingInstanceIdMap) {
+  if (!numberingInstanceIdMap?.size || !value || typeof value !== "object") {
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const entry of value) {
+      remapNumberingReferences(entry, numberingInstanceIdMap);
+    }
+    return;
+  }
+  const record = value;
+  if (record.numbering?.numberingInstanceId) {
+    const mappedId = numberingInstanceIdMap.get(record.numbering.numberingInstanceId) ?? record.numbering.numberingInstanceId;
+    record.numbering = {
+      ...record.numbering,
+      numberingInstanceId: mappedId
     };
   }
-  return JSON.parse(JSON.stringify(block));
+  remapNumberingReferences(record.children, numberingInstanceIdMap);
+  remapNumberingReferences(record.rows, numberingInstanceIdMap);
+  remapNumberingReferences(record.cells, numberingInstanceIdMap);
+  remapNumberingReferences(record.txbxBlocks, numberingInstanceIdMap);
+  remapNumberingReferences(record.content, numberingInstanceIdMap);
 }
 function insertFragmentBlocksAfterPath(document2, blockPath, fragmentBlocks) {
   const tokens = parseCanonicalBlockPath2(blockPath);
@@ -56458,6 +56699,16 @@ function coerceIssueValue2(value) {
 function insertScopeMarkers(document2, params) {
   const { scopeId } = params;
   const root = document2.content;
+  if (!Number.isFinite(params.from) || !Number.isFinite(params.to)) {
+    const from = Number.isFinite(params.from) ? params.from : 0;
+    const to = Number.isFinite(params.to) ? params.to : from;
+    return {
+      status: "non-finite-range",
+      scopeId,
+      from,
+      to
+    };
+  }
   const normalizedFrom = Math.min(params.from, params.to);
   const normalizedTo = Math.max(params.from, params.to);
   if (!root || root.type !== "doc" || root.children.length === 0) {
@@ -56910,6 +57161,14 @@ function isRecord3(value) {
 }
 
 // src/runtime/workflow/coordinator.ts
+function createScopeMarkerMutationMapping() {
+  return {
+    steps: [],
+    metadata: {
+      layoutNeutralScopeMarkers: true
+    }
+  };
+}
 var MODE_RESTRICTIVENESS = {
   edit: 0,
   suggest: 1,
@@ -57101,12 +57360,12 @@ function createWorkflowCoordinator(deps) {
   function getCachedInteractionGuardSnapshot() {
     const state = deps.getState();
     const activeStory = deps.getActiveStory();
-    const activeStoryKey = storyTargetKey(activeStory);
+    const activeStoryKey2 = storyTargetKey(activeStory);
     const protectionSnapshot = deps.getProtectionSnapshot();
     const documentMode = deps.getDocumentMode();
     const overlay = overlayStore.getOverlay();
     const sharedWorkflowState = overlayStore.getSharedWorkflowState();
-    if (cachedInteractionGuardSnapshot && cachedInteractionGuardSnapshot.activeStoryKey === activeStoryKey && cachedInteractionGuardSnapshot.selection === state.selection && cachedInteractionGuardSnapshot.readOnly === state.readOnly && cachedInteractionGuardSnapshot.documentMode === documentMode && cachedInteractionGuardSnapshot.protectionSnapshot === protectionSnapshot && cachedInteractionGuardSnapshot.overlay === overlay && cachedInteractionGuardSnapshot.sharedWorkflowState === sharedWorkflowState) {
+    if (cachedInteractionGuardSnapshot && cachedInteractionGuardSnapshot.activeStoryKey === activeStoryKey2 && cachedInteractionGuardSnapshot.selection === state.selection && cachedInteractionGuardSnapshot.readOnly === state.readOnly && cachedInteractionGuardSnapshot.documentMode === documentMode && cachedInteractionGuardSnapshot.protectionSnapshot === protectionSnapshot && cachedInteractionGuardSnapshot.overlay === overlay && cachedInteractionGuardSnapshot.sharedWorkflowState === sharedWorkflowState) {
       return cachedInteractionGuardSnapshot.snapshot;
     }
     const blockedReasons = evaluateBlockedReasons(state.selection);
@@ -57147,7 +57406,7 @@ function createWorkflowCoordinator(deps) {
       blockedReasons
     };
     cachedInteractionGuardSnapshot = {
-      activeStoryKey,
+      activeStoryKey: activeStoryKey2,
       selection: state.selection,
       readOnly: state.readOnly,
       documentMode,
@@ -57176,13 +57435,13 @@ function createWorkflowCoordinator(deps) {
   function getCachedWorkflowMarkupSnapshot() {
     const state = deps.getState();
     const activeStory = deps.getActiveStory();
-    const activeStoryKey = storyTargetKey(activeStory);
+    const activeStoryKey2 = storyTargetKey(activeStory);
     const protectionSnapshot = deps.getProtectionSnapshot();
     const preservation = deps.getDocument().preservation;
     const overlay = overlayStore.getOverlay();
     const metadataDefinitions = overlayStore.getMetadataDefinitions();
     const metadataEntries = overlayStore.getMetadataEntries();
-    if (cachedWorkflowMarkupSnapshot && cachedWorkflowMarkupSnapshot.activeStoryKey === activeStoryKey && cachedWorkflowMarkupSnapshot.protectionSnapshot === protectionSnapshot && cachedWorkflowMarkupSnapshot.preservation === preservation && cachedWorkflowMarkupSnapshot.overlay === overlay && cachedWorkflowMarkupSnapshot.metadataDefinitions === metadataDefinitions && cachedWorkflowMarkupSnapshot.metadataEntries === metadataEntries) {
+    if (cachedWorkflowMarkupSnapshot && cachedWorkflowMarkupSnapshot.activeStoryKey === activeStoryKey2 && cachedWorkflowMarkupSnapshot.protectionSnapshot === protectionSnapshot && cachedWorkflowMarkupSnapshot.preservation === preservation && cachedWorkflowMarkupSnapshot.overlay === overlay && cachedWorkflowMarkupSnapshot.metadataDefinitions === metadataDefinitions && cachedWorkflowMarkupSnapshot.metadataEntries === metadataEntries) {
       return cachedWorkflowMarkupSnapshot.snapshot;
     }
     const snapshot = collectWorkflowMarkupSnapshot({
@@ -57193,7 +57452,7 @@ function createWorkflowCoordinator(deps) {
       workflowMetadataSnapshot: overlayStore.getMetadataSnapshot()
     });
     cachedWorkflowMarkupSnapshot = {
-      activeStoryKey,
+      activeStoryKey: activeStoryKey2,
       protectionSnapshot,
       preservation,
       overlay,
@@ -57217,6 +57476,60 @@ function createWorkflowCoordinator(deps) {
       activeStory: deps.getActiveStory()
     };
   }
+  function createPlantFailureResult(input) {
+    const { scopeId, anchor, assoc, plantResult } = input;
+    return {
+      scopeId: "",
+      anchor: {
+        kind: "range",
+        from: anchor.from,
+        to: anchor.to,
+        assoc
+      },
+      plantStatus: {
+        planted: false,
+        reason: plantResult.status,
+        ...plantResult.status === "non-paragraph-target" ? {
+          blockIndex: plantResult.blockIndex,
+          blockKind: plantResult.blockKind
+        } : {},
+        ...plantResult.status === "range-out-of-bounds" ? { storyLength: plantResult.storyLength } : {},
+        requestedFrom: plantResult.from,
+        requestedTo: plantResult.to
+      }
+    };
+  }
+  function buildWorkflowScope(input) {
+    const { params, scopeId, publicAnchor } = input;
+    return {
+      scopeId,
+      mode: params.mode ?? "comment",
+      anchor: publicAnchor,
+      ...params.storyTarget ? { storyTarget: params.storyTarget } : {},
+      ...params.label ? { label: params.label } : {},
+      ...params.visibility ? { visibility: params.visibility } : {},
+      ...params.guardPolicy ? { guardPolicy: params.guardPolicy } : {},
+      ...params.scopeMetadataFields && params.scopeMetadataFields.length > 0 ? { metadata: [...params.scopeMetadataFields] } : {}
+    };
+  }
+  function buildWorkflowMetadataEntry(input) {
+    const { params, scopeId, publicAnchor } = input;
+    if (!params.persistence || params.persistence === "runtime-only") return null;
+    const requestedMetadata = params.metadata ?? {};
+    const entryPersistence = requestedMetadata.metadataPersistence ?? (params.persistence === "session" ? "external" : "internal");
+    return {
+      entryId: requestedMetadata.entryId ?? `scope-metadata-${scopeId}`,
+      metadataId: requestedMetadata.metadataId ?? "workflow.scope",
+      anchor: publicAnchor,
+      ...params.storyTarget ? { storyTarget: params.storyTarget } : {},
+      scopeId,
+      ...requestedMetadata.workItemId ? { workItemId: requestedMetadata.workItemId } : {},
+      ...requestedMetadata.value !== void 0 ? { value: requestedMetadata.value } : params.persistence === "document-metadata" && params.label ? { value: { label: params.label } } : {},
+      metadataPersistence: entryPersistence,
+      ...requestedMetadata.storageRef !== void 0 ? { storageRef: requestedMetadata.storageRef } : {},
+      ...requestedMetadata.metadataVersion !== void 0 ? { metadataVersion: requestedMetadata.metadataVersion } : {}
+    };
+  }
   function addScope(params) {
     const state = deps.getState();
     const scopeId = params.scopeId ?? `scope-${clock().replace(/[^0-9]/gu, "")}-${Math.floor(Math.random() * 1e6)}`;
@@ -57259,6 +57572,7 @@ function createWorkflowCoordinator(deps) {
     deps.dispatch({
       type: "document.replace",
       document: nextDocument,
+      mapping: createScopeMarkerMutationMapping(),
       origin: { source: "api", at: clock() }
     });
     const callerAssoc = params.anchor.kind === "range" ? params.anchor.assoc : { start: -1, end: 1 };
@@ -57315,6 +57629,84 @@ function createWorkflowCoordinator(deps) {
     }
     return { scopeId, anchor: publicAnchor };
   }
+  function addScopes(paramsList) {
+    if (paramsList.length === 0) return [];
+    let nextDocument = deps.getDocument();
+    let documentChanged = false;
+    const results = [];
+    const scopesToAdd = [];
+    const metadataEntriesToAdd = [];
+    const newScopeIds = /* @__PURE__ */ new Set();
+    for (const params of paramsList) {
+      const scopeId = params.scopeId ?? `scope-${clock().replace(/[^0-9]/gu, "")}-${Math.floor(Math.random() * 1e6)}`;
+      const anchor = params.anchor.kind === "range" ? { from: params.anchor.from, to: params.anchor.to } : null;
+      if (!anchor) {
+        results.push({ scopeId, anchor: params.anchor });
+        continue;
+      }
+      const callerAssoc = params.anchor.kind === "range" ? params.anchor.assoc : { start: -1, end: 1 };
+      const plantResult = insertScopeMarkers(nextDocument, {
+        scopeId,
+        from: anchor.from,
+        to: anchor.to
+      });
+      if (plantResult.status !== "planted") {
+        results.push(
+          createPlantFailureResult({
+            scopeId,
+            anchor,
+            assoc: callerAssoc,
+            plantResult
+          })
+        );
+        continue;
+      }
+      nextDocument = plantResult.document;
+      documentChanged = true;
+      const publicAnchor = {
+        kind: "range",
+        from: plantResult.plantedRange.from,
+        to: plantResult.plantedRange.to,
+        assoc: callerAssoc
+      };
+      newScopeIds.add(scopeId);
+      scopesToAdd.push(buildWorkflowScope({ params, scopeId, publicAnchor }));
+      const entry = buildWorkflowMetadataEntry({ params, scopeId, publicAnchor });
+      if (entry) metadataEntriesToAdd.push(entry);
+      results.push({ scopeId, anchor: publicAnchor });
+    }
+    if (documentChanged) {
+      deps.dispatch({
+        type: "document.replace",
+        document: nextDocument,
+        mapping: createScopeMarkerMutationMapping(),
+        origin: { source: "api", at: clock() }
+      });
+    }
+    if (scopesToAdd.length > 0) {
+      const currentOverlay = overlayStore.getOverlay() ?? {
+        overlayVersion: "workflow-overlay/1",
+        scopes: []
+      };
+      const existingScopes = currentOverlay.scopes.filter(
+        (existing) => !newScopeIds.has(existing.scopeId)
+      );
+      deps.dispatch({
+        type: "workflow.set-overlay",
+        overlay: { ...currentOverlay, scopes: [...existingScopes, ...scopesToAdd] },
+        origin: { source: "api", at: clock() }
+      });
+    }
+    if (metadataEntriesToAdd.length > 0) {
+      const priorEntries = overlayStore.getMetadataEntries();
+      deps.dispatch({
+        type: "workflow.set-metadata-entries",
+        entries: [...priorEntries, ...metadataEntriesToAdd],
+        origin: { source: "api", at: clock() }
+      });
+    }
+    return results;
+  }
   function removeScope(scopeId) {
     const overlay = overlayStore.getOverlay();
     if (overlay) {
@@ -57332,6 +57724,7 @@ function createWorkflowCoordinator(deps) {
       deps.dispatch({
         type: "document.replace",
         document: nextDocument,
+        mapping: createScopeMarkerMutationMapping(),
         origin: { source: "api", at: clock() }
       });
     }
@@ -57725,6 +58118,7 @@ function createWorkflowCoordinator(deps) {
   }
   return {
     addScope,
+    addScopes,
     removeScope,
     addInvisibleScope,
     setScopeVisibility,
@@ -69706,8 +70100,8 @@ function resolveEditableTextTarget(input) {
       `Editable target ref is malformed: ${shapeIssues[0]?.path ?? "$"}.`
     );
   }
-  const activeStoryKey = input.activeStoryKey ?? "main";
-  if (input.target.storyKey !== activeStoryKey) {
+  const activeStoryKey2 = input.activeStoryKey ?? "main";
+  if (input.target.storyKey !== activeStoryKey2) {
     return reject(
       "editable_target_wrong_story",
       "Editable target ref does not belong to the active story."
@@ -69803,8 +70197,8 @@ function resolveEditableCommandTarget(input) {
       `Editable target ref is malformed: ${shapeIssues[0]?.path ?? "$"}.`
     );
   }
-  const activeStoryKey = input.activeStoryKey ?? input.target.storyKey;
-  if (input.target.storyKey !== activeStoryKey) {
+  const activeStoryKey2 = input.activeStoryKey ?? input.target.storyKey;
+  if (input.target.storyKey !== activeStoryKey2) {
     return rejectCommand(
       "editable_target_wrong_story",
       "Editable target ref does not belong to the active story."
@@ -70219,8 +70613,8 @@ function resolveEditableTableStructureTarget(input) {
       `Editable target ref is malformed: ${shapeIssues[0]?.path ?? "$"}.`
     );
   }
-  const activeStoryKey = input.activeStoryKey ?? input.target.storyKey;
-  if (input.target.storyKey !== activeStoryKey) {
+  const activeStoryKey2 = input.activeStoryKey ?? input.target.storyKey;
+  if (input.target.storyKey !== activeStoryKey2) {
     return reject2(
       "editable_target_wrong_story",
       "Editable target ref does not belong to the active story."
@@ -70555,6 +70949,36 @@ function createDocumentRuntime(options) {
   let viewportBlockRanges = null;
   let viewportRangesKey = serializeViewportRanges(viewportBlockRanges);
   let viewportBlocksPerPageEstimate = null;
+  let fullSurfaceWarmupScheduled = false;
+  let fullSurfaceWarmupCompleted = false;
+  function scheduleFullSurfaceWarmupAfterCull() {
+    if (fullSurfaceWarmupScheduled || fullSurfaceWarmupCompleted) return;
+    fullSurfaceWarmupScheduled = true;
+    perfCounters.increment("surface.fullSurfaceWarmup.scheduled");
+    runOnIdle(() => {
+      fullSurfaceWarmupScheduled = false;
+      if (cachedFullSurface) {
+        perfCounters.increment("surface.fullSurfaceWarmup.alreadyCached");
+        fullSurfaceWarmupCompleted = true;
+        return;
+      }
+      const t0 = performance.now();
+      try {
+        getCachedFullSurface(state.document, activeStory);
+        fullSurfaceWarmupCompleted = true;
+        perfCounters.increment("surface.fullSurfaceWarmup.committed");
+      } catch (error) {
+        perfCounters.increment("surface.fullSurfaceWarmup.failed");
+        fullSurfaceWarmupCompleted = false;
+        void error;
+      } finally {
+        perfCounters.increment(
+          "surface.fullSurfaceWarmup.us",
+          Math.round((performance.now() - t0) * 1e3)
+        );
+      }
+    });
+  }
   const getRuntimeForLayoutFacet = () => {
     if (!runtimeRef) {
       throw new Error("Document runtime viewport methods are not initialized");
@@ -70747,6 +71171,15 @@ function createDocumentRuntime(options) {
   let cachedSurface;
   let cachedFullSurface;
   const editableTargetBlockCache = createEditableTargetBlockCache();
+  let paragraphCascadeCache = /* @__PURE__ */ new WeakMap();
+  let paragraphCascadeCacheStylesRef = null;
+  function ensureParagraphCascadeCacheForStyles(nextStyles) {
+    if (paragraphCascadeCacheStylesRef !== nextStyles) {
+      paragraphCascadeCache = /* @__PURE__ */ new WeakMap();
+      paragraphCascadeCacheStylesRef = nextStyles;
+    }
+    return paragraphCascadeCache;
+  }
   let cachedEditableTargetMap = null;
   function getEditableTargetsByBlockPath(document2) {
     if (cachedEditableTargetMap !== null && cachedEditableTargetMap.document === document2) {
@@ -70796,10 +71229,11 @@ function createDocumentRuntime(options) {
     if (cached) {
       return cached;
     }
-    const activeStoryKey = storyTargetKey(nextActiveStory);
+    const activeStoryKey2 = storyTargetKey(nextActiveStory);
     const snapshot = createEditorSurfaceSnapshot(document2, state.selection, nextActiveStory, {
       viewportBlockRanges: null,
       editableTargetsByBlockPath: getEditableTargetsByBlockPath(document2),
+      paragraphCascadeCache: ensureParagraphCascadeCacheForStyles(document2.styles),
       ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
     });
     recordPerfSample("snapshot.surface");
@@ -70813,33 +71247,34 @@ function createDocumentRuntime(options) {
       preservation: document2.preservation,
       review: document2.review,
       effectiveMarkupModeProvider,
-      activeStoryKey,
+      activeStoryKey: activeStoryKey2,
       snapshot
     };
     return snapshot;
   }
   function getReusableCachedFullSurface(document2, nextActiveStory) {
-    const activeStoryKey = storyTargetKey(nextActiveStory);
-    if (cachedFullSurface && cachedFullSurface.content === document2.content && cachedFullSurface.subParts === document2.subParts && cachedFullSurface.styles === document2.styles && cachedFullSurface.numbering === document2.numbering && cachedFullSurface.media === document2.media && cachedFullSurface.preservation === document2.preservation && cachedFullSurface.review === document2.review && cachedFullSurface.effectiveMarkupModeProvider === effectiveMarkupModeProvider && cachedFullSurface.activeStoryKey === activeStoryKey) {
+    const activeStoryKey2 = storyTargetKey(nextActiveStory);
+    if (cachedFullSurface && cachedFullSurface.content === document2.content && cachedFullSurface.subParts === document2.subParts && cachedFullSurface.styles === document2.styles && cachedFullSurface.numbering === document2.numbering && cachedFullSurface.media === document2.media && cachedFullSurface.preservation === document2.preservation && cachedFullSurface.review === document2.review && cachedFullSurface.effectiveMarkupModeProvider === effectiveMarkupModeProvider && cachedFullSurface.activeStoryKey === activeStoryKey2) {
       return cachedFullSurface.snapshot;
     }
     return void 0;
   }
   function getCachedSurface(document2, nextActiveStory, options2 = {}) {
-    const activeStoryKey = storyTargetKey(nextActiveStory);
+    const activeStoryKey2 = storyTargetKey(nextActiveStory);
     const surfaceViewportRanges = "viewportBlockRangesOverride" in options2 ? options2.viewportBlockRangesOverride ?? null : viewportBlockRanges;
     const surfaceViewportRangesKey = "viewportBlockRangesOverride" in options2 ? serializeViewportRanges(surfaceViewportRanges) : viewportRangesKey;
     const surfaceCacheKey = options2.enrichCulledPlaceholders === false ? `${surfaceViewportRangesKey}|raw-placeholders` : surfaceViewportRangesKey;
-    if (cachedSurface && cachedSurface.content === document2.content && cachedSurface.subParts === document2.subParts && cachedSurface.styles === document2.styles && cachedSurface.numbering === document2.numbering && cachedSurface.media === document2.media && cachedSurface.preservation === document2.preservation && cachedSurface.review === document2.review && cachedSurface.effectiveMarkupModeProvider === effectiveMarkupModeProvider && cachedSurface.activeStoryKey === activeStoryKey && cachedSurface.viewportRangesKey === surfaceCacheKey) {
+    if (cachedSurface && cachedSurface.content === document2.content && cachedSurface.subParts === document2.subParts && cachedSurface.styles === document2.styles && cachedSurface.numbering === document2.numbering && cachedSurface.media === document2.media && cachedSurface.preservation === document2.preservation && cachedSurface.review === document2.review && cachedSurface.effectiveMarkupModeProvider === effectiveMarkupModeProvider && cachedSurface.activeStoryKey === activeStoryKey2 && cachedSurface.viewportRangesKey === surfaceCacheKey) {
       return cachedSurface.snapshot;
     }
     const snapshot = createEditorSurfaceSnapshot(document2, state.selection, nextActiveStory, {
       viewportBlockRanges: surfaceViewportRanges,
       editableTargetsByBlockPath: options2.editableTargetsByBlockPathOverride ?? getEditableTargetsByBlockPathForRanges(
         document2,
-        activeStoryKey,
+        activeStoryKey2,
         surfaceViewportRanges
       ),
+      paragraphCascadeCache: ensureParagraphCascadeCacheForStyles(document2.styles),
       ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
     });
     recordPerfSample("snapshot.surface");
@@ -70859,7 +71294,7 @@ function createDocumentRuntime(options) {
         preservation: document2.preservation,
         review: document2.review,
         effectiveMarkupModeProvider,
-        activeStoryKey,
+        activeStoryKey: activeStoryKey2,
         snapshot: enrichedSnapshot
       };
     }
@@ -70872,11 +71307,11 @@ function createDocumentRuntime(options) {
       preservation: document2.preservation,
       review: document2.review,
       effectiveMarkupModeProvider,
-      activeStoryKey,
+      activeStoryKey: activeStoryKey2,
       viewportRangesKey: surfaceCacheKey,
       snapshot: enrichedSnapshot
     };
-    cachedSurfaceFingerprint = `${activeStoryKey}|${surfaceCacheKey}|${String(state.selection.anchor)}:${String(state.selection.head)}`;
+    cachedSurfaceFingerprint = `${activeStoryKey2}|${surfaceCacheKey}|${String(state.selection.anchor)}:${String(state.selection.head)}`;
     return enrichedSnapshot;
   }
   function getSelectionCorridorViewportRanges(previousSurface) {
@@ -70907,7 +71342,7 @@ function createDocumentRuntime(options) {
     return -1;
   }
   function cachePatchedLocalTextSurface(surface, fullSurfaceForCache) {
-    const activeStoryKey = storyTargetKey(activeStory);
+    const activeStoryKey2 = storyTargetKey(activeStory);
     const rangesKey = serializeViewportRanges(surface.viewportBlockRanges);
     cachedSurface = {
       content: state.document.content,
@@ -70918,7 +71353,7 @@ function createDocumentRuntime(options) {
       preservation: state.document.preservation,
       review: state.document.review,
       effectiveMarkupModeProvider,
-      activeStoryKey,
+      activeStoryKey: activeStoryKey2,
       viewportRangesKey: rangesKey,
       snapshot: surface
     };
@@ -70933,11 +71368,11 @@ function createDocumentRuntime(options) {
         preservation: state.document.preservation,
         review: state.document.review,
         effectiveMarkupModeProvider,
-        activeStoryKey,
+        activeStoryKey: activeStoryKey2,
         snapshot: fullSurface
       };
     }
-    cachedSurfaceFingerprint = `${activeStoryKey}|${rangesKey}|${String(state.selection.anchor)}:${String(state.selection.head)}`;
+    cachedSurfaceFingerprint = `${activeStoryKey2}|${rangesKey}|${String(state.selection.anchor)}:${String(state.selection.head)}`;
   }
   function createLocalTextCorridorSurfaceFromFullSurface(fullSurface) {
     const ranges = getSelectionCorridorViewportRanges(fullSurface);
@@ -71051,7 +71486,17 @@ function createDocumentRuntime(options) {
     }
   }
   function tryPatchNestedLocalTextSurface(previousSurface, editFrom, editTo, insertedText) {
-    const shiftBudget = estimateLocalTextPatchShiftBudget(previousSurface.blocks, 0);
+    const containerIndex = previousSurface.blocks.findIndex(
+      (block) => editFrom >= block.from && editTo <= block.to
+    );
+    if (containerIndex < 0) {
+      perfCounters.increment("surface.localText.patchMiss");
+      return null;
+    }
+    const shiftBudget = estimateLocalTextPatchShiftBudget(
+      previousSurface.blocks,
+      containerIndex + 1
+    );
     perfCounters.increment("surface.localText.shiftedBlocks", shiftBudget.shiftedBlocks);
     perfCounters.increment("surface.localText.shiftedNodes", shiftBudget.shiftedNodes);
     if (!shiftBudget.withinBudget) {
@@ -71131,19 +71576,9 @@ function createDocumentRuntime(options) {
     for (let index = startIndex; index < blocks.length; index += 1) {
       const shiftedBlockNodes = countSurfaceShiftNodesUpTo(
         blocks[index],
-        Math.min(
-          policy.maxShiftedNodesPerBlock,
-          policy.maxShiftedSurfaceNodes - shiftedNodes
-        ) + 1
+        policy.maxShiftedSurfaceNodes - shiftedNodes + 1
       );
       shiftedNodes += shiftedBlockNodes;
-      if (shiftedBlockNodes > policy.maxShiftedNodesPerBlock) {
-        return {
-          shiftedBlocks,
-          shiftedNodes,
-          withinBudget: false
-        };
-      }
       if (shiftedNodes > policy.maxShiftedSurfaceNodes) {
         return {
           shiftedBlocks,
@@ -71332,7 +71767,7 @@ function createDocumentRuntime(options) {
     return snapshot.suggestions.find((suggestion) => suggestion.changeIds.includes(changeId));
   }
   function getCachedDocumentNavigationSnapshot(nextState, nextActiveStory) {
-    const activeStoryKey = storyTargetKey(nextActiveStory);
+    const activeStoryKey2 = storyTargetKey(nextActiveStory);
     const buildSnapshot = () => layoutEngine.getNavigationSnapshot(
       {
         document: nextState.document,
@@ -71345,7 +71780,7 @@ function createDocumentRuntime(options) {
       nextState.selection,
       nextActiveStory
     );
-    if (cachedNavigation && cachedNavigation.document === nextState.document && cachedNavigation.activeStoryKey === activeStoryKey && cachedNavigation.workspaceMode === viewState.workspaceMode && cachedNavigation.zoomLevel === viewState.zoomLevel) {
+    if (cachedNavigation && cachedNavigation.document === nextState.document && cachedNavigation.activeStoryKey === activeStoryKey2 && cachedNavigation.workspaceMode === viewState.workspaceMode && cachedNavigation.zoomLevel === viewState.zoomLevel) {
       if (cachedNavigation.selectionHead === nextState.selection.head) {
         return cachedNavigation.snapshot;
       }
@@ -71353,7 +71788,7 @@ function createDocumentRuntime(options) {
       if (snapshot2.activePageIndex === cachedNavigation.snapshot.activePageIndex && snapshot2.activeSectionIndex === cachedNavigation.snapshot.activeSectionIndex) {
         cachedNavigation = {
           document: nextState.document,
-          activeStoryKey,
+          activeStoryKey: activeStoryKey2,
           workspaceMode: viewState.workspaceMode,
           zoomLevel: viewState.zoomLevel,
           selectionHead: nextState.selection.head,
@@ -71363,7 +71798,7 @@ function createDocumentRuntime(options) {
       }
       cachedNavigation = {
         document: nextState.document,
-        activeStoryKey,
+        activeStoryKey: activeStoryKey2,
         workspaceMode: viewState.workspaceMode,
         zoomLevel: viewState.zoomLevel,
         selectionHead: nextState.selection.head,
@@ -71376,7 +71811,7 @@ function createDocumentRuntime(options) {
     incrementInvalidationCounter("runtime.snapshot.navigationMisses");
     cachedNavigation = {
       document: nextState.document,
-      activeStoryKey,
+      activeStoryKey: activeStoryKey2,
       workspaceMode: viewState.workspaceMode,
       zoomLevel: viewState.zoomLevel,
       selectionHead: nextState.selection.head,
@@ -71394,18 +71829,18 @@ function createDocumentRuntime(options) {
     return storyTargetKey(nextActiveStory);
   }
   function getCachedPageLayoutSnapshot(nextState, nextActiveStory) {
-    const activeStoryKey = storyTargetKey(nextActiveStory);
+    const activeStoryKey2 = storyTargetKey(nextActiveStory);
     const activeSectionIndex = resolvePageLayoutActiveSectionIndex(
       nextState,
       nextActiveStory
     );
-    if (cachedPageLayout && cachedPageLayout.revisionToken === nextState.revisionToken && cachedPageLayout.activeStoryKey === activeStoryKey && cachedPageLayout.activeSectionIndex === activeSectionIndex) {
+    if (cachedPageLayout && cachedPageLayout.revisionToken === nextState.revisionToken && cachedPageLayout.activeStoryKey === activeStoryKey2 && cachedPageLayout.activeSectionIndex === activeSectionIndex) {
       return cachedPageLayout.snapshot;
     }
     const snapshot = derivePageLayoutSnapshot(nextState, nextActiveStory, storySelections);
     cachedPageLayout = {
       revisionToken: nextState.revisionToken,
-      activeStoryKey,
+      activeStoryKey: activeStoryKey2,
       activeSectionIndex,
       snapshot
     };
@@ -71475,8 +71910,8 @@ function createDocumentRuntime(options) {
     if (activeStory.kind === "main") {
       return surface.blocks;
     }
-    const activeStoryKey = storyTargetKey(activeStory);
-    return surface.secondaryStories.find((story) => storyTargetKey(story.target) === activeStoryKey)?.blocks ?? null;
+    const activeStoryKey2 = storyTargetKey(activeStory);
+    return surface.secondaryStories.find((story) => storyTargetKey(story.target) === activeStoryKey2)?.blocks ?? null;
   }
   function findSurfaceOpaqueTargetIntersectingRange(blocks, range) {
     for (const block of blocks) {
@@ -71651,12 +72086,12 @@ function createDocumentRuntime(options) {
     };
   }
   function getCachedRuntimeContextAnalytics(query) {
-    const activeStoryKey = storyTargetKey(activeStory);
+    const activeStoryKey2 = storyTargetKey(activeStory);
     const queryKey = getRuntimeContextAnalyticsQueryKey(query);
     const cachedEntry = cachedContextAnalyticsSnapshots.get(queryKey);
     const effectiveScopeKind = query?.scopeKind ?? "selection";
     const selectionCacheKey = effectiveScopeKind === "selection" ? state.selection : null;
-    if (cachedEntry && cachedEntry.revisionToken === state.revisionToken && cachedEntry.activeStoryKey === activeStoryKey && cachedEntry.selection === selectionCacheKey && cachedEntry.readOnly === state.readOnly && cachedEntry.documentMode === viewState.documentMode && cachedEntry.workflowOverlay === overlayStore.getOverlay() && cachedEntry.protectionSnapshot === protectionSnapshot && cachedEntry.warnings === state.warnings && cachedEntry.fatalError === state.fatalError) {
+    if (cachedEntry && cachedEntry.revisionToken === state.revisionToken && cachedEntry.activeStoryKey === activeStoryKey2 && cachedEntry.selection === selectionCacheKey && cachedEntry.readOnly === state.readOnly && cachedEntry.documentMode === viewState.documentMode && cachedEntry.workflowOverlay === overlayStore.getOverlay() && cachedEntry.protectionSnapshot === protectionSnapshot && cachedEntry.warnings === state.warnings && cachedEntry.fatalError === state.fatalError) {
       return cachedEntry.snapshot;
     }
     const tWf = performance.now();
@@ -71713,7 +72148,7 @@ function createDocumentRuntime(options) {
     perfCounters.increment("ctxa.build.us", Math.round((performance.now() - tBuild) * 1e3));
     cachedContextAnalyticsSnapshots.set(queryKey, {
       revisionToken: state.revisionToken,
-      activeStoryKey,
+      activeStoryKey: activeStoryKey2,
       // L7 Phase 1.6: store the selectionCacheKey we tested against, so the
       // same scopeKind invariant applies to future reads.
       selection: selectionCacheKey,
@@ -71815,6 +72250,9 @@ function createDocumentRuntime(options) {
         viewportBlockRangesOverride: firstSurfaceViewportBlockRanges
       }) : getCachedSurface(state.document, activeStory)
     );
+    if (firstSurfaceViewportBlockRanges) {
+      scheduleFullSurfaceWarmupAfterCull();
+    }
     const snapshot = {
       documentId: state.documentId,
       sessionId: state.sessionId,
@@ -71908,7 +72346,7 @@ function createDocumentRuntime(options) {
   }
   let cachedSurfaceFingerprint = null;
   function refreshSurfaceOnly(options2 = {}) {
-    const activeStoryKey = storyTargetKey(activeStory);
+    const activeStoryKey2 = storyTargetKey(activeStory);
     if (options2.forceProjection) {
       cachedFullSurface = void 0;
     }
@@ -71925,9 +72363,12 @@ function createDocumentRuntime(options) {
         viewportBlockRanges,
         editableTargetsByBlockPath: getEditableTargetsByBlockPathForRanges(
           state.document,
-          activeStoryKey,
+          activeStoryKey2,
           viewportBlockRanges
         ),
+        paragraphCascadeCache: ensureParagraphCascadeCacheForStyles(
+          state.document.styles
+        ),
         ...effectiveMarkupModeProvider ? { getEffectiveMarkupMode: effectiveMarkupModeProvider } : {}
       }
     );
@@ -71952,7 +72393,7 @@ function createDocumentRuntime(options) {
           preservation: state.document.preservation,
           review: state.document.review,
           effectiveMarkupModeProvider,
-          activeStoryKey,
+          activeStoryKey: activeStoryKey2,
           snapshot: newSurface
         };
       }
@@ -71967,7 +72408,7 @@ function createDocumentRuntime(options) {
       preservation: state.document.preservation,
       review: state.document.review,
       effectiveMarkupModeProvider,
-      activeStoryKey,
+      activeStoryKey: activeStoryKey2,
       viewportRangesKey,
       snapshot: newSurface
     };
@@ -72028,10 +72469,10 @@ function createDocumentRuntime(options) {
     return true;
   }
   function getCachedViewStateSnapshot() {
-    const activeStoryKey = storyTargetKey(activeStory);
+    const activeStoryKey2 = storyTargetKey(activeStory);
     const surface = cachedRenderSnapshot.surface;
     const pageLayout = cachedRenderSnapshot.pageLayout;
-    if (cachedViewStateSnapshot && cachedViewStateSnapshot.activeStoryKey === activeStoryKey && cachedViewStateSnapshot.selection === state.selection && cachedViewStateSnapshot.viewStateRef === viewState && cachedViewStateSnapshot.surface === surface && cachedViewStateSnapshot.pageLayout === pageLayout && cachedViewStateSnapshot.numbering === state.document.numbering) {
+    if (cachedViewStateSnapshot && cachedViewStateSnapshot.activeStoryKey === activeStoryKey2 && cachedViewStateSnapshot.selection === state.selection && cachedViewStateSnapshot.viewStateRef === viewState && cachedViewStateSnapshot.surface === surface && cachedViewStateSnapshot.pageLayout === pageLayout && cachedViewStateSnapshot.numbering === state.document.numbering) {
       return cachedViewStateSnapshot.snapshot;
     }
     const mainSurface = activeStory.kind === "main" ? surface : getCachedSurface(state.document, MAIN_STORY_TARGET);
@@ -72045,7 +72486,7 @@ function createDocumentRuntime(options) {
       state.document.numbering
     );
     cachedViewStateSnapshot = {
-      activeStoryKey,
+      activeStoryKey: activeStoryKey2,
       selection: state.selection,
       viewStateRef: viewState,
       surface,
@@ -72579,6 +73020,17 @@ function createDocumentRuntime(options) {
           };
           resolvedReplayTextTarget = prepared.textTarget;
         } else {
+          const listBoundaryJoinCommand = createListItemBoundaryJoinReplayCommand({
+            command,
+            document: replayState.document,
+            selection: replayState.selection,
+            surface: replaySnapshot.surface?.blocks ?? [],
+            storyTarget: replayStory,
+            timestamp: context.timestamp
+          });
+          if (listBoundaryJoinCommand) {
+            executableCommand = listBoundaryJoinCommand;
+          }
           const selectedListItemDeleteCommand = createSelectedListItemDeleteReplayCommand({
             command,
             document: replayState.document,
@@ -72736,6 +73188,17 @@ function createDocumentRuntime(options) {
             };
             resolvedReplayTextTarget = prepared.textTarget;
           } else {
+            const listBoundaryJoinCommand = createListItemBoundaryJoinReplayCommand({
+              command,
+              document: stateForCommand.document,
+              selection: stateForCommand.selection,
+              surface: snapshotForCommand.surface?.blocks ?? [],
+              storyTarget: replayStory,
+              timestamp: context.timestamp
+            });
+            if (listBoundaryJoinCommand) {
+              executableCommand = listBoundaryJoinCommand;
+            }
             const selectedListItemDeleteCommand = createSelectedListItemDeleteReplayCommand({
               command,
               document: stateForCommand.document,
@@ -73045,8 +73508,8 @@ function createDocumentRuntime(options) {
     applyScopeReplacement(plan) {
       const resolveEditableTargetHint = (hint) => {
         if (!hint) return void 0;
-        const activeStoryKey = storyTargetKey(activeStory);
-        if (hint.storyKey !== activeStoryKey) return null;
+        const activeStoryKey2 = storyTargetKey(activeStory);
+        if (hint.storyKey !== activeStoryKey2) return null;
         const currentTargets = collectEditableTargetRefs(
           state.document,
           editableTargetBlockCache
@@ -73065,7 +73528,7 @@ function createDocumentRuntime(options) {
           document: state.document,
           surface: cachedRenderSnapshot.surface?.blocks ?? [],
           target,
-          activeStoryKey,
+          activeStoryKey: activeStoryKey2,
           editableTargetCache: editableTargetBlockCache
         });
         if (resolved.kind === "rejected") {
@@ -73765,6 +74228,9 @@ function createDocumentRuntime(options) {
     addScope(params) {
       return workflowCoordinator.addScope(params);
     },
+    addScopes(params) {
+      return workflowCoordinator.addScopes(params);
+    },
     getScope(scopeId) {
       return workflowCoordinator.getScope(scopeId);
     },
@@ -74748,6 +75214,9 @@ function createDocumentRuntime(options) {
     if (transaction.mapping.metadata?.scopeTagTouches) return false;
     return getLocalTextPatchMetadata(transaction.mapping) !== null;
   }
+  function isLayoutNeutralScopeMarkerCommit(previous, next, transaction) {
+    return transaction.markDirty && previous.document !== next.document && transaction.mapping.steps.length === 0 && transaction.mapping.metadata?.layoutNeutralScopeMarkers === true;
+  }
   function applyTransactionToState(transaction, options2 = {}) {
     const effects = transaction.effects;
     const selectionUnchanged = transaction.nextState.selection === state.selection;
@@ -74776,6 +75245,11 @@ function createDocumentRuntime(options) {
       transaction,
       transaction.effects
     );
+    const layoutNeutralScopeMarkerCommit = isLayoutNeutralScopeMarkerCommit(
+      previous,
+      state,
+      transaction
+    );
     perfCounters.increment("commit.refreshClassify.us", Math.round((performance.now() - tClassify0) * 1e3));
     const tOverlay0 = performance.now();
     const skipOverlaySync = useLocalTextCommitSnapshot && canSkipOverlaySyncForLocalText(transaction);
@@ -74824,9 +75298,12 @@ function createDocumentRuntime(options) {
         ...detachedWorkflowScopeWarnings.cleared
       ]
     };
-    if (!useLocalTextCommitSnapshot && transaction.markDirty && previous.document !== state.document) {
+    if (!useLocalTextCommitSnapshot && !layoutNeutralScopeMarkerCommit && transaction.markDirty && previous.document !== state.document) {
       applyViewportRanges(getSelectionCorridorViewportRanges(cachedRenderSnapshot.surface));
     }
+    if (layoutNeutralScopeMarkerCommit && viewportBlockRanges !== null) {
+      getCachedFullSurface(state.document, activeStory);
+    }
     const tValidation0 = performance.now();
     const patchSourceSurface = getReusableCachedFullSurface(previous.document, activeStory) ?? cachedRenderSnapshot.surface;
     const patchedFullLocalTextSurface = useLocalTextCommitSnapshot ? tryPatchLocalTextSurface(patchSourceSurface, transaction.mapping) : null;
@@ -75195,15 +75672,49 @@ function createDocumentRuntime(options) {
     const preSelection = selection;
     const preActiveStory = activeStory;
     const priorDocument = state.document;
+    const listBoundaryJoin = createListItemBoundaryJoinReplacement({
+      command: commandForDispatch,
+      document: state.document,
+      editableTarget,
+      selection,
+      storyTarget: activeStory,
+      targetResolution,
+      timestamp
+    });
+    if (listBoundaryJoin && context.documentMode !== "suggesting") {
+      const replacementCommand = {
+        type: "document.replace",
+        document: listBoundaryJoin.document,
+        selection: listBoundaryJoin.selection,
+        mapping: listBoundaryJoin.mapping,
+        protectionSelection: selection,
+        origin: commandForDispatch.origin
+      };
+      const transaction = executeEditorCommand(baseState, replacementCommand, context);
+      commit(transaction);
+      options.onCommandApplied?.(commandForDispatch, transaction, context, {
+        preSelection,
+        activeStory: preActiveStory,
+        priorDocument
+      });
+      return completeDispatch(classifyAck({
+        command: commandForDispatch,
+        opId,
+        priorState: baseState,
+        transaction,
+        newRevisionToken: state.revisionToken
+      }));
+    }
     const selectedListItemDelete = createSelectedListItemDeleteReplacement({
       command: commandForDispatch,
       document: state.document,
       editableTarget,
       selection,
+      storyTarget: activeStory,
       targetResolution,
       timestamp
     });
-    if (selectedListItemDelete && activeStory.kind === "main" && context.documentMode !== "suggesting") {
+    if (selectedListItemDelete && context.documentMode !== "suggesting") {
       const replacementCommand = {
         type: "document.replace",
         document: selectedListItemDelete.document,
@@ -75468,6 +75979,9 @@ function createDocumentRuntime(options) {
     });
   }
   function scheduleIdleContextAnalytics(callback) {
+    runOnIdle(callback);
+  }
+  function runOnIdle(callback) {
     const requestIdle = globalThis.requestIdleCallback;
     if (typeof requestIdle === "function") {
       requestIdle(callback, { timeout: 250 });
@@ -78098,8 +78612,58 @@ function stripStoryTarget2(selection) {
 function isTopLevelMainStoryBlockPath(blockPath) {
   return typeof blockPath === "string" && /^main\/block\[\d+\]$/u.test(blockPath);
 }
+function createListItemBoundaryJoinReplacement(input) {
+  const { command, document: document2, editableTarget, selection, storyTarget, targetResolution, timestamp } = input;
+  const direction = listItemBoundaryJoinDirection(command, selection, targetResolution);
+  if (!direction || editableTarget?.listAddress?.operationScope !== "list-text" || targetResolution?.kind !== "accepted") {
+    return null;
+  }
+  const storyBlocks = getStoryBlocks(document2, storyTarget);
+  const replacement = joinNumberedParagraphAtStoryPath(
+    storyBlocks,
+    editableTarget.blockPath,
+    storyTarget,
+    direction
+  );
+  if (!replacement) {
+    return null;
+  }
+  const nextDocument = replaceStoryBlocks({
+    ...document2,
+    updatedAt: timestamp
+  }, storyTarget, replacement.blocks);
+  const deletedFrom = direction === "backward" ? Math.max(0, selection.anchor - 1) : selection.anchor;
+  const deletedTo = direction === "backward" ? selection.anchor : selection.anchor + 1;
+  const nextAnchor = direction === "backward" ? deletedFrom : selection.anchor;
+  return {
+    document: nextDocument,
+    selection: createSelectionSnapshot(nextAnchor, nextAnchor),
+    mapping: {
+      steps: [{
+        from: deletedFrom,
+        to: deletedTo,
+        insertSize: 0
+      }],
+      metadata: {
+        invalidatesStructures: true
+      }
+    }
+  };
+}
+function listItemBoundaryJoinDirection(command, selection, targetResolution) {
+  if (selection.isCollapsed !== true || targetResolution?.kind !== "accepted") {
+    return null;
+  }
+  if (command.type === "text.delete-backward" && selection.anchor === targetResolution.range.from) {
+    return "backward";
+  }
+  if (command.type === "text.delete-forward" && selection.anchor === targetResolution.range.to) {
+    return "forward";
+  }
+  return null;
+}
 function createSelectedListItemDeleteReplacement(input) {
-  const { command, document: document2, editableTarget, selection, targetResolution, timestamp } = input;
+  const { command, document: document2, editableTarget, selection, storyTarget, targetResolution, timestamp } = input;
   if (command.type !== "text.delete-backward" && command.type !== "text.delete-forward") {
     return null;
   }
@@ -78111,20 +78675,19 @@ function createSelectedListItemDeleteReplacement(input) {
   if (selectionFrom !== targetResolution.range.from || selectionTo !== targetResolution.range.to) {
     return null;
   }
-  const root = document2.content;
-  const replacement = removeNumberedParagraphAtMainStoryPath(root.children, editableTarget.blockPath);
+  const storyBlocks = getStoryBlocks(document2, storyTarget);
+  const replacement = removeNumberedParagraphAtStoryPath(storyBlocks, editableTarget.blockPath, storyTarget);
   if (!replacement) {
     return null;
   }
-  const nextDocument = {
+  const nextDocument = replaceStoryBlocks({
     ...document2,
-    updatedAt: timestamp,
-    content: {
-      ...root,
-      children: replacement.blocks
-    }
-  };
-  const nextStorySize = parseTextStory(nextDocument.content).size;
+    updatedAt: timestamp
+  }, storyTarget, replacement.blocks);
+  const nextStorySize = parseTextStory({
+    type: "doc",
+    children: [...getStoryBlocks(nextDocument, storyTarget)]
+  }).size;
   const nextAnchor = Math.min(selectionFrom, nextStorySize);
   return {
     document: nextDocument,
@@ -78141,11 +78704,157 @@ function createSelectedListItemDeleteReplacement(input) {
     }
   };
 }
-function removeNumberedParagraphAtMainStoryPath(blocks, blockPath) {
-  const tokens = parseMainStoryBlockPathTokens(blockPath);
+function removeNumberedParagraphAtStoryPath(blocks, blockPath, storyTarget) {
+  const tokens = parseStoryBlockPathTokens(blockPath, storyTarget);
   if (!tokens) return null;
   return removeNumberedParagraphFromBlocks(blocks, tokens);
 }
+function joinNumberedParagraphAtStoryPath(blocks, blockPath, storyTarget, direction) {
+  const tokens = parseStoryBlockPathTokens(blockPath, storyTarget);
+  if (!tokens) return null;
+  return joinNumberedParagraphFromBlocks(blocks, tokens, direction);
+}
+function joinNumberedParagraphFromBlocks(blocks, tokens, direction) {
+  const [token, ...rest] = tokens;
+  if (!token || token.kind !== "block") return null;
+  const block = blocks[token.index];
+  if (!block) return null;
+  if (rest.length === 0) {
+    return joinAdjacentNumberedParagraphs(blocks, token.index, direction);
+  }
+  const next = rest[0];
+  if (block.type === "table" && next?.kind === "row") {
+    const updatedTable = joinNumberedParagraphInTable(block, rest, direction);
+    if (!updatedTable) return null;
+    return {
+      blocks: [
+        ...blocks.slice(0, token.index),
+        updatedTable,
+        ...blocks.slice(token.index + 1)
+      ]
+    };
+  }
+  if ((block.type === "sdt" || block.type === "custom_xml") && next?.kind === "block") {
+    const updatedChildren = joinNumberedParagraphFromBlocks(block.children, rest, direction);
+    if (!updatedChildren) return null;
+    return {
+      blocks: [
+        ...blocks.slice(0, token.index),
+        { ...block, children: updatedChildren.blocks },
+        ...blocks.slice(token.index + 1)
+      ]
+    };
+  }
+  if (block.type === "paragraph" && next?.kind === "inline") {
+    const updatedParagraph = joinNumberedParagraphInTextBoxInline(block, rest, direction);
+    if (!updatedParagraph) return null;
+    return {
+      blocks: [
+        ...blocks.slice(0, token.index),
+        updatedParagraph,
+        ...blocks.slice(token.index + 1)
+      ]
+    };
+  }
+  return null;
+}
+function joinAdjacentNumberedParagraphs(blocks, targetIndex, direction) {
+  const target = blocks[targetIndex];
+  if (target?.type !== "paragraph" || !target.numbering) {
+    return null;
+  }
+  if (direction === "backward") {
+    const previousIndex = targetIndex - 1;
+    const previous = blocks[previousIndex];
+    if (previous?.type !== "paragraph" || !previous.numbering) {
+      return null;
+    }
+    const merged2 = {
+      ...previous,
+      children: [...previous.children, ...target.children]
+    };
+    return {
+      blocks: [
+        ...blocks.slice(0, previousIndex),
+        merged2,
+        ...blocks.slice(targetIndex + 1)
+      ]
+    };
+  }
+  const nextIndex = targetIndex + 1;
+  const next = blocks[nextIndex];
+  if (next?.type !== "paragraph" || !next.numbering) {
+    return null;
+  }
+  const merged = {
+    ...target,
+    children: [...target.children, ...next.children]
+  };
+  return {
+    blocks: [
+      ...blocks.slice(0, targetIndex),
+      merged,
+      ...blocks.slice(nextIndex + 1)
+    ]
+  };
+}
+function joinNumberedParagraphInTable(table, tokens, direction) {
+  const [rowToken, cellToken, ...childTokens] = tokens;
+  if (rowToken?.kind !== "row" || cellToken?.kind !== "cell" || childTokens[0]?.kind !== "block") {
+    return null;
+  }
+  const row2 = table.rows[rowToken.index];
+  const cell = row2?.cells[cellToken.index];
+  if (!row2 || !cell) return null;
+  const updatedChildren = joinNumberedParagraphFromBlocks(cell.children, childTokens, direction);
+  if (!updatedChildren) return null;
+  const nextCells = [
+    ...row2.cells.slice(0, cellToken.index),
+    { ...cell, children: updatedChildren.blocks },
+    ...row2.cells.slice(cellToken.index + 1)
+  ];
+  const nextRows = [
+    ...table.rows.slice(0, rowToken.index),
+    { ...row2, cells: nextCells },
+    ...table.rows.slice(rowToken.index + 1)
+  ];
+  return { ...table, rows: nextRows };
+}
+function joinNumberedParagraphInTextBoxInline(paragraph, tokens, direction) {
+  const [inlineToken, textBoxToken, ...childTokens] = tokens;
+  if (inlineToken?.kind !== "inline" || textBoxToken?.kind !== "txbx" || childTokens[0]?.kind !== "block") {
+    return null;
+  }
+  const inline = paragraph.children[inlineToken.index];
+  if (!inline) return null;
+  const updatedInline = joinNumberedParagraphInInlineTextBox(inline, childTokens, direction);
+  if (!updatedInline) return null;
+  return {
+    ...paragraph,
+    children: [
+      ...paragraph.children.slice(0, inlineToken.index),
+      updatedInline,
+      ...paragraph.children.slice(inlineToken.index + 1)
+    ]
+  };
+}
+function joinNumberedParagraphInInlineTextBox(inline, tokens, direction) {
+  if (inline.type === "shape" && inline.txbxBlocks) {
+    const updatedBlocks = joinNumberedParagraphFromBlocks(inline.txbxBlocks, tokens, direction);
+    return updatedBlocks ? { ...inline, txbxBlocks: updatedBlocks.blocks } : null;
+  }
+  if (inline.type === "drawing_frame" && inline.content.type === "shape" && inline.content.txbxBlocks) {
+    const updatedBlocks = joinNumberedParagraphFromBlocks(inline.content.txbxBlocks, tokens, direction);
+    return updatedBlocks ? {
+      ...inline,
+      content: {
+        ...inline.content,
+        txbxBlocks: updatedBlocks.blocks
+      }
+    } : null;
+  }
+  return null;
+}
 function removeNumberedParagraphFromBlocks(blocks, tokens) {
   const [token, ...rest] = tokens;
   if (!token || token.kind !== "block") return null;
@@ -78188,6 +78897,52 @@ function removeNumberedParagraphFromBlocks(blocks, tokens) {
       ]
     };
   }
+  if (block.type === "paragraph" && next?.kind === "inline") {
+    const updatedParagraph = removeNumberedParagraphFromTextBoxInline(block, rest);
+    if (!updatedParagraph) return null;
+    return {
+      blocks: [
+        ...blocks.slice(0, token.index),
+        updatedParagraph,
+        ...blocks.slice(token.index + 1)
+      ]
+    };
+  }
+  return null;
+}
+function removeNumberedParagraphFromTextBoxInline(paragraph, tokens) {
+  const [inlineToken, textBoxToken, ...childTokens] = tokens;
+  if (inlineToken?.kind !== "inline" || textBoxToken?.kind !== "txbx" || childTokens[0]?.kind !== "block") {
+    return null;
+  }
+  const inline = paragraph.children[inlineToken.index];
+  if (!inline) return null;
+  const updatedInline = removeNumberedParagraphFromInlineTextBox(inline, childTokens);
+  if (!updatedInline) return null;
+  return {
+    ...paragraph,
+    children: [
+      ...paragraph.children.slice(0, inlineToken.index),
+      updatedInline,
+      ...paragraph.children.slice(inlineToken.index + 1)
+    ]
+  };
+}
+function removeNumberedParagraphFromInlineTextBox(inline, tokens) {
+  if (inline.type === "shape" && inline.txbxBlocks) {
+    const updatedBlocks = removeNumberedParagraphFromBlocks(inline.txbxBlocks, tokens);
+    return updatedBlocks ? { ...inline, txbxBlocks: updatedBlocks.blocks } : null;
+  }
+  if (inline.type === "drawing_frame" && inline.content.type === "shape" && inline.content.txbxBlocks) {
+    const updatedBlocks = removeNumberedParagraphFromBlocks(inline.content.txbxBlocks, tokens);
+    return updatedBlocks ? {
+      ...inline,
+      content: {
+        ...inline.content,
+        txbxBlocks: updatedBlocks.blocks
+      }
+    } : null;
+  }
   return null;
 }
 function removeNumberedParagraphFromTable(table, tokens) {
@@ -78228,15 +78983,29 @@ function createSelectedListItemDeleteReplayCommand(input) {
     target: editableTarget,
     activeStoryKey: canonicalEditableTargetStoryKey(storyTarget)
   });
+  const resolvedEditableTarget = targetResolution.kind === "accepted" ? editableTarget : storyTarget.kind !== "main" && blockPathBelongsToStoryTarget(editableTarget.blockPath, storyTarget) ? resolveEditableCommandTarget({
+    document: document2,
+    target: editableTarget,
+    activeStoryKey: canonicalEditableTargetStoryKey(storyTarget),
+    commandFamilies: ["text-leaf"]
+  }) : null;
+  const selectedRange = {
+    from: Math.min(selection.anchor, selection.head),
+    to: Math.max(selection.anchor, selection.head)
+  };
   const replacement = createSelectedListItemDeleteReplacement({
     command,
     document: document2,
-    editableTarget,
+    editableTarget: resolvedEditableTarget && resolvedEditableTarget.kind === "accepted" ? resolvedEditableTarget.target : editableTarget,
     selection,
-    targetResolution,
+    storyTarget,
+    targetResolution: resolvedEditableTarget && resolvedEditableTarget.kind === "accepted" ? {
+      kind: "accepted",
+      range: selectedRange
+    } : targetResolution,
     timestamp
   });
-  if (!replacement || storyTarget.kind !== "main") {
+  if (!replacement) {
     return null;
   }
   return {
@@ -78248,22 +79017,99 @@ function createSelectedListItemDeleteReplayCommand(input) {
     origin: command.origin
   };
 }
-function parseMainStoryBlockPathTokens(blockPath) {
-  const parts = blockPath?.split("/") ?? [];
-  if (parts[0] !== "main" || parts.length < 2) {
+function createListItemBoundaryJoinReplayCommand(input) {
+  const { command, document: document2, selection, surface, storyTarget, timestamp } = input;
+  if (command.type !== "text.delete-backward" && command.type !== "text.delete-forward") {
     return null;
   }
+  const editableTarget = command.editableTarget;
+  if (!editableTarget) {
+    return null;
+  }
+  const targetResolution = resolveEditableTextTarget({
+    document: document2,
+    selection,
+    surface,
+    target: editableTarget,
+    activeStoryKey: canonicalEditableTargetStoryKey(storyTarget)
+  });
+  const resolvedEditableTarget = targetResolution.kind === "accepted" ? editableTarget : storyTarget.kind !== "main" && blockPathBelongsToStoryTarget(editableTarget.blockPath, storyTarget) ? resolveEditableCommandTarget({
+    document: document2,
+    target: editableTarget,
+    activeStoryKey: canonicalEditableTargetStoryKey(storyTarget),
+    commandFamilies: ["text-leaf"]
+  }) : null;
+  const selectedRange = {
+    from: Math.min(selection.anchor, selection.head),
+    to: Math.max(selection.anchor, selection.head)
+  };
+  const replacement = createListItemBoundaryJoinReplacement({
+    command,
+    document: document2,
+    editableTarget: resolvedEditableTarget && resolvedEditableTarget.kind === "accepted" ? resolvedEditableTarget.target : editableTarget,
+    selection,
+    storyTarget,
+    targetResolution: resolvedEditableTarget && resolvedEditableTarget.kind === "accepted" ? {
+      kind: "accepted",
+      range: selectedRange
+    } : targetResolution,
+    timestamp
+  });
+  if (!replacement) {
+    return null;
+  }
+  return {
+    type: "document.replace",
+    document: replacement.document,
+    selection: replacement.selection,
+    mapping: replacement.mapping,
+    protectionSelection: selection,
+    origin: command.origin
+  };
+}
+function parseStoryBlockPathTokens(blockPath, storyTarget) {
+  if (!blockPath) {
+    return null;
+  }
+  const firstTokenMatch = /\/(?:block|row|cell)\[\d+\]/u.exec(blockPath);
+  if (!firstTokenMatch?.index) {
+    return null;
+  }
+  const storyPrefix = blockPath.slice(0, firstTokenMatch.index);
+  if (!blockPathBelongsToStoryTarget(storyPrefix, storyTarget)) {
+    return null;
+  }
+  const parts = blockPath.slice(firstTokenMatch.index + 1).split("/");
   const tokens = [];
-  for (const part of parts.slice(1)) {
-    const match = /^(block|row|cell)\[(\d+)\]$/u.exec(part);
+  for (const part of parts) {
+    if (part === "txbx") {
+      tokens.push({ kind: "txbx" });
+      continue;
+    }
+    const match = /^(block|row|cell|inline)\[(\d+)\]$/u.exec(part);
     if (!match) return null;
+    const kind = match[1];
     tokens.push({
-      kind: match[1],
+      kind,
       index: Number.parseInt(match[2], 10)
     });
   }
   return tokens;
 }
+function blockPathBelongsToStoryTarget(storyPrefix, storyTarget) {
+  switch (storyTarget.kind) {
+    case "main":
+      return storyPrefix === "main" || storyPrefix.startsWith("main/");
+    case "header":
+      return storyPrefix.startsWith("header:");
+    case "footer":
+      return storyPrefix.startsWith("footer:");
+    case "footnote":
+      return storyPrefix === `footnote:${storyTarget.noteId}` || storyPrefix.startsWith(`footnote:${storyTarget.noteId}/`);
+    case "endnote":
+      return storyPrefix === `endnote:${storyTarget.noteId}` || storyPrefix.startsWith(`endnote:${storyTarget.noteId}/`);
+  }
+}
 function toInternalSelectionSnapshot2(selection) {
   return {
     anchor: selection.anchor,
@@ -94387,6 +95233,9 @@ function createLoadingRuntimeBridge(input) {
     addScope: () => {
       throw createLoadingBoundaryError(input.snapshot.documentId, "scope");
     },
+    addScopes: () => {
+      throw createLoadingBoundaryError(input.snapshot.documentId, "scope");
+    },
     getScope: () => null,
     compileScopeBundleById: () => null,
     compileScopeList: () => [],
@@ -94737,7 +95586,8 @@ async function persistAndExport(input) {
     });
     result = withExportDelivery(result, {
       mode: "persisted-by-host",
-      savedAt: saveResult.savedAt
+      savedAt: saveResult.savedAt,
+      ...input.options?.download === false ? { downloadSuppressed: true } : {}
     });
   } catch (error) {
     const normalized = normalizeStorageError(error, {
@@ -108247,6 +109097,10 @@ function TwTableGripLayer({
     tableGeometry,
     plan.columnsTwips
   );
+  const columnWidthCapability = tableContext.operations.setColumnWidth;
+  const rowHeightCapability = tableContext.operations.setRowHeight;
+  const columnResizeDisabled = !!disabled || !onSetColumnWidth || columnWidthCapability?.enabled === false;
+  const rowResizeDisabled = !!disabled || !onSetRowHeight || rowHeightCapability?.enabled === false;
   return /* @__PURE__ */ (0, import_jsx_runtime61.jsxs)(import_jsx_runtime61.Fragment, { children: [
     plan.columnResizeHandles.map((handle) => {
       const rect3 = resolveColumnEdgeRect(
@@ -108261,7 +109115,8 @@ function TwTableGripLayer({
           colIndex: handle.columnIndex,
           originalTwips: plan.columnsTwips[handle.columnIndex] ?? 720,
           pxPerTwip,
-          disabled: !!disabled || !onSetColumnWidth,
+          disabled: columnResizeDisabled,
+          disabledReason: columnWidthCapability?.reason,
           onCommit: onSetColumnWidth
         },
         `col-${blockId}-${handle.columnIndex}`
@@ -108282,7 +109137,8 @@ function TwTableGripLayer({
           rowIndex,
           originalTwips,
           pxPerTwip,
-          disabled: !!disabled || !onSetRowHeight,
+          disabled: rowResizeDisabled,
+          disabledReason: rowHeightCapability?.reason,
           onCommit: onSetRowHeight
         },
         `row-${blockId}-${rowIndex}`
@@ -108372,6 +109228,7 @@ function ColResizeGrip({
   originalTwips,
   pxPerTwip,
   disabled,
+  disabledReason,
   onCommit
 }) {
   const dragRef = (0, import_react34.useRef)(null);
@@ -108430,11 +109287,13 @@ function ColResizeGrip({
       role: "separator",
       "aria-orientation": "vertical",
       "aria-label": `Resize column ${colIndex + 1}`,
+      "aria-disabled": disabled ? "true" : void 0,
       "data-testid": `col-resize-grip-${colIndex}`,
       "data-active": isActive ? "true" : "false",
+      title: disabled ? disabledReason : void 0,
       className: [
-        "wre-table-grip-col pointer-events-auto absolute",
-        disabled ? "opacity-0 cursor-default" : ""
+        "wre-table-grip-col absolute",
+        disabled ? "pointer-events-none opacity-0 cursor-default" : "pointer-events-auto"
       ].filter(Boolean).join(" "),
       style: {
         left: `calc(${pos.left} - ${GRIP_HIT_PX / 2}px)`,
@@ -108452,6 +109311,7 @@ function RowResizeGrip({
   originalTwips,
   pxPerTwip,
   disabled,
+  disabledReason,
   onCommit
 }) {
   const dragRef = (0, import_react34.useRef)(null);
@@ -108511,11 +109371,13 @@ function RowResizeGrip({
       role: "separator",
       "aria-orientation": "horizontal",
       "aria-label": `Resize row ${rowIndex + 1}`,
+      "aria-disabled": disabled ? "true" : void 0,
       "data-testid": `row-resize-grip-${rowIndex}`,
       "data-active": isActive ? "true" : "false",
+      title: disabled ? disabledReason : void 0,
       className: [
-        "wre-table-grip-row pointer-events-auto absolute",
-        disabled ? "opacity-0 cursor-default" : ""
+        "wre-table-grip-row absolute",
+        disabled ? "pointer-events-none opacity-0 cursor-default" : "pointer-events-auto"
       ].filter(Boolean).join(" "),
       style: {
         left: pos.left,
@@ -126641,7 +127503,7 @@ var LAYER_DEBUG_PANES = [
     snippets: [
       { label: "Selection context", expression: "ref?.getRuntimeContextAnalytics?.()" },
       { label: "Document context", expression: "ref?.getRuntimeContextAnalytics?.({ scopeKind: 'document' })" },
-      { label: "Hot edit trace", expression: "runtime?.debug?.getHotEditTraces?.().at(-1)" },
+      { label: "Hot edit trace", expression: "runtime?.debug?.getHotEditTraces?.()?.at(-1)" },
       { label: "View state", expression: "ref?.getViewState?.()" }
     ],
     routed: [
@@ -126655,8 +127517,8 @@ var LAYER_DEBUG_PANES = [
     focus: "Workflow scopes, markup, metadata, candidates, and scope-derived context.",
     snippets: [
       { label: "Scope snapshot", expression: "ref?.getWorkflowScopeSnapshot?.()" },
-      { label: "Query scopes", expression: "ref?.queryScopes?.({ includeHidden: true, includeInvisible: true })" },
-      { label: "Workflow markup", expression: "ref?.getWorkflowMarkupSnapshot?.()" }
+      { label: "Query scopes", expression: "ref?.queryScopes?.({ includeHidden: true, includeInvisible: true, limit: 50 })" },
+      { label: "Workflow markup", expression: "(() => { const m = ref?.getWorkflowMarkupSnapshot?.(); return m ? { itemCount: m.items?.length ?? 0, items: m.items?.slice(0, 50) ?? [] } : m; })()" }
     ],
     routed: [
       "Compiler replacement planning and semantic scope normalization remain Layer 08-owned."
@@ -126670,7 +127532,7 @@ var LAYER_DEBUG_PANES = [
     snippets: [
       { label: "Document analytics", expression: "ref?.getRuntimeContextAnalytics?.({ scopeKind: 'document' })" },
       { label: "Workflow analytics", expression: "ref?.getRuntimeContextAnalytics?.({ scopeKind: 'workflow_scope', scopeId: ref?.getInteractionGuardSnapshot?.()?.matchedScopeId })" },
-      { label: "Available scopes", expression: "ref?.queryScopes?.({ includeHidden: true, includeInvisible: true })" }
+      { label: "Available scopes", expression: "ref?.queryScopes?.({ includeHidden: true, includeInvisible: true, limit: 50 })" }
     ],
     routed: [
       "AI audit references and action policy payloads are Layer 09-owned."
@@ -126698,7 +127560,7 @@ var LAYER_DEBUG_PANES = [
     snippets: [
       { label: "Navigation", expression: "ref?.getDocumentNavigationSnapshot?.()" },
       { label: "Review surface", expression: "({ comments: ref?.getCommentSidebarSnapshot?.(), changes: ref?.getTrackedChangesSnapshot?.() })" },
-      { label: "Hot edit traces", expression: "runtime?.debug?.getHotEditTraces?.()" },
+      { label: "Hot edit traces", expression: "runtime?.debug?.getHotEditTraces?.()?.slice?.(-10)" },
       { label: "Compatibility", expression: "ref?.getCompatibilityReport?.()" }
     ],
     routed: [
@@ -126731,6 +127593,11 @@ var import_jsx_runtime83 = require("react/jsx-runtime");
 var MAX_HISTORY = 30;
 var MAX_ENTRIES = 50;
 var MAX_OUTPUT_CHARS = 8e3;
+var MAX_SERIALIZE_DEPTH = 6;
+var MAX_SERIALIZE_STRING_CHARS = 1e3;
+var MAX_SERIALIZE_ARRAY_ITEMS = 40;
+var MAX_SERIALIZE_OBJECT_KEYS = 80;
+var MAX_SERIALIZE_NODES = 2500;
 var HISTORY_STORAGE_KEY = "wre-runtime-repl-history";
 var HISTORY_STORAGE_VERSION = 1;
 function TwRuntimeReplDialog(props) {
@@ -127196,7 +128063,7 @@ function formatReplValue(value) {
   if (value === void 0) return "undefined";
   if (value === null) return "null";
   const type = typeof value;
-  if (type === "string") return JSON.stringify(value);
+  if (type === "string") return truncate2(JSON.stringify(value), MAX_OUTPUT_CHARS);
   if (type === "number" || type === "boolean" || type === "bigint") {
     return String(value);
   }
@@ -127206,7 +128073,7 @@ function formatReplValue(value) {
     return `[Function${fn.name ? `: ${fn.name}` : ""}]`;
   }
   try {
-    const serialized = JSON.stringify(value, createCircularReplacer(), 2);
+    const serialized = JSON.stringify(createReplPreview(value), null, 2);
     if (serialized === void 0) {
       return String(value);
     }
@@ -127222,21 +128089,113 @@ function formatReplError(error) {
   }
   return truncate2(String(error), MAX_OUTPUT_CHARS);
 }
-function createCircularReplacer() {
-  const seen = /* @__PURE__ */ new WeakSet();
-  return function replacer(_key, value) {
-    if (typeof value === "bigint") return `${value.toString()}n`;
-    if (typeof value === "function") {
-      const fn = value;
-      return `[Function${fn.name ? `: ${fn.name}` : ""}]`;
+function createReplPreview(value) {
+  return createReplPreviewValue(value, 0, {
+    seen: /* @__PURE__ */ new WeakSet(),
+    nodes: 0
+  });
+}
+function createReplPreviewValue(value, depth, state) {
+  if (value === null || typeof value === "number" || typeof value === "boolean") {
+    return value;
+  }
+  if (typeof value === "string") {
+    return value.length > MAX_SERIALIZE_STRING_CHARS ? `${value.slice(0, MAX_SERIALIZE_STRING_CHARS)}... [truncated ${value.length - MAX_SERIALIZE_STRING_CHARS} chars]` : value;
+  }
+  if (typeof value === "bigint") return `${value.toString()}n`;
+  if (typeof value === "symbol") return value.toString();
+  if (typeof value === "function") {
+    const fn = value;
+    return `[Function${fn.name ? `: ${fn.name}` : ""}]`;
+  }
+  if (typeof value !== "object") return String(value);
+  state.nodes += 1;
+  if (state.nodes > MAX_SERIALIZE_NODES) {
+    return "[Max REPL preview nodes reached]";
+  }
+  const objectValue = value;
+  if (state.seen.has(objectValue)) return "[Circular]";
+  state.seen.add(objectValue);
+  if (depth >= MAX_SERIALIZE_DEPTH) {
+    return summarizePreviewBoundary(objectValue);
+  }
+  const domPreview = summarizeDomNode(objectValue);
+  if (domPreview) return domPreview;
+  if (Array.isArray(value)) {
+    const preview = value.slice(0, MAX_SERIALIZE_ARRAY_ITEMS).map((item) => createReplPreviewValue(item, depth + 1, state));
+    if (value.length > MAX_SERIALIZE_ARRAY_ITEMS) {
+      preview.push(`[... ${value.length - MAX_SERIALIZE_ARRAY_ITEMS} more items]`);
     }
-    if (typeof value === "symbol") return value.toString();
-    if (value !== null && typeof value === "object") {
-      if (seen.has(value)) return "[Circular]";
-      seen.add(value);
+    return preview;
+  }
+  if (value instanceof Date) {
+    return Number.isNaN(value.getTime()) ? "[Invalid Date]" : value.toISOString();
+  }
+  if (value instanceof Map) {
+    const entries = [];
+    let index = 0;
+    for (const [key, entryValue] of value.entries()) {
+      if (index >= MAX_SERIALIZE_OBJECT_KEYS) {
+        entries.push("[additional map entries omitted]");
+        break;
+      }
+      entries.push([
+        createReplPreviewValue(key, depth + 1, state),
+        createReplPreviewValue(entryValue, depth + 1, state)
+      ]);
+      index += 1;
     }
-    return value;
-  };
+    return { "[Map]": entries };
+  }
+  if (value instanceof Set) {
+    const entries = [];
+    let index = 0;
+    for (const entryValue of value.values()) {
+      if (index >= MAX_SERIALIZE_OBJECT_KEYS) {
+        entries.push("[additional set entries omitted]");
+        break;
+      }
+      entries.push(createReplPreviewValue(entryValue, depth + 1, state));
+      index += 1;
+    }
+    return { "[Set]": entries };
+  }
+  const output = {};
+  let count = 0;
+  for (const key in value) {
+    if (!Object.prototype.propertyIsEnumerable.call(value, key)) continue;
+    if (count >= MAX_SERIALIZE_OBJECT_KEYS) {
+      output["..."] = "[additional properties omitted]";
+      break;
+    }
+    try {
+      output[key] = createReplPreviewValue(
+        value[key],
+        depth + 1,
+        state
+      );
+    } catch (error) {
+      output[key] = `[unreadable property: ${formatReplError(error)}]`;
+    }
+    count += 1;
+  }
+  return output;
+}
+function summarizePreviewBoundary(value) {
+  if (Array.isArray(value)) return `[Array(${value.length}) depth limit]`;
+  const domPreview = summarizeDomNode(value);
+  if (domPreview) return domPreview;
+  const constructorName = value.constructor?.name;
+  return constructorName && constructorName !== "Object" ? `[${constructorName} depth limit]` : "[Object depth limit]";
+}
+function summarizeDomNode(value) {
+  const maybeNode = value;
+  if (typeof maybeNode.nodeType !== "number" || typeof maybeNode.nodeName !== "string") {
+    return null;
+  }
+  const id = typeof maybeNode.id === "string" && maybeNode.id.length > 0 ? `#${maybeNode.id}` : "";
+  const className = typeof maybeNode.className === "string" && maybeNode.className.length > 0 ? `.${maybeNode.className.trim().replace(/\s+/g, ".")}` : "";
+  return `[DOM ${maybeNode.nodeName.toLowerCase()}${id}${className}]`;
 }
 function truncate2(text, max) {
   if (text.length <= max) return text;
@@ -128586,9 +129545,23 @@ function findSurfaceBlockById(blocks, blockId) {
 }
 function createScopeFromAnchor(runtime, input) {
   const doc = runtime.getCanonicalDocument();
-  const storyTarget = input.anchor.storyTarget ?? { kind: "main" };
+  const normalizedInputAnchor = normalizeCreateScopeAnchor(input.anchor);
+  const storyTarget = normalizedInputAnchor.storyTarget ?? { kind: "main" };
   const storyLength = storyTarget.kind === "main" ? computeMainStoryLength(doc) : Number.MAX_SAFE_INTEGER;
-  const { from, to } = input.anchor;
+  const { from, to } = normalizedInputAnchor;
+  if (!Number.isFinite(from) || !Number.isFinite(to)) {
+    const diagnosticFrom = Number.isFinite(from) ? from : 0;
+    const diagnosticTo = Number.isFinite(to) ? to : diagnosticFrom;
+    return {
+      status: "range-invalid",
+      reason: "non-finite-range",
+      from: diagnosticFrom,
+      to: diagnosticTo,
+      storyLength,
+      message: `createScopeFromAnchor requires finite numeric from/to offsets. Pass selection.activeRange or an object shaped as {from, to}; do not pass a malformed range.`,
+      nextStep: "pass-selection-activeRange-or-finite-from-to"
+    };
+  }
   if (from < 0) {
     return {
       status: "range-invalid",
@@ -128686,6 +129659,29 @@ function createScopeFromAnchor(runtime, input) {
   }
   return { status: "created", scopeId: result.scopeId, anchor: result.anchor };
 }
+function normalizeCreateScopeAnchor(anchor) {
+  const candidate = anchor;
+  const activeRange = candidate.activeRange;
+  if (activeRange?.kind === "range") {
+    return {
+      from: activeRange.from,
+      to: activeRange.to,
+      storyTarget: candidate.storyTarget
+    };
+  }
+  if (candidate.kind === "range") {
+    return {
+      from: candidate.from ?? Number.NaN,
+      to: candidate.to ?? Number.NaN,
+      storyTarget: candidate.storyTarget
+    };
+  }
+  return {
+    from: candidate.from ?? Number.NaN,
+    to: candidate.to ?? Number.NaN,
+    storyTarget: candidate.storyTarget
+  };
+}
 
 // src/api/v3/runtime/workflow.ts
 var createScopeMetadata = {
@@ -129932,7 +130928,8 @@ var SUPPORTED_COMMANDS2 = [
   "indent",
   "outdent",
   "restart-numbering",
-  "continue-numbering"
+  "continue-numbering",
+  "set-value"
 ];
 var UNSUPPORTED_COMMANDS2 = [
   "create",
@@ -129941,7 +130938,6 @@ var UNSUPPORTED_COMMANDS2 = [
   "join",
   "separate",
   "split",
-  "set-value",
   "apply-template",
   "capture-template",
   "apply-preset",
@@ -129990,10 +130986,10 @@ function createListsFamily2(runtime) {
       return resolved.kind === "resolved" ? toReadback(runtime.getCanonicalDocument(), resolved.target, resolved.paragraph) : null;
     },
     previewCommand(input) {
-      return previewListCommand(runtime.getCanonicalDocument(), input);
+      return previewListCommand(runtime.getCanonicalDocument(), input, activeStoryKey(runtime));
     },
     applyCommand(input) {
-      const preview = previewListCommand(runtime.getCanonicalDocument(), input);
+      const preview = previewListCommand(runtime.getCanonicalDocument(), input, activeStoryKey(runtime));
       if (!preview.supported || !preview.target) {
         return {
           applied: false,
@@ -130053,7 +131049,7 @@ function createListsFamily2(runtime) {
     }
   };
 }
-function previewListCommand(document2, input) {
+function previewListCommand(document2, input, activeStoryKey2) {
   const resolved = resolveCurrentListTarget(document2, input);
   if (resolved.kind !== "resolved") {
     return {
@@ -130065,6 +131061,20 @@ function previewListCommand(document2, input) {
   }
   const target = toReadback(document2, resolved.target, resolved.paragraph);
   const targetRef = { targetKey: target.targetKey, addressKey: target.addressKey };
+  if (activeStoryKey2 !== void 0 && target.storyKey !== activeStoryKey2) {
+    return {
+      command: input.command,
+      supported: false,
+      target,
+      affectedTargets: [target],
+      blockers: [{
+        code: "list-target-wrong-story",
+        ownerLayer: "L07",
+        message: "List target does not belong to the runtime active story.",
+        ...targetRef
+      }]
+    };
+  }
   if (!SUPPORTED_COMMANDS2.includes(input.command)) {
     return {
       command: input.command,
@@ -130077,6 +131087,17 @@ function previewListCommand(document2, input) {
   const canContinuePrevious = canContinuePreviousSequence(document2, resolved.paragraphIndex);
   const canJoin = canJoinPreviousSequence(document2, resolved.paragraphIndex);
   const blockers = [];
+  if (input.command === "set-value") {
+    const value = input.startAt;
+    if (!Number.isInteger(value) || value === void 0 || value < 1) {
+      blockers.push({
+        code: "list-command-preflight-blocked",
+        ownerLayer: "L07",
+        message: "runtime.lists.set-value requires a positive integer startAt value.",
+        ...targetRef
+      });
+    }
+  }
   if (input.command === "continue-numbering" && !canContinuePrevious) {
     blockers.push({
       code: "list-continue-target-missing",
@@ -130107,6 +131128,7 @@ function editorCommandForListCommand(command, editableTarget, timestamp, startAt
     case "outdent":
       return { type: "list.outdent", editableTargets: [editableTarget], origin };
     case "restart-numbering":
+    case "set-value":
       return {
         type: "list.restart-numbering",
         editableTarget,
@@ -130190,33 +131212,35 @@ function resolveCurrentListTarget(document2, input) {
   return { kind: "resolved", ...resolved };
 }
 function currentListTargets(document2) {
-  const paragraphs = collectParagraphEntries(document2.content.children, "main");
+  const paragraphs = collectParagraphEntries(document2);
   const targets = collectEditableTargetRefs(document2).filter(isListTextTarget);
-  const byBlockPath = /* @__PURE__ */ new Map();
-  for (const target of targets) byBlockPath.set(target.blockPath, target);
+  const byStoryBlockPath = /* @__PURE__ */ new Map();
+  for (const target of targets) byStoryBlockPath.set(storyBlockPathKey(target.storyKey, target.blockPath), target);
   const out = [];
   for (let paragraphIndex = 0; paragraphIndex < paragraphs.length; paragraphIndex += 1) {
     const entry = paragraphs[paragraphIndex];
     if (!entry?.paragraph.numbering) continue;
-    const target = byBlockPath.get(entry.blockPath);
+    const target = byStoryBlockPath.get(storyBlockPathKey(entry.storyKey, entry.blockPath));
     if (!target) continue;
-    out.push({ target, paragraph: entry.paragraph, paragraphIndex });
+    out.push({ target, paragraph: entry.paragraph, paragraphIndex, storyKey: entry.storyKey });
   }
   return out;
 }
-function collectParagraphEntries(blocks, basePath) {
+function collectParagraphEntries(document2) {
   const out = [];
-  collectParagraphEntriesInto(blocks, basePath, out);
+  for (const context of collectStoryBlockContexts(document2)) {
+    collectParagraphEntriesInto(context.blocks, context.storyKey, context.basePath, out);
+  }
   return out;
 }
-function collectParagraphEntriesInto(blocks, basePath, out) {
+function collectParagraphEntriesInto(blocks, storyKey2, basePath, out) {
   for (let blockIndex = 0; blockIndex < blocks.length; blockIndex += 1) {
     const block = blocks[blockIndex];
     if (!block) continue;
     const blockPath = `${basePath}/block[${blockIndex}]`;
     switch (block.type) {
       case "paragraph":
-        out.push({ paragraph: block, blockPath });
+        out.push({ paragraph: block, storyKey: storyKey2, blockPath });
         break;
       case "table":
         for (let rowIndex = 0; rowIndex < block.rows.length; rowIndex += 1) {
@@ -130227,6 +131251,7 @@ function collectParagraphEntriesInto(blocks, basePath, out) {
             if (!cell) continue;
             collectParagraphEntriesInto(
               cell.children,
+              storyKey2,
               `${blockPath}/row[${rowIndex}]/cell[${cellIndex}]`,
               out
             );
@@ -130234,7 +131259,7 @@ function collectParagraphEntriesInto(blocks, basePath, out) {
         }
         break;
       case "sdt":
-        collectParagraphEntriesInto(block.children, blockPath, out);
+        collectParagraphEntriesInto(block.children, storyKey2, blockPath, out);
         break;
       case "custom_xml":
         break;
@@ -130278,13 +131303,16 @@ function toReadback(document2, target, paragraph) {
   };
 }
 function canContinuePreviousSequence(document2, paragraphIndex) {
-  const paragraphs = collectParagraphEntries(document2.content.children, "main");
-  const current = paragraphs[paragraphIndex]?.paragraph;
+  const paragraphs = collectParagraphEntries(document2);
+  const currentEntry = paragraphs[paragraphIndex];
+  const current = currentEntry?.paragraph;
   if (!current?.numbering) return false;
   const currentKind = getListKind(document2.numbering, current.numbering.numberingInstanceId);
   if (!currentKind) return false;
   for (let index = paragraphIndex - 1; index >= 0; index -= 1) {
-    const previous = paragraphs[index]?.paragraph;
+    const previousEntry = paragraphs[index];
+    if (previousEntry?.storyKey !== currentEntry.storyKey) break;
+    const previous = previousEntry.paragraph;
     if (!previous?.numbering) continue;
     const previousKind = getListKind(document2.numbering, previous.numbering.numberingInstanceId);
     return previousKind === currentKind && previous.numbering.numberingInstanceId !== current.numbering.numberingInstanceId;
@@ -130292,14 +131320,25 @@ function canContinuePreviousSequence(document2, paragraphIndex) {
   return false;
 }
 function canJoinPreviousSequence(document2, paragraphIndex) {
-  const paragraphs = collectParagraphEntries(document2.content.children, "main");
-  const current = paragraphs[paragraphIndex]?.paragraph;
-  const previous = paragraphs[paragraphIndex - 1]?.paragraph;
+  const paragraphs = collectParagraphEntries(document2);
+  const currentEntry = paragraphs[paragraphIndex];
+  const previousEntry = paragraphs[paragraphIndex - 1];
+  if (previousEntry?.storyKey !== currentEntry?.storyKey) return false;
+  const current = currentEntry?.paragraph;
+  const previous = previousEntry?.paragraph;
   if (!current?.numbering || !previous?.numbering) return false;
   const currentKind = getListKind(document2.numbering, current.numbering.numberingInstanceId);
   const previousKind = getListKind(document2.numbering, previous.numbering.numberingInstanceId);
   return Boolean(currentKind) && currentKind === previousKind && current.numbering.numberingInstanceId !== previous.numbering.numberingInstanceId;
 }
+function storyBlockPathKey(storyKey2, blockPath) {
+  return `${storyKey2}
+${blockPath}`;
+}
+function activeStoryKey(runtime) {
+  const activeStory = runtime.getRenderSnapshot()?.activeStory;
+  return activeStory ? storyTargetKey(activeStory) : void 0;
+}
 function unsupportedCommandBlocker(command, target) {
   return {
     code: "list-command-unsupported",
@@ -134594,33 +135633,51 @@ function createPlaceholderScopes(runtime, input) {
       blockerDetails: Object.freeze([detail])
     };
   }
-  const compiler = createScopeCompilerService(runtime);
   const byOriginalIndex = /* @__PURE__ */ new Map();
-  for (const item of orderedHits) {
+  const createdScopeIds = [];
+  const scopeRequests = orderedHits.map((item) => {
     const text = item.text || query;
     const label = input.labelPrefix === void 0 ? text : `${input.labelPrefix} ${item.originalIndex + 1}`;
-    const result = createScopeFromAnchor(runtime, {
-      anchor: { from: item.hit.from, to: item.hit.to },
+    return {
+      anchor: {
+        kind: "range",
+        from: item.hit.from,
+        to: item.hit.to,
+        assoc: input.assoc ?? { start: 1, end: -1 }
+      },
       mode: input.mode ?? "edit",
       label,
       ...input.visibility ? { visibility: input.visibility } : {},
       ...input.guardPolicy ? { guardPolicy: input.guardPolicy } : {},
       ...input.assoc ? { assoc: input.assoc } : {},
-      ...input.stableRefHint ? { stableRefHint: input.stableRefHint } : {}
-    });
-    if (result.status === "created") {
-      const compiled = compiler.compileScopeById(result.scopeId)?.scope;
+      ...input.stableRefHint ? {
+        scopeMetadataFields: [
+          {
+            key: "stableRefHint",
+            valueType: "string",
+            value: input.stableRefHint
+          }
+        ]
+      } : {}
+    };
+  });
+  const scopeResults = runtime.addScopes(scopeRequests);
+  orderedHits.forEach((item, requestIndex) => {
+    const text = item.text || query;
+    const result = scopeResults[requestIndex];
+    if (result && result.scopeId && result.plantStatus?.planted !== false) {
+      createdScopeIds.push(result.scopeId);
       byOriginalIndex.set(item.originalIndex, {
         status: "created",
         text,
         excerpt: excerpt(text),
-        scopeId: result.scopeId,
-        ...compiled?.handle ? { handle: compiled.handle } : {}
+        scopeId: result.scopeId
       });
-      continue;
+      return;
     }
+    const reason = result?.plantStatus?.reason ?? "unknown";
     const detail = blockerWithOwner(
-      `actions:placeholder-scopes:create-refused:${result.reason}`,
+      `actions:placeholder-scopes:create-refused:${reason}`,
       "blocked",
       "The placeholder match could not be converted into a workflow scope.",
       "Refresh the document and retry; if it still refuses, route the target to the workflow/scope writer owner.",
@@ -134633,6 +135690,38 @@ function createPlaceholderScopes(runtime, input) {
       blockers: Object.freeze([detail.code]),
       blockerDetails: Object.freeze([detail])
     });
+  });
+  if (createdScopeIds.length > 0) {
+    const createdScopeIdSet = new Set(createdScopeIds);
+    const handlesByScopeId = new Map(
+      createScopeCompilerService(runtime).compileAllScopes().filter((scope) => createdScopeIdSet.has(scope.handle.scopeId)).map((scope) => [scope.handle.scopeId, scope.handle])
+    );
+    for (const [originalIndex, item] of byOriginalIndex) {
+      if (item.status !== "created" || !item.scopeId) continue;
+      const handle = handlesByScopeId.get(item.scopeId);
+      if (!handle) {
+        const detail = blockerWithOwner(
+          `actions:placeholder-scopes:create-unresolved:${item.scopeId}`,
+          "blocked",
+          "The placeholder scope marker was planted but did not enumerate as a current semantic scope handle.",
+          "Treat this target as unresolved, refresh scope enumeration, and route persistent misses to the semantic-scope compiler owner.",
+          "L08"
+        );
+        byOriginalIndex.set(originalIndex, {
+          status: "blocked",
+          text: item.text,
+          excerpt: item.excerpt,
+          scopeId: item.scopeId,
+          blockers: Object.freeze([detail.code]),
+          blockerDetails: Object.freeze([detail])
+        });
+        continue;
+      }
+      byOriginalIndex.set(originalIndex, {
+        ...item,
+        handle
+      });
+    }
   }
   const scopes = orderedHits.map((item) => byOriginalIndex.get(item.originalIndex)).filter((value) => value !== void 0);
   const created = scopes.filter((scope) => scope.status === "created").length;