@playfast/reform-forms 0.0.10 → 0.0.11

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@playfast/reform-forms",
   "playbook": "./playbook",
-  "version": "0.0.10",
+  "version": "0.0.11",
   "type": "module",
   "description": "Headless, schema-driven form state for reform — values, validation, field limitations, list operations, and submit flow, rendering nothing.",
   "keywords": [

package/src/form.ts

@@ -2,8 +2,10 @@ import {
   Context,
   Effect,
   Either,
+  Function as Fn,
   Layer,
   Option,
+  Record,
   Runtime,
   Schema as S,
 } from 'effect'
@@ -44,7 +46,10 @@ import {
 
 export { error }
 
-export interface FieldLimitations<A = unknown> {
+// Plain-JSON UI-contract shape (flows into FieldBinding.limitations, serialized
+// over the wire): optional knobs are part of the external contract, so the
+// `ExternalApi` postfix opts this out of the Option-only field rule.
+export interface FieldLimitationsExternalApi<A = unknown> {
   readonly required?: boolean
   readonly disabled?: boolean
   readonly readonly?: boolean
@@ -59,6 +64,8 @@ export interface FieldLimitations<A = unknown> {
   readonly meta?: Readonly<Record<string, unknown>>
 }
 
+export type FieldLimitations<A = unknown> = FieldLimitationsExternalApi<A>
+
 export type Limitations = Readonly<Record<string, FieldLimitations>>
 
 export interface FormState<Values> {
@@ -144,6 +151,7 @@ type DecodedOfSchema<S extends S.Schema.Any> = S.Schema.Type<S>
 
 export interface RuntimeConfig<Values, Decoded, Inputs> {
   readonly initial: Values
+  // oxlint-disable-next-line reform-rules/no-optional-fields -- optional Effect-returning config knob (not a serializable shape); Option would break external form definitions
   readonly limit?: (ctx: {
     readonly values: Values
     readonly inputs: Inputs
@@ -162,10 +170,12 @@ export interface RuntimeConfig<Values, Decoded, Inputs> {
 
 export interface FormLiveConfig<Values, Decoded, Inputs, R = never> {
   readonly initial: Values
+  // oxlint-disable-next-line reform-rules/no-optional-fields -- optional Effect-returning config knob; Option would break external form definitions
   readonly limit?: (ctx: {
     readonly values: Values
     readonly inputs: Inputs
   }) => Limitations
+  // oxlint-disable-next-line reform-rules/no-optional-fields -- optional Effect-returning config knob; Option would break external form definitions
   readonly validate?: (ctx: {
     readonly values: Values
     readonly decoded: Decoded
@@ -175,6 +185,7 @@ export interface FormLiveConfig<Values, Decoded, Inputs, R = never> {
     | FormError
     | ReadonlyArray<FormError>
     | Effect.Effect<void | FormError | ReadonlyArray<FormError>, never, R>
+  // oxlint-disable-next-line reform-rules/no-optional-fields -- optional Effect-returning config knob; Option would break external form definitions
   readonly submit?: (ctx: {
     readonly values: Values
     readonly decoded: Decoded
@@ -241,26 +252,26 @@ export type Inputs<F extends AnyForm> = F extends FormClass<string, S.Schema.Any
 
 export type View<F extends AnyForm> = FormView<Values<F>, Inputs<F>>
 
-const unknownSchema = S.Unknown as S.Schema<any, any>
+const unknownSchema: S.Schema<any, any> = Fn.unsafeCoerce(S.Unknown)
 
-let nextArrayKey = 0
-const makeArrayKey = (): string => `form-item-${nextArrayKey++}`
+const arrayKeyCounter = { current: 0 }
+const makeArrayKey = (): string => `form-item-${arrayKeyCounter.current++}`
 
-export const arrayKeysFor = (value: unknown, path = ''): Record<string, ReadonlyArray<string>> => {
+export const arrayKeysFor = (source: unknown, path = ''): Record<string, ReadonlyArray<string>> => {
   const out: Record<string, ReadonlyArray<string>> = {}
-  const visit = (current: unknown, currentPath: string): void => {
-    if (Array.isArray(current)) {
-      out[currentPath] = current.map(() => makeArrayKey())
-      current.forEach((item, index) => visit(item, `${currentPath}[${index}]`))
+  const visit = (node: KeyVisitNode): void => {
+    if (Array.isArray(node.current)) {
+      out[node.path] = node.current.map(() => makeArrayKey())
+      node.current.forEach((element, index) => visit({ current: element, path: `${node.path}[${index}]` }))
       return
     }
-    if (current !== null && typeof current === 'object') {
-      for (const [key, child] of Object.entries(current)) {
-        visit(child, currentPath.length === 0 ? key : `${currentPath}.${key}`)
-      }
+    if (node.current !== null && typeof node.current === 'object') {
+      Record.toEntries(Fn.unsafeCoerce<unknown, Record<string, unknown>>(node.current)).forEach(([key, child]) =>
+        visit({ current: child, path: node.path.length === 0 ? key : `${node.path}.${key}` }),
+      )
     }
   }
-  visit(value, path)
+  visit({ current: source, path })
   return out
 }
 
@@ -279,106 +290,144 @@ const initialState = <Values>(initial: Values): FormState<Values> => ({
 const markTouched = (touched: Readonly<Record<string, boolean>>, path: string): Readonly<Record<string, boolean>> =>
   ({ ...touched, [path]: true })
 
-const withValues = <Values>(state: FormState<Values>, values: Values): FormState<Values> => ({
+interface ArrayLookup {
+  readonly source: unknown
+  readonly path: string
+}
+
+interface KeyVisitNode {
+  readonly current: unknown
+  readonly path: string
+}
+
+interface PathInput<Values> {
+  readonly state: FormState<Values>
+  readonly path: string
+}
+
+interface SetPathInput<Values> extends PathInput<Values> {
+  readonly value: unknown
+}
+
+interface RemovePathInput<Values> extends PathInput<Values> {
+  readonly index: number
+}
+
+interface MovePathInput<Values> extends PathInput<Values> {
+  readonly from: number
+  readonly to: number
+}
+
+interface SwapPathInput<Values> extends PathInput<Values> {
+  readonly first: number
+  readonly second: number
+}
+
+const withValues = <Values>(state: FormState<Values>, nextValues: Values): FormState<Values> => ({
   ...state,
-  values,
-  dirtyPaths: recalculateDirtyPaths(state.initialValues, values),
+  values: nextValues,
+  dirtyPaths: recalculateDirtyPaths(state.initialValues, nextValues),
 })
 
-const currentArray = (values: unknown, path: string): ReadonlyArray<unknown> => {
-  const current = getNestedValue(values, path)
+const currentArray = (input: ArrayLookup): ReadonlyArray<unknown> => {
+  const current = getNestedValue(input.source, input.path)
   return Array.isArray(current) ? current : []
 }
 
 const updateKeys = (
   state: FormState<unknown>,
   path: string,
-  f: (keys: ReadonlyArray<string>) => ReadonlyArray<string>,
+  transform: (keys: ReadonlyArray<string>) => ReadonlyArray<string>,
 ): Readonly<Record<string, ReadonlyArray<string>>> => {
-  const existing = state.arrayKeys[path] ?? currentArray(state.values, path).map(() => makeArrayKey())
-  return { ...state.arrayKeys, [path]: f(existing) }
+  const existing = state.arrayKeys[path] ?? currentArray({ source: state.values, path }).map(() => makeArrayKey())
+  return { ...state.arrayKeys, [path]: transform(existing) }
 }
 
-const setAtPath = <Values>(state: FormState<Values>, path: string, value: unknown): FormState<Values> =>
-  withValues(state, setNestedValue(state.values, path, value))
+const setAtPath = <Values>(input: SetPathInput<Values>): FormState<Values> =>
+  withValues(input.state, setNestedValue(input.state.values, input.path, input.value))
 
-const appendAtPath = <Values>(
-  state: FormState<Values>,
-  path: string,
-  value: unknown,
-): FormState<Values> => {
-  const items = currentArray(state.values, path)
-  const values = setNestedValue(state.values, path, [...items, value])
+const appendAtPath = <Values>(input: SetPathInput<Values>): FormState<Values> => {
+  const elements = currentArray({ source: input.state.values, path: input.path })
+  const nextValues = setNestedValue(input.state.values, input.path, [...elements, input.value])
   return {
-    ...withValues(state, values),
-    arrayKeys: updateKeys(state as FormState<unknown>, path, (keys) => [...keys, makeArrayKey()]),
+    ...withValues(input.state, nextValues),
+    arrayKeys: updateKeys(Fn.unsafeCoerce(input.state), input.path, (keys) => [...keys, makeArrayKey()]),
   }
 }
 
-const removeAtPath = <Values>(
-  state: FormState<Values>,
-  path: string,
-  index: number,
-): FormState<Values> => {
-  const items = currentArray(state.values, path)
-  if (index < 0 || index >= items.length) return state
-  const values = setNestedValue(state.values, path, items.filter((_, i) => i !== index))
+const removeAtPath = <Values>(input: RemovePathInput<Values>): FormState<Values> => {
+  const elements = currentArray({ source: input.state.values, path: input.path })
+  if (input.index < 0 || input.index >= elements.length) {
+    return input.state
+  }
+  const nextValues = setNestedValue(
+    input.state.values,
+    input.path,
+    elements.filter((_, position) => position !== input.index),
+  )
   return {
-    ...withValues(state, values),
-    arrayKeys: updateKeys(state as FormState<unknown>, path, (keys) => keys.filter((_, i) => i !== index)),
+    ...withValues(input.state, nextValues),
+    arrayKeys: updateKeys(Fn.unsafeCoerce(input.state), input.path, (keys) =>
+      keys.filter((_, position) => position !== input.index),
+    ),
   }
 }
 
-const moveAtPath = <Values>(
-  state: FormState<Values>,
-  path: string,
-  from: number,
-  to: number,
-): FormState<Values> => {
-  const items = currentArray(state.values, path)
-  const next = moveAt(items, from, to)
-  if (next === items) return state
-  const values = setNestedValue(state.values, path, next)
+const moveAtPath = <Values>(input: MovePathInput<Values>): FormState<Values> => {
+  const elements = currentArray({ source: input.state.values, path: input.path })
+  const next = moveAt(elements, input.from, input.to)
+  if (next === elements) {
+    return input.state
+  }
+  const nextValues = setNestedValue(input.state.values, input.path, next)
   return {
-    ...withValues(state, values),
-    arrayKeys: updateKeys(state as FormState<unknown>, path, (keys) => moveAt(keys, from, to)),
+    ...withValues(input.state, nextValues),
+    arrayKeys: updateKeys(Fn.unsafeCoerce(input.state), input.path, (keys) => moveAt(keys, input.from, input.to)),
   }
 }
 
-const swapAtPath = <Values>(
-  state: FormState<Values>,
-  path: string,
-  a: number,
-  b: number,
-): FormState<Values> => {
-  const items = currentArray(state.values, path)
-  if (a < 0 || b < 0 || a >= items.length || b >= items.length || a === b) return state
-  const swapped = replaceAt(replaceAt(items, a, items[b]), b, items[a])
-  const values = setNestedValue(state.values, path, swapped)
+const swapAtPath = <Values>(input: SwapPathInput<Values>): FormState<Values> => {
+  const elements = currentArray({ source: input.state.values, path: input.path })
+  if (
+    input.first < 0 ||
+    input.second < 0 ||
+    input.first >= elements.length ||
+    input.second >= elements.length ||
+    input.first === input.second
+  ) {
+    return input.state
+  }
+  const swapped = replaceAt(replaceAt(elements, input.first, elements[input.second]), input.second, elements[input.first])
+  const nextValues = setNestedValue(input.state.values, input.path, swapped)
   return {
-    ...withValues(state, values),
-    arrayKeys: updateKeys(
-      state as FormState<unknown>,
-      path,
-      (keys) => replaceAt(replaceAt(keys, a, keys[b] ?? makeArrayKey()), b, keys[a] ?? makeArrayKey()),
+    ...withValues(input.state, nextValues),
+    arrayKeys: updateKeys(Fn.unsafeCoerce(input.state), input.path, (keys) =>
+      replaceAt(
+        replaceAt(keys, input.first, keys[input.second] ?? makeArrayKey()),
+        input.second,
+        keys[input.first] ?? makeArrayKey(),
+      ),
     ),
   }
 }
 
+interface MakeConfig<Schema extends S.Schema.Any, Inputs extends InputRecord> {
+  readonly schema: Schema
+  // oxlint-disable-next-line reform-rules/no-optional-fields -- optional source map on the public make() config; Option would break callers passing only a schema
+  readonly inputs?: Inputs
+}
+
 export const make = <
   const N extends string,
   Schema extends S.Schema.Any,
   const Inputs extends InputRecord = {},
 >(
   name: N,
-  config: {
-    readonly schema: Schema
-    readonly inputs?: Inputs
-  },
+  config: MakeConfig<Schema, Inputs>,
 ): FormClass<N, Schema, Inputs> => {
-  const state = State.make(`${name}/state`, unknownSchema, {
-    title: `${name} form state`,
-  }) as State.StateClass<`${N}/state`, FormState<ValuesOfSchema<Schema>>>
+  const state: State.StateClass<`${N}/state`, FormState<ValuesOfSchema<Schema>>> = Fn.unsafeCoerce(
+    State.make(`${name}/state`, unknownSchema, { title: `${name} form state` }),
+  )
   const events: FormEvents = {
     set: Event.make(`${name}/SetField`, S.Struct({ path: S.String, value: S.Unknown })),
     blur: Event.make(`${name}/BlurField`, S.Struct({ path: S.String })),
@@ -401,19 +450,20 @@ export const make = <
     RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<Inputs>>,
     RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<Inputs>>
   >(`reform/form/${name}/config`)
-  const inputs = (config.inputs ?? {}) as Inputs
-  return Object.assign(class {}, {
-    manifest: {
+  const inputs: Inputs = Fn.unsafeCoerce(Option.getOrElse(Option.fromNullable(config.inputs), () => ({})))
+  class FormImpl {
+    static readonly manifest = {
       kind: 'Form' as const,
       name,
       schema: config.schema,
       inputs,
-    },
-    state,
-    config: runtimeConfig,
-    events,
-    reducer,
-  }) as unknown as FormClass<N, Schema, Inputs>
+    }
+    static readonly state = state
+    static readonly config = runtimeConfig
+    static readonly events = events
+    static readonly reducer = reducer
+  }
+  return Fn.unsafeCoerce(FormImpl)
 }
 
 export const live = <
@@ -427,27 +477,26 @@ export const live = <
   never,
   Bus | Reducers | R
 > => {
-  const configTag = form.config as unknown as Context.Tag<
+  const configTag: Context.Tag<
     RuntimeConfig<Values<F>, Decoded<F>, Inputs<F>>,
     RuntimeConfig<Values<F>, Decoded<F>, Inputs<F>>
-  >
+  > = Fn.unsafeCoerce(form.config)
   const configLayer = Layer.effect(
     configTag,
     Effect.map(Effect.context<R | Bus>(), (context) => {
       const runtimeConfig: RuntimeConfig<Values<F>, Decoded<F>, Inputs<F>> = {
         initial: config.initial,
         validate: (ctx) => {
-          const result = config.validate?.(ctx)
-          const effect = Effect.isEffect(result) ? result : Effect.succeed(result)
-          return Effect.map(
-            Effect.provide(effect, context),
-            (value) => normalizeErrors(value),
-          ) as Effect.Effect<ReadonlyArray<FormError>, never, never>
+          const validationOutput = config.validate?.(ctx)
+          const effect = Effect.isEffect(validationOutput) ? validationOutput : Effect.succeed(validationOutput)
+          return Fn.unsafeCoerce(
+            Effect.map(Effect.provide(effect, context), (rawErrors) => normalizeErrors(rawErrors)),
+          )
         },
         submit: (ctx) => {
-          const result = config.submit?.(ctx)
-          const effect = Effect.isEffect(result) ? result : Effect.succeed(result)
-          return Effect.asVoid(Effect.provide(effect, context)) as Effect.Effect<void, unknown, never>
+          const submitOutput = config.submit?.(ctx)
+          const effect = Effect.isEffect(submitOutput) ? submitOutput : Effect.succeed(submitOutput)
+          return Fn.unsafeCoerce(Effect.asVoid(Effect.provide(effect, context)))
         },
       }
       return config.limit === undefined
@@ -466,84 +515,115 @@ export const live = <
     | { readonly _tag: string; readonly path: string; readonly a: number; readonly b: number }
     | { readonly _tag: string }
 
-  const reducerLayer = Reducer.live(form.reducer, (state: FormState<Values<F>>, event: InternalEvent): FormState<Values<F>> => {
-    switch (event._tag) {
-      case form.events.set.tag:
-        return 'path' in event && 'value' in event ? setAtPath(state, event.path, event.value) : state
-      case form.events.blur.tag:
+  const reducerLayer = Reducer.live(
+    form.reducer,
+    (state: FormState<Values<F>>, event: InternalEvent): FormState<Values<F>> => {
+      if (event._tag === form.events.set.tag) {
+        return 'path' in event && 'value' in event ? setAtPath({ state, path: event.path, value: event.value }) : state
+      }
+      if (event._tag === form.events.blur.tag) {
         return 'path' in event ? { ...state, touched: markTouched(state.touched, event.path) } : state
-      case form.events.reset.tag:
+      }
+      if (event._tag === form.events.reset.tag) {
         return initialState(state.initialValues)
-      case form.events.validationFinished.tag:
-        return 'errors' in event ? { ...state, errors: event.errors, validationCount: state.validationCount + 1 } : state
-      case form.events.submitAttempted.tag:
+      }
+      if (event._tag === form.events.validationFinished.tag) {
+        return 'errors' in event
+          ? { ...state, errors: event.errors, validationCount: state.validationCount + 1 }
+          : state
+      }
+      if (event._tag === form.events.submitAttempted.tag) {
         return { ...state, submitCount: state.submitCount + 1 }
-      case form.events.submitSucceeded.tag:
-        return 'values' in event ? { ...state, lastSubmittedValues: Option.some(event.values as Values<F>) } : state
-      case form.events.append.tag:
-        return 'path' in event && 'value' in event ? appendAtPath(state, event.path, event.value) : state
-      case form.events.remove.tag:
-        return 'path' in event && 'index' in event ? removeAtPath(state, event.path, event.index) : state
-      case form.events.move.tag:
-        return 'path' in event && 'from' in event && 'to' in event ? moveAtPath(state, event.path, event.from, event.to) : state
-      case form.events.swap.tag:
-        return 'path' in event && 'a' in event && 'b' in event ? swapAtPath(state, event.path, event.a, event.b) : state
-      default:
-        return state
-    }
-  })
+      }
+      if (event._tag === form.events.submitSucceeded.tag) {
+        return 'values' in event
+          ? { ...state, lastSubmittedValues: Option.some(Fn.unsafeCoerce<unknown, Values<F>>(event.values)) }
+          : state
+      }
+      if (event._tag === form.events.append.tag) {
+        return 'path' in event && 'value' in event
+          ? appendAtPath({ state, path: event.path, value: event.value })
+          : state
+      }
+      if (event._tag === form.events.remove.tag) {
+        return 'path' in event && 'index' in event
+          ? removeAtPath({ state, path: event.path, index: event.index })
+          : state
+      }
+      if (event._tag === form.events.move.tag) {
+        return 'path' in event && 'from' in event && 'to' in event
+          ? moveAtPath({ state, path: event.path, from: event.from, to: event.to })
+          : state
+      }
+      if (event._tag === form.events.swap.tag) {
+        return 'path' in event && 'a' in event && 'b' in event
+          ? swapAtPath({ state, path: event.path, first: event.a, second: event.b })
+          : state
+      }
+      return state
+    },
+  )
 
-  return Layer.mergeAll(configLayer, reducerLayer).pipe(
-    Layer.provideMerge(State.live(form.state, initialState(config.initial))),
-  ) as Layer.Layer<
-    Store<FormState<Values<F>>> | RuntimeConfig<Values<F>, Decoded<F>, Inputs<F>>,
-    never,
-    Bus | Reducers | R
-  >
+  return Fn.unsafeCoerce(
+    Layer.mergeAll(configLayer, reducerLayer).pipe(
+      Layer.provideMerge(State.live(form.state, initialState(config.initial))),
+    ),
+  )
 }
 
 const readInput = <Source extends AnySource>(
   source: Source,
 ): Effect.Effect<SourceValue<Source>, never, Store<SourceValue<Source>>> =>
-  Effect.gen(function* () {
-    const store = yield* source.store
-    const tracker = yield* Effect.serviceOption(CurrentTracker)
-    if (Option.isSome(tracker)) tracker.value.add(store)
-    return store.getSnapshot()
-  }) as Effect.Effect<SourceValue<Source>, never, Store<SourceValue<Source>>>
+  Fn.unsafeCoerce(
+    Effect.gen(function* () {
+      const store = yield* source.store
+      const tracker = yield* Effect.serviceOption(CurrentTracker)
+      if (Option.isSome(tracker)) {
+        tracker.value.add(store)
+      }
+      return store.getSnapshot()
+    }),
+  )
 
 const readInputs = <Inputs extends InputRecord>(
   inputs: Inputs,
 ): Effect.Effect<InputsObject<Inputs>, never, InputStores<Inputs>> =>
-  Effect.gen(function* () {
-    const out: Record<string, unknown> = {}
-    for (const source of Object.values(inputs)) {
-      out[source.name] = yield* readInput(source)
-    }
-    return out as InputsObject<Inputs>
-  }) as Effect.Effect<InputsObject<Inputs>, never, InputStores<Inputs>>
+  Fn.unsafeCoerce(
+    Effect.gen(function* () {
+      const pairs = yield* Effect.forEach(Object.values(inputs), (source) =>
+        Effect.map(readInput(source), (snapshot) => [source.name, snapshot] as const),
+      )
+      return Record.fromEntries(pairs)
+    }),
+  )
 
 const limitationsFor = <A>(
   limitations: Limitations,
   path: string,
 ): FieldLimitations<A> =>
-  (limitations[path] ?? {}) as FieldLimitations<A>
+  Fn.unsafeCoerce(Option.getOrElse(Option.fromNullable(limitations[path]), () => ({})))
 
 const trigger = <P>(eventTrigger: Effect.Effect<Trigger<P>, never, Bus>): Effect.Effect<Trigger<P>, never, Bus> =>
   eventTrigger
 
+// oxlint-disable-next-line reform-rules/prefer-effect-fn -- public generic view: the explicit R (Store | RuntimeConfig | Bus | InputStores) must be preserved verbatim; Effect.fn would re-infer requirements off the erased AnyForm wildcard
 export const view = <F extends AnyForm>(
   form: F,
 ): Effect.Effect<View<F>, never, Store<FormState<Values<F>>> | RuntimeConfig<Values<F>, Decoded<F>, Inputs<F>> | Bus | InputStores<F['manifest']['inputs']>> =>
   Effect.gen(function* () {
     const state = yield* form.state
     const runtimeConfig = yield* form.config
-    // Erased boundary (same shape as the casts closing `live`/`readInputs`):
+    // Erased boundary (same shape as the coercions closing `live`/`readInputs`):
     // under the `AnyForm` constraint `form.manifest.inputs` is the wildcard
     // `any`, which would dissolve the generator's R to `unknown`; restate the
     // call at the concrete `F`'s types so R keeps the declared input stores.
-    const inputs = (yield* readInputs(form.manifest.inputs as InputRecord)) as Inputs<F>
-    const limitations = runtimeConfig.limit?.({ values: state.values, inputs }) ?? {}
+    const inputs: Inputs<F> = Fn.unsafeCoerce(
+      yield* readInputs(Fn.unsafeCoerce<typeof form.manifest.inputs, InputRecord>(form.manifest.inputs)),
+    )
+    const limitations = Option.getOrElse(
+      Option.fromNullable(runtimeConfig.limit?.({ values: state.values, inputs })),
+      () => ({}),
+    )
     const setField = yield* trigger(form.events.set.trigger)
     const blurField = yield* trigger(form.events.blur.trigger)
     const reset = yield* trigger(form.events.reset.trigger)
@@ -553,13 +633,16 @@ export const view = <F extends AnyForm>(
     const swap = yield* trigger(form.events.swap.trigger)
     const runtime = yield* Effect.runtime<Bus>()
 
-    const schema = form.manifest.schema as S.Schema<Decoded<F>, Values<F>, never>
+    const schema: S.Schema<Decoded<F>, Values<F>, never> = Fn.unsafeCoerce(form.manifest.schema)
     const decodeEither = S.decodeUnknownEither(schema, { errors: 'all' })(state.values)
-    const canSubmit = Either.isRight(decodeEither) && Object.keys(state.errors).length === 0
+    const canSubmit = Either.isRight(decodeEither) && Record.keys(state.errors).length === 0
 
+    // oxlint-disable-next-line reform-rules/prefer-effect-fn -- local closure whose inferred R must flow into the parent view gen; Effect.fn would force an explicit Return annotation over the erased AnyForm requirements
     const runValidation = (publishSubmitAttempt: boolean) =>
       Effect.gen(function* () {
-        if (publishSubmitAttempt) yield* Event.dispatch(form.events.submitAttempted, {})
+        if (publishSubmitAttempt) {
+          yield* Event.dispatch(form.events.submitAttempted, {})
+        }
         const decoded = S.decodeUnknownEither(schema, { errors: 'all' })(state.values)
         if (Either.isLeft(decoded)) {
           yield* Event.dispatch(form.events.validationFinished, { errors: routeParseError(decoded.left) })
@@ -568,14 +651,18 @@ export const view = <F extends AnyForm>(
         const custom = yield* runtimeConfig.validate({ values: state.values, decoded: decoded.right, inputs })
         const errors = errorsToRecord(custom)
         yield* Event.dispatch(form.events.validationFinished, { errors })
-        return Object.keys(errors).length === 0 ? Option.some(decoded.right as Decoded<F>) : Option.none<Decoded<F>>()
+        return Record.keys(errors).length === 0
+          ? Option.some(Fn.unsafeCoerce<unknown, Decoded<F>>(decoded.right))
+          : Option.none<Decoded<F>>()
       })
 
     const submit = () => {
       Runtime.runFork(runtime)(
         Effect.gen(function* () {
           const decoded = yield* runValidation(true)
-          if (Option.isNone(decoded)) return
+          if (Option.isNone(decoded)) {
+            return
+          }
           yield* runtimeConfig.submit({ values: state.values, decoded: decoded.value, inputs })
           yield* Event.dispatch(form.events.submitSucceeded, { values: state.values })
         }).pipe(Effect.catchAllCause((cause) => Effect.logError('reform form submit failed', cause))),
@@ -587,15 +674,20 @@ export const view = <F extends AnyForm>(
     }
 
     const field = <P extends FieldPath<Values<F>>>(path: P): FieldBinding<PathValue<Values<F>, P>> => {
-      const value = getNestedValue(state.values, path) as PathValue<Values<F>, P>
+      const fieldValue: PathValue<Values<F>, P> = Fn.unsafeCoerce(getNestedValue(state.values, path))
       return {
         path,
-        value,
-        set: (next) =>
-          setField({
-            path,
-            value: typeof next === 'function' ? (next as (prev: PathValue<Values<F>, P>) => PathValue<Values<F>, P>)(value) : next,
-          }),
+        value: fieldValue,
+        set: (next) => {
+          if (typeof next === 'function') {
+            const updater = Fn.unsafeCoerce<typeof next, (prev: PathValue<Values<F>, P>) => PathValue<Values<F>, P>>(
+              next,
+            )
+            setField({ path, value: updater(fieldValue) })
+            return
+          }
+          setField({ path, value: next })
+        },
         blur: () => blurField({ path }),
         error: firstError(state.errors, path),
         dirty: isPathOrParentDirty(state.dirtyPaths, path),
@@ -606,26 +698,28 @@ export const view = <F extends AnyForm>(
     }
 
     const array = <P extends ArrayPath<Values<F>>>(path: P): ArrayBinding<ArrayItem<Values<F>, P>> => {
-      const values = currentArray(state.values, path) as ReadonlyArray<ArrayItem<Values<F>, P>>
-      const keys = state.arrayKeys[path] ?? values.map((_, i) => `${path}-${i}`)
+      const arrayValues: ReadonlyArray<ArrayItem<Values<F>, P>> = Fn.unsafeCoerce(
+        currentArray({ source: state.values, path }),
+      )
+      const keys = state.arrayKeys[path] ?? arrayValues.map((_, index) => `${path}-${index}`)
       return {
         path,
-        items: values.map((value, index) => ({
-          value,
+        items: arrayValues.map((element, index) => ({
+          value: element,
           index,
           key: keys[index] ?? `${path}-${index}`,
           remove: () => remove({ path, index }),
           move: (to) => move({ path, from: index, to }),
         })),
-        append: (value) => append({ path, value }),
+        append: (element) => append({ path, value: element }),
         remove: (index) => remove({ path, index }),
         move: (from, to) => move({ path, from, to }),
-        swap: (a, b) => swap({ path, a, b }),
+        swap: (first, second) => swap({ path, a: first, b: second }),
         limitations: limitationsFor<ReadonlyArray<ArrayItem<Values<F>, P>>>(limitations, path),
       }
     }
 
-    return {
+    const formView: View<F> = Fn.unsafeCoerce({
       values: state.values,
       inputs,
       errors: state.errors,
@@ -639,6 +733,7 @@ export const view = <F extends AnyForm>(
       validate,
       field,
       array,
-      variantValue: (path) => getNestedValue(state.values, path) as VariantValue<Values<F>, typeof path>,
-    } as View<F>
+      variantValue: (path: string) => Fn.unsafeCoerce(getNestedValue(state.values, path)),
+    })
+    return formView
   })

package/src/path.ts

@@ -1,13 +1,19 @@
-import { Equal } from 'effect'
+import { Equal, Function as Fn, Option, Order, Record, String as Str } from 'effect'
+import { lastIndexOf as lastIndexOfOpt } from 'effect/String'
+import { sort as sortArray } from 'effect/Array'
 
 const BRACKET_NOTATION_REGEX = /\[(\d+)\]/g
+const NO_INDEX = -1
 
+// `null` is a genuine leaf of arbitrary form values (JSON-shaped user data); it
+// is matched here to stop path recursion at primitive leaves.
 export type Primitive =
   | string
   | number
   | boolean
   | bigint
   | symbol
+  // oxlint-disable-next-line reform-rules/no-null-literal -- arbitrary form values include JSON null leaves
   | null
   | undefined
   | Date
@@ -77,82 +83,113 @@ export type VariantCase<V, Tag extends string> = Extract<V, { readonly _tag: Tag
 
 export type VariantBody<V, Tag extends string> = Omit<VariantCase<V, Tag>, '_tag'>
 
-export const schemaPathToFieldPath = (path: ReadonlyArray<PropertyKey>): string => {
-  if (path.length === 0) return ''
-  let result = String(path[0])
-  for (let i = 1; i < path.length; i++) {
-    const segment = path[i]
-    result += typeof segment === 'number' ? `[${segment}]` : `.${String(segment)}`
-  }
-  return result
-}
-
+// Typed view over an arbitrary object for string-keyed traversal of unknown form
+// values. `unsafeCoerce` is the Effect-blessed identity coercion (no `as`).
+const asRecord = (source: unknown): Record<string, unknown> => Fn.unsafeCoerce(source)
+
+export const schemaPathToFieldPath = (path: ReadonlyArray<PropertyKey>): string =>
+  path
+    .map((segment, index) =>
+      index === 0
+        ? String(segment)
+        : typeof segment === 'number'
+          ? `[${segment}]`
+          : `.${String(segment)}`,
+    )
+    .join('')
+
+// oxlint-disable-next-line reform-rules/no-multiple-primitive-params -- public positional path API
 export const joinPath = (prefix: string, path: string): string =>
   prefix.length === 0 ? path : path.length === 0 ? prefix : `${prefix}.${path}`
 
+// oxlint-disable-next-line reform-rules/no-multiple-primitive-params -- public positional path API
 export const isPathUnderRoot = (path: string, rootPath: string): boolean =>
   path === rootPath || path.startsWith(`${rootPath}.`) || path.startsWith(`${rootPath}[`)
 
 export const isPathOrParentDirty = (dirtyPaths: ReadonlyArray<string>, path: string): boolean => {
-  if (dirtyPaths.includes(path)) return true
-  let parent = path
-  while (true) {
-    const lastDot = parent.lastIndexOf('.')
-    const lastBracket = parent.lastIndexOf('[')
+  const isDirty = (candidate: string): boolean => {
+    if (dirtyPaths.includes(candidate)) {
+      return true
+    }
+    const lastDot = Option.getOrElse(lastIndexOfOpt('.')(candidate), () => NO_INDEX)
+    const lastBracket = Option.getOrElse(lastIndexOfOpt('[')(candidate), () => NO_INDEX)
     const splitIndex = Math.max(lastDot, lastBracket)
-    if (splitIndex === -1) return false
-    parent = parent.substring(0, splitIndex)
-    if (dirtyPaths.includes(parent)) return true
+    if (splitIndex === NO_INDEX) {
+      return false
+    }
+    return isDirty(candidate.substring(0, splitIndex))
   }
+  return isDirty(path)
 }
 
 const pathParts = (path: string): ReadonlyArray<string> =>
-  path === '' ? [] : path.replace(BRACKET_NOTATION_REGEX, '.$1').split('.')
-
-export const getNestedValue = (obj: unknown, path: string): unknown => {
+  path === '' ? [] : Str.split('.')(path.replace(BRACKET_NOTATION_REGEX, '.$1'))
+
+// oxlint-disable-next-line reform-rules/no-multiple-primitive-params -- public positional path accessor
+export const getNestedValue = (source: unknown, path: string): unknown =>
+  pathParts(path).reduce<unknown>(
+    (current, part) =>
+      current === null || current === undefined || typeof current !== 'object'
+        ? undefined
+        : asRecord(current)[part],
+    source,
+  )
+
+// oxlint-disable-next-line reform-rules/no-multiple-primitive-params -- public positional path setter
+export const setNestedValue = <T>(target: T, path: string, nextValue: unknown): T => {
   const parts = pathParts(path)
-  let current: unknown = obj
-  for (const part of parts) {
-    if (current === null || current === undefined || typeof current !== 'object') return undefined
-    current = (current as Record<string, unknown>)[part]
+  if (parts.length === 0) {
+    return Fn.unsafeCoerce(nextValue)
   }
-  return current
-}
-
-export const setNestedValue = <T>(obj: T, path: string, value: unknown): T => {
-  const parts = pathParts(path)
-  if (parts.length === 0) return value as T
-  const result = Array.isArray(obj) ? [...obj] : { ...(obj as Record<string, unknown>) }
-  let current = result as Record<string, unknown>
-  for (let i = 0; i < parts.length - 1; i++) {
-    const part = parts[i]
-    if (part === undefined) return result as T
+  const root = Array.isArray(target) ? [...target] : { ...asRecord(target) }
+  const descend = (current: Record<string, unknown>, depth: number): void => {
+    const part = parts[depth]
+    if (part === undefined) {
+      return
+    }
+    if (depth === parts.length - 1) {
+      current[part] = nextValue
+      return
+    }
     const next = current[part]
-    current[part] = Array.isArray(next) ? [...next] : { ...(next as Record<string, unknown>) }
-    current = current[part] as Record<string, unknown>
+    const copy = Array.isArray(next) ? [...next] : { ...asRecord(next) }
+    current[part] = copy
+    descend(asRecord(copy), depth + 1)
   }
-  const last = parts[parts.length - 1]
-  if (last !== undefined) current[last] = value
-  return result as T
+  descend(asRecord(root), 0)
+  return Fn.unsafeCoerce(root)
+}
+
+interface DiffNode {
+  readonly current: unknown
+  readonly original: unknown
+  readonly path: string
 }
 
+// oxlint-disable-next-line reform-rules/no-multiple-primitive-params -- public positional diff over arbitrary form values
 export const recalculateDirtyPaths = (
   initial: unknown,
-  values: unknown,
+  currentValues: unknown,
   rootPath = '',
 ): ReadonlyArray<string> => {
-  const dirty = new Set<string>()
-  const visit = (current: unknown, original: unknown, path: string): void => {
-    if (Equal.equals(current, original)) return
+  const visit = (node: DiffNode): ReadonlyArray<string> => {
+    const { current, original, path } = node
+    if (Equal.equals(current, original)) {
+      return []
+    }
     if (Array.isArray(current) || Array.isArray(original)) {
       const currentItems = Array.isArray(current) ? current : []
       const originalItems = Array.isArray(original) ? original : []
-      if (currentItems.length !== originalItems.length && path.length > 0) dirty.add(path)
+      const lengthChanged = currentItems.length !== originalItems.length && path.length > 0
       const length = Math.max(currentItems.length, originalItems.length)
-      for (let i = 0; i < length; i++) {
-        visit(currentItems[i], originalItems[i], path.length === 0 ? `[${i}]` : `${path}[${i}]`)
-      }
-      return
+      const childPaths = Array.from({ length }, (_, index) =>
+        visit({
+          current: currentItems[index],
+          original: originalItems[index],
+          path: path.length === 0 ? `[${index}]` : `${path}[${index}]`,
+        }),
+      ).flat()
+      return lengthChanged ? [path, ...childPaths] : childPaths
     }
     if (
       current !== null &&
@@ -160,35 +197,44 @@ export const recalculateDirtyPaths = (
       typeof current === 'object' &&
       typeof original === 'object'
     ) {
-      const currentRecord = current as Record<string, unknown>
-      const originalRecord = original as Record<string, unknown>
-      const keys = new Set([...Object.keys(currentRecord), ...Object.keys(originalRecord)])
-      for (const key of keys) {
-        visit(currentRecord[key], originalRecord[key], path.length === 0 ? key : `${path}.${key}`)
-      }
-      return
+      const currentRecord = asRecord(current)
+      const originalRecord = asRecord(original)
+      const keys = Array.from(new Set([...Record.keys(currentRecord), ...Record.keys(originalRecord)]))
+      return keys.flatMap((key) =>
+        visit({
+          current: currentRecord[key],
+          original: originalRecord[key],
+          path: path.length === 0 ? key : `${path}.${key}`,
+        }),
+      )
     }
-    if (path.length > 0) dirty.add(path)
+    return path.length > 0 ? [path] : []
   }
-  visit(rootPath.length === 0 ? values : getNestedValue(values, rootPath), rootPath.length === 0 ? initial : getNestedValue(initial, rootPath), rootPath)
-  return Array.from(dirty).sort()
+  const dirty = visit({
+    current: rootPath.length === 0 ? currentValues : getNestedValue(currentValues, rootPath),
+    original: rootPath.length === 0 ? initial : getNestedValue(initial, rootPath),
+    path: rootPath,
+  })
+  return sortArray(Order.string)(Array.from(new Set(dirty)))
 }
 
 export const replaceAt = <A>(
-  values: ReadonlyArray<A>,
+  elements: ReadonlyArray<A>,
   index: number,
-  value: A,
+  replacement: A,
 ): ReadonlyArray<A> =>
-  values.map((item, i) => (i === index ? value : item))
+  elements.map((element, position) => (position === index ? replacement : element))
 
+// oxlint-disable-next-line reform-rules/no-multiple-primitive-params -- public positional array move
 export const moveAt = <A>(
-  values: ReadonlyArray<A>,
+  elements: ReadonlyArray<A>,
   from: number,
   to: number,
 ): ReadonlyArray<A> => {
-  if (from < 0 || from >= values.length || to < 0 || to > values.length || from === to) return values
-  const next = [...values]
-  const item = next.splice(from, 1)[0]
-  if (item !== undefined) next.splice(to, 0, item)
-  return next
+  if (from < 0 || from >= elements.length || to < 0 || to > elements.length || from === to) {
+    return elements
+  }
+  const moved = elements[from]
+  const without = elements.filter((_, index) => index !== from)
+  return moved === undefined ? without : [...without.slice(0, to), moved, ...without.slice(to)]
 }

package/src/validation.ts

@@ -1,4 +1,4 @@
-import { Option, ParseResult } from 'effect'
+import { Array as Arr, Option, ParseResult } from 'effect'
 import { schemaPathToFieldPath } from './path'
 
 export interface FormError {
@@ -8,33 +8,33 @@ export interface FormError {
 
 export type FormErrors = Readonly<Record<string, string>>
 
+// oxlint-disable-next-line reform-rules/no-multiple-primitive-params -- public positional FormError constructor; (path, message) is the documented API
 export const error = (path: string, message: string): FormError => ({ path, message })
 
 export const normalizeErrors = (
-  value: void | FormError | ReadonlyArray<FormError>,
+  input: void | FormError | ReadonlyArray<FormError>,
 ): ReadonlyArray<FormError> => {
-  if (value === undefined) return []
-  if (Array.isArray(value)) return value as ReadonlyArray<FormError>
-  return [value as FormError]
-}
-
-export const errorsToRecord = (errors: ReadonlyArray<FormError>): FormErrors => {
-  const out: Record<string, string> = {}
-  for (const entry of errors) {
-    if (out[entry.path] === undefined) out[entry.path] = entry.message
+  if (input === undefined) {
+    return []
   }
-  return out
+  return Arr.ensure(input)
 }
 
-export const routeParseError = (parseError: ParseResult.ParseError): FormErrors => {
-  const formatted = ParseResult.ArrayFormatter.formatErrorSync(parseError)
-  const out: Record<string, string> = {}
-  for (const issue of formatted) {
-    const path = schemaPathToFieldPath(issue.path)
-    if (out[path] === undefined) out[path] = issue.message
-  }
-  return out
-}
+export const errorsToRecord = (errors: ReadonlyArray<FormError>): FormErrors =>
+  errors.reduce<Record<string, string>>(
+    (accumulated, entry) =>
+      entry.path in accumulated ? accumulated : { ...accumulated, [entry.path]: entry.message },
+    {},
+  )
+
+export const routeParseError = (parseError: ParseResult.ParseError): FormErrors =>
+  ParseResult.ArrayFormatter.formatErrorSync(parseError).reduce<Record<string, string>>(
+    (accumulated, issue) => {
+      const path = schemaPathToFieldPath(issue.path)
+      return path in accumulated ? accumulated : { ...accumulated, [path]: issue.message }
+    },
+    {},
+  )
 
 export const firstError = (errors: FormErrors, path: string): Option.Option<string> => {
   const message = errors[path]