@pilotiq/pilotiq 0.1.0

package/src/validation/runValidators.ts

@@ -0,0 +1,435 @@
+import { Element } from '../schema/Element.js'
+import { Field, type DistinctOptions } from '../fields/Field.js'
+import { RepeaterField } from '../fields/RepeaterField.js'
+import { BuilderField } from '../fields/BuilderField.js'
+
+export interface ValidationErrors {
+  [fieldName: string]: string[]
+}
+
+/**
+ * Walk an Element tree, run every Field's validators against the matching
+ * value in `values`, and return a `{ name -> errors[] }` map.
+ *
+ * The map is empty when every field passes. Fields with no validators
+ * (and no `required` flag) never appear in the output. The caller decides
+ * whether a non-empty map should reject the submit.
+ *
+ * `record` is the persisted record under edit, when present — it propagates
+ * to each validator's `ctx` for cross-field rules that need it.
+ *
+ * Plan #14 — Repeater fields validate each row's inner schema recursively.
+ * Per-row errors are flat-keyed as `${fieldName}.${i}.${childName}` so the
+ * client can surface them inline on the right row. `minItems` / `maxItems`
+ * land under the bare repeater name.
+ *
+ * Async — `Field.runValidators` is awaited per field, so async validators
+ * (e.g. `unique()` probing the DB) work transparently. The walker is still
+ * sequential per field within the same scope to preserve declaration order
+ * in the error output; cross-field parallelism would only matter on forms
+ * with many DB-probing validators and is left for a future profile.
+ */
+export async function validateSchema(
+  elements: Element[],
+  values:   Record<string, unknown>,
+  record?:  unknown,
+): Promise<ValidationErrors> {
+  const errors: ValidationErrors = {}
+  const fields:    Field[]         = []
+  const repeaters: RepeaterField[] = []
+  const builders:  BuilderField[]  = []
+
+  // Two-pass to preserve order: collect first (sync walk), then await each.
+  walk(elements, el => {
+    if (el instanceof RepeaterField) { repeaters.push(el); return }
+    if (el instanceof BuilderField)  { builders.push(el);  return }
+    if (el instanceof Field) fields.push(el)
+  })
+
+  for (const el of fields) {
+    const value = values[el.name]
+    const ctx: { values: Record<string, unknown>; record?: unknown } = { values }
+    if (record !== undefined) ctx.record = record
+    const fieldErrors = await el.runValidators(value, ctx)
+    if (fieldErrors.length > 0) errors[el.name] = fieldErrors
+  }
+
+  for (const rep of repeaters) {
+    const raw = values[rep.name]
+    const rows = Array.isArray(raw) ? raw : foldFlatRepeaterRows(values, rep.name)
+    await validateRepeater(rep, rows, record, errors)
+  }
+
+  for (const bld of builders) {
+    const raw = values[bld.name]
+    const rows = Array.isArray(raw) ? raw : foldFlatBuilderRows(values, bld.name)
+    await validateBuilder(bld, rows, record, errors)
+  }
+
+  return errors
+}
+
+async function validateRepeater(
+  field:  RepeaterField,
+  raw:    unknown,
+  record: unknown,
+  errors: ValidationErrors,
+): Promise<void> {
+  const rows = Array.isArray(raw) ? raw : []
+  const baseErrors: string[] = []
+
+  const min = field.getMinItems()
+  if (min !== undefined && rows.length < min) {
+    baseErrors.push(min === 1
+      ? 'At least 1 item is required'
+      : `At least ${min} items are required`)
+  }
+
+  const max = field.getMaxItems()
+  if (max !== undefined && rows.length > max) {
+    baseErrors.push(max === 1
+      ? 'At most 1 item is allowed'
+      : `At most ${max} items are allowed`)
+  }
+
+  if (baseErrors.length > 0) errors[field.name] = baseErrors
+
+  const inner       = field.getInnerSchema()
+  const simpleInner = field.getSimpleInnerField()
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i]
+    // For `simple()` repeaters, wrap primitive entries inline so per-field
+    // validators run against the standard `{ <innerName>: v }` shape. A
+    // primitive in a non-simple Repeater is genuinely malformed and gets
+    // skipped (the prior posture).
+    let rowValues: Record<string, unknown> | null
+    if (row && typeof row === 'object' && !Array.isArray(row)) {
+      rowValues = row as Record<string, unknown>
+    } else if (simpleInner && row !== undefined) {
+      rowValues = { [simpleInner.name]: row }
+    } else {
+      rowValues = null
+    }
+    if (!rowValues) continue
+    const rowErrors = await validateSchema(inner, rowValues, record)
+    for (const [childName, msgs] of Object.entries(rowErrors)) {
+      errors[`${field.name}.${i}.${childName}`] = msgs
+    }
+  }
+
+  checkDistinctRows({
+    fieldName: field.name,
+    innerFields: collectDistinctFields(inner),
+    rows,
+    errorKey: (rowIdx, childName) => `${field.name}.${rowIdx}.${childName}`,
+    // `simple()` repeaters can hand bare primitive rows to the comparator;
+    // when the row matches the inner field, treat the primitive itself as
+    // the value. Object rows still read by child key as normal.
+    extractValue: (row, childName) => {
+      if (row && typeof row === 'object' && !Array.isArray(row)) {
+        return (row as Record<string, unknown>)[childName]
+      }
+      if (simpleInner && simpleInner.name === childName) return row
+      return undefined
+    },
+    rowMatches: () => true,
+    errors,
+  })
+}
+
+/**
+ * Validate a single Builder field's rows. Per-row errors are flat-keyed
+ * `${field.name}.${i}.data.${childName}` so the client can surface them
+ * inline on the right row's inner field. `minItems` / `maxItems` /
+ * `Block.maxItems` (per-block-type ceiling) and unknown-block-type
+ * errors land under the bare builder name.
+ */
+async function validateBuilder(
+  field:  BuilderField,
+  raw:    unknown,
+  record: unknown,
+  errors: ValidationErrors,
+): Promise<void> {
+  const rows = Array.isArray(raw) ? raw : []
+  const baseErrors: string[] = []
+
+  const min = field.getMinItems()
+  if (min !== undefined && rows.length < min) {
+    baseErrors.push(min === 1
+      ? 'At least 1 item is required'
+      : `At least ${min} items are required`)
+  }
+
+  const max = field.getMaxItems()
+  if (max !== undefined && rows.length > max) {
+    baseErrors.push(max === 1
+      ? 'At most 1 item is allowed'
+      : `At most ${max} items are allowed`)
+  }
+
+  // Per-block-type ceiling (`Block.maxItems`) is enforced post-row-walk
+  // so we can count the rows of each type in one pass.
+  const typeCounts = new Map<string, number>()
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i]
+    if (!row || typeof row !== 'object' || Array.isArray(row)) continue
+    const t = (row as Record<string, unknown>)['type']
+    if (typeof t === 'string' && t !== '') {
+      typeCounts.set(t, (typeCounts.get(t) ?? 0) + 1)
+    }
+  }
+  for (const block of field.getBlocks()) {
+    const cap = block.getMaxItems()
+    if (cap === undefined) continue
+    const count = typeCounts.get(block.name) ?? 0
+    if (count > cap) {
+      baseErrors.push(cap === 1
+        ? `At most 1 "${block.getLabel()}" block is allowed`
+        : `At most ${cap} "${block.getLabel()}" blocks are allowed`)
+    }
+  }
+
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i]
+    if (!row || typeof row !== 'object' || Array.isArray(row)) continue
+    const r = row as Record<string, unknown>
+    const t = r['type']
+    if (typeof t !== 'string' || t === '') {
+      errors[`${field.name}.${i}`] = ['Block type is required']
+      continue
+    }
+    const block = field.getBlock(t)
+    if (!block) {
+      errors[`${field.name}.${i}`] = [`Unknown block type "${t}"`]
+      continue
+    }
+    const dataRaw = r['data']
+    const data: Record<string, unknown> = (dataRaw && typeof dataRaw === 'object' && !Array.isArray(dataRaw))
+      ? (dataRaw as Record<string, unknown>)
+      : {}
+    const rowErrors = await validateSchema(block.getSchema(), data, record)
+    for (const [childName, msgs] of Object.entries(rowErrors)) {
+      errors[`${field.name}.${i}.data.${childName}`] = msgs
+    }
+  }
+
+  // Distinct check is per-block-type — comparing a `heading.title` against a
+  // `paragraph.text` is meaningless (different schemas, different fields).
+  // We re-walk the rows once per block type so each pass only sees rows
+  // matching that type.
+  for (const block of field.getBlocks()) {
+    const distinctFields = collectDistinctFields(block.getSchema())
+    if (distinctFields.length === 0) continue
+    checkDistinctRows({
+      fieldName: field.name,
+      innerFields: distinctFields,
+      rows,
+      errorKey: (rowIdx, childName) => `${field.name}.${rowIdx}.data.${childName}`,
+      extractValue: (row, childName) => {
+        if (!row || typeof row !== 'object' || Array.isArray(row)) return undefined
+        const r = row as Record<string, unknown>
+        const data = r['data']
+        if (!data || typeof data !== 'object' || Array.isArray(data)) return undefined
+        return (data as Record<string, unknown>)[childName]
+      },
+      rowMatches: row => {
+        if (!row || typeof row !== 'object' || Array.isArray(row)) return false
+        return (row as Record<string, unknown>)['type'] === block.name
+      },
+      errors,
+    })
+  }
+
+  if (baseErrors.length > 0) errors[field.name] = baseErrors
+}
+
+/**
+ * Walk the inner schema for fields with `.distinct()` set. Stops at any
+ * nested Repeater / Builder so the outer field's distinct pass doesn't
+ * accidentally walk into a child array's leaves (those rows are
+ * validated by their own array-field pass when they're submitted).
+ */
+function collectDistinctFields(elements: Element[]): Array<{ field: Field; opts: DistinctOptions }> {
+  const out: Array<{ field: Field; opts: DistinctOptions }> = []
+  const visit = (els: Element[]): void => {
+    for (const el of els) {
+      if (el instanceof RepeaterField) continue
+      if (el instanceof BuilderField)  continue
+      if (el instanceof Field) {
+        const opts = el.getDistinct()
+        if (opts) out.push({ field: el, opts })
+      }
+      const children = el.getChildren()
+      if (children && children.length > 0) visit(children)
+    }
+  }
+  visit(elements)
+  return out
+}
+
+/**
+ * Cross-row distinct comparison shared by Repeater + Builder. The first
+ * occurrence of each value passes; subsequent rows with the same value
+ * (after `caseInsensitive` / `ignoreNulls` normalization) get the
+ * configured rejection message under their flat-keyed error path.
+ *
+ * `rowMatches` lets the Builder caller scope the comparison to a single
+ * block type; Repeater always passes `() => true`.
+ */
+function checkDistinctRows(args: {
+  fieldName:    string
+  innerFields:  Array<{ field: Field; opts: DistinctOptions }>
+  rows:         unknown[]
+  errorKey:     (rowIdx: number, childName: string) => string
+  extractValue: (row: unknown, childName: string) => unknown
+  rowMatches:   (row: unknown) => boolean
+  errors:       ValidationErrors
+}): void {
+  if (args.innerFields.length === 0) return
+  for (const { field: child, opts } of args.innerFields) {
+    const ignoreNulls = opts.ignoreNulls !== false   // default true
+    const seen = new Map<unknown, number>()
+    for (let i = 0; i < args.rows.length; i++) {
+      const row = args.rows[i]
+      if (!args.rowMatches(row)) continue
+      const value = args.extractValue(row, child.name)
+      if (ignoreNulls && (value === undefined || value === null || value === '')) continue
+      const key = (opts.caseInsensitive && typeof value === 'string')
+        ? value.toLowerCase()
+        : value
+      if (!seen.has(key)) {
+        seen.set(key, i)
+        continue
+      }
+      const errKey = args.errorKey(i, child.name)
+      const message = opts.message ?? 'Must be unique'
+      const existing = args.errors[errKey]
+      if (existing) existing.push(message)
+      else args.errors[errKey] = [message]
+    }
+  }
+}
+
+/**
+ * Group flat-key form-encoded Builder rows into an array of row bodies
+ * shaped `{ __id?, type, data: {…} }`. Mirrors `coerceBuilderValue` in
+ * `dispatchForm.ts`. Validation runs before coercion so we can't reuse
+ * the coerced array directly.
+ */
+function foldFlatBuilderRows(
+  values:    Record<string, unknown>,
+  fieldName: string,
+): Array<Record<string, unknown>> {
+  const prefix  = `${fieldName}.`
+  const grouped = new Map<number, { __id?: string; type: string; data: Record<string, unknown> }>()
+  let maxIdx = -1
+  for (const key of Object.keys(values)) {
+    if (!key.startsWith(prefix)) continue
+    const rest = key.slice(prefix.length)
+    const dot  = rest.indexOf('.')
+    if (dot < 0) continue
+    const idxStr = rest.slice(0, dot)
+    const tail   = rest.slice(dot + 1)
+    const idx    = Number(idxStr)
+    if (!Number.isInteger(idx) || idx < 0) continue
+    if (idx > maxIdx) maxIdx = idx
+    let row = grouped.get(idx)
+    if (!row) { row = { type: '', data: {} }; grouped.set(idx, row) }
+    const value = values[key]
+    if (tail === '__id') {
+      if (typeof value === 'string') row.__id = value
+    } else if (tail === 'type') {
+      if (typeof value === 'string') row.type = value
+    } else if (tail.startsWith('data.')) {
+      row.data[tail.slice('data.'.length)] = value
+    }
+  }
+  if (maxIdx < 0) return []
+  const out: Array<Record<string, unknown>> = []
+  for (let i = 0; i <= maxIdx; i++) {
+    const row = grouped.get(i) ?? { type: '', data: {} }
+    const obj: Record<string, unknown> = { type: row.type, data: row.data }
+    if (typeof row.__id === 'string') obj['__id'] = row.__id
+    out.push(obj)
+  }
+  while (out.length > 0 && isBuilderRowEmpty(out[out.length - 1]!)) out.pop()
+  return out
+}
+
+function isBuilderRowEmpty(row: Record<string, unknown>): boolean {
+  const data = row['data']
+  if (!data || typeof data !== 'object' || Array.isArray(data)) return true
+  for (const [, v] of Object.entries(data as Record<string, unknown>)) {
+    if (v === undefined || v === null || v === '') continue
+    return false
+  }
+  return true
+}
+
+/** True when no field returned any error. */
+export function isValid(errors: ValidationErrors): boolean {
+  return Object.keys(errors).length === 0
+}
+
+/**
+ * Group flat-key form-encoded Repeater rows into an array of row bodies.
+ * Mirrors the same fold path as `coerceRepeaterValue` in
+ * `dispatchForm.ts` but kept private here so validation works against
+ * raw bodies (validation runs before coercion in `dispatchFormSubmit`).
+ *
+ * Returns an empty array when no matching keys exist — the Repeater's
+ * `minItems` validator then surfaces the right error.
+ */
+function foldFlatRepeaterRows(
+  values:    Record<string, unknown>,
+  fieldName: string,
+): Array<Record<string, unknown>> {
+  const prefix = `${fieldName}.`
+  const grouped = new Map<number, Record<string, unknown>>()
+  let maxIdx = -1
+  for (const key of Object.keys(values)) {
+    if (!key.startsWith(prefix)) continue
+    const rest = key.slice(prefix.length)
+    const dot = rest.indexOf('.')
+    if (dot < 0) continue
+    const idxStr = rest.slice(0, dot)
+    const childKey = rest.slice(dot + 1)
+    const idx = Number(idxStr)
+    if (!Number.isInteger(idx) || idx < 0) continue
+    if (idx > maxIdx) maxIdx = idx
+    let row = grouped.get(idx)
+    if (!row) { row = {}; grouped.set(idx, row) }
+    row[childKey] = values[key]
+  }
+  if (maxIdx < 0) return []
+  // Trim trailing untouched rows so `minItems` lines up with what
+  // coercion will eventually persist.
+  const out: Array<Record<string, unknown>> = []
+  for (let i = 0; i <= maxIdx; i++) out.push(grouped.get(i) ?? {})
+  while (out.length > 0 && isRowEmpty(out[out.length - 1]!)) out.pop()
+  return out
+}
+
+function isRowEmpty(row: Record<string, unknown>): boolean {
+  for (const [k, v] of Object.entries(row)) {
+    if (k === '__id') continue
+    if (v === undefined || v === null || v === '') continue
+    return false
+  }
+  return true
+}
+
+function walk(elements: Element[], visit: (el: Element) => void): void {
+  for (const el of elements) {
+    visit(el)
+    // Plan #14 — don't recurse into Repeater / Builder children. The
+    // visitor handles per-row validation by calling `validateSchema`
+    // recursively against the row's local values map (per-block schema
+    // for Builder). Recursing here would validate inner fields against
+    // the parent `values`, missing the row scope entirely.
+    if (el instanceof RepeaterField) continue
+    if (el instanceof BuilderField)  continue
+    const children = el.getChildren()
+    if (children && children.length > 0) walk(children, visit)
+  }
+}

