@pilotiq/pilotiq 0.24.1 → 0.24.2

package/src/react/fields/TextLikeInput.tsx

@@ -1,256 +0,0 @@
-import React, { useCallback, useEffect, useRef, useState } from 'react'
-import type { ElementMeta } from '../../schema/Element.js'
-import { useFieldState } from '../FormStateContext.js'
-import { useCollabRoom } from '../CollabRoomContext.js'
-import { getCollabTextRenderer, type CollabTextRenderer } from '../CollabTextRendererRegistry.js'
-import { useRowCoords } from '../RowCoordsContext.js'
-import { parseRowFieldPath } from '../formStateHelpers.js'
-import { Input } from '../ui/input.js'
-import { Textarea } from '../ui/textarea.js'
-
-/**
- * Bridge between controlled (FormStateProvider) and uncontrolled
- * (defaultValue) modes for text-style inputs. When inside a form with
- * `live()` fields, the input is bound to the context's values map and
- * fires the live trigger on change/blur according to the field's `live`
- * config. Outside a controlled form, falls back to plain `defaultValue`.
- *
- * **Collab branch — Tiptap-backed `Y.XmlFragment`.** When a
- * `<RecordCollabRoom>` is mounted up-tree AND `@pilotiq/tiptap`'s
- * `registerTiptap()` registered a collab text renderer, the input
- * mounts the Tiptap-backed editor against a `Y.XmlFragment` keyed by
- * either the bare field name (top-level) or
- * `${arrayName}.${rowId}.${fieldName}` (Repeater / Builder row leaves
- * via `useRowCoords()`). Selections anchor to `Y.RelativePosition` via
- * y-prosemirror, so cursors survive both mid-word remote edits and
- * concurrent inserts. Masked fields fall through to the legacy
- * whole-string LWW path (mask + character-level CRDT is incompatible
- * — peers would see raw keystrokes desynced from the rendered mask).
- */
-export function TextLikeInput({
-  el, name, common, type, extraProps, multiline, applyMask,
-}: {
-  el:         ElementMeta
-  name:       string
-  common:     Record<string, unknown>
-  type:       string
-  extraProps: Record<string, unknown>
-  multiline:  boolean
-  /** Optional keystroke formatter — `TextField.mask(pattern)`. When
-   *  set, every change runs the value through this fn before it lands
-   *  in state / the DOM. Defaults to identity. */
-  applyMask?: (value: string) => string
-}): React.ReactElement {
-  const fs = useFieldState(name)
-  const room = useCollabRoom()
-  const collabRenderer = getCollabTextRenderer()
-  const rowCoords = useRowCoords()
-  const liveCfg = el['live']
-  const liveOpts = (typeof liveCfg === 'object' && liveCfg !== null
-    ? liveCfg as { onBlur?: boolean; debounce?: number }
-    : {})
-  const onBlurMode = liveOpts.onBlur === true
-  const mask = applyMask ?? identity
-
-  // Masking is mutually exclusive with character-level CRDT (peers would
-  // see raw keystrokes diverged from the local mask render); masked
-  // fields fall through to LWW. We read the mask from the field meta
-  // directly — `applyMask` is a `useCallback`-wrapped fn that's *always*
-  // defined (identity when no mask), so its truthiness can't gate the
-  // branch.
-  const hasMask = typeof el['mask'] === 'string'
-
-  // Collab branch — Tiptap-backed plain-text editor. Top-level fields
-  // use the bare `name` as the fragment-key; Repeater / Builder row
-  // leaves compose `${arrayName}.${rowId}.${fieldName}` from
-  // `useRowCoords()` so the Y.XmlFragment survives row reorders (keyed
-  // by the stable rowId, not the array index). The hidden FormData
-  // input keeps the original dotted path so submission lands on the
-  // server at the right slot.
-  //
-  // Dotted paths that don't match a row shape (no rowCoords OR
-  // `parseRowFieldPath` returns null — nested row arrays, malformed
-  // names) skip the collab path and fall through to the controlled /
-  // uncontrolled branches below.
-  const fieldCollab = el['collab'] as boolean | undefined
-  // Auto-upgrade to the Tiptap-backed editor whenever the field has AI
-  // agents attached, even outside collab — the inline-diff chip widget
-  // (red strikethrough on the current value + green chip with the suggested
-  // text + ✓/✕) needs a real ProseMirror surface to render. The renderer
-  // handles `useCollabRoom() === null` cleanly (mounts the editor without
-  // the Yjs Collaboration extension), so this widening doesn't force a
-  // collab room.
-  //
-  // `field.ai([…])` from `@pilotiq-pro/ai` lands on `FieldMeta.aiActions`
-  // as a resolved `PilotiqAgentMeta[]`. Read the array; non-empty means
-  // "this field has AI surfaces wired".
-  const aiActions = el['aiActions']
-  const hasAi = Array.isArray(aiActions) && aiActions.length > 0
-  const fragmentKey: string | null = (() => {
-    if (!name.includes('.')) return name
-    if (!rowCoords) return null
-    const parsed = parseRowFieldPath(name)
-    if (!parsed) return null
-    if (parsed.arrayName !== rowCoords.arrayName) return null
-    if (parsed.index     !== rowCoords.rowIndex)  return null
-    return `${rowCoords.arrayName}.${rowCoords.rowId}.${parsed.fieldName}`
-  })()
-  if (
-    (room || hasAi) &&
-    collabRenderer &&
-    fieldCollab !== false &&
-    !hasMask &&
-    fragmentKey !== null
-  ) {
-    return (
-      <CollabTextField
-        Renderer={collabRenderer}
-        fragmentKey={fragmentKey}
-        hiddenInputName={name}
-        multiline={multiline}
-        defaultValue={stringValue(common['defaultValue'])}
-        {...(common['placeholder'] !== undefined ? { placeholder: String(common['placeholder']) } : {})}
-        disabled={Boolean(common['disabled'])}
-        triggerLive={fs.triggerLive}
-        setValue={fs.setValue}
-        controlled={fs.controlled}
-        onBlurMode={onBlurMode}
-      />
-    )
-  }
-
-  if (fs.controlled) {
-    const ctxValue = fs.value !== undefined && fs.value !== null ? String(fs.value) : ''
-    const onChange = (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement>): void => {
-      const formatted = mask(e.target.value)
-      fs.setValue(formatted)
-      if (!onBlurMode) fs.triggerLive()
-    }
-    const onBlur = (): void => {
-      if (onBlurMode) fs.triggerLive()
-    }
-    const props = {
-      ...common,
-      ...extraProps,
-      defaultValue: undefined,
-      value:        ctxValue,
-      onChange,
-      onBlur,
-    }
-    if (multiline) return <Textarea {...(props as React.ComponentProps<typeof Textarea>)} />
-    return <Input {...(props as React.ComponentProps<typeof Input>)} type={type} />
-  }
-
-  // Uncontrolled path with mask: wire onInput so the user sees the
-  // formatted value as they type. Without `applyMask`, fall through to
-  // the legacy bare-defaultValue render so the DOM stays unchanged.
-  if (applyMask) {
-    const onInput = (e: React.FormEvent<HTMLInputElement | HTMLTextAreaElement>): void => {
-      const target = e.currentTarget
-      target.value = mask(target.value)
-    }
-    if (multiline) return <Textarea {...(common as React.ComponentProps<typeof Textarea>)} {...extraProps} onInput={onInput} />
-    return <Input {...(common as React.ComponentProps<typeof Input>)} type={type} {...extraProps} onInput={onInput} />
-  }
-
-  if (multiline) return <Textarea {...(common as React.ComponentProps<typeof Textarea>)} {...extraProps} />
-  return <Input {...(common as React.ComponentProps<typeof Input>)} type={type} {...extraProps} />
-}
-
-/**
- * Wrapper around the registered Tiptap-backed collab editor.
- * Owns the local text mirror so the hidden `<input>` always carries the
- * editor's current value for FormData submission. When `FormStateProvider`
- * is mounted up-tree, also mirrors every update into the values map via
- * `fs.setValue` so `$get/$set` computations and any Y.Map LWW path (kept
- * for non-text consumers) stay in sync.
- *
- * No IME / cursor-preservation gymnastics in here — the underlying Tiptap
- * editor handles composition natively and y-prosemirror anchors selections
- * to `Yjs.RelativePosition`, so the cursor survives concurrent + mid-word
- * remote edits without any client-side bookkeeping.
- *
- * `fragmentKey` and `hiddenInputName` diverge for row-text leaves (Phase
- * 1 of collab-row-text-tiptap-backed.md): the renderer's Y.XmlFragment is
- * keyed by `${arrayName}.${rowId}.${fieldName}` so it survives row
- * reorders, while the hidden FormData input keeps the dotted path
- * (`items.0.title`) so submission lands at the right server-side slot.
- * For top-level fields the two are identical.
- */
-function CollabTextField({
-  Renderer, fragmentKey, hiddenInputName, multiline, defaultValue, placeholder, disabled,
-  triggerLive, setValue, controlled, onBlurMode,
-}: {
-  Renderer:        CollabTextRenderer
-  fragmentKey:     string
-  hiddenInputName: string
-  multiline:       boolean
-  defaultValue:    string
-  placeholder?:    string
-  disabled:        boolean
-  triggerLive:     (valueOverride?: unknown) => void
-  setValue:        (v: unknown) => void
-  controlled:      boolean
-  onBlurMode:      boolean
-}): React.ReactElement {
-  const [text, setText] = useState<string>(defaultValue)
-  const textRef = useRef(text)
-  useEffect(() => { textRef.current = text }, [text])
-
-  const handleChange = useCallback((next: string): void => {
-    setText(next)
-    if (controlled) setValue(next)
-    if (!onBlurMode) triggerLive(next)
-  }, [controlled, onBlurMode, setValue, triggerLive])
-
-  const handleBlur = useCallback((): void => {
-    if (onBlurMode) triggerLive(textRef.current)
-  }, [onBlurMode, triggerLive])
-
-  // Match the visual chrome of `<Input>` / `<Textarea>` so the editor reads
-  // as a drop-in replacement. The adapter forwards this class to its
-  // contenteditable wrapper; `whitespace-nowrap` on the single-line variant
-  // keeps the editor from wrapping into a second line if a stray paragraph
-  // split somehow makes it through.
-  //
-  // `overflow-x-clip` (not `auto`) on the single-line variant matters for
-  // `CollaborationCaret` presence labels: per the CSS overflow spec, setting
-  // either axis to a non-visible / non-clip value (`auto` / `scroll` /
-  // `hidden`) forces the other axis to compute as `auto` too — so
-  // `overflow-x-auto` would clip the caret's user-name label, which renders
-  // `-1.4em` above the line. `clip` is the one non-visible value that does
-  // NOT force the other axis, so `overflow-y` stays `visible` and the label
-  // escapes the chrome upward as designed. Trade-off: long text gets clipped
-  // on the right rather than horizontally scrollable (native `<input>`
-  // semantics) — acceptable for plain-text fields, where typing past the
-  // visible width is rare and the caret presence label is the higher-value
-  // affordance.
-  const className = multiline
-    ? 'flex min-h-[60px] w-full rounded-md border border-input bg-transparent px-3 py-2 text-base shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 md:text-sm whitespace-pre-wrap break-words'
-    : 'flex h-9 w-full items-center rounded-md border border-input bg-transparent px-3 py-1 text-base shadow-sm placeholder:text-muted-foreground focus-visible:outline-none focus-visible:ring-1 focus-visible:ring-ring disabled:cursor-not-allowed disabled:opacity-50 md:text-sm whitespace-nowrap overflow-x-clip'
-
-  return (
-    <>
-      <input type="hidden" name={hiddenInputName} value={text} />
-      <Renderer
-        name={hiddenInputName}
-        {...(fragmentKey !== hiddenInputName ? { fragmentKey } : {})}
-        multiline={multiline}
-        defaultValue={defaultValue}
-        {...(placeholder !== undefined ? { placeholder } : {})}
-        disabled={disabled}
-        onChange={handleChange}
-        onBlur={handleBlur}
-        className={className}
-      />
-    </>
-  )
-}
-
-function identity(v: string): string { return v }
-
-function stringValue(v: unknown): string {
-  if (v === undefined || v === null) return ''
-  if (typeof v === 'string') return v
-  return String(v)
-}

