hyper-undo 0.7.0 → 0.8.0

package/src/replay-plan.js

@@ -53,9 +53,18 @@ function childIdentities(parent, isIgnored) {
 // `host` is the element a removed subtree belongs under. A detached node has no
 // ancestors left, so a predicate that reads them (is this attribute painted by an
 // app above it?) receives the host and answers as it did while attached.
-export function durableProjection(node, ignoredAttribute, host = null, ignoredNode = null) {
+function ownForm(node, form, host) {
+  if (typeof form !== 'function' || !isNode(node) || node.nodeType !== 1) return null
+  let own = null
+  try { own = form(node, host) } catch (_) { own = null }
+  return typeof own === 'string' ? `#form:${JSON.stringify(own)}` : null
+}
+
+export function durableProjection(node, ignoredAttribute, host = null, ignoredNode = null, form = null, texts = null) {
   if (!isNode(node)) return null
-  if (node.nodeType === 3) return `#text:${JSON.stringify(node.data)}`
+  const own = ownForm(node, form, host)
+  if (own != null) return own
+  if (node.nodeType === 3) return `#text:${JSON.stringify(texts && texts.has(node) ? texts.get(node) : node.data)}`
   if (node.nodeType === 8) return `#comment:${JSON.stringify(node.data)}`
   if (node.nodeType !== 1) return `#node:${node.nodeType}`
   const attributes = []
@@ -69,8 +78,10 @@ export function durableProjection(node, ignoredAttribute, host = null, ignoredNo
   const children = []
   if (node.childNodes) {
     for (const child of node.childNodes) {
+      const ownChild = ownForm(child, form, host)
+      if (ownChild != null) { children.push(ownChild); continue }
       if (isIgnoredNode(child, ignoredNode)) continue
-      children.push(durableProjection(child, ignoredAttribute, host, ignoredNode))
+      children.push(durableProjection(child, ignoredAttribute, host, ignoredNode, form, texts))
     }
   }
   const tag = String(node.tagName || '').toLowerCase()
@@ -153,7 +164,8 @@ function slotIndex(list, primitive) {
 export function compileCertificate(primitives, env = {}) {
   const isIgnored = env.isIgnored || null
   const ignoredAttribute = env.ignoreAttribute || null
-  const normalized = normalizePrimitives(primitives)
+  const durableForm = env.durableForm || null
+  const normalized = normalizePrimitives(primitives, { sameContent })
 
   const structural = []
   for (const p of normalized) {
@@ -183,7 +195,7 @@ export function compileCertificate(primitives, env = {}) {
       if (move.at === item) steps.push(move.step)
       continue
     }
-    steps.push(structuralStep(item, states.get(item), ignoredAttribute, isIgnored))
+    steps.push(structuralStep(item, states.get(item), ignoredAttribute, isIgnored, durableForm))
   }
   return { replayable: true, reason: null, steps }
 }
@@ -276,7 +288,7 @@ function pairMoves(structural, states) {
   return moves
 }
 
-function structuralStep(item, state, ignoredAttribute, ignoredNode) {
+function structuralStep(item, state, ignoredAttribute, ignoredNode, durableForm = null) {
   const kind = item.primitive.kind
   return {
     type: kind === 'add' ? 'add' : 'restore',
@@ -285,7 +297,7 @@ function structuralStep(item, state, ignoredAttribute, ignoredNode) {
     seqBefore: state.before,
     seqAfter: state.after,
     slot: item.primitive,
-    content: item.nodes.map((node) => durableProjection(node, ignoredAttribute, item.parent, ignoredNode)),
+    content: item.nodes.map((node) => durableProjection(node, ignoredAttribute, item.parent, ignoredNode, durableForm)),
     ids: kind === 'remove' ? item.nodes.flatMap((node) => durableIdsIn(node)) : [],
     targets: targetsOf(item.nodes, kind === 'add' ? 'added' : 'removed', item.parent),
   }
@@ -305,11 +317,13 @@ export function preflight(certificate, direction, env = {}) {
   const context = {
     isIgnored: env.isIgnored || null,
     ignoreAttribute: env.ignoreAttribute || null,
+    durableForm: env.durableForm || null,
     isProtected: env.isProtected || null,
     inScope: env.inScope || (() => true),
     liveNodesWithIds: env.liveNodesWithIds || (() => []),
     sim: new Map(),
     planned: new Map(),
+    texts: new Map(),
     operations: [],
   }
 
@@ -344,6 +358,12 @@ function refuseStep(code, targets) {
   return { code, targets: targets || [] }
 }
 
+export function sameContent(a, b) {
+  if (a === b) return true
+  if (typeof a !== 'string' || typeof b !== 'string') return false
+  return a.replace(/\u00A0| /g, ' ') === b.replace(/\u00A0| /g, ' ')
+}
+
 function liveValue(primitive) {
   if (primitive.kind === 'text') return primitive.target.data
   if (primitive.kind === 'value') {
@@ -369,11 +389,13 @@ function checkScalar(step, undoing, context) {
   if (primitive.kind === 'value' && typeof primitive.write === 'function' && typeof primitive.read !== 'function') {
     return refuseStep('unsupported', step.targets)
   }
-  if (liveValue(primitive) !== expected) return refuseStep('content-changed', step.targets)
+  const live = liveValue(primitive)
+  if (primitive.content === true ? !sameContent(live, expected) : live !== expected) return refuseStep('content-changed', step.targets)
   if (primitive.kind === 'value') {
-    context.operations.push({ type: 'value', target: primitive.target, prop: primitive.prop || 'value', value: next, read: primitive.read || null, write: primitive.write || null })
+    context.operations.push({ type: 'value', target: primitive.target, prop: primitive.prop || 'value', value: next, read: primitive.read || null, write: primitive.write || null, content: primitive.content === true })
   } else if (primitive.kind === 'text') {
     context.operations.push({ type: 'text', target: primitive.target, data: next })
+    context.texts.set(primitive.target, next)
   } else {
     context.operations.push({ type: 'attr', target: primitive.target, name: primitive.name, value: next == null ? null : next })
   }
@@ -381,13 +403,13 @@ function checkScalar(step, undoing, context) {
 }
 
 function checkAdd(step, undoing, context) {
-  if (!isNode(step.parent) || !context.inScope(step.parent)) return refuseStep('target-detached', step.targets)
+  if (!isNode(step.parent) || !inPlannedScope(step.parent, context)) return refuseStep('target-detached', step.targets)
   if (undoing) {
     if (!sameSequence(listFor(context, step.parent), step.seqAfter)) return refuseStep('structure-changed', step.targets)
     const protectedTargets = protectedWithin(step.nodes, context.isProtected)
     if (protectedTargets.length > 0) return refuseStep('protected', protectedTargets)
     for (let i = 0; i < step.nodes.length; i++) {
-      if (durableProjection(step.nodes[i], context.ignoreAttribute, step.parent, context.isIgnored) !== step.content[i]) return refuseStep('content-changed', step.targets)
+      if (durableProjection(step.nodes[i], context.ignoreAttribute, step.parent, context.isIgnored, context.durableForm) !== step.content[i]) return refuseStep('content-changed', step.targets)
     }
     for (const node of step.nodes) {
       context.operations.push({ type: 'remove', node })
@@ -417,12 +439,12 @@ function checkAdd(step, undoing, context) {
 }
 
 function checkRestore(step, undoing, context) {
-  if (!isNode(step.parent) || !context.inScope(step.parent)) return refuseStep('target-detached', step.targets)
+  if (!isNode(step.parent) || !inPlannedScope(step.parent, context)) return refuseStep('target-detached', step.targets)
   if (undoing) {
     if (!sameSequence(listFor(context, step.parent), step.seqAfter)) return refuseStep('structure-changed', step.targets)
     for (let i = 0; i < step.nodes.length; i++) {
       const node = step.nodes[i]
-      if (node.parentNode || durableProjection(node, context.ignoreAttribute, step.parent, context.isIgnored) !== step.content[i]) return refuseStep('content-changed', step.targets)
+      if (node.parentNode || durableProjection(node, context.ignoreAttribute, step.parent, context.isIgnored, context.durableForm) !== step.content[i]) return refuseStep('content-changed', step.targets)
     }
     if (step.ids.length > 0 && liveDuplicates(step.ids, context)) return refuseStep('duplicate-id', step.targets)
     const at = slotIndex(step.seqAfter, step.slot)
@@ -441,9 +463,15 @@ function checkRestore(step, undoing, context) {
   if (!sameSequence(listFor(context, step.parent), step.seqBefore)) return refuseStep('structure-changed', step.targets)
   const protectedTargets = protectedWithin(step.nodes, context.isProtected)
   if (protectedTargets.length > 0) return refuseStep('protected', protectedTargets)
+  // A child an earlier step of this replay moves out (a card moved to another
+  // column before its column is removed) is leaving, so the removed subtree is
+  // compared without it, as it was when it was recorded.
+  const leaving = (node) => context.planned.get(node) === true || (typeof context.isIgnored === 'function' && context.isIgnored(node))
+  // Text an earlier step of this replay rewrites (a field emptied before its text node
+  // is taken out) is compared as that step leaves it, as it was when it was recorded.
   for (let i = 0; i < step.nodes.length; i++) {
     const node = step.nodes[i]
-    if (node.parentNode !== step.parent || durableProjection(node, context.ignoreAttribute, step.parent, context.isIgnored) !== step.content[i]) return refuseStep('content-changed', step.targets)
+    if (node.parentNode !== step.parent || durableProjection(node, context.ignoreAttribute, step.parent, leaving, context.durableForm, context.texts) !== step.content[i]) return refuseStep('content-changed', step.targets)
   }
   for (const node of step.nodes) {
     context.operations.push({ type: 'remove', node })
@@ -469,7 +497,7 @@ function checkMove(step, undoing, context) {
   const gap = undoing ? step.source.after : step.dest.before
   const slot = undoing ? step.sourceSlot : step.destSlot
   if (!isNode(fromParent) || !isNode(toParent)) return refuseStep('target-detached', step.targets)
-  if (!context.inScope(fromParent) || !context.inScope(toParent)) return refuseStep('target-detached', step.targets)
+  if (!inPlannedScope(fromParent, context) || !inPlannedScope(toParent, context)) return refuseStep('target-detached', step.targets)
   if (!sameSequence(fromList, expectedFrom)) return refuseStep('structure-changed', step.targets)
   const toGap = fromParent === toParent ? withoutIdentity(toList, nodeId) : toList
   if (!sameSequence(toGap, gap)) return refuseStep('structure-changed', step.targets)
@@ -501,6 +529,15 @@ function findChildByIdentity(parent, id) {
   return null
 }
 
+function changedEnd(before, after) {
+  const max = Math.min(before.length, after.length)
+  let prefix = 0
+  while (prefix < max && before[prefix] === after[prefix]) prefix++
+  let suffix = 0
+  while (suffix < max - prefix && before[before.length - 1 - suffix] === after[after.length - 1 - suffix]) suffix++
+  return after.length - suffix
+}
+
 function writeValue(op, value) {
   if (typeof op.write === 'function') op.write(op.target, value)
   else op.target[op.prop] = value
@@ -509,8 +546,9 @@ function writeValue(op, value) {
 export function applyOperations(operations) {
   const journal = []
   try {
-    for (const op of operations) applyOne(op, journal)
-    return { ok: true }
+    let caret = null
+    for (const op of operations) caret = applyOne(op, journal) || caret
+    return { ok: true, caret }
   } catch (error) {
     for (let i = journal.length - 1; i >= 0; i--) {
       try { journal[i]() } catch (_) { /* the rollback keeps trying the rest */ }
@@ -534,13 +572,16 @@ function applyOne(op, journal) {
     const previous = op.target.data
     op.target.data = op.data
     journal.push(() => { op.target.data = previous })
-    return
+    return { node: op.target, offset: changedEnd(previous, op.data) }
   }
   if (op.type === 'value') {
     const previous = typeof op.read === 'function' ? op.read(op.target) : op.target[op.prop]
+    const textBefore = op.content ? op.target.textContent : null
     writeValue(op, op.value)
     journal.push(() => writeValue(op, previous))
-    return
+    if (!op.content) return
+    const textAfter = op.target.textContent
+    return textAfter === textBefore ? undefined : { root: op.target, textOffset: changedEnd(textBefore, textAfter) }
   }
   if (op.type === 'insert') {
     const before = op.beforeId == null ? null : findChildByIdentity(op.parent, op.beforeId)
@@ -552,13 +593,17 @@ function applyOne(op, journal) {
       if (fromParent) fromParent.insertBefore(op.node, fromNext && fromNext.parentNode === fromParent ? fromNext : null)
       else if (op.node.parentNode === op.parent) op.parent.removeChild(op.node)
     })
-    return
+    if (op.node.nodeType !== 3) return
+    return { node: op.node, offset: op.node.data.length }
   }
   if (op.type === 'remove') {
     const parent = op.node.parentNode
     if (!parent) throw new Error('hyper-undo: replay target is no longer attached')
     const next = op.node.nextSibling
+    const index = Array.prototype.indexOf.call(parent.childNodes, op.node)
     parent.removeChild(op.node)
     journal.push(() => parent.insertBefore(op.node, next))
+    if (op.node.nodeType !== 3) return
+    return { node: parent, offset: index }
   }
 }

package/src/scope.js

@@ -1,7 +1,8 @@
 import { recordsToPrimitives } from './primitives.js'
-import { compileCertificate, preflight, applyOperations, described } from './replay-plan.js'
+import { compileCertificate, preflight, applyOperations, described, sameContent } from './replay-plan.js'
 import { shouldIgnore } from './filter.js'
 import { createEmitter } from './emitter.js'
+import { watchTyping } from './typing.js'
 
 const DEFAULTS = {
   maxHistory: 100,
@@ -11,6 +12,9 @@ const DEFAULTS = {
   ignoreAttribute: null,
   isProtected: null,
   ignoreNode: null,
+  durableForm: null,
+  typingBreak: null,
+  refused: null,
   debug: false,
 }
 
@@ -32,6 +36,10 @@ export function createScope(opts) {
   let recordingMode = config.recording === 'commands' ? 'commands' : 'automatic'
   let capture = null       // { records, primitives } while an explicit command runs
   let replaying = false    // true only inside an undo/redo preflight and apply
+  let tracked = new WeakMap()   // root element -> { prop, read, write, baseline }
+  let composing = false        // an input method composition is open
+  let movedUnderStep = false   // a paused writer changed what the open step changed
+  let typingCleanup = null     // watchTyping's cleanup, kept for stop()
 
   function log(...args) { if (config.debug) console.log('[hyper-undo]', ...args) }
 
@@ -49,6 +57,15 @@ export function createScope(opts) {
       attributeOldValue: true,
       characterDataOldValue: true,
     })
+    typingCleanup = watchTyping(config.scope, {
+      sentence: config.typingBreak === 'sentence',
+      stepOpen: () => {
+        if (pauseDepth === 0 && observer) handleRecords(observer.takeRecords())
+        return pendingPrimitives.length > 0
+      },
+      endStep: flush,
+      composing: setComposing,
+    })
     log('started')
   }
 
@@ -74,6 +91,8 @@ export function createScope(opts) {
     if (!started) return
     started = false
     if (observer) { observer.disconnect(); observer = null }
+    if (typingCleanup) { typingCleanup(); typingCleanup = null }
+    composing = false
     clearIdleTimer()
     undoStack.length = 0
     redoStack.length = 0
@@ -82,6 +101,7 @@ export function createScope(opts) {
     capture = null
     replaying = false
     pauseDepth = 0   // reset so a reused (created) scope doesn't restart paused
+    tracked = new WeakMap()
     log('stopped')
   }
 
@@ -93,6 +113,70 @@ export function createScope(opts) {
     return !!(el && el.nodeType === 1 && el.isConnected === false)
   }
 
+  // --- Tracked content ---
+
+  function readContent(root, read) {
+    try { const value = read(root); return typeof value === 'string' ? value : null } catch (_) { return null }
+  }
+
+  function trackContent(root, { read, write, prop = 'content' } = {}) {
+    if (!root || typeof read !== 'function' || typeof write !== 'function') return () => {}
+    const state = { prop, read, write, baseline: readContent(root, read) }
+    tracked.set(root, state)
+    return () => { if (tracked.get(root) === state) tracked.delete(root) }
+  }
+
+  function trackedRootOf(node) {
+    for (let n = node; n; n = n.parentNode) if (tracked.has(n)) return n
+    return null
+  }
+
+  function isTrackedContent(record) {
+    const root = trackedRootOf(record.target)
+    return !!root && !(record.type === 'attributes' && record.target === root)
+  }
+
+  function contentRootsIn(records) {
+    const roots = new Set()
+    for (const record of records) if (isTrackedContent(record)) roots.add(trackedRootOf(record.target))
+    return roots
+  }
+
+  function sampleContent(roots) {
+    const out = []
+    for (const root of roots) {
+      const state = tracked.get(root)
+      const now = readContent(root, state.read)
+      if (now == null) continue
+      if (sameContent(now, state.baseline)) { state.baseline = now; continue }
+      if (state.baseline != null) out.push({ kind: 'value', target: root, prop: state.prop, oldValue: state.baseline, newValue: now, read: state.read, write: state.write, content: true })
+      state.baseline = now
+    }
+    return out
+  }
+
+  function rebaseContent(roots) {
+    for (const root of roots) {
+      const state = tracked.get(root)
+      state.baseline = readContent(root, state.read)
+    }
+  }
+
+  // Records another writer made while this scope was paused are dropped. When one of
+  // them changed a text node, an attribute or a tracked field the open step has already
+  // changed, the step has to close before this tab types again: joined with that typing
+  // it would run from before the other writer's change to after it, and its undo would
+  // take their change back.
+  function dropPaused(records) {
+    const roots = contentRootsIn(records)
+    if (!movedUnderStep && pendingPrimitives.some((p) => p.kind === 'value'
+      ? roots.has(p.target)
+      : records.some((r) => r.target === p.target && (r.type === 'characterData' ? p.kind === 'text' : r.type === 'attributes' && r.attributeName === p.name)))) {
+      movedUnderStep = true
+    }
+    rebaseContent(roots)
+  }
+
   // --- Observer callback ---
 
   // The record source's callback. It hands over its own instance as a second
@@ -115,9 +199,10 @@ export function createScope(opts) {
     // Commands mode: an unbracketed record is some other writer's (a merge, a
     // sap paint, a sortable gesture). It changes the document, so later guards
     // see it, but it is not a local action and earns no entry.
-    if (recordingMode === 'commands') return
-    if (pauseDepth > 0) return
+    if (recordingMode === 'commands') { rebaseContent(contentRootsIn(records)); return }
+    if (pauseDepth > 0) { dropPaused(records); return }
     const prims = convertRecords(dropIgnoredRecords(records), bracketed)
+    for (const p of sampleContent(contentRootsIn(records))) prims.push(p)
     if (prims.length > 0) {
       for (const p of prims) pendingPrimitives.push(p)
       restartIdleTimer()
@@ -154,15 +239,28 @@ export function createScope(opts) {
   // what it wrote there is one entry, so it may own the scope document's head
   // fields too; head's <title> stays with the bracket's own title capture.
   function convertRecords(records, bracketed = false) {
-    const kept = records.filter((r) => (observedHere(r.target) || (bracketed && inHead(r.target))) && !shouldIgnore(r.target, config.ignoreAttribute, r))
+    const removedHere = removedFromScope(records)
+    const kept = records.filter((r) => (observedHere(r.target) || removedHere(r.target) || (bracketed && inHead(r.target))) && !isTrackedContent(r) && !shouldIgnore(r.target, config.ignoreAttribute, r))
     return recordsToPrimitives(kept, (node) => shouldIgnore(node, config.ignoreAttribute))
   }
 
   // --- Idle batching ---
 
+  function setComposing(on) {
+    composing = !!on
+    if (!composing && pendingPrimitives.length > 0) restartIdleTimer()
+  }
+
   function restartIdleTimer() {
     clearIdleTimer()
-    idleTimer = setTimeout(closeIdleBatch, config.idleWindowMs)
+    idleTimer = setTimeout(onIdle, config.idleWindowMs)
+  }
+  // A step never closes while a composition is open: the timer waits it out and
+  // the composed text lands in one entry.
+  function onIdle() {
+    idleTimer = null
+    if (composing) { idleTimer = setTimeout(onIdle, config.idleWindowMs); return }
+    closeIdleBatch()
   }
   function clearIdleTimer() {
     if (idleTimer != null) { clearTimeout(idleTimer); idleTimer = null }
@@ -178,7 +276,7 @@ export function createScope(opts) {
   // --- Commit machinery ---
 
   function pushCommit(label, primitives) {
-    const certificate = compileCertificate(primitives, { isIgnored: isIgnoredNode, ignoreAttribute: isIgnoredAttribute })
+    const certificate = compileCertificate(primitives, { isIgnored: isIgnoredNode, ignoreAttribute: isIgnoredAttribute, durableForm: config.durableForm })
     if (certificate.steps.length === 0) {
       log('commit', label, 'with nothing to record')
       emitter.emit('commit')
@@ -253,20 +351,22 @@ export function createScope(opts) {
     // If an OUTER pause is still active (this capture frame is nested inside an
     // exclusion pause), honor the outer "exclude everything" contract: discard
     // the captured records instead of committing through the outer pause.
-    if (pauseDepth > 1) { observer.takeRecords(); return }
+    if (pauseDepth > 1) { rebaseContent(contentRootsIn(observer.takeRecords())); return }
     // Close any pending idle batch (e.g. in-progress typing captured BEFORE the
     // pause) as its own commit FIRST, so the structural commit we're about to
     // push lands AFTER it in history. Without this, type-then-immediately-add
     // would record the structural op before the typing, inverting undo order.
     flush()
-    const primitives = convertRecords(observer.takeRecords(), true)
+    const records = observer.takeRecords()
+    const primitives = convertRecords(records, true)
+    for (const p of sampleContent(contentRootsIn(records))) primitives.push(p)
     if (primitives.length === 0) return
     clearIdleTimer()
     pushCommit(label, primitives)
   }
 
   function discardCaptured() {
-    if (observer) observer.takeRecords()
+    if (observer) rebaseContent(contentRootsIn(observer.takeRecords()))
   }
 
   // --- Explicit commands ---
@@ -332,6 +432,7 @@ export function createScope(opts) {
     capture = null
     if (!held) return []
     const primitives = convertRecords(held.records, true)
+    for (const p of sampleContent(contentRootsIn(held.records))) primitives.push(p)
     for (const p of held.primitives) primitives.push(p)
     return primitives
   }
@@ -464,7 +565,14 @@ export function createScope(opts) {
     if (pauseDepth === 0) return  // underflow guard
     pauseDepth--
     // Discard records captured during the pause only on the outermost release.
-    if (pauseDepth === 0 && observer) observer.takeRecords()
+    if (pauseDepth === 0 && observer) {
+      dropPaused(observer.takeRecords())
+      if (movedUnderStep) {
+        movedUnderStep = false
+        clearIdleTimer()
+        closeIdleBatch()
+      }
+    }
     log('resumed', pauseDepth)
   }
 
@@ -473,51 +581,88 @@ export function createScope(opts) {
   // One entry is applied whole or not at all. Preflight compares the certificate
   // against the live document without writing; only a fully validated plan
   // reaches the DOM, and a native failure rolls it back and keeps both stacks.
+  // With `refused: 'skip'` a refused entry is dropped and the call goes on to the
+  // next one, so a step that can no longer be replayed never blocks older ones.
   function replay(direction, requestedId) {
     if (scopeDisconnected()) { stop(); return { ok: false, code: 'disconnected' } }
+    // A consumer can hold replay (an open gesture, a pending save) without
+    // refusing the entry: the stacks and the document stay as they are.
+    if (typeof config.holdReplay === 'function' && config.holdReplay()) return { ok: false, code: 'held' }
     flush()
     const source = direction === 'undo' ? undoStack : redoStack
     const destination = direction === 'undo' ? redoStack : undoStack
-    const entry = source.at(-1)
+    const skipped = []
+    let entry = source.at(-1)
     if (!entry) return { ok: false, code: 'empty' }
     if (requestedId && requestedId !== entry.id) {
       const requested = findEntry(requestedId) || entry
       return refuse(requested, direction, 'stale-entry')
     }
-    let checked
-    replaying = true
-    try {
-      checked = preflight(entry.certificate, direction, {
-        isIgnored: isIgnoredNode,
-        ignoreAttribute: isIgnoredAttribute,
-        isProtected: isProtectedNode,
-        inScope,
-        liveNodesWithIds,
-      })
-    } finally {
-      replaying = false
-    }
-    if (!checked.ok) return refuse(entry, direction, checked.code, checked.targets)
-    pause()
-    let applied
-    replaying = true
-    try {
-      applied = applyOperations(checked.operations)
-    } finally {
-      replaying = false
-      resume()
-    }
-    if (!applied.ok) {
-      log(`${direction} failed and was rolled back`, applied.error)
-      return refuse(entry, direction, 'replay-error')
+    const canSkip = config.refused === 'skip' && !requestedId
+    while (entry) {
+      let checked
+      replaying = true
+      try {
+        checked = preflight(entry.certificate, direction, {
+          isIgnored: isIgnoredNode,
+          ignoreAttribute: isIgnoredAttribute,
+          durableForm: config.durableForm,
+          isProtected: isProtectedNode,
+          inScope,
+          liveNodesWithIds,
+        })
+      } finally {
+        replaying = false
+      }
+      if (!checked.ok) {
+        if (!canSkip) return refuse(entry, direction, checked.code, checked.targets)
+        skipEntry(entry, direction, checked.code, checked.targets, skipped)
+        entry = source.at(-1)
+        continue
+      }
+      pause()
+      let applied
+      replaying = true
+      try {
+        applied = applyOperations(checked.operations)
+      } finally {
+        replaying = false
+        resume()
+      }
+      if (!applied.ok) {
+        log(`${direction} failed and was rolled back`, applied.error)
+        if (!canSkip) return refuse(entry, direction, 'replay-error')
+        skipEntry(entry, direction, 'replay-error', [], skipped)
+        entry = source.at(-1)
+        continue
+      }
+      rebaseContent(new Set(checked.operations.filter((op) => op.type === 'value' && tracked.has(op.target)).map((op) => op.target)))
+      source.pop()
+      destination.push(entry)
+      refusedTop = null
+      const receipt = { ok: true, entryId: entry.id, label: entry.label, direction }
+      if (skipped.length) receipt.skipped = skipped
+      if (applied.caret) receipt.caret = applied.caret
+      log(direction, entry.label)
+      emitter.emit(direction, receipt)
+      return receipt
     }
-    source.pop()
-    destination.push(entry)
+    return { ok: false, code: 'empty', direction, skipped }
+  }
+
+  // Drop a refused entry in the same press. Its description is built while it is
+  // still on its stack (describe() reads refusedTop), so a consumer can keep a
+  // recovery copy of what the removed entry would have restored.
+  function skipEntry(entry, direction, code, targets, skipped) {
+    refusedTop = { entryId: entry.id, direction, code, targets }
+    const description = describe(entry.id)
+    const stack = direction === 'undo' ? undoStack : redoStack
+    stack.pop()
     refusedTop = null
-    const receipt = { ok: true, entryId: entry.id, label: entry.label, direction }
-    log(direction, entry.label)
-    emitter.emit(direction, receipt)
-    return receipt
+    const record = { entryId: entry.id, label: entry.label, direction, code, targets, description }
+    log('skipped', direction, code)
+    emitter.emit('skipped', record)
+    skipped.push(record)
   }
 
   function undo(opts) { return replay('undo', opts && opts.entryId) }
@@ -572,6 +717,15 @@ export function createScope(opts) {
     }
   }
 
+  // A host's durable form is stored as #form:"<json string>"; a description shows the
+  // string itself, not the token.
+  function readableForm(content) {
+    if (typeof content !== 'string') return null
+    return content.replace(/#form:("(?:[^"\\]|\\.)*")/g, (_, json) => {
+      try { return JSON.parse(json) } catch (_) { return '' }
+    })
+  }
+
   function describeStep(step) {
     if (step.type === 'move') {
       return {
@@ -587,7 +741,7 @@ export function createScope(opts) {
       return {
         kind: step.type === 'add' ? 'add' : 'remove',
         parent: { id: described(step.parent).id },
-        nodes: step.nodes.map((node, i) => ({ id: described(node).id, html: step.content[i] ?? null })),
+        nodes: step.nodes.map((node, i) => ({ id: described(node).id, html: readableForm(step.content[i]) })),
       }
     }
     const primitive = step.primitive
@@ -604,9 +758,34 @@ export function createScope(opts) {
     return { kind: step.type, target, before, after }
   }
 
+  // A subtree removed from the scope in this batch is detached by the time the
+  // batch is read, yet what happened inside it before the removal (a child moved
+  // out of it, say) belongs to the same edit: dropping it would restore the
+  // subtree as it was left, not as it was.
+  function removedFromScope(records) {
+    const removed = new Set()
+    let grew = true
+    while (grew) {
+      grew = false
+      for (const r of records) {
+        if (r.type !== 'childList' || !r.removedNodes?.length) continue
+        if (isTrackedContent(r)) continue
+        if (!observedHere(r.target) && !insideRemoved(r.target, removed)) continue
+        if (shouldIgnore(r.target, config.ignoreAttribute, r)) continue
+        for (const node of r.removedNodes) if (!removed.has(node)) { removed.add(node); grew = true }
+      }
+    }
+    return (node) => !observedHere(node) && insideRemoved(node, removed)
+  }
+
+  function insideRemoved(node, removed) {
+    for (let n = node; n; n = n.parentNode) if (removed.has(n)) return true
+    return false
+  }
+
   function observedHere(node) {
     const root = config.scope
-    if (!root || !node) return false
+    if (!root || !node || typeof node.nodeType !== 'number') return false
     return node === root || (typeof root.contains === 'function' && root.contains(node))
   }
 
@@ -653,7 +832,7 @@ export function createScope(opts) {
     // Discard any same-tick buffered records too, so a bootstrap mutation
     // followed by clear() in the same turn doesn't resurface as a commit once
     // the observer callback fires.
-    if (observer) observer.takeRecords()
+    if (observer) rebaseContent(contentRootsIn(observer.takeRecords()))
     undoStack.length = 0
     redoStack.length = 0
     pendingPrimitives = []
@@ -667,10 +846,12 @@ export function createScope(opts) {
 
   return {
     _config: config,  // private: used by keys.js to read shadowKeydownIn
+    _tracksContentAt: (node) => recordingMode !== 'commands' && !!trackedRootOf(node),  // private: keys.js rule 4
+    _recordsAt: (node) => recordingMode !== 'commands' && !isIgnoredNode(node),  // private: keys.js rule 4
     start, stop,
     commit, commitCaptured, discardCaptured, flush,
     command, setRecording,
-    record, recordValue,
+    record, recordValue, trackContent,
     undo, redo, clear, discard, describe,
     pause, resume,
     on: emitter.on, off: emitter.off,