package/src/validation/uniqueValidator.test.ts

@@ -0,0 +1,196 @@
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import { unique } from './uniqueValidator.js'
+import type { ModelLike, ModelQuery } from '../orm/modelDefaults.js'
+
+// ── Fake ModelLike — records every where() call so tests can assert ──
+
+interface FakeQueryOp { op: string; args: unknown[] }
+
+class FakeQuery implements ModelQuery {
+  ops: FakeQueryOp[] = []
+  constructor(private readonly _data: unknown[]) {}
+
+  where(...args: unknown[]): ModelQuery   { this.ops.push({ op: 'where',   args }); return this }
+  orWhere(...args: unknown[]): ModelQuery { this.ops.push({ op: 'orWhere', args }); return this }
+  orderBy(column: string, direction: 'ASC' | 'DESC' = 'ASC'): ModelQuery {
+    this.ops.push({ op: 'orderBy', args: [column, direction] }); return this
+  }
+  async paginate(page: number, perPage?: number) {
+    this.ops.push({ op: 'paginate', args: [page, perPage] })
+    return { data: this._data, total: this._data.length }
+  }
+}
+
+function makeModel(opts: { rows?: unknown[]; primaryKey?: string } = {}) {
+  let lastQuery: FakeQuery | null = null
+  const model = {
+    primaryKey: opts.primaryKey,
+    async find() { return null },
+    async create(data: Record<string, unknown>) { return { id: 'new', ...data } },
+    async update(id: string | number, data: Record<string, unknown>) { return { id, ...data } },
+    async delete() {},
+    query(): ModelQuery {
+      const q = new FakeQuery(opts.rows ?? [])
+      lastQuery = q
+      return q
+    },
+    get lastQuery() { return lastQuery },
+  } as unknown as ModelLike & { lastQuery: FakeQuery | null }
+  return model
+}
+
+describe('unique() validator', () => {
+  it('passes when value is empty (defers to required())', async () => {
+    const model = makeModel({ rows: [{ id: 1, email: 'a@b.com' }] })
+    const v = unique({ model, column: 'email' })
+    assert.equal(await v(''),        null)
+    assert.equal(await v(null),      null)
+    assert.equal(await v(undefined), null)
+  })
+
+  it('passes when no row matches', async () => {
+    const model = makeModel({ rows: [] })
+    const v = unique({ model, column: 'email' })
+    assert.equal(await v('new@b.com', { values: { email: 'new@b.com' } }), null)
+  })
+
+  it('rejects when a row matches and there is no current record (create)', async () => {
+    const model = makeModel({ rows: [{ id: 1, email: 'a@b.com' }] })
+    const v = unique({ model, column: 'email' })
+    assert.equal(await v('a@b.com', { values: { email: 'a@b.com' } }), 'Already taken')
+  })
+
+  it('passes on edit when the only matching row is the record under edit', async () => {
+    const model = makeModel({ rows: [{ id: 7, email: 'a@b.com' }] })
+    const v = unique({ model, column: 'email' })
+    const ctx = { values: { email: 'a@b.com' }, record: { id: 7, email: 'a@b.com' } }
+    assert.equal(await v('a@b.com', ctx), null)
+  })
+
+  it('rejects on edit when matching row is a DIFFERENT record', async () => {
+    const model = makeModel({ rows: [{ id: 99, email: 'a@b.com' }] })
+    const v = unique({ model, column: 'email' })
+    const ctx = { values: { email: 'a@b.com' }, record: { id: 7, email: 'old@b.com' } }
+    assert.equal(await v('a@b.com', ctx), 'Already taken')
+  })
+
+  it('honors primaryKey override on the model', async () => {
+    const model = makeModel({ rows: [{ uuid: 'abc', email: 'a@b.com' }], primaryKey: 'uuid' })
+    const v = unique({ model, column: 'email' })
+    const ctx = { values: { email: 'a@b.com' }, record: { uuid: 'abc' } }
+    assert.equal(await v('a@b.com', ctx), null)
+  })
+
+  it('ignoreRecord:false rejects even when the match is the current record', async () => {
+    const model = makeModel({ rows: [{ id: 7, email: 'a@b.com' }] })
+    const v = unique({ model, column: 'email', ignoreRecord: false })
+    const ctx = { values: { email: 'a@b.com' }, record: { id: 7 } }
+    assert.equal(await v('a@b.com', ctx), 'Already taken')
+  })
+
+  it('emits a custom message when configured', async () => {
+    const model = makeModel({ rows: [{ id: 1, email: 'a@b.com' }] })
+    const v = unique({ model, column: 'email', message: 'That email is taken' })
+    assert.equal(await v('a@b.com', { values: { email: 'a@b.com' } }), 'That email is taken')
+  })
+
+  it('caseInsensitive uses LIKE with escaped wildcards', async () => {
+    const model = makeModel({ rows: [] })
+    const v = unique({ model, column: 'name', caseInsensitive: true })
+    await v('100% solid_steel\\bar', { values: { name: '100% solid_steel\\bar' } })
+    const where = model.lastQuery!.ops.find(o => o.op === 'where')
+    assert.deepEqual(where!.args, ['name', 'LIKE', '100\\% solid\\_steel\\\\bar'])
+  })
+
+  it('caseInsensitive uses plain where for non-strings', async () => {
+    const model = makeModel({ rows: [] })
+    const v = unique({ model, column: 'count', caseInsensitive: true })
+    await v(42, { values: { count: 42 } })
+    const where = model.lastQuery!.ops.find(o => o.op === 'where')
+    assert.deepEqual(where!.args, ['count', 42])
+  })
+
+  it('applies extra where() clauses for scoped uniqueness', async () => {
+    const model = makeModel({ rows: [] })
+    const v = unique({
+      model, column: 'name',
+      where: ({ values }) => ({ tenantId: values?.tenantId }),
+    })
+    await v('Alpha', { values: { name: 'Alpha', tenantId: 't-1' } })
+    const wheres = model.lastQuery!.ops.filter(o => o.op === 'where')
+    assert.equal(wheres.length, 2)
+    assert.deepEqual(wheres[0]!.args, ['name', 'Alpha'])
+    assert.deepEqual(wheres[1]!.args, ['tenantId', 't-1'])
+  })
+
+  it('skips where() entries with undefined value', async () => {
+    const model = makeModel({ rows: [] })
+    const v = unique({
+      model, column: 'name',
+      where: () => ({ tenantId: undefined, status: 'active' }),
+    })
+    await v('Alpha', { values: { name: 'Alpha' } })
+    const wheres = model.lastQuery!.ops.filter(o => o.op === 'where')
+    assert.equal(wheres.length, 2) // primary + status, NOT tenantId
+    assert.deepEqual(wheres[1]!.args, ['status', 'active'])
+  })
+
+  it('falls back to ctx.values key when column option is omitted', async () => {
+    // The validator doesn't know its owning Field's name, so without
+    // `column` it scans ctx.values for a key whose value matches `value`.
+    const model = makeModel({ rows: [{ id: 1, slug: 'taken' }] })
+    const v = unique({ model })
+    assert.equal(await v('taken', { values: { slug: 'taken' } }), 'Already taken')
+    const where = model.lastQuery!.ops.find(o => o.op === 'where')
+    assert.deepEqual(where!.args, ['slug', 'taken'])
+  })
+
+  it('paginates with (1, 2) so we can distinguish own-record from real conflict', async () => {
+    const model = makeModel({ rows: [] })
+    const v = unique({ model, column: 'email' })
+    await v('x@y.com', { values: { email: 'x@y.com' } })
+    const page = model.lastQuery!.ops.find(o => o.op === 'paginate')
+    assert.deepEqual(page!.args, [1, 2])
+  })
+
+  it('rejects on edit when 2+ rows match, even if one is the current record', async () => {
+    // Defensive: shouldn't happen with a real unique index, but if it
+    // does, "every match is me" is false → conflict.
+    const model = makeModel({
+      rows: [{ id: 7, email: 'a@b.com' }, { id: 99, email: 'a@b.com' }],
+    })
+    const v = unique({ model, column: 'email' })
+    const ctx = { values: { email: 'a@b.com' }, record: { id: 7 } }
+    assert.equal(await v('a@b.com', ctx), 'Already taken')
+  })
+
+  it('thrown errors propagate (no silent fail-closed)', async () => {
+    const model = {
+      async find() { return null },
+      async create() { return null },
+      async update() { return null },
+      async delete() {},
+      query(): ModelQuery {
+        return {
+          where() { return this },
+          orWhere() { return this },
+          orderBy() { return this },
+          async paginate() { throw new Error('db down') },
+        } as unknown as ModelQuery
+      },
+    } as ModelLike
+    const v = unique({ model, column: 'email' })
+    await assert.rejects(
+      async () => { await v('a@b.com', { values: { email: 'a@b.com' } }) },
+      /db down/,
+    )
+  })
+
+  it('carries no serialized descriptor (skips client mirroring)', () => {
+    const model = makeModel({ rows: [] })
+    const v = unique({ model, column: 'email' })
+    assert.equal(v.serialized, undefined)
+  })
+})