@pilotiq/pilotiq 0.24.1 → 0.24.3

package/src/fields/TextareaField.test.ts

@@ -1,58 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { TextareaField } from './TextareaField.js'
-
-describe('TextareaField', () => {
-  it('emits fieldType "textarea" and rows defaulting to 4', () => {
-    const meta = TextareaField.make('bio').toMeta()
-    assert.equal(meta.fieldType, 'textarea')
-    assert.equal(meta['rows'], 4)
-  })
-
-  it('rows(n) overrides the default', () => {
-    const meta = TextareaField.make('bio').rows(10).toMeta()
-    assert.equal(meta['rows'], 10)
-  })
-
-  it('cols(n) emits cols only when set', () => {
-    const off = TextareaField.make('bio').toMeta()
-    const on  = TextareaField.make('bio').cols(40).toMeta()
-    assert.equal(off['cols'], undefined)
-    assert.equal(on['cols'],  40)
-  })
-
-  it('autosize() emits the flag only when called', () => {
-    const off = TextareaField.make('bio').toMeta()
-    const on  = TextareaField.make('bio').autosize().toMeta()
-    assert.equal(off['autosize'], undefined)
-    assert.equal(on['autosize'],  true)
-  })
-
-  it('autosize(false) is a no-op default', () => {
-    const meta = TextareaField.make('bio').autosize(false).toMeta()
-    assert.equal(meta['autosize'], undefined)
-  })
-
-  it('disableGrammarly() emits the flag only when called', () => {
-    const off = TextareaField.make('bio').toMeta()
-    const on  = TextareaField.make('bio').disableGrammarly().toMeta()
-    assert.equal(off['disableGrammarly'], undefined)
-    assert.equal(on['disableGrammarly'],  true)
-  })
-
-  it('the chainables compose with each other and with rows/required', () => {
-    const meta = TextareaField.make('bio')
-      .rows(8)
-      .cols(60)
-      .autosize()
-      .disableGrammarly()
-      .required()
-      .toMeta()
-    assert.equal(meta['rows'],             8)
-    assert.equal(meta['cols'],             60)
-    assert.equal(meta['autosize'],         true)
-    assert.equal(meta['disableGrammarly'], true)
-    assert.equal(meta.required,            true)
-  })
-})

package/src/fields/TextareaField.ts

@@ -1,59 +0,0 @@
-import { Field, type FieldMeta } from './Field.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-
-export class TextareaField extends Field {
-  private _rows = 4
-  private _cols?: number
-  private _autosize = false
-  private _disableGrammarly = false
-
-  private constructor(name: string) {
-    super(name, 'textarea')
-  }
-
-  static make(name: string): TextareaField {
-    return new TextareaField(name)
-  }
-
-  rows(n: number): this { this._rows = n; return this }
-  getRows(): number { return this._rows }
-
-  /**
-   * HTML `cols` attribute on the underlying `<textarea>`. Sets the
-   * visible character width independent of the parent column / span.
-   * Most apps lean on `rows()` + the field's flex layout instead — pass
-   * `cols(n)` only when you need an explicit character-grid width.
-   */
-  cols(n: number): this { this._cols = n; return this }
-  getCols(): number | undefined { return this._cols }
-
-  /**
-   * Auto-grow the textarea so its height matches the typed content (no
-   * scrollbar until `maxHeight`). Implemented in CSS via the existing
-   * `field-sizing-content` utility on `<Textarea>` — `autosize()` simply
-   * keeps the chrome and unsets the explicit `rows` so the browser can
-   * size to content. Off by default to preserve the legacy fixed-height
-   * look on bare `TextareaField.make(...)`.
-   */
-  autosize(v = true): this { this._autosize = v; return this }
-  isAutosize(): boolean { return this._autosize }
-
-  /**
-   * Add `data-gramm="false"` (plus the matching Grammarly extension
-   * disable attributes) so the third-party browser overlay doesn't mount
-   * on this field. Use for sensitive content (slug source, DB queries,
-   * code snippets) where the overlay's UI corrupts cursor placement.
-   */
-  disableGrammarly(v = true): this { this._disableGrammarly = v; return this }
-  isGrammarlyDisabled(): boolean { return this._disableGrammarly }
-
-  override toMeta(ctx?: RenderContext): FieldMeta {
-    return {
-      ...this.buildMeta(ctx),
-      rows: this._rows,
-      ...(this._cols !== undefined ? { cols: this._cols } : {}),
-      ...(this._autosize ? { autosize: true } : {}),
-      ...(this._disableGrammarly ? { disableGrammarly: true } : {}),
-    }
-  }
-}

