rapier-html 1.1.99 → 1.1.102

package/dist/ledger/transport.mjs

@@ -1,6 +1,7 @@
 // SPDX-License-Identifier: MIT
 // Paired source placement, shared by live editing and canonical-history proof.
 import {_rapierTransformSplices, _rapierValidAuthored, _rapierHistoryEffects} from './journal-records.mjs';
+import {projectInverseSource} from './inverse-source.mjs';
 import {sha256} from './hash.mjs';
 import {canonicalJSON} from './data.mjs';
 
@@ -169,7 +170,38 @@ function authoredReplay(base, records, append = null) {
   const origins = new Map(), byId = new Map(), originalOrder = [], cache = new Map(), frontier = new Set();
   const effects = _rapierHistoryEffects(append ? [...records, append] : records);
   if (!effects.ok) throw new RangeError('canonical_origin_invalid');
-  let source = base;
+  const referenced = new Set();
+  let sharedInverses = false;
+  for (const refs of effects.references.values()) for (const id of refs) {
+    if (referenced.has(id)) sharedInverses = true;
+    referenced.add(id);
+  }
+  const projectInverse = (text, placed, id) => {
+    const refs = effects.references.get(id), before = _rapierHistoryEffects(placed);
+    const after = _rapierHistoryEffects([...placed, {transaction: {id, sourceTransactionIds: refs}}]);
+    if (!before.ok || !after.ok) throw new RangeError('canonical_origin_invalid');
+    const result = projectInverseSource({source: text, initialSource: base,
+      rows: placed.map(record => ({record, splices: record.splices})), effects: before}, new Set(refs), after);
+    if (!result.ok) throw new RangeError('canonical_origin_invalid');
+    return result;
+  };
+  // Only immutable text digests are reused, within this one replay. Every
+  // authored-source comparison and physical placement proof still runs.
+  const textHashes = new Map();
+  const hashText = text => {
+    if (typeof text !== 'string') return sha256(text);
+    let digest = textHashes.get(text);
+    if (digest === undefined) { digest = sha256(text); textHashes.set(text, digest); }
+    return digest;
+  };
+  const same = (a, b) => canonicalJSON(a) === canonicalJSON(b);
+  // Only owner-created ordered views of already admitted string IDs use this.
+  const sameIds = (a, b) => {
+    if (a.length !== b.length) return false;
+    for (let index = 0; index < a.length; index++) if (a[index] !== b[index]) return false;
+    return true;
+  };
+  let source = base, linearPrefix = 0;
   for (const record of append ? [...records, append] : records) {
     const id = record.transaction.id;
     if (byId.has(id)) throw new RangeError('canonical_origin_invalid');
@@ -189,6 +221,11 @@ function authoredReplay(base, records, append = null) {
     })()))) throw new RangeError('canonical_origin_invalid');
     const refs = effects.references.get(id) || [];
     if (refs.some(id => !seen.has(id))) throw new RangeError('canonical_origin_invalid');
+    // An explicit origin can prove the same linear placement as an implicit one.
+    // Preserve the origin, but do not reconstruct every growing prefix to prove it again.
+    if (linearPrefix === originalOrder.length && same(origin.basis, [...frontier].sort()) &&
+        same(origin.splices, record.splices) && (!Object.hasOwn(record, 'authored') || origin.source === sha256(source)))
+      linearPrefix++;
     for (const prior of seen) frontier.delete(prior); frontier.add(id);
     origins.set(id, origin); byId.set(id, record); originalOrder.push(id);
     if (record !== append) {
@@ -196,7 +233,6 @@ function authoredReplay(base, records, append = null) {
       if (source === null) throw new RangeError('canonical_origin_invalid');
     }
   }
-  const same = (a, b) => canonicalJSON(a) === canonicalJSON(b);
   const ordered = (ids, selected = null) => {
     const order = [], known = new Set(ids), waiting = new Map(), dependents = new Map(), ready = [];
     const rank = id => selected ? Number(selected.has(id)) : Number(origins.get(id).splices.some(row => row.removed.length));
@@ -229,17 +265,60 @@ function authoredReplay(base, records, append = null) {
       closure.add(prior); pending.push(...origins.get(prior).basis); }
     return closure;
   };