package/src/react/fields/ToggleButtonsInput.tsx

@@ -1,60 +0,0 @@
-import React, { useState } from 'react'
-import { useFieldState } from '../FormStateContext.js'
-
-/**
- * Single-choice field rendered as a horizontal row of pill-shaped
- * buttons styled like a segmented control. Submits via a hidden input
- * carrying the active value (form submission contract identical to
- * `RadioInput`).
- *
- * Controlled when inside a `FormStateProvider`, uncontrolled otherwise.
- */
-export function ToggleButtonsInput({
-  name, defaultValue, disabled, options,
-}: {
-  name:         string
-  defaultValue: string | undefined
-  disabled:     boolean
-  options:      Array<{ value: string; label: string; disabled?: boolean }>
-}): React.ReactElement {
-  const fs = useFieldState(name)
-  const [localValue, setLocalValue] = useState<string>(defaultValue ?? '')
-  const value = fs.controlled
-    ? (fs.value !== undefined && fs.value !== null ? String(fs.value) : '')
-    : localValue
-  const onPick = (next: string): void => {
-    if (disabled) return
-    if (fs.controlled) { fs.setValue(next); fs.triggerLive(next) }
-    else { setLocalValue(next); fs.triggerLive(next) }
-  }
-  return (
-    <div role="radiogroup" className="inline-flex flex-wrap rounded-md border border-input bg-background overflow-hidden">
-      <input type="hidden" name={name} value={value} />
-      {options.map((o, i) => {
-        const active = value === o.value
-        const optDisabled = disabled || Boolean(o.disabled)
-        return (
-          <button
-            key={o.value}
-            type="button"
-            role="radio"
-            aria-checked={active}
-            disabled={optDisabled}
-            data-state={active ? 'on' : 'off'}
-            onClick={() => { if (!optDisabled) onPick(o.value) }}
-            className={
-              'px-3 py-1.5 text-sm transition-colors focus:outline-none focus:ring-2 focus:ring-ring ' +
-              (i > 0 ? 'border-l border-input ' : '') +
-              (active
-                ? 'bg-primary text-primary-foreground hover:bg-primary/90 '
-                : 'bg-transparent hover:bg-accent hover:text-accent-foreground ') +
-              (optDisabled ? 'opacity-50 cursor-not-allowed ' : 'cursor-pointer ')
-            }
-          >
-            {o.label}
-          </button>
-        )
-      })}
-    </div>
-  )
-}