package/src/fields/ToggleButtonsField.test.ts

@@ -1,106 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { ToggleButtonsField, ToggleButtons } from './ToggleButtonsField.js'
-
-describe('ToggleButtonsField', () => {
-  it('emits fieldType "toggleButtons"', async () => {
-    const meta = await ToggleButtonsField.make('priority').toMeta()
-    assert.equal(meta.fieldType, 'toggleButtons')
-  })
-
-  it('exports an alias `ToggleButtons`', () => {
-    assert.equal(ToggleButtons, ToggleButtonsField)
-  })
-
-  it('does NOT emit an `inline` flag (chips are always horizontal)', async () => {
-    const meta = await ToggleButtonsField.make('x').toMeta()
-    assert.equal('inline' in meta, false)
-  })
-
-  describe('options(static array)', () => {
-    it('emits options array verbatim', async () => {
-      const meta = await ToggleButtonsField.make('priority').options([
-        { value: 'low',  label: 'Low' },
-        { value: 'high', label: 'High' },
-      ]).toMeta()
-      assert.deepEqual(meta['options'], [
-        { value: 'low',  label: 'Low' },
-        { value: 'high', label: 'High' },
-      ])
-    })
-
-    it('hasDynamicOptions is false for static arrays', () => {
-      const f = ToggleButtonsField.make('priority').options([{ value: 'a', label: 'A' }])
-      assert.equal(f.hasDynamicOptions(), false)
-    })
-
-    it('getOptions returns the array', () => {
-      const f = ToggleButtonsField.make('priority').options([{ value: 'a', label: 'A' }])
-      assert.deepEqual(f.getOptions(), [{ value: 'a', label: 'A' }])
-    })
-
-    it('options default to [] when never configured', async () => {
-      const meta = await ToggleButtonsField.make('x').toMeta()
-      assert.deepEqual(meta['options'], [])
-    })
-  })
-
-  describe('options(resolver function)', () => {
-    it('runs the resolver against ctx', async () => {
-      const f = ToggleButtonsField.make('plan').options(({ $get }) => {
-        const tier = $get?.('tier') as string | undefined
-        if (tier === 'pro') return [{ value: 'monthly', label: 'Monthly' }]
-        return [{ value: 'free', label: 'Free' }]
-      })
-      assert.equal(f.hasDynamicOptions(), true)
-      const meta = await f.toMeta({
-        values: { tier: 'pro' },
-        $get:   (n) => ({ tier: 'pro' } as Record<string, unknown>)[n],
-      })
-      assert.deepEqual(meta['options'], [{ value: 'monthly', label: 'Monthly' }])
-    })
-
-    it('async resolver is awaited', async () => {
-      const f = ToggleButtonsField.make('items').options(async () => {
-        await new Promise(r => setTimeout(r, 1))
-        return [{ value: 'a', label: 'A' }]
-      })
-      const meta = await f.toMeta()
-      assert.deepEqual(meta['options'], [{ value: 'a', label: 'A' }])
-    })
-
-    it('thrown resolver returns empty options + console.warn', async () => {
-      const original = console.warn
-      const calls: unknown[] = []
-      console.warn = (...args: unknown[]) => { calls.push(args) }
-      try {
-        const f = ToggleButtonsField.make('broken').options(() => { throw new Error('boom') })
-        const meta = await f.toMeta()
-        assert.deepEqual(meta['options'], [])
-        assert.equal(calls.length, 1)
-      } finally {
-        console.warn = original
-      }
-    })
-  })
-
-  it('participates in cross-field plumbing (default / required / live)', async () => {
-    const f = ToggleButtonsField.make('priority')
-      .label('Priority')
-      .required()
-      .default('medium')
-      .live()
-      .options([
-        { value: 'low',    label: 'Low' },
-        { value: 'medium', label: 'Medium' },
-        { value: 'high',   label: 'High' },
-      ])
-    const meta = await f.toMeta()
-    assert.equal(meta.fieldType,    'toggleButtons')
-    assert.equal(meta.required,     true)
-    assert.equal(meta['defaultValue'], 'medium')
-    assert.equal(meta['live'],      true)
-    assert.equal(meta.label,        'Priority')
-  })
-})

package/src/fields/ToggleButtonsField.ts