-  const canonicalOrder = ordered(originalOrder), firstExplicit = (append ? [...records, append] : records).findIndex(record => Object.hasOwn(record, 'authored'));
-  const implicitPrefix = firstExplicit < 0 ? records.length : firstExplicit;
-  const materialize = order => {
-    const key = canonicalJSON(order);
+  const canonicalOrder = ordered(originalOrder);
+  // Only the three immediate fresh-spread call sites use this entry. Nothing
+  // retains allocation trust after an array has crossed an observable method.
+  const literalKey = order => {
+    // An input iterator can supply arbitrary values. Preserve the whole-array
+    // depth/refusal path before any per-string encoding in that case.
+    for (let index = 0; index < order.length; index++)
+      if (typeof order[index] !== 'string') return canonicalJSON(order);
+    // Keep each canonical primitive encoder call and its serializer behavior.
+    return '[' + Array.from({length: order.length}, (_, index) => canonicalJSON(order[index])).join(',') + ']';
+  };
+  const materialize = (order, rawSubmitted = false) => materializeKey(order, canonicalJSON(order), rawSubmitted);
+  const materializeLiteral = order => materializeKey(order, literalKey(order), false);
+  const materializeKey = (order, key, rawSubmitted) => {
     if (cache.has(key)) return cache.get(key);
-    const placed = [], ids = new Set(), sourceIndices = new Map(); let text = base;
+    let prefixEnds = null;
+    const prefixKey = length => {
+      // The original submitted array keeps its existing slice/species/data gate.
+      // Only this module's own order allocations use the validated key string.
+      if (rawSubmitted) return canonicalJSON(order.slice(0, length));
+      if (!prefixEnds) {
+        prefixEnds = [1];
+        let quoted = false, depth = 0;
+        // Scan canonical JSON only: an escaped code unit cannot end a string,
+        // and commas inside strings or nested values cannot split this array.
+        for (let at = 1; at < key.length - 1; at++) {
+          const code = key.charCodeAt(at);
+          if (quoted) {
+            if (code === 92) at++;
+            else if (code === 34) quoted = false;
+          } else if (code === 34) quoted = true;
+          else if (code === 91 || code === 123) depth++;
+          else if (code === 93 || code === 125) depth--;
+          else if (code === 44 && depth === 0) prefixEnds.push(at);
+        }
+        if (key.length > 2) prefixEnds.push(key.length - 1);
+      }
+      return length === prefixEnds.length - 1 ? key : key.slice(0, prefixEnds[length]) + ']';
+    };
+    let placed = [], ids = new Set(), sourceIndices = new Map(), text = base;
     if (!order.length) { const empty = {text, records: [], sourceIndices}; cache.set(key, empty); return empty; }
-    // An implicit linear prefix already is its authored view. Replay it once;
+    // A proved linear prefix already is its authored view. Replay it once;
     // reconstructing every growing prefix adds no evidence.
     let prefix = 0;
-    while (prefix < order.length && prefix < implicitPrefix && order[prefix] === originalOrder[prefix]) {
+    // Resume only an exact ordered prefix already proved in this replay. Copy its
+    // mutable containers before extending it; transported rows retain their placement.
+    for (let length = order.length - 1; length > 0; length--) {
+      const prior = cache.get(prefixKey(length));
+      if (!prior) continue;
+      placed = prior.records.slice(); ids = new Set(order.slice(0, length));
+      sourceIndices = new Map(prior.sourceIndices); text = prior.text; prefix = length;
+      break;
+    }
+    while (prefix < order.length && prefix < linearPrefix && order[prefix] === originalOrder[prefix]) {
       const record = byId.get(order[prefix]); text = _rapierTransformSplices(text, record.splices);
       if (text === null) throw new RangeError('canonical_origin_invalid');
       placed.push(record); ids.add(order[prefix++]);
@@ -249,28 +328,53 @@ function authoredReplay(base, records, append = null) {
       const original = byId.get(id), origin = origins.get(id);
       if (!original || ids.has(id) || origin.basis.some(prior => !ids.has(prior)))
         throw new RangeError('canonical_origin_invalid');
-      const closure = closureOf(origin.basis), basisOrder = canonicalOrder.filter(prior => closure.has(prior)), basis = materialize(basisOrder);
-      if (sha256(basis.text) !== origin.source) throw new RangeError('canonical_origin_invalid');
+      const closure = closureOf(origin.basis);
+      if (closure.size === ids.size && [...closure].every(prior => ids.has(prior))) {
+        // The current view already is the complete authored context. There are no
+        // independent rows to cross, even when earlier acts were concurrent.
+        if (hashText(text) !== origin.source) throw new RangeError('canonical_origin_invalid');
+        const next = _rapierTransformSplices(text, origin.splices);
+        if (next === null) throw new RangeError('canonical_origin_invalid');
+        placed.push({...original, splices: origin.splices}); text = next; ids.add(id);
+        if (original.derivedCommentIndex != null) sourceIndices.set(id, origin.splices.map((_, index) => index));
+        cache.set(prefixKey(placed.length), {text, records: placed.slice(), sourceIndices: new Map(sourceIndices)});
+        continue;
+      }
+      const basisOrder = canonicalOrder.filter(prior => closure.has(prior)), basis = materialize(basisOrder);
+      if (hashText(basis.text) !== origin.source) throw new RangeError('canonical_origin_invalid');
       // Reconstruct causal context before crossing it. Physical gaps may already
       // have collapsed under a deletion; they cannot choose concurrent ordering.
-      const contextOrder = canonicalOrder.filter(prior => ids.has(prior)), context = same(contextOrder, [...ids]) ? {text, records: placed} : materialize(contextOrder);
+      const contextOrder = canonicalOrder.filter(prior => ids.has(prior)), context = sameIds(contextOrder, [...ids]) ? {text, records: placed} : materialize(contextOrder);
       if (context.text !== text) throw new RangeError('canonical_origin_invalid');
       const alignedOrder = [...basisOrder, ...contextOrder.filter(prior => !closure.has(prior))];
-      const aligned = same(alignedOrder, [...ids]) ? {text, records: placed} : materialize(alignedOrder);
+      const aligned = sameIds(alignedOrder, [...ids]) ? {text, records: placed} : materializeLiteral(alignedOrder);
       if (aligned.text !== text) throw new RangeError('canonical_origin_invalid');
       const crossed = aligned.records.slice(basisOrder.length);
-      const moved = transposeRecord(basis.text, origin.splices, id, crossed);
+      let moved;
+      if (sharedInverses && effects.references.get(id)?.length) {
+        // Each inverse retains its own targets. First prove the exact intention
+        // in its causal source, then place that choice in the accepted effect
+        // graph. Another inverse may already suppress the same original bytes.
+        const authored = projectInverse(basis.text, basis.records, id);
+        if (!same(origin.splices, authored.splices) ||
+            _rapierTransformSplices(basis.text, origin.splices) !== authored.after)
+          throw new RangeError('canonical_origin_invalid');
+        const accepted = projectInverse(text, aligned.records, id);
+        moved = {text: accepted.after, splices: accepted.splices};
+      } else moved = transposeRecord(basis.text, origin.splices, id, crossed);
       if (_rapierTransformSplices(text, moved.splices) !== moved.text) throw new RangeError('canonical_origin_invalid');
       placed.push({...original, splices: moved.splices}); text = moved.text; ids.add(id);
       if (original.derivedCommentIndex != null) sourceIndices.set(id, moved.sourceIndices);
-      cache.set(canonicalJSON(order.slice(0, placed.length)), {text, records: placed.slice(), sourceIndices: new Map(sourceIndices)});
+      cache.set(prefixKey(placed.length), {text, records: placed.slice(), sourceIndices: new Map(sourceIndices)});
     }
     const value = {text, records: placed, sourceIndices}; cache.set(key, value); return value;
   };
   const physicalOrder = append ? originalOrder.slice(0, -1) : originalOrder, physical = materialize(physicalOrder);
   if (physical.text !== source || physical.records.some((row, index) => !same(row.splices, records[index].splices)))
     throw new RangeError('canonical_origin_invalid');
-  return {source, origins, originalOrder, materialize, ordered};
+  // Raw submission is selected here by a private call site, never an input flag.
+  return {source, origins, originalOrder, materialize, materializeLiteral,
+    materializeSubmitted: order => materialize(order, true), ordered};
 }
 
 export function authoredHistory(base, records, selected = null) {
@@ -306,13 +410,13 @@ export function authoredSourceReader(base, records) {
 export function transposeAuthored(base, records, incoming, submitted) {
   if (!incoming.authored || !Array.isArray(submitted)) throw new RangeError('canonical_origin_invalid');
   const replay = authoredReplay(base, records, incoming), id = incoming.transaction.id;
-  const authored = replay.materialize([...submitted, id]);
+  const authored = replay.materializeLiteral([...submitted, id]);
   if (canonicalJSON(authored.records.at(-1).splices) !== canonicalJSON(incoming.splices))
     throw new RangeError('canonical_origin_invalid');
   const accepted = replay.materialize(replay.originalOrder), known = new Set([...submitted, id]);
-  const reciprocal = replay.materialize([...submitted, id, ...replay.ordered(replay.originalOrder).filter(prior => !known.has(prior))]);
+  const reciprocal = replay.materializeLiteral([...submitted, id, ...replay.ordered(replay.originalOrder).filter(prior => !known.has(prior))]);
   if (reciprocal.text !== accepted.text) throw new RangeError('canonical_origin_invalid');
   return {text: accepted.text, splices: accepted.records.at(-1).splices,
-    submittedBefore: replay.materialize(submitted).text, submitted: authored.text,
+    submittedBefore: replay.materializeSubmitted(submitted).text, submitted: authored.text,
     against: reciprocal.records.slice(submitted.length + 1)};
 }