package/src/react/fields/ToggleFieldInput.tsx

@@ -1,56 +0,0 @@
-import React, { useContext, useEffect, useRef, useState } from 'react'
-import { useFieldState, FormIdContext } from '../FormStateContext.js'
-import { registerPendingSuggestionApplier, type PendingSuggestionApplier } from '../PendingSuggestionApplierRegistry.js'
-import { Switch } from '../ui/switch.js'
-
-export function ToggleFieldInput({
-  name, defaultChecked, disabled,
-}: { name: string; defaultChecked: boolean; disabled: boolean }): React.ReactElement {
-  const fs = useFieldState(name)
-  const [localChecked, setLocalChecked] = useState(defaultChecked)
-  const checked = fs.controlled
-    ? (fs.value === true || fs.value === 'true' || fs.value === 1 || fs.value === '1')
-    : localChecked
-  // Base UI Switch's onCheckedChange callback does NOT dispatch a native
-  // bubbling change event, so RepeaterInput's container-level delegate
-  // can't pick up inner-row live() triggers. Call triggerLive explicitly
-  // in BOTH paths — the function is a no-op outside FormStateProvider
-  // and when the field has no `live` config, so it's safe to fire
-  // unconditionally. The value is passed as a `valueOverride` so
-  // dotted-path inner-Repeater fields pass through correctly.
-  const onChange = (next: boolean): void => {
-    if (fs.controlled) { fs.setValue(next); fs.triggerLive(next) }
-    else { setLocalChecked(next); fs.triggerLive(next) }
-  }
-
-  // Cross-tree applier — Switch state lives in React, not in the hidden
-  // mirror input below. FieldShell's generic DOM-write applier would
-  // dispatch a change on the hidden input, but the visible Switch has
-  // no listener for it, so the toggle wouldn't flip. FieldShell skips
-  // its generic registration for fieldType === 'toggle'.
-  const fsRef = useRef(fs)
-  useEffect(() => { fsRef.current = fs }, [fs])
-  const formId = useContext(FormIdContext) || undefined
-  useEffect(() => {
-    if (name.includes('.')) return
-    const applier: PendingSuggestionApplier = (suggestion) => {
-      const v = suggestion.suggestedValue
-      const next = v === true || v === 'true' || v === 1 || v === '1'
-      const cur = fsRef.current
-      if (cur.controlled) { cur.setValue(next); cur.triggerLive(next) }
-      else { setLocalChecked(next); cur.triggerLive(next) }
-    }
-    return registerPendingSuggestionApplier(formId, name, applier)
-  }, [name, formId])
-  return (
-    <div className="flex items-center gap-2">
-      <input type="hidden" name={name} value={checked ? 'true' : 'false'} />
-      <Switch
-        id={name}
-        checked={checked}
-        onCheckedChange={onChange}
-        disabled={disabled}
-      />
-    </div>
-  )
-}

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

