@playfast/reform-forms 1.1.1 → 1.2.0

package/src/form.ts

@@ -1,76 +1,443 @@
 import {
   Context,
   Effect,
+  Either,
   Function as Fn,
   Layer,
   Option,
+  Record,
+  Runtime,
   Schema as S,
 } from 'effect'
+import { Event, Reducer, State, type Trigger } from '@playfast/reform'
 import {
+  type AnySource,
   Bus,
-  Event,
-  Reducer,
+  CurrentTracker,
   Reducers,
-  State,
+  type SourceIdentifier,
+  type SourceName,
+  type SourceValue as ReformSourceValue,
   type Store,
-} from '@playfast/reform'
-import type {
-  AnyForm,
-  Decoded,
-  DecodedOfSchema,
-  FormClass,
-  FormEvents,
-  FormLiveConfig,
-  FormState,
-  InputRecord,
-  Inputs,
-  InputsObject,
-  RuntimeConfig,
-  Values,
-  ValuesOfSchema,
-} from './formTypes'
+} from '@playfast/reform/internal'
 import {
-  appendAtPath,
-  initialState,
-  markTouched,
-  moveAtPath,
-  removeAtPath,
-  setAtPath,
-  swapAtPath,
-} from './formState'
+  getNestedValue,
+  isPathOrParentDirty,
+  moveAt,
+  recalculateDirtyPaths,
+  replaceAt,
+  setNestedValue,
+  type ArrayItem,
+  type ArrayPath,
+  type FieldPath,
+  type PathValue,
+  type VariantPath,
+  type VariantValue,
+} from './path'
 import {
   error,
+  errorsToRecord,
+  firstError,
   normalizeErrors,
+  routeParseError,
+  type FormError,
   type FormErrors,
 } from './validation'
 
 export { error }
 