@@ -1,59 +0,0 @@
-import { Field, type FieldMeta } from './Field.js'
-import {
-  resolveOptions,
-  disableOptionsTakenInSiblings,
-  type OptionsResolver,
-  type SelectOption,
-} from './optionsResolver.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-
-/**
- * Single-choice field rendered as a horizontal segmented chip group.
- * Sugar over `RadioField` with the same `OptionsResolver` shape; the
- * difference is purely visual — `RadioField` paints a vertical (or
- * `inline:true`) stack of native radios, `ToggleButtonsField` paints
- * a row of pill-shaped buttons styled like a segmented control.
- *
- * Multi-select is intentionally out of scope in v1; reach for
- * `CheckboxListField` for that.
- */
-export class ToggleButtonsField extends Field {
-  private _options: SelectOption[] | OptionsResolver = []
-
-  private constructor(name: string) {
-    super(name, 'toggleButtons')
-  }
-
-  static make(name: string): ToggleButtonsField {
-    return new ToggleButtonsField(name)
-  }
-
-  options(opts: SelectOption[] | OptionsResolver): this {
-    this._options = opts
-    return this
-  }
-
-  getOptions(): SelectOption[] {
-    return Array.isArray(this._options) ? this._options : []
-  }
-
-  hasDynamicOptions(): boolean {
-    return typeof this._options === 'function'
-  }
-
-  override async toMeta(ctx?: RenderContext): Promise<FieldMeta> {
-    const base    = this.buildMeta(ctx)
-    const options = disableOptionsTakenInSiblings(
-      await resolveOptions(this._options, ctx, this.name),
-      this.shouldDisableOptionsTakenInSiblings(),
-      this.name,
-      ctx,
-    )
-    return {
-      ...base,
-      options,
-    }
-  }
-}
-
-export const ToggleButtons = ToggleButtonsField

package/src/fields/ToggleField.ts

@@ -1,16 +0,0 @@
-import { Field, type FieldMeta } from './Field.js'
-import type { RenderContext } from '../schema/resolveSchema.js'
-
-export class ToggleField extends Field {
-  private constructor(name: string) {
-    super(name, 'toggle')
-  }
-
-  static make(name: string): ToggleField {
-    return new ToggleField(name)
-  }
-
-  override toMeta(ctx?: RenderContext): FieldMeta {
-    return this.buildMeta(ctx)
-  }
-}

package/src/fields/disableOptionsWhenSelectedInSiblingRepeaterItems.test.ts