@@ -1,106 +0,0 @@
-import { describe, it, beforeEach } from 'node:test'
-import assert from 'node:assert/strict'
-
-import {
-  applyRelationshipRenames,
-  registerRelationshipRenameHandler,
-  _resetRelationshipRenameRegistryForTests,
-  type RelationshipRenameEntry,
-  type RelationshipRenameHandler,
-} from './relationshipRenameDispatch.js'
-
-describe('relationshipRenameDispatch', () => {
-  beforeEach(() => {
-    _resetRelationshipRenameRegistryForTests()
-  })
-
-  it('routes a rename through the registered handler for its formId', () => {
-    const seen: ReadonlyArray<RelationshipRenameEntry>[] = []
-    registerRelationshipRenameHandler('form-1', (renames) => { seen.push(renames) })
-
-    applyRelationshipRenames('form-1', [
-      { field: 'comments', old: 'uuid-foo', new: '42' },
-    ])
-
-    assert.equal(seen.length, 1)
-    assert.deepEqual(seen[0], [{ field: 'comments', old: 'uuid-foo', new: '42' }])
-  })
-
-  it('isolates handlers across formIds — multi-form pages do not cross-fire', () => {
-    const a: RelationshipRenameEntry[][] = []
-    const b: RelationshipRenameEntry[][] = []
-    registerRelationshipRenameHandler('form-a', (r) => { a.push([...r]) })
-    registerRelationshipRenameHandler('form-b', (r) => { b.push([...r]) })
-
-    applyRelationshipRenames('form-a', [{ field: 'x', old: 'u', new: '1' }])
-
-    assert.equal(a.length, 1)
-    assert.equal(b.length, 0)
-  })
-
-  it('cleanup unregisters the handler', () => {
-    let calls = 0
-    const off = registerRelationshipRenameHandler('form-1', () => { calls += 1 })
-    off()
-    applyRelationshipRenames('form-1', [{ field: 'x', old: 'u', new: '1' }])
-    assert.equal(calls, 0)
-  })
-
-  it("cleanup does NOT wipe a handler that another caller replaced (StrictMode-safe)", () => {
-    // StrictMode dev double-mount: provider A mounts, registers fn1; React
-    // schedules cleanup; provider A's effect re-runs and registers fn2; THEN
-    // the cleanup of the first effect fires. fn2 must survive.
-    let calls1 = 0
-    let calls2 = 0
-    const fn1: RelationshipRenameHandler = () => { calls1 += 1 }
-    const fn2: RelationshipRenameHandler = () => { calls2 += 1 }
-
-    const off1 = registerRelationshipRenameHandler('form-1', fn1)
-    registerRelationshipRenameHandler('form-1', fn2)
-    off1()
-
-    applyRelationshipRenames('form-1', [{ field: 'x', old: 'u', new: '1' }])
-    assert.equal(calls1, 0)
-    assert.equal(calls2, 1, 'second registration survived the first cleanup')
-  })
-
-  it('apply with no handler registered is a silent no-op', () => {
-    // The success path always fires apply; consumers without a collab
-    // plugin shouldn't see any error.
-    assert.doesNotThrow(() => {
-      applyRelationshipRenames('form-unknown', [{ field: 'x', old: 'u', new: '1' }])
-    })
-  })
-
-  it('apply with empty or undefined rename list short-circuits', () => {
-    let calls = 0
-    registerRelationshipRenameHandler('form-1', () => { calls += 1 })
-
-    applyRelationshipRenames('form-1', [])
-    applyRelationshipRenames('form-1', undefined)
-
-    assert.equal(calls, 0)
-  })
-
-  it('apply with empty formId is a no-op', () => {
-    let calls = 0
-    registerRelationshipRenameHandler('', () => { calls += 1 })
-    applyRelationshipRenames('', [{ field: 'x', old: 'u', new: '1' }])
-    assert.equal(calls, 0)
-  })
-
-  it('register returns a stub cleanup when formId is empty (no crash)', () => {
-    const off = registerRelationshipRenameHandler('', () => {})
-    assert.doesNotThrow(off)
-  })
-
-  it('handler errors propagate so FormRenderer can surface a save-failed toast', () => {
-    registerRelationshipRenameHandler('form-1', () => {
-      throw new Error('binding wedged')
-    })
-    assert.throws(
-      () => applyRelationshipRenames('form-1', [{ field: 'x', old: 'u', new: '1' }]),
-      /binding wedged/,
-    )
-  })
-})