-export type {
-  AnyForm,
-  ArrayBinding,
-  ArrayItemView,
-  Decoded,
-  FieldBinding,
-  FieldLimitations,
-  FieldLimitationsExternalApi,
-  FormClass,
-  FormLiveConfig,
-  FormManifest,
-  FormState,
-  FormView,
-  Inputs,
-  Limitations,
-  RuntimeConfig,
-  Values,
-  View,
-} from './formTypes'
-
-const unknownSchema: S.Schema.AnyNoContext = Fn.unsafeCoerce(S.Unknown)
-
-export { arrayKeysFor } from './formState'
-
-interface MakeConfig<Schema extends S.Schema.Any, Inputs extends InputRecord> {
+export interface FieldLimitationsExternalApi<A = unknown> {
+  readonly required?: boolean
+  readonly disabled?: boolean
+  readonly readonly?: boolean
+  readonly visible?: boolean
+  readonly min?: number
+  readonly max?: number
+  readonly minLength?: number
+  readonly maxLength?: number
+  readonly minItems?: number
+  readonly maxItems?: number
+  readonly options?: ReadonlyArray<A>
+  readonly meta?: Readonly<Record<string, unknown>>
+}
+
+export type FieldLimitations<A = unknown> = FieldLimitationsExternalApi<A>
+
+export type Limitations = Readonly<Record<string, FieldLimitations>>
+
+export interface FormState<Values> {
+  readonly values: Values
+  readonly initialValues: Values
+  readonly touched: Readonly<Record<string, boolean>>
+  readonly errors: FormErrors
+  readonly dirtyPaths: ReadonlyArray<string>
+  readonly submitCount: number
+  readonly validationCount: number
+  readonly lastSubmittedValues: Option.Option<Values>
+  readonly arrayKeys: Readonly<Record<string, ReadonlyArray<string>>>
+}
+
+export interface FieldBinding<A> {
+  readonly path: string
+  readonly value: A
+  readonly set: (value: A | ((prev: A) => A)) => void
+  readonly blur: () => void
+  readonly error: Option.Option<string>
+  readonly dirty: boolean
+  readonly touched: boolean
+  readonly validating: boolean
+  readonly limitations: FieldLimitations<A>
+}
+
+export interface ArrayItemView<Item> {
+  readonly key: string
+  readonly index: number
+  readonly value: Item
+  readonly remove: () => void
+  readonly move: (to: number) => void
+}
+
+export interface ArrayBinding<Item> {
+  readonly path: string
+  readonly items: ReadonlyArray<ArrayItemView<Item>>
+  readonly append: (value?: Item) => void
+  readonly remove: (index: number) => void
+  readonly move: (from: number, to: number) => void
+  readonly swap: (a: number, b: number) => void
+  readonly limitations: FieldLimitations<ReadonlyArray<Item>>
+}
+
+export interface FormView<Values, Inputs = {}> {
+  readonly values: Values
+  readonly inputs: Inputs
+  readonly errors: FormErrors
+  readonly dirty: boolean
+  readonly canSubmit: boolean
+  readonly submitCount: number
+  readonly validationCount: number
+  readonly lastSubmittedValues: Option.Option<Values>
+  readonly submit: () => void
+  readonly reset: () => void
+  readonly validate: () => void
+  readonly field: <P extends FieldPath<Values>>(path: P) => FieldBinding<PathValue<Values, P>>
+  readonly array: <P extends ArrayPath<Values>>(path: P) => ArrayBinding<ArrayItem<Values, P>>
+  readonly variantValue: <P extends VariantPath<Values>>(path: P) => VariantValue<Values, P>
+}
+
+type InputRecord = Readonly<Record<string, AnySource>>
+
+type InputsObject<Inputs extends InputRecord> = {
+  readonly [K in keyof Inputs as SourceName<Inputs[K]>]: ReformSourceValue<Inputs[K]>
+}
+
+type InputStores<Inputs extends InputRecord> = {
+  [K in keyof Inputs]: Inputs[K] extends {
+    readonly store: Context.Tag<infer Service, infer _Store>
+  }
+    ? Service
+    : never
+}[keyof Inputs]
+
+type ValuesOfSchema<Schema extends S.Schema.AnyNoContext> = S.Schema.Encoded<Schema>
+type DecodedOfSchema<Schema extends S.Schema.AnyNoContext> = S.Schema.Type<Schema>
+
+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 }) => Limitations
+  readonly validate: (ctx: {
+    readonly values: Values
+    readonly decoded: Decoded
+    readonly inputs: Inputs
+  }) => Effect.Effect<ReadonlyArray<FormError>, never, never>
+  readonly submit: (ctx: {
+    readonly values: Values
+    readonly decoded: Decoded
+    readonly inputs: Inputs
+  }) => Effect.Effect<void, unknown, never>
+}
+
+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
+    readonly inputs: Inputs
+  }) =>
+    | void
+    | 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
+    readonly inputs: Inputs
+  }) => void | Effect.Effect<unknown, unknown, R>
+}
+
+export interface FormSchemaReflection {
+  readonly ast: S.Schema<unknown, unknown, unknown>['ast']
+}
+
+export interface FormManifestReflection<N extends string> {
+  readonly kind: 'Form'
+  readonly name: N
+  readonly schema: FormSchemaReflection
+  readonly inputs: InputRecord
+}
+
+export interface FormManifest<
+  N extends string,
+  Schema extends S.Schema.AnyNoContext,
+  Inputs extends InputRecord,
+> extends FormManifestReflection<N> {
+  readonly schema: Schema
+  readonly inputs: Inputs
+}
+
+interface FormEvents {
+  readonly set: Event.EventClass<string, { readonly path: string; readonly value: unknown }>
+  readonly blur: Event.EventClass<string, { readonly path: string }>
+  readonly reset: Event.EventClass<string, {}>
+  readonly validationFinished: Event.EventClass<string, { readonly errors: FormErrors }>
+  readonly submitAttempted: Event.EventClass<string, {}>
+  readonly submitSucceeded: Event.EventClass<string, { readonly values: unknown }>
+  readonly append: Event.EventClass<string, { readonly path: string; readonly value: unknown }>
+  readonly remove: Event.EventClass<string, { readonly path: string; readonly index: number }>
+  readonly move: Event.EventClass<
+    string,
+    { readonly path: string; readonly from: number; readonly to: number }
+  >
+  readonly swap: Event.EventClass<
+    string,
+    { readonly path: string; readonly a: number; readonly b: number }
+  >
+}
+
+export interface FormVisitor<Result> {
+  readonly visit: <
+    N extends string,
+    Schema extends S.Schema.AnyNoContext,
+    Inputs extends InputRecord,
+  >(
+    form: FormClass<N, Schema, Inputs>,
+  ) => Result
+}
+
+export interface AnyForm {
+  new (): {}
+  readonly manifest: FormManifestReflection<string>
+  readonly capture: <Result>(visitor: FormVisitor<Result>) => Result
+}
+
+export interface FormClass<
+  N extends string,
+  Schema extends S.Schema.AnyNoContext,
+  Inputs extends InputRecord,
+> {
+  new (): {}
+  readonly manifest: FormManifest<N, Schema, Inputs>
+  readonly capture: <Result>(visitor: FormVisitor<Result>) => Result
+  readonly state: State.StateClass<`${N}/state`, FormState<ValuesOfSchema<Schema>>>
+  readonly config: Context.Tag<
+    RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<Inputs>>,
+    RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<Inputs>>
+  >
+  readonly events: FormEvents
+  readonly reducer: Reducer.StateReducerClass<
+    State.StateClass<`${N}/state`, FormState<ValuesOfSchema<Schema>>>,
+    ReadonlyArray<Event.AnyEvent>
+  >
+}
+
+export type Values<F> =
+  F extends FormClass<infer _Name, infer Schema, infer _Inputs> ? ValuesOfSchema<Schema> : never
+
+export type Decoded<F> =
+  F extends FormClass<infer _Name, infer Schema, infer _Inputs> ? DecodedOfSchema<Schema> : never
+
+export type Inputs<F> =
+  F extends FormClass<infer _Name, infer _Schema, infer Inputs> ? InputsObject<Inputs> : never
+
+export type View<F> = FormView<Values<F>, Inputs<F>>
+
+const arrayKeyCounter = { current: 0 }
+const makeArrayKey = (): string => `form-item-${arrayKeyCounter.current++}`
+
+export const arrayKeysFor = (source: unknown, path = ''): Record<string, ReadonlyArray<string>> => {
+  const out: Record<string, ReadonlyArray<string>> = {}
+  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 (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({ current: source, path })
+  return out
+}
+
+const initialState = <Values>(initial: Values): FormState<Values> => ({
+  values: initial,
+  initialValues: initial,
+  touched: {},
+  errors: {},
+  dirtyPaths: [],
+  submitCount: 0,
+  validationCount: 0,
+  lastSubmittedValues: Option.none(),
+  arrayKeys: arrayKeysFor(initial),
+})
+
+const markTouched = (
+  touched: Readonly<Record<string, boolean>>,
+  path: string,
+): Readonly<Record<string, boolean>> => ({ ...touched, [path]: true })
+
+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: nextValues,
+  dirtyPaths: recalculateDirtyPaths(state.initialValues, nextValues),
+})
+
+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,
+  transform: (keys: ReadonlyArray<string>) => ReadonlyArray<string>,
+): Readonly<Record<string, ReadonlyArray<string>>> => {
+  const existing =
+    state.arrayKeys[path] ?? currentArray({ source: state.values, path }).map(() => makeArrayKey())
+  return { ...state.arrayKeys, [path]: transform(existing) }
+}
+
+const setAtPath = <Values>(input: SetPathInput<Values>): FormState<Values> =>
+  withValues(input.state, setNestedValue(input.state.values, input.path, input.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(input.state, nextValues),
+    arrayKeys: updateKeys(Fn.unsafeCoerce(input.state), input.path, (keys) => [
+      ...keys,
+      makeArrayKey(),
+    ]),
+  }
+}
+
+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(input.state, nextValues),
+    arrayKeys: updateKeys(Fn.unsafeCoerce(input.state), input.path, (keys) =>
+      keys.filter((_, position) => position !== input.index),
+    ),
+  }
+}
+
+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(input.state, nextValues),
+    arrayKeys: updateKeys(Fn.unsafeCoerce(input.state), input.path, (keys) =>
+      moveAt(keys, input.from, input.to),
+    ),
+  }
+}
+
+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(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.AnyNoContext, 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
@@ -78,30 +445,51 @@ interface MakeConfig<Schema extends S.Schema.Any, Inputs extends InputRecord> {
 
 export const make = <
   const N extends string,
-  Schema extends S.Schema.Any,
+  Schema extends S.Schema.AnyNoContext,
   const Inputs extends InputRecord = {},
 >(
   name: N,
   config: MakeConfig<Schema, Inputs>,
 ): FormClass<N, Schema, Inputs> => {
-  const state: State.StateClass<`${N}/state`, FormState<ValuesOfSchema<Schema>>> = Fn.unsafeCoerce(
-    State.make(`${name}/state`, unknownSchema, { title: `${name} form state` }),
+  const valuesSchema = S.encodedSchema(config.schema)
+  const stringRecord = S.Record({ key: S.String, value: S.String })
+  const stateSchema = S.Struct({
+    values: valuesSchema,
+    initialValues: valuesSchema,
+    touched: S.Record({ key: S.String, value: S.Boolean }),
+    errors: stringRecord,
+    dirtyPaths: S.Array(S.String),
+    submitCount: S.Number,
+    validationCount: S.Number,
+    lastSubmittedValues: S.OptionFromSelf(valuesSchema),
+    arrayKeys: S.Record({ key: S.String, value: S.Array(S.String) }),
+  })
+  const state: State.StateClass<`${N}/state`, FormState<ValuesOfSchema<Schema>>> = State.make(
+    `${name}/state`,
+    stateSchema,
+    { 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 })),
     reset: Event.make(`${name}/Reset`, S.Struct({})),
-    validationFinished: Event.make(`${name}/ValidationFinished`, S.Struct({
-      errors: S.Record({ key: S.String, value: S.String }),
-    })),
+    validationFinished: Event.make(
+      `${name}/ValidationFinished`,
+      S.Struct({
+        errors: S.Record({ key: S.String, value: S.String }),
+      }),
+    ),
     submitAttempted: Event.make(`${name}/SubmitAttempted`, S.Struct({})),
     submitSucceeded: Event.make(`${name}/SubmitSucceeded`, S.Struct({ values: S.Unknown })),
     append: Event.make(`${name}/AppendItem`, S.Struct({ path: S.String, value: S.Unknown })),
     remove: Event.make(`${name}/RemoveItem`, S.Struct({ path: S.String, index: S.Number })),
-    move: Event.make(`${name}/MoveItem`, S.Struct({ path: S.String, from: S.Number, to: S.Number })),
+    move: Event.make(
+      `${name}/MoveItem`,
+      S.Struct({ path: S.String, from: S.Number, to: S.Number }),
+    ),
     swap: Event.make(`${name}/SwapItems`, S.Struct({ path: S.String, a: S.Number, b: S.Number })),
   }
-  const reducer = Reducer.make(`${name}/FormReducer`, {
+  const reducer: FormClass<N, Schema, Inputs>['reducer'] = Reducer.make(`${name}/FormReducer`, {
     states: [state],
     events: Object.values(events),
   })
@@ -109,10 +497,12 @@ export const make = <
     RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<Inputs>>,
     RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<Inputs>>
   >(`reform/form/${name}/config`)
-  const inputs: Inputs = Fn.unsafeCoerce(Option.getOrElse(Option.fromNullable(config.inputs), () => ({})))
+  const inputs: Inputs = Fn.unsafeCoerce(
+    Option.getOrElse(Option.fromNullable(config.inputs), () => ({})),
+  )
   class FormImpl {
-    static readonly manifest = {
-      kind: 'Form' as const,
+    static readonly manifest: FormManifest<N, Schema, Inputs> = {
+      kind: 'Form',
       name,
       schema: config.schema,
       inputs,
@@ -121,33 +511,50 @@ export const make = <
     static readonly config = runtimeConfig
     static readonly events = events
     static readonly reducer = reducer
+    static capture<Result>(visitor: FormVisitor<Result>): Result {
+      return visitor.visit(FormImpl)
+    }
   }
-  return Fn.unsafeCoerce(FormImpl)
+  return FormImpl
 }
 
 export const live = <
-  F extends AnyForm,
+  N extends string,
+  Schema extends S.Schema.AnyNoContext,
+  FormInputs extends InputRecord,
   R = never,
 >(
-  form: F,
-  config: FormLiveConfig<Values<F>, Decoded<F>, Inputs<F>, R>,
+  form: FormClass<N, Schema, FormInputs>,
+  config: FormLiveConfig<
+    ValuesOfSchema<Schema>,
+    DecodedOfSchema<Schema>,
+    InputsObject<FormInputs>,
+    R
+  >,
 ): Layer.Layer<
-  Store<FormState<Values<F>>> | RuntimeConfig<Values<F>, Decoded<F>, Inputs<F>>,
+  | State.StateStore<`${N}/state`, FormState<ValuesOfSchema<Schema>>>
+  | RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<FormInputs>>,
   never,
   Bus | Reducers | R
 > => {
   const configTag: Context.Tag<
-    RuntimeConfig<Values<F>, Decoded<F>, Inputs<F>>,
-    RuntimeConfig<Values<F>, Decoded<F>, Inputs<F>>
-  > = Fn.unsafeCoerce(form.config)
+    RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<FormInputs>>,
+    RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<FormInputs>>
+  > = form.config
   const configLayer = Layer.effect(
     configTag,
     Effect.map(Effect.context<R | Bus>(), (context) => {
-      const runtimeConfig: RuntimeConfig<Values<F>, Decoded<F>, Inputs<F>> = {
+      const runtimeConfig: RuntimeConfig<
+        ValuesOfSchema<Schema>,
+        DecodedOfSchema<Schema>,
+        InputsObject<FormInputs>
+      > = {
         initial: config.initial,
         validate: (ctx) => {
           const validationOutput = config.validate?.(ctx)
-          const effect = Effect.isEffect(validationOutput) ? validationOutput : Effect.succeed(validationOutput)
+          const effect = Effect.isEffect(validationOutput)
+            ? validationOutput
+            : Effect.succeed(validationOutput)
           return Fn.unsafeCoerce(
             Effect.map(Effect.provide(effect, context), (rawErrors) => normalizeErrors(rawErrors)),
           )
@@ -158,9 +565,7 @@ export const live = <
           return Fn.unsafeCoerce(Effect.asVoid(Effect.provide(effect, context)))
         },
       }
-      return config.limit === undefined
-        ? runtimeConfig
-        : { ...runtimeConfig, limit: config.limit }
+      return config.limit === undefined ? runtimeConfig : { ...runtimeConfig, limit: config.limit }
     }),
   )
 
@@ -176,12 +581,19 @@ export const live = <
 
   const reducerLayer = Reducer.live(
     form.reducer,
-    (state: FormState<Values<F>>, event: InternalEvent): FormState<Values<F>> => {
+    (
+      state: FormState<ValuesOfSchema<Schema>>,
+      event: InternalEvent,
+    ): FormState<ValuesOfSchema<Schema>> => {
       if (event._tag === form.events.set.tag) {
-        return 'path' in event && 'value' in event ? setAtPath({ state, path: event.path, value: event.value }) : state
+        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
+        return 'path' in event
+          ? { ...state, touched: markTouched(state.touched, event.path) }
+          : state
       }
       if (event._tag === form.events.reset.tag) {
         return initialState(state.initialValues)
@@ -195,9 +607,15 @@ export const live = <
         return { ...state, submitCount: state.submitCount + 1 }
       }
       if (event._tag === form.events.submitSucceeded.tag) {
-        return 'values' in event
-          ? { ...state, lastSubmittedValues: Option.some(Fn.unsafeCoerce<unknown, Values<F>>(event.values)) }
-          : state
+        if (!('values' in event)) {
+          return state
+        }
+        return {
+          ...state,
+          lastSubmittedValues: Option.some(
+            Fn.unsafeCoerce<unknown, ValuesOfSchema<Schema>>(event.values),
+          ),
+        }
       }
       if (event._tag === form.events.append.tag) {
         return 'path' in event && 'value' in event
@@ -223,11 +641,197 @@ export const live = <
     },
   )
 
-  return Fn.unsafeCoerce(
-    Layer.mergeAll(configLayer, reducerLayer).pipe(
-      Layer.provideMerge(State.live(form.state, initialState(config.initial))),
-    ),
+  return Layer.mergeAll(configLayer, reducerLayer).pipe(
+    Layer.provideMerge(State.live(form.state, initialState(config.initial))),
   )
 }
 
-export { view } from './formView'
+const readInput = Effect.fn('forms.readInput')(function* <Input extends AnySource>(
+  source: Input,
+): Effect.fn.Return<ReformSourceValue<Input>, never, SourceIdentifier<Input>> {
+  const store = yield* Context.GenericTag<SourceIdentifier<Input>, Store<ReformSourceValue<Input>>>(
+    source.store.key,
+  )
+  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>> =>
+  Fn.unsafeCoerce(
+    Effect.gen(function* () {
+      const pairs = yield* Effect.forEach(Object.values(inputs), (source) =>
+        Effect.map(readInput(source), (snapshot): readonly [string, unknown] => [
+          source.name,
+          snapshot,
+        ]),
+      )
+      return Record.fromEntries(pairs)
+    }),
+  )
+
+const limitationsFor = <A>(limitations: Limitations, path: string): 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 preserves the exact form state/config/input requirements verbatim
+export const view = <
+  N extends string,
+  Schema extends S.Schema.AnyNoContext,
+  FormInputs extends InputRecord,
+>(
+  form: FormClass<N, Schema, FormInputs>,
+): Effect.Effect<
+  FormView<ValuesOfSchema<Schema>, InputsObject<FormInputs>>,
+  never,
+  | State.StateStore<`${N}/state`, FormState<ValuesOfSchema<Schema>>>
+  | RuntimeConfig<ValuesOfSchema<Schema>, DecodedOfSchema<Schema>, InputsObject<FormInputs>>
+  | Bus
+  | InputStores<FormInputs>
+> =>
+  Effect.gen(function* () {
+    const state = yield* form.state
+    const runtimeConfig = yield* form.config
+    const inputs = yield* readInputs(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)
+    const append = yield* trigger(form.events.append.trigger)
+    const remove = yield* trigger(form.events.remove.trigger)
+    const move = yield* trigger(form.events.move.trigger)
+    const swap = yield* trigger(form.events.swap.trigger)
+    const runtime = yield* Effect.runtime<Bus>()
+
+    const schema = form.manifest.schema
+    const decodeEither = S.decodeUnknownEither(schema, { errors: 'all' })(state.values)
+    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, {})
+        }
+        const decoded = S.decodeUnknownEither(schema, { errors: 'all' })(state.values)
+        if (Either.isLeft(decoded)) {
+          yield* Event.dispatch(form.events.validationFinished, {
+            errors: routeParseError(decoded.left),
+          })
+          return Option.none<DecodedOfSchema<Schema>>()
+        }
+        const custom = yield* runtimeConfig.validate({
+          values: state.values,
+          decoded: decoded.right,
+          inputs,
+        })
+        const errors = errorsToRecord(custom)
+        yield* Event.dispatch(form.events.validationFinished, { errors })
+        return Record.keys(errors).length === 0
+          ? Option.some(decoded.right)
+          : Option.none<DecodedOfSchema<Schema>>()
+      })
+
+    const submit = () => {
+      Runtime.runFork(runtime)(
+        Effect.gen(function* () {
+          const decoded = yield* runValidation(true)
+          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)),
+        ),
+      )
+    }
+
+    const validate = () => {
+      Runtime.runFork(runtime)(runValidation(false))
+    }
+
+    const field = <P extends FieldPath<ValuesOfSchema<Schema>>>(
+      path: P,
+    ): FieldBinding<PathValue<ValuesOfSchema<Schema>, P>> => {
+      const fieldValue: PathValue<ValuesOfSchema<Schema>, P> = Fn.unsafeCoerce(
+        getNestedValue(state.values, path),
+      )
+      return {
+        path,
+        value: fieldValue,
+        set: (next) => {
+          if (typeof next === 'function') {
+            const updater = Fn.unsafeCoerce<
+              typeof next,
+              (prev: PathValue<ValuesOfSchema<Schema>, P>) => PathValue<ValuesOfSchema<Schema>, 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),
+        touched: state.touched[path] === true,
+        validating: false,
+        limitations: limitationsFor<PathValue<ValuesOfSchema<Schema>, P>>(limitations, path),
+      }
+    }
+
+    const array = <P extends ArrayPath<ValuesOfSchema<Schema>>>(
+      path: P,
+    ): ArrayBinding<ArrayItem<ValuesOfSchema<Schema>, P>> => {
+      const arrayValues: ReadonlyArray<ArrayItem<ValuesOfSchema<Schema>, P>> = Fn.unsafeCoerce(
+        currentArray({ source: state.values, path }),
+      )
+      const keys = state.arrayKeys[path] ?? arrayValues.map((_, index) => `${path}-${index}`)
+      return {
+        path,
+        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: (element) => append({ path, value: element }),
+        remove: (index) => remove({ path, index }),
+        move: (from, to) => move({ path, from, to }),
+        swap: (first, second) => swap({ path, a: first, b: second }),
+        limitations: limitationsFor<ReadonlyArray<ArrayItem<ValuesOfSchema<Schema>, P>>>(
+          limitations,
+          path,
+        ),
+      }
+    }
+
+    const formView: FormView<ValuesOfSchema<Schema>, InputsObject<FormInputs>> = Fn.unsafeCoerce({
+      values: state.values,
+      inputs,
+      errors: state.errors,
+      dirty: state.dirtyPaths.length > 0,
+      canSubmit,
+      submitCount: state.submitCount,
+      validationCount: state.validationCount,
+      lastSubmittedValues: state.lastSubmittedValues,
+      submit,
+      reset: () => reset({}),
+      validate,
+      field,
+      array,
+      variantValue: (path: string) => Fn.unsafeCoerce(getNestedValue(state.values, path)),
+    })
+    return formView
+  })