@@ -1,319 +0,0 @@
-import { describe, it } from 'node:test'
-import assert from 'node:assert/strict'
-
-import { SelectField } from './SelectField.js'
-import { RadioField } from './RadioField.js'
-import { CheckboxListField } from './CheckboxListField.js'
-import { ToggleButtonsField } from './ToggleButtonsField.js'
-import { TextField } from './TextField.js'
-import { RepeaterField, type RepeaterFieldMeta } from './RepeaterField.js'
-import { BuilderField, type BuilderFieldMeta } from './BuilderField.js'
-import { Block } from '../schema/Block.js'
-import { resolveSchema } from '../schema/resolveSchema.js'
-import { disableOptionsTakenInSiblings, type SelectOption } from './optionsResolver.js'
-
-const colours = [
-  { value: 'red',   label: 'Red'   },
-  { value: 'green', label: 'Green' },
-  { value: 'blue',  label: 'Blue'  },
-]
-
-function rowOptions(meta: RepeaterFieldMeta | BuilderFieldMeta, rowIdx: number, fieldName: string): SelectOption[] {
-  const row = meta.rows[rowIdx]
-  if (!row) throw new Error(`row ${rowIdx} missing`)
-  const child = row.children.find(c => c['name'] === fieldName)
-  if (!child) throw new Error(`field "${fieldName}" missing in row ${rowIdx}`)
-  return (child['options'] as SelectOption[]) ?? []
-}
-
-describe('disableOptionsWhenSelectedInSiblingRepeaterItems', () => {
-  describe('flag plumbing', () => {
-    it('default is disabled', () => {
-      const f = SelectField.make('color')
-      assert.equal(f.shouldDisableOptionsTakenInSiblings(), false)
-    })
-
-    it('enables flag + auto-arms distinct() and live()', () => {
-      const f = SelectField.make('color').disableOptionsWhenSelectedInSiblingRepeaterItems()
-      assert.equal(f.shouldDisableOptionsTakenInSiblings(), true)
-      assert.notEqual(f.getDistinct(), undefined)
-      assert.equal(f.isLive(), true)
-    })
-
-    it('disableOptionsWhenSelectedInSiblingRepeaterItems(false) clears the flag', () => {
-      const f = SelectField.make('color').disableOptionsWhenSelectedInSiblingRepeaterItems()
-        .disableOptionsWhenSelectedInSiblingRepeaterItems(false)
-      assert.equal(f.shouldDisableOptionsTakenInSiblings(), false)
-    })
-
-    it('available on Radio / CheckboxList / ToggleButtons too', () => {
-      assert.equal(
-        RadioField.make('x').disableOptionsWhenSelectedInSiblingRepeaterItems().shouldDisableOptionsTakenInSiblings(),
-        true,
-      )
-      assert.equal(
-        CheckboxListField.make('x').disableOptionsWhenSelectedInSiblingRepeaterItems().shouldDisableOptionsTakenInSiblings(),
-        true,
-      )
-      assert.equal(
-        ToggleButtonsField.make('x').disableOptionsWhenSelectedInSiblingRepeaterItems().shouldDisableOptionsTakenInSiblings(),
-        true,
-      )
-    })
-  })
-
-  describe('disableOptionsTakenInSiblings helper', () => {
-    it('no-op when disabled', () => {
-      const out = disableOptionsTakenInSiblings(colours, false, 'color', { row: { index: 0, $get: () => undefined, $set: () => {}, siblings: [{ color: 'red' }] } })
-      assert.deepEqual(out, colours)
-    })
-
-    it('no-op without row.siblings (top-level form)', () => {
-      const out = disableOptionsTakenInSiblings(colours, true, 'color', undefined)
-      assert.deepEqual(out, colours)
-    })
-
-    it('marks taken values disabled', () => {
-      const out = disableOptionsTakenInSiblings(colours, true, 'color', {
-        row: { index: 1, $get: () => undefined, $set: () => {}, siblings: [{ color: 'red' }] },
-      })
-      assert.equal(out[0]?.disabled, true)   // red is taken
-      assert.equal(out[1]?.disabled, undefined)
-      assert.equal(out[2]?.disabled, undefined)
-    })
-
-    it('skips empty / null sibling values', () => {
-      const out = disableOptionsTakenInSiblings(colours, true, 'color', {
-        row: {
-          index: 1,
-          $get: () => undefined,
-          $set: () => {},
-          siblings: [{ color: '' }, { color: null }, { color: undefined }, { other: 'red' }],
-        },
-      })
-      assert.equal(out[0]?.disabled, undefined)
-      assert.equal(out[1]?.disabled, undefined)
-    })
-
-    it('unfolds array sibling values (CheckboxList semantics)', () => {
-      const out = disableOptionsTakenInSiblings(colours, true, 'tags', {
-        row: { index: 1, $get: () => undefined, $set: () => {}, siblings: [{ tags: ['red', 'blue'] }] },
-      })
-      assert.equal(out[0]?.disabled, true)
-      assert.equal(out[1]?.disabled, undefined)
-      assert.equal(out[2]?.disabled, true)
-    })
-
-    it('preserves user-set option.disabled (does not toggle it back to undefined)', () => {
-      const opts: SelectOption[] = [
-        { value: 'red', label: 'Red', disabled: true },
-        { value: 'green', label: 'Green' },
-      ]
-      const out = disableOptionsTakenInSiblings(opts, true, 'color', {
-        row: { index: 1, $get: () => undefined, $set: () => {}, siblings: [{ color: 'green' }] },
-      })
-      assert.equal(out[0]?.disabled, true)   // user-set, untouched
-      assert.equal(out[1]?.disabled, true)   // newly taken
-    })
-  })
-
-  describe('inside Repeater', () => {
-    function makeRep() {
-      return RepeaterField.make('picks').schema([
-        SelectField.make('color')
-          .options(colours)
-          .disableOptionsWhenSelectedInSiblingRepeaterItems(),
-      ])
-    }
-
-    it('first row sees all options enabled when no sibling has picked', async () => {
-      const [raw] = await resolveSchema([makeRep()], {
-        values: { picks: [{ color: '' }, { color: '' }] },
-      })
-      const m = raw as RepeaterFieldMeta
-      assert.equal(rowOptions(m, 0, 'color').every(o => !o.disabled), true)
-      assert.equal(rowOptions(m, 1, 'color').every(o => !o.disabled), true)
-    })
-
-    it('when row 0 picks "red", row 1 sees red disabled', async () => {
-      const [raw] = await resolveSchema([makeRep()], {
-        values: { picks: [{ color: 'red' }, { color: '' }] },
-      })
-      const m = raw as RepeaterFieldMeta
-      const row1 = rowOptions(m, 1, 'color')
-      assert.equal(row1.find(o => o.value === 'red')?.disabled, true)
-      assert.equal(row1.find(o => o.value === 'green')?.disabled, undefined)
-      assert.equal(row1.find(o => o.value === 'blue')?.disabled, undefined)
-    })
-
-    it('the picking row keeps its own pick selectable (not disabled by self)', async () => {
-      const [raw] = await resolveSchema([makeRep()], {
-        values: { picks: [{ color: 'red' }, { color: 'green' }] },
-      })
-      const m = raw as RepeaterFieldMeta
-      // Row 0 sees its own red as enabled (siblings = [{green}])
-      assert.equal(rowOptions(m, 0, 'color').find(o => o.value === 'red')?.disabled, undefined)
-      // Row 1 sees its own green as enabled (siblings = [{red}])
-      assert.equal(rowOptions(m, 1, 'color').find(o => o.value === 'green')?.disabled, undefined)
-      // … but the OTHER row's pick is disabled
-      assert.equal(rowOptions(m, 0, 'color').find(o => o.value === 'green')?.disabled, true)
-      assert.equal(rowOptions(m, 1, 'color').find(o => o.value === 'red')?.disabled, true)
-    })
-
-    it('flag off → no options ever disabled (sanity check)', async () => {
-      const f = RepeaterField.make('picks').schema([
-        SelectField.make('color').options(colours), // no disable flag
-      ])
-      const [raw] = await resolveSchema([f], {
-        values: { picks: [{ color: 'red' }, { color: '' }] },
-      })
-      const m = raw as RepeaterFieldMeta
-      assert.equal(rowOptions(m, 1, 'color').find(o => o.value === 'red')?.disabled, undefined)
-    })
-
-    it('CheckboxList — sibling array values mark each entry disabled', async () => {
-      const f = RepeaterField.make('groups').schema([
-        CheckboxListField.make('tags')
-          .options(colours)
-          .disableOptionsWhenSelectedInSiblingRepeaterItems(),
-      ])
-      const [raw] = await resolveSchema([f], {
-        values: { groups: [{ tags: ['red', 'blue'] }, { tags: [] }] },
-      })
-      const m = raw as RepeaterFieldMeta
-      const row1 = rowOptions(m, 1, 'tags')
-      assert.equal(row1.find(o => o.value === 'red')?.disabled, true)
-      assert.equal(row1.find(o => o.value === 'blue')?.disabled, true)
-      assert.equal(row1.find(o => o.value === 'green')?.disabled, undefined)
-    })
-
-    it('Radio + ToggleButtons honor the flag the same way', async () => {
-      const f = RepeaterField.make('rows').schema([
-        RadioField.make('r').options(colours).disableOptionsWhenSelectedInSiblingRepeaterItems(),
-        ToggleButtonsField.make('t').options(colours).disableOptionsWhenSelectedInSiblingRepeaterItems(),
-      ])
-      const [raw] = await resolveSchema([f], {
-        values: { rows: [{ r: 'red', t: 'blue' }, { r: '', t: '' }] },
-      })
-      const m = raw as RepeaterFieldMeta
-      assert.equal(rowOptions(m, 1, 'r').find(o => o.value === 'red')?.disabled, true)
-      assert.equal(rowOptions(m, 1, 't').find(o => o.value === 'blue')?.disabled, true)
-    })
-
-    it('top-level (non-Repeater) Select with the flag set is a no-op', async () => {
-      const top = SelectField.make('color').options(colours).disableOptionsWhenSelectedInSiblingRepeaterItems()
-      const [raw] = await resolveSchema([top], { values: { color: 'red' } })
-      const opts = (raw?.['options'] as SelectOption[]) ?? []
-      assert.equal(opts.every(o => !o.disabled), true)
-    })
-
-    it('zero submitted rows + defaultItems → no errors, options all enabled', async () => {
-      const [raw] = await resolveSchema([makeRep().defaultItems(2)])
-      const m = raw as RepeaterFieldMeta
-      // Two empty default rows; nobody has picked anything yet.
-      assert.equal(rowOptions(m, 0, 'color').every(o => !o.disabled), true)
-      assert.equal(rowOptions(m, 1, 'color').every(o => !o.disabled), true)
-    })
-  })
-
-  describe('inside Builder (per-block-type scoping)', () => {
-    function makeBuilder() {
-      return BuilderField.make('blocks').blocks([
-        Block.make('hero').schema([
-          SelectField.make('layout').options([
-            { value: 'left',  label: 'Left'  },
-            { value: 'right', label: 'Right' },
-          ]).disableOptionsWhenSelectedInSiblingRepeaterItems(),
-        ]),
-        Block.make('cta').schema([
-          // Same field name on a different block type — must NOT shadow.
-          SelectField.make('layout').options([
-            { value: 'left',  label: 'Left'  },
-            { value: 'right', label: 'Right' },
-          ]).disableOptionsWhenSelectedInSiblingRepeaterItems(),
-        ]),
-      ])
-    }
-
-    it('same-type sibling pick disables the option on the next same-type row', async () => {
-      const [raw] = await resolveSchema([makeBuilder()], {
-        values: { blocks: [
-          { type: 'hero', data: { layout: 'left' } },
-          { type: 'hero', data: { layout: '' } },
-        ] },
-      })
-      const m = raw as BuilderFieldMeta
-      const row1 = rowOptions(m, 1, 'layout')
-      assert.equal(row1.find(o => o.value === 'left')?.disabled, true)
-      assert.equal(row1.find(o => o.value === 'right')?.disabled, undefined)
-    })
-
-    it('different block types DO NOT shadow each other (cross-block isolation)', async () => {
-      const [raw] = await resolveSchema([makeBuilder()], {
-        values: { blocks: [
-          { type: 'hero', data: { layout: 'left' } },
-          { type: 'cta',  data: { layout: '' } },
-        ] },
-      })
-      const m = raw as BuilderFieldMeta
-      // The cta row at index 1 is a different block — its `layout` is its
-      // own namespace. None of its options should be disabled by the hero
-      // row's pick.
-      const row1 = rowOptions(m, 1, 'layout')
-      assert.equal(row1.every(o => !o.disabled), true)
-    })
-
-    it('three rows, two same-type → only the third sees both prior picks disabled', async () => {
-      const [raw] = await resolveSchema([makeBuilder()], {
-        values: { blocks: [
-          { type: 'hero', data: { layout: 'left'  } },
-          { type: 'hero', data: { layout: 'right' } },
-          { type: 'hero', data: { layout: ''      } },
-        ] },
-      })
-      const m = raw as BuilderFieldMeta
-      const row2 = rowOptions(m, 2, 'layout')
-      assert.equal(row2.find(o => o.value === 'left')?.disabled, true)
-      assert.equal(row2.find(o => o.value === 'right')?.disabled, true)
-    })
-  })
-
-  describe('static option.disabled is preserved alongside taken-disabled', () => {
-    it('user-set disabled stays even when not taken', async () => {
-      const f = RepeaterField.make('picks').schema([
-        SelectField.make('color')
-          .options([
-            { value: 'red',   label: 'Red'   },
-            { value: 'green', label: 'Green', disabled: true },
-            { value: 'blue',  label: 'Blue'  },
-          ])
-          .disableOptionsWhenSelectedInSiblingRepeaterItems(),
-      ])
-      const [raw] = await resolveSchema([f], {
-        values: { picks: [{ color: 'red' }, { color: '' }] },
-      })
-      const m = raw as RepeaterFieldMeta
-      const row1 = rowOptions(m, 1, 'color')
-      assert.equal(row1.find(o => o.value === 'red')?.disabled, true)    // taken
-      assert.equal(row1.find(o => o.value === 'green')?.disabled, true)  // user-set
-      assert.equal(row1.find(o => o.value === 'blue')?.disabled, undefined)
-    })
-  })
-
-  describe('cross-row interaction with non-option fields', () => {
-    it('coexists with sibling fields that are not option-bearing', async () => {
-      const f = RepeaterField.make('rows').schema([
-        TextField.make('title'),
-        SelectField.make('color').options(colours).disableOptionsWhenSelectedInSiblingRepeaterItems(),
-      ])
-      const [raw] = await resolveSchema([f], {
-        values: { rows: [
-          { title: 'A', color: 'red' },
-          { title: 'B', color: '' },
-        ] },
-      })
-      const m = raw as RepeaterFieldMeta
-      assert.equal(rowOptions(m, 1, 'color').find(o => o.value === 'red')?.disabled, true)
-    })
-  })
-})