package/src/react/fields/relationshipRenameDispatch.ts

@@ -1,97 +0,0 @@
-/**
- * PK-switch Phase B — client-side dispatcher.
- *
- * The pilotiq server returns `relationshipRenames: { field, old, new }[]`
- * in the JSON form-submit response whenever a `Repeater.relationship` /
- * `Builder.relationship` create persisted under a DB-assigned PK that
- * differs from the submitter's pre-assigned `__id` (see
- * `pilotiq-pro/docs/plans/repeater-relationship-pk-switch.md`,
- * `pilotiq/src/elements/dispatchForm.ts` for the wire shape).
- *
- * The renames need to land on the form's collab binding so other peers
- * see the CRDT row re-keyed from UUID → PK without reloading. But the
- * binding lives inside `FormStateProvider` (it owns `bindingRef`), while
- * the JSON success path lives in `FormRenderer`'s `onSubmit` — a sibling
- * component, not a context consumer. We bridge them with a per-`formId`
- * module-level registry: `FormStateProvider` registers a handler when
- * its binding mounts; `FormRenderer` dispatches against it after a
- * successful submit.
- *
- * Pattern parallels `repeaterReconcile.ts`'s sessionStorage flag — same
- * formId-keyed seam, different storage. SessionStorage was right for
- * Phase A (the flag has to survive a navigation between submit and
- * next mount); Phase B has to fire BEFORE the navigation, so a plain
- * in-memory Map is the right shape (no SSR / cross-tab concerns).
- *
- * No-op when no handler is registered (consumer has no collab plugin,
- * or the active binding doesn't implement `renameRow`).
- */
-
-/**
- * One UUID → PK rename emitted by the server. Shape mirrors
- * `pilotiq/src/elements/dispatchForm.ts` `RelationshipRename`; we
- * duplicate the shape here so this module stays free of server-only
- * imports (would otherwise pull the form-submit pipeline into the
- * client bundle).
- */
-export interface RelationshipRenameEntry {
-  field: string
-  old:   string
-  new:   string
-}
-
-export type RelationshipRenameHandler = (
-  renames: ReadonlyArray<RelationshipRenameEntry>,
-) => void
-
-const handlers = new Map<string, RelationshipRenameHandler>()
-
-/**
- * Called by `FormStateProvider` when its `FormCollabBinding` mounts AND
- * implements `renameRow`. Returns the unsubscribe fn to call on
- * unmount. Idempotent under re-registration on the same `formId` —
- * later writers replace earlier handlers (Forms only mount one
- * provider per id; a second mount means the first unmounted without
- * firing its cleanup, which is acceptable to overwrite).
- */
-export function registerRelationshipRenameHandler(
-  formId: string,
-  fn:     RelationshipRenameHandler,
-): () => void {
-  if (!formId) return () => {}
-  handlers.set(formId, fn)
-  return () => {
-    // Only clear when the current handler is still ours — protects
-    // against StrictMode dev double-mount where the cleanup of the
-    // first mount fires AFTER the second mount has installed its
-    // handler. Without this guard, the second mount's handler would
-    // be wiped before any submit completes.
-    if (handlers.get(formId) === fn) handlers.delete(formId)
-  }
-}
-
-/**
- * Called by `FormRenderer`'s `onSubmit` success path. Invokes the
- * formId's registered handler with the rename list, or no-ops when
- * either side is empty.
- *
- * Errors thrown by the handler propagate — pilotiq's submit path
- * already catches in a `try`, so a misbehaving binding fails the
- * navigate cleanly with a toast rather than wedging the form.
- */
-export function applyRelationshipRenames(
-  formId:  string,
-  renames: ReadonlyArray<RelationshipRenameEntry> | undefined,
-): void {
-  if (!formId) return
-  if (!renames || renames.length === 0) return
-  const fn = handlers.get(formId)
-  if (!fn) return
-  fn(renames)
-}
-
-/** Test seam — drop every registered handler. Not exported from the
- *  react barrel. */
-export function _resetRelationshipRenameRegistryForTests(): void {
-  handlers.clear()
-}