@pilotiq/pilotiq 0.12.0 → 0.13.1

package/src/react/formStateHelpers.test.ts

@@ -4,7 +4,6 @@ import assert from 'node:assert/strict'
 import {
   collectFieldDefaults,
   collectRowArrayFieldNames,
-  collectRowTextLeavesByArray,
   fieldOptsOutOfCollab,
   findFieldMeta,
   parseFormDataToNested,
@@ -492,104 +491,6 @@ describe('routeBindingWrite', () => {
   })
 })
 
-describe('collectRowTextLeavesByArray', () => {
-  const textField = (name: string, fieldType: string = 'text', collab?: boolean): ElementMeta => ({
-    type:      'field',
-    fieldType,
-    name,
-    label:     name,
-    required:  false,
-    disabled:  false,
-    ...(collab === false ? { collab: false } : {}),
-  } as ElementMeta)
-
-  // Repeater meta carries the row schema under `template` (`children` is
-  // the per-resolved-row child list, not the field-level template). Tests
-  // must mirror what `RepeaterField.toMeta()` actually emits.
-  const repeater = (name: string, template: ElementMeta[], collab?: boolean): ElementMeta => ({
-    type:      'field',
-    fieldType: 'repeater',
-    name,
-    label:     name,
-    required:  false,
-    disabled:  false,
-    template,
-    ...(collab === false ? { collab: false } : {}),
-  } as ElementMeta)
-
-  it('collects text-shaped inner-field names per Repeater', () => {
-    const meta = formMeta([
-      repeater('tags', [
-        textField('label', 'text'),
-        textField('summary', 'textarea'),
-        textField('count', 'number'),
-      ]),
-    ])
-    const out = collectRowTextLeavesByArray(meta)
-    assert.equal(out.size, 1)
-    assert.deepEqual([...out.get('tags')!].sort(), ['label', 'summary'])
-  })
-
-  it('walks Builder block templates', () => {
-    const meta = formMeta([
-      {
-        type:      'field',
-        fieldType: 'builder',
-        name:      'blocks',
-        children:  [],
-        blocks: [
-          { name: 'heading',   template: [textField('text', 'text')] },
-          { name: 'paragraph', template: [textField('body', 'markdown')] },
-        ],
-      } as unknown as ElementMeta,
-    ])
-    const out = collectRowTextLeavesByArray(meta)
-    assert.deepEqual([...out.get('blocks')!].sort(), ['body', 'text'])
-  })
-
-  it('skips opted-out inner fields', () => {
-    const meta = formMeta([
-      repeater('tags', [
-        textField('label',  'text'),
-        textField('private', 'text', false),   // .collab(false)
-      ]),
-    ])
-    const out = collectRowTextLeavesByArray(meta)
-    assert.deepEqual([...out.get('tags')!], ['label'])
-  })
-
-  it('omits opted-out top-level arrays', () => {
-    const meta = formMeta([
-      repeater('public',  [textField('a', 'text')]),
-      repeater('private', [textField('b', 'text')], false),
-    ])
-    const out = collectRowTextLeavesByArray(meta)
-    assert.equal(out.has('public'),  true)
-    assert.equal(out.has('private'), false)
-  })
-
-  it('stops at nested array boundaries (no 5+ segment dotted paths)', () => {
-    const meta = formMeta([
-      repeater('outer', [
-        textField('outerLabel', 'text'),
-        repeater('inner', [textField('innerLabel', 'text')]),
-      ]),
-    ])
-    const out = collectRowTextLeavesByArray(meta)
-    assert.deepEqual([...out.get('outer')!], ['outerLabel'])
-    assert.equal(out.has('inner'), false, 'nested Repeater not surfaced as a top-level array')
-  })
-
-  it('returns empty map when no Repeater/Builder has text leaves', () => {
-    const meta = formMeta([
-      textField('top', 'text'),
-      repeater('numbers', [textField('count', 'number')]),
-    ])
-    const out = collectRowTextLeavesByArray(meta)
-    assert.equal(out.size, 0)
-  })
-})
-
 describe('fieldOptsOutOfCollab', () => {
   it('returns true only when the field carries an explicit collab=false', () => {
     const meta = formMeta([

package/src/react/formStateHelpers.ts

@@ -379,86 +379,3 @@ export function collectRowArrayFieldNames(formMeta: ElementMeta): string[] {
   }
 }
 
-/**
- * Phase F.5c — text-shaped fieldTypes whose row-leaf values should be
- * routed through `Y.Text` instead of `Y.Map` LWW. Mirrors the same
- * allowlist `@pilotiq-pro/collab`'s top-level binding uses; consumers
- * registering character-level CRDT for additional plain-text-shaped
- * fields update both copies in lockstep until a cross-repo shared
- * constants module exists.
- */
-const ROW_TEXT_FIELD_TYPES: ReadonlySet<string> = new Set([
-  'text', 'textarea', 'email', 'slug', 'markdown',
-])
-
-/**
- * Phase F.5c — per-Repeater/Builder set of inner-field names that
- * carry text-shaped leaves eligible for character-level CRDT. Drives
- * `useFieldState(dottedName).textBinding` resolution: only fields in
- * the per-array set go through `binding.getRowTextBinding`; everything
- * else stays on row-level Y.Map LWW.
- *
- * Repeater rows expose their schema directly under `meta.children`;
- * Builder rows nest schemas under `meta.blocks[i].template`. The
- * walker descends through every block's template so a `markdown` leaf
- * inside any block-type lands in the array's allowlist. Nested
- * Repeaters / Builders inside row schemas are out of scope v1 (their
- * dotted paths are 5+ segments and `parseRowFieldPath` rejects them).
- */
-export function collectRowTextLeavesByArray(formMeta: ElementMeta): Map<string, Set<string>> {
-  const out = new Map<string, Set<string>>()
-  walkTop(formMeta)
-  return out
-
-  function walkTop(node: ElementMeta): void {
-    if (node.type === 'field') {
-      const fieldType = String(node['fieldType'] ?? '')
-      if (fieldType === 'repeater' || fieldType === 'builder') {
-        if ((node as { collab?: boolean }).collab === false) return
-        const name = String(node['name'] ?? '')
-        if (!name) return
-        const set = new Set<string>()
-        // Repeater's `toMeta()` emits the row schema under `template` (not
-        // `children` — that's per-resolved-row). Builder nests row schemas
-        // under `blocks[i].template`. Reading `children` here pre-fix gave
-        // every Repeater an empty text-leaf set → row text never CRDT'd.
-        if (fieldType === 'repeater') walkRow((node as { template?: unknown }).template, set)
-        else                          walkBlocks((node as { blocks?: unknown }).blocks, set)
-        if (set.size > 0) out.set(name, set)
-        return
-      }
-    }
-    const children = node.children
-    if (Array.isArray(children)) {
-      for (const child of children) walkTop(child as ElementMeta)
-    }
-  }
-
-  function walkRow(children: unknown, set: Set<string>): void {
-    if (!Array.isArray(children)) return
-    for (const child of children) walkRowEl(child as ElementMeta, set)
-  }
-
-  function walkRowEl(node: ElementMeta, set: Set<string>): void {
-    if (node.type === 'field') {
-      const fieldType = String(node['fieldType'] ?? '')
-      if (fieldType === 'repeater' || fieldType === 'builder') return   // nested array
-      if ((node as { collab?: boolean }).collab === false) return
-      const name = String(node['name'] ?? '')
-      if (name && ROW_TEXT_FIELD_TYPES.has(fieldType)) set.add(name)
-      return
-    }
-    const children = node.children
-    if (Array.isArray(children)) {
-      for (const child of children) walkRowEl(child as ElementMeta, set)
-    }
-  }
-
-  function walkBlocks(blocks: unknown, set: Set<string>): void {
-    if (!Array.isArray(blocks)) return
-    for (const block of blocks) {
-      const tpl = (block as { template?: unknown }).template
-      walkRow(tpl, set)
-    }
-  }
-}

package/src/react/index.ts

@@ -55,8 +55,6 @@ export {
   type FormCollabBinding,
   type FormCollabBindingFactory,
   type FormCollabBindingFactoryArgs,
-  type TextBinding,
-  type TextDelta,
   type RowsEvent,
   type RowBindingApi,
 } from './FormCollabBindingRegistry.js'

package/src/react/schemaRenderer/form/FormRenderer.tsx

@@ -6,6 +6,7 @@ import { useCollabRoom } from '../../CollabRoomContext.js'
 import { getFormCollabBinding } from '../../FormCollabBindingRegistry.js'
 import { useNavigate } from '../../navigate.js'
 import { useToast } from '../../Toaster.js'
+import { markSubmitForReconcile } from '../../fields/repeaterReconcile.js'
 import { renderField } from './renderField.js'
 
 // ─── Form ───────────────────────────────────────────────────
@@ -111,6 +112,15 @@ export function FormRenderer({
       }
 
       // Success — drain notifications and SPA-navigate to the redirect.
+      //
+      // Before navigating, mark this tab for the relationship-backed
+      // Repeater/Builder PK-switch reconciler. The next mount of any
+      // child Repeater/Builder under this formId will run a one-shot
+      // CRDT reconcile to drop orphan UUIDs whose rows just persisted
+      // under a fresh DB PK. See
+      // `pilotiq-pro/docs/plans/repeater-relationship-pk-switch.md`
+      // (Phase A).
+      markSubmitForReconcile(formId)
       const notifs = (data as { notifications?: NotificationMeta[] }).notifications
       if (notifs && notifs.length > 0) for (const n of notifs) notify(n)
       const redirect = String((data as { redirect?: string }).redirect ?? '')

package/dist/react/fields/textDelta.d.ts

@@ -1,44 +0,0 @@
-import type { TextDelta } from '../FormCollabBindingRegistry.js';
-/**
- * Phase F.6 — derive a single character-level edit op from two strings.
- *
- * Strategy: find the longest common prefix and suffix between `before`
- * and `after`; whatever's left in the middle is the changed region.
- *
- *   - middle-after empty + middle-before non-empty → `delete`
- *   - middle-before empty + middle-after non-empty → `insert`
- *   - both non-empty                              → `replace`
- *   - both empty (identical strings)              → `null`
- *
- * This correctly handles the common edit shapes: single-key insert,
- * single-key backspace, multi-char paste replacing a selection, IME
- * commits, accent-key composition. It does NOT preserve user intent
- * when the same character appears at multiple positions and the edit
- * could be attributed to either occurrence — Yjs's per-character
- * identity makes that distinction lossy at the string-diff layer
- * (the `Y.Text` itself maintains item identity internally). For v1
- * we accept the ambiguity; the CRDT semantics still converge.
- */
-export declare function computeDelta(before: string, after: string): TextDelta | null;
-/**
- * Phase F.6 — best-effort cursor anchor across a remote-applied edit.
- *
- *   - Edit landed AFTER cursor (cursor inside the common prefix) → keep
- *     cursor where it is.
- *   - Edit landed BEFORE cursor                                  → shift
- *     cursor by `after.length − before.length` so its character-offset
- *     into the post-edit string matches its pre-edit anchor.
- *   - Edit landed OVERLAPPING the cursor                         → cursor
- *     ends up at the boundary between the changed region and the
- *     unchanged suffix (which `Math.max(0, cursor + delta)` produces
- *     naturally and clamps to the new bounds).
- *
- * This is a heuristic, not a Yjs `RelativePosition`. Two peers typing
- * at the exact same insertion point can still see a one-character cursor
- * twitch on the remote-mirror side; v2 (in-input remote carets) would
- * upgrade to relative positions if/when a consumer asks. Native input
- * cursors are clamped to `[0, after.length]` by every browser, so this
- * function does the same to avoid `setSelectionRange` throwing.
- */
-export declare function preserveCursor(before: string, after: string, cursor: number): number;
-//# sourceMappingURL=textDelta.d.ts.map

package/dist/react/fields/textDelta.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"textDelta.d.ts","sourceRoot":"","sources":["../../../src/react/fields/textDelta.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iCAAiC,CAAA;AAEhE;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CA8B5E;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAWpF"}

package/dist/react/fields/textDelta.js

@@ -1,80 +0,0 @@
-/**
- * Phase F.6 — derive a single character-level edit op from two strings.
- *
- * Strategy: find the longest common prefix and suffix between `before`
- * and `after`; whatever's left in the middle is the changed region.
- *
- *   - middle-after empty + middle-before non-empty → `delete`
- *   - middle-before empty + middle-after non-empty → `insert`
- *   - both non-empty                              → `replace`
- *   - both empty (identical strings)              → `null`
- *
- * This correctly handles the common edit shapes: single-key insert,
- * single-key backspace, multi-char paste replacing a selection, IME
- * commits, accent-key composition. It does NOT preserve user intent
- * when the same character appears at multiple positions and the edit
- * could be attributed to either occurrence — Yjs's per-character
- * identity makes that distinction lossy at the string-diff layer
- * (the `Y.Text` itself maintains item identity internally). For v1
- * we accept the ambiguity; the CRDT semantics still converge.
- */
-export function computeDelta(before, after) {
-    if (before === after)
-        return null;
-    let prefix = 0;
-    const minLen = Math.min(before.length, after.length);
-    while (prefix < minLen && before[prefix] === after[prefix])
-        prefix++;
-    // Walk back from each end, capped so suffix can't overlap the prefix
-    // on either side. Without the cap, identical strings of repeated
-    // chars (e.g. 'aaa' → 'aa') would consume the same byte from both
-    // directions and produce an empty middle on both sides.
-    let suffix = 0;
-    const maxSuffix = Math.min(before.length - prefix, after.length - prefix);
-    while (suffix < maxSuffix &&
-        before[before.length - 1 - suffix] === after[after.length - 1 - suffix]) {
-        suffix++;
-    }
-    const beforeMid = before.slice(prefix, before.length - suffix);
-    const afterMid = after.slice(prefix, after.length - suffix);
-    if (beforeMid.length === 0 && afterMid.length > 0) {
-        return { kind: 'insert', index: prefix, text: afterMid };
-    }
-    if (afterMid.length === 0 && beforeMid.length > 0) {
-        return { kind: 'delete', index: prefix, length: beforeMid.length };
-    }
-    return { kind: 'replace', from: prefix, to: prefix + beforeMid.length, text: afterMid };
-}
-/**
- * Phase F.6 — best-effort cursor anchor across a remote-applied edit.
- *
- *   - Edit landed AFTER cursor (cursor inside the common prefix) → keep
- *     cursor where it is.
- *   - Edit landed BEFORE cursor                                  → shift
- *     cursor by `after.length − before.length` so its character-offset
- *     into the post-edit string matches its pre-edit anchor.
- *   - Edit landed OVERLAPPING the cursor                         → cursor
- *     ends up at the boundary between the changed region and the
- *     unchanged suffix (which `Math.max(0, cursor + delta)` produces
- *     naturally and clamps to the new bounds).
- *
- * This is a heuristic, not a Yjs `RelativePosition`. Two peers typing
- * at the exact same insertion point can still see a one-character cursor
- * twitch on the remote-mirror side; v2 (in-input remote carets) would
- * upgrade to relative positions if/when a consumer asks. Native input
- * cursors are clamped to `[0, after.length]` by every browser, so this
- * function does the same to avoid `setSelectionRange` throwing.
- */
-export function preserveCursor(before, after, cursor) {
-    if (before === after)
-        return cursor;
-    let prefix = 0;
-    const minLen = Math.min(before.length, after.length);
-    while (prefix < minLen && before[prefix] === after[prefix])
-        prefix++;
-    if (cursor <= prefix)
-        return Math.min(cursor, after.length);
-    const delta = after.length - before.length;
-    return Math.max(0, Math.min(after.length, cursor + delta));
-}
-//# sourceMappingURL=textDelta.js.map

package/dist/react/fields/textDelta.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"textDelta.js","sourceRoot":"","sources":["../../../src/react/fields/textDelta.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,YAAY,CAAC,MAAc,EAAE,KAAa;IACxD,IAAI,MAAM,KAAK,KAAK;QAAE,OAAO,IAAI,CAAA;IAEjC,IAAI,MAAM,GAAG,CAAC,CAAA;IACd,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACpD,OAAO,MAAM,GAAG,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,KAAK,CAAC,MAAM,CAAC;QAAE,MAAM,EAAE,CAAA;IAEpE,qEAAqE;IACrE,iEAAiE;IACjE,kEAAkE;IAClE,wDAAwD;IACxD,IAAI,MAAM,GAAG,CAAC,CAAA;IACd,MAAM,SAAS,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,GAAG,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAA;IACzE,OACE,MAAM,GAAG,SAAS;QAClB,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,GAAG,MAAM,CAAC,KAAK,KAAK,CAAC,KAAK,CAAC,MAAM,GAAG,CAAC,GAAG,MAAM,CAAC,EACvE,CAAC;QACD,MAAM,EAAE,CAAA;IACV,CAAC;IAED,MAAM,SAAS,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,GAAG,MAAM,CAAC,CAAA;IAC9D,MAAM,QAAQ,GAAI,KAAK,CAAC,KAAK,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,CAAA;IAE5D,IAAI,SAAS,CAAC,MAAM,KAAK,CAAC,IAAI,QAAQ,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAClD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAA;IAC1D,CAAC;IACD,IAAI,QAAQ,CAAC,MAAM,KAAK,CAAC,IAAI,SAAS,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QAClD,OAAO,EAAE,IAAI,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,CAAA;IACpE,CAAC;IACD,OAAO,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,CAAC,MAAM,EAAE,IAAI,EAAE,QAAQ,EAAE,CAAA;AACzF,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,cAAc,CAAC,MAAc,EAAE,KAAa,EAAE,MAAc;IAC1E,IAAI,MAAM,KAAK,KAAK;QAAE,OAAO,MAAM,CAAA;IAEnC,IAAI,MAAM,GAAG,CAAC,CAAA;IACd,MAAM,MAAM,GAAG,IAAI,CAAC,GAAG,CAAC,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IACpD,OAAO,MAAM,GAAG,MAAM,IAAI,MAAM,CAAC,MAAM,CAAC,KAAK,KAAK,CAAC,MAAM,CAAC;QAAE,MAAM,EAAE,CAAA;IAEpE,IAAI,MAAM,IAAI,MAAM;QAAE,OAAO,IAAI,CAAC,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,MAAM,CAAC,CAAA;IAE3D,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,GAAG,MAAM,CAAC,MAAM,CAAA;IAC1C,OAAO,IAAI,CAAC,GAAG,CAAC,CAAC,EAAE,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,KAAK,CAAC,CAAC,CAAA;AAC5D,CAAC"}

package/src/react/fields/textDelta.test.ts

@@ -1,141 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { computeDelta, preserveCursor } from './textDelta.js'
-
-describe('computeDelta — string-diff to TextDelta', () => {
-  it('returns null for identical strings', () => {
-    assert.equal(computeDelta('hello', 'hello'), null)
-    assert.equal(computeDelta('', ''),           null)
-  })
-
-  it('emits insert when text is appended', () => {
-    assert.deepEqual(
-      computeDelta('hello', 'hello!'),
-      { kind: 'insert', index: 5, text: '!' },
-    )
-  })
-
-  it('emits insert when text is prepended', () => {
-    assert.deepEqual(
-      computeDelta('world', 'hello world'),
-      { kind: 'insert', index: 0, text: 'hello ' },
-    )
-  })
-
-  it('emits insert when text is spliced mid-string', () => {
-    // Inserting an 'l' to make 'helo' → 'hello'. The longest common
-    // prefix is 'hel' (3 chars — before[2]='l' and after[2]='l' both
-    // match), so the insertion lands at index 3. Either interpretation
-    // (index 2 or index 3) produces the same CRDT result; the diff
-    // picks the rightmost feasible point deterministically.
-    assert.deepEqual(
-      computeDelta('helo', 'hello'),
-      { kind: 'insert', index: 3, text: 'l' },
-    )
-  })
-
-  it('emits delete when a trailing run is removed', () => {
-    assert.deepEqual(
-      computeDelta('hello!', 'hello'),
-      { kind: 'delete', index: 5, length: 1 },
-    )
-  })
-
-  it('emits delete when a leading run is removed', () => {
-    assert.deepEqual(
-      computeDelta('hello world', 'world'),
-      { kind: 'delete', index: 0, length: 6 },
-    )
-  })
-
-  it('emits delete when a mid-string run is removed', () => {
-    assert.deepEqual(
-      computeDelta('hello', 'hlo'),
-      { kind: 'delete', index: 1, length: 2 },
-    )
-  })
-
-  it('emits replace when a mid-string selection is swapped', () => {
-    assert.deepEqual(
-      computeDelta('hello world', 'hello pilot'),
-      { kind: 'replace', from: 6, to: 11, text: 'pilot' },
-    )
-  })
-
-  it('emits replace when the whole string is swapped', () => {
-    assert.deepEqual(
-      computeDelta('foo', 'bar'),
-      { kind: 'replace', from: 0, to: 3, text: 'bar' },
-    )
-  })
-
-  it('emits insert when growing from empty', () => {
-    assert.deepEqual(
-      computeDelta('', 'a'),
-      { kind: 'insert', index: 0, text: 'a' },
-    )
-  })
-
-  it('emits delete when shrinking to empty', () => {
-    assert.deepEqual(
-      computeDelta('abc', ''),
-      { kind: 'delete', index: 0, length: 3 },
-    )
-  })
-
-  it('handles repeated-char shrink without prefix/suffix overlap', () => {
-    // 'aaa' → 'aa' — the prefix walk could greedily eat all 2 chars from
-    // the after side; the suffix cap must stop suffix at 2 so beforeMid
-    // is 'a' (length 1) instead of '' (length 0, identity).
-    assert.deepEqual(
-      computeDelta('aaa', 'aa'),
-      { kind: 'delete', index: 2, length: 1 },
-    )
-  })
-})
-
-describe('preserveCursor — anchor across remote edits', () => {
-  it('returns input cursor when strings are identical', () => {
-    assert.equal(preserveCursor('hello', 'hello', 3), 3)
-  })
-
-  it('leaves cursor untouched when edit lands AFTER cursor', () => {
-    // Cursor at index 2 ('he|llo'); remote appends ' world'. Edit prefix
-    // length is 5, cursor 2 ≤ prefix → no shift.
-    assert.equal(preserveCursor('hello', 'hello world', 2), 2)
-  })
-
-  it('shifts cursor when edit lands BEFORE cursor', () => {
-    // Cursor at 5 ('hello|'); remote prepends 'XX '. The common prefix
-    // is empty, so cursor > prefix → shift by (8 − 5) = 3, landing at
-    // 8 (the end of the new string, same logical position as before).
-    assert.equal(preserveCursor('hello', 'XX hello', 5), 8)
-  })
-
-  it('lands at end-of-string for non-contiguous edits (heuristic limit)', () => {
-    // Both-sides insertion ('hello' → 'X hello world') flattens into a
-    // single full-string `replace` at the diff layer because the prefix
-    // and suffix walks find no common ground. Cursor lands at the end
-    // of the new string — imperfect for this case but harmless. A
-    // future v2 using Yjs `RelativePosition` would land it at 7
-    // (just after the original 'hello' substring).
-    assert.equal(preserveCursor('hello', 'X hello world', 5), 13)
-  })
-
-  it('clamps cursor when remote deletes around the cursor', () => {
-    // Cursor at 5 ('hello|world'); remote deletes 'hello'. Prefix is 0,
-    // delta is -5 → shifted to 0.
-    assert.equal(preserveCursor('helloworld', 'world', 5), 0)
-  })
-
-  it('never returns a negative cursor', () => {
-    assert.equal(preserveCursor('abcdef', '', 3), 0)
-  })
-
-  it('never returns a cursor past the new length', () => {
-    // Defensive — caller might pass a stale cursor longer than the new
-    // string. Clamp to new bounds.
-    assert.equal(preserveCursor('hello', 'hi', 10), 2)
-  })
-})

package/src/react/fields/textDelta.ts

@@ -1,86 +0,0 @@
-import type { TextDelta } from '../FormCollabBindingRegistry.js'
-
-/**
- * Phase F.6 — derive a single character-level edit op from two strings.
- *
- * Strategy: find the longest common prefix and suffix between `before`
- * and `after`; whatever's left in the middle is the changed region.
- *
- *   - middle-after empty + middle-before non-empty → `delete`
- *   - middle-before empty + middle-after non-empty → `insert`
- *   - both non-empty                              → `replace`
- *   - both empty (identical strings)              → `null`
- *
- * This correctly handles the common edit shapes: single-key insert,
- * single-key backspace, multi-char paste replacing a selection, IME
- * commits, accent-key composition. It does NOT preserve user intent
- * when the same character appears at multiple positions and the edit
- * could be attributed to either occurrence — Yjs's per-character
- * identity makes that distinction lossy at the string-diff layer
- * (the `Y.Text` itself maintains item identity internally). For v1
- * we accept the ambiguity; the CRDT semantics still converge.
- */
-export function computeDelta(before: string, after: string): TextDelta | null {
-  if (before === after) return null
-
-  let prefix = 0
-  const minLen = Math.min(before.length, after.length)
-  while (prefix < minLen && before[prefix] === after[prefix]) prefix++
-
-  // Walk back from each end, capped so suffix can't overlap the prefix
-  // on either side. Without the cap, identical strings of repeated
-  // chars (e.g. 'aaa' → 'aa') would consume the same byte from both
-  // directions and produce an empty middle on both sides.
-  let suffix = 0
-  const maxSuffix = Math.min(before.length - prefix, after.length - prefix)
-  while (
-    suffix < maxSuffix &&
-    before[before.length - 1 - suffix] === after[after.length - 1 - suffix]
-  ) {
-    suffix++
-  }
-
-  const beforeMid = before.slice(prefix, before.length - suffix)
-  const afterMid  = after.slice(prefix, after.length - suffix)
-
-  if (beforeMid.length === 0 && afterMid.length > 0) {
-    return { kind: 'insert', index: prefix, text: afterMid }
-  }
-  if (afterMid.length === 0 && beforeMid.length > 0) {
-    return { kind: 'delete', index: prefix, length: beforeMid.length }
-  }
-  return { kind: 'replace', from: prefix, to: prefix + beforeMid.length, text: afterMid }
-}
-
-/**
- * Phase F.6 — best-effort cursor anchor across a remote-applied edit.
- *
- *   - Edit landed AFTER cursor (cursor inside the common prefix) → keep
- *     cursor where it is.
- *   - Edit landed BEFORE cursor                                  → shift
- *     cursor by `after.length − before.length` so its character-offset
- *     into the post-edit string matches its pre-edit anchor.
- *   - Edit landed OVERLAPPING the cursor                         → cursor
- *     ends up at the boundary between the changed region and the
- *     unchanged suffix (which `Math.max(0, cursor + delta)` produces
- *     naturally and clamps to the new bounds).
- *
- * This is a heuristic, not a Yjs `RelativePosition`. Two peers typing
- * at the exact same insertion point can still see a one-character cursor
- * twitch on the remote-mirror side; v2 (in-input remote carets) would
- * upgrade to relative positions if/when a consumer asks. Native input
- * cursors are clamped to `[0, after.length]` by every browser, so this
- * function does the same to avoid `setSelectionRange` throwing.
- */
-export function preserveCursor(before: string, after: string, cursor: number): number {
-  if (before === after) return cursor
-
-  let prefix = 0
-  const minLen = Math.min(before.length, after.length)
-  while (prefix < minLen && before[prefix] === after[prefix]) prefix++
-
-  if (cursor <= prefix) return Math.min(cursor, after.length)
-
-  const delta = after.length - before.length
-  return Math.max(0, Math.min(after.length, cursor + delta))
-}