@playfast/reform-forms 1.1.1 → 1.2.1

package/README.md

@@ -13,7 +13,7 @@ Values, validation, field metadata, list operations, submit flow, and correlatio
 
 ---
 
-`@playfast/reform-forms` owns everything a form needs *except* its widgets. It has no DOM and no React API — it produces a typed, platform-neutral view that any renderer can map. Pair it with [`@playfast/reform-forms-react`](https://www.npmjs.com/package/@playfast/reform-forms-react) for typed JSX, or consume the view directly from a custom host.
+`@playfast/reform-forms` owns everything a form needs _except_ its widgets. It has no DOM and no React API — it produces a typed, platform-neutral view that any renderer can map. Pair it with [`@playfast/reform-forms-react`](https://www.npmjs.com/package/@playfast/reform-forms-react) for typed JSX, or consume the view directly from a custom host.
 
 ## Install
 
@@ -61,9 +61,7 @@ const CheckoutFormLive = Form.live(CheckoutForm, {
     items: { minItems: 1, maxItems: inputs.settings.maxItems },
   }),
   validate: ({ values }) =>
-    values.email.includes('@')
-      ? undefined
-      : Form.error('email', 'Email must contain @'),
+    values.email.includes('@') ? undefined : Form.error('email', 'Email must contain @'),
   submit: ({ decoded, inputs }) => saveCheckout(decoded, inputs.user.id),
 })
 ```
@@ -71,7 +69,7 @@ const CheckoutFormLive = Form.live(CheckoutForm, {
 Read the form inside compositions with `Form.view(CheckoutForm)` — a typed, platform-neutral object:
 
 ```ts
-const form = yield* Form.view(CheckoutForm)
+const form = yield * Form.view(CheckoutForm)
 
 form.field('email').set('a@example.com')
 form.array('items').append({ name: 'Milk', qty: 1 })

package/package.json

@@ -1,37 +1,39 @@
 {
   "name": "@playfast/reform-forms",
-  "playbook": "./playbook",
-  "version": "1.1.1",
-  "type": "module",
+  "version": "1.2.1",
   "description": "Headless, schema-driven form state for reform — values, validation, field limitations, list operations, and submit flow, rendering nothing.",
   "keywords": [
-    "reform",
     "effect",
-    "forms",
     "form-state",
-    "validation",
+    "forms",
+    "headless",
+    "reform",
     "schema",
-    "headless"
+    "validation"
   ],
+  "bugs": {
+    "url": "https://github.com/playfast/reform/issues"
+  },
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/playfast/reform.git",
     "directory": "packages/forms"
   },
-  "bugs": {
-    "url": "https://github.com/playfast/reform/issues"
-  },
+  "files": [
+    "src",
+    "README.md"
+  ],
+  "type": "module",
   "sideEffects": false,
   "exports": {
     "./package.json": "./package.json",
     ".": "./src/index.ts",
     "./*": "./src/*.ts"
   },
-  "files": [
-    "src",
-    "README.md"
-  ],
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
     "clean": "rm -rf dist .tsbuildinfo",
     "check": "tsc --noEmit",
@@ -43,10 +45,8 @@
     "lint:fix": "oxlint --fix src"
   },
   "peerDependencies": {
-    "effect": "*",
-    "@playfast/reform": "*"
+    "@playfast/reform": "*",
+    "effect": "*"
   },
-  "publishConfig": {
-    "access": "public"
-  }
+  "playbook": "./playbook"
 }

package/src/form.test.ts

@@ -1,7 +1,7 @@
-import { expect, it } from "@effect/vitest";
-import { Effect, Layer, Option, Schema as S } from "effect";
-import { Engine } from "@playfast/reform";
-import * as Form from "./form";
+import { expect, it } from '@effect/vitest'
+import { Effect, Layer, Option, Schema as S } from 'effect'
+import { Engine } from '@playfast/reform'
+import * as Form from './form'
 
 const waitUntil = <A, R>(
   read: Effect.Effect<A, never, R>,
@@ -11,81 +11,66 @@ const waitUntil = <A, R>(
   Effect.flatMap(read, (value) =>
     pred(value) || rounds <= 0
       ? Effect.succeed(value)
-      : Effect.flatMap(Effect.yieldNow(), () =>
-          waitUntil(read, pred, rounds - 1),
-        ),
-  );
+      : Effect.flatMap(Effect.yieldNow(), () => waitUntil(read, pred, rounds - 1)),
+  )
 
 const CheckoutSchema = S.Struct({
   email: S.String,
   items: S.Array(S.Struct({ name: S.String, qty: S.Number })),
   payment: S.Union(
-    S.TaggedStruct("Card", { cardNumber: S.String }),
-    S.TaggedStruct("Paypal", { email: S.String }),
+    S.TaggedStruct('Card', { cardNumber: S.String }),
+    S.TaggedStruct('Paypal', { email: S.String }),
   ),
-});
+})
 
-class CheckoutForm extends Form.make("CheckoutForm", {
+class CheckoutForm extends Form.make('CheckoutForm', {
   schema: CheckoutSchema,
 }) {}
 
 const layer = Form.live(CheckoutForm, {
   initial: {
-    email: "",
+    email: '',
     items: [],
-    payment: { _tag: "Card", cardNumber: "" },
+    payment: { _tag: 'Card', cardNumber: '' },
   },
   validate: ({ values }) =>
-    values.email.includes("@")
-      ? undefined
-      : Form.error("email", "Email must contain @"),
-}).pipe(Layer.provideMerge(Engine));
+    values.email.includes('@') ? undefined : Form.error('email', 'Email must contain @'),
+}).pipe(Layer.provideMerge(Engine))
 
-it.scopedLive("field bindings write through the form reducer", () =>
+it.scopedLive('field bindings write through the form reducer', () =>
   Effect.gen(function* () {
-    const view = yield* Form.view(CheckoutForm);
-    view.field("email").set("a@example.com");
+    const view = yield* Form.view(CheckoutForm)
+    view.field('email').set('a@example.com')
 
     const next = yield* waitUntil(
       Form.view(CheckoutForm),
-      (v) => v.values.email === "a@example.com",
-    );
-    expect(next.field("email").dirty).toBe(true);
+      (v) => v.values.email === 'a@example.com',
+    )
+    expect(next.field('email').dirty).toBe(true)
   }).pipe(Effect.provide(layer)),
-);
+)
 
-it.scopedLive("array bindings append and remove items", () =>
+it.scopedLive('array bindings append and remove items', () =>
   Effect.gen(function* () {
-    const view = yield* Form.view(CheckoutForm);
-    view.array("items").append({ name: "milk", qty: 1 });
+    const view = yield* Form.view(CheckoutForm)
+    view.array('items').append({ name: 'milk', qty: 1 })
 
-    const withItem = yield* waitUntil(
-      Form.view(CheckoutForm),
-      (v) => v.values.items.length === 1,
-    );
-    expect(withItem.array("items").items[0]?.key).toMatch(/^form-item-/);
+    const withItem = yield* waitUntil(Form.view(CheckoutForm), (v) => v.values.items.length === 1)
+    expect(withItem.array('items').items[0]?.key).toMatch(/^form-item-/)
 
-    withItem.array("items").remove(0);
-    const empty = yield* waitUntil(
-      Form.view(CheckoutForm),
-      (v) => v.values.items.length === 0,
-    );
-    expect(empty.values.items).toEqual([]);
+    withItem.array('items').remove(0)
+    const empty = yield* waitUntil(Form.view(CheckoutForm), (v) => v.values.items.length === 0)
+    expect(empty.values.items).toEqual([])
   }).pipe(Effect.provide(layer)),
-);
+)
 
-it.scopedLive("submit routes custom validation errors to fields", () =>
+it.scopedLive('submit routes custom validation errors to fields', () =>
   Effect.gen(function* () {
-    const view = yield* Form.view(CheckoutForm);
-    view.submit();
+    const view = yield* Form.view(CheckoutForm)
+    view.submit()
 
-    const invalid = yield* waitUntil(
-      Form.view(CheckoutForm),
-      (v) => v.validationCount > 0,
-    );
-    const error = invalid.field("email").error;
-    expect(Option.isSome(error) ? error.value : undefined).toBe(
-      "Email must contain @",
-    );
+    const invalid = yield* waitUntil(Form.view(CheckoutForm), (v) => v.validationCount > 0)
+    const error = invalid.field('email').error
+    expect(Option.isSome(error) ? error.value : undefined).toBe('Email must contain @')
   }).pipe(Effect.provide(layer)),
-);
+)

package/src/form.ts

@@ -1,51 +1,31 @@
+import { type Context, Effect, Function as Fn, Layer, Option, Schema as S } from 'effect'
+import { Reducer, State } from '@playfast/reform'
+import { Bus, Reducers } from '@playfast/reform/internal'
+import { error, normalizeErrors, type FormErrors } from './validation'
 import {
-  Context,
-  Effect,
-  Function as Fn,
-  Layer,
-  Option,
-  Schema as S,
-} from 'effect'
-import {
-  Bus,
-  Event,
-  Reducer,
-  Reducers,
-  State,
-  type Store,
-} from '@playfast/reform'
+  appendAtPath,
+  initialState,
+  markTouched,
+  moveAtPath,
+  removeAtPath,
+  setAtPath,
+  swapAtPath,
+} from './formState'
 import type {
-  AnyForm,
-  Decoded,
   DecodedOfSchema,
   FormClass,
-  FormEvents,
   FormLiveConfig,
   FormState,
   InputRecord,
-  Inputs,
   InputsObject,
   RuntimeConfig,
-  Values,
   ValuesOfSchema,
 } from './formTypes'
-import {
-  appendAtPath,
-  initialState,
-  markTouched,
-  moveAtPath,
-  removeAtPath,
-  setAtPath,
-  swapAtPath,
-} from './formState'
-import {
-  error,
-  normalizeErrors,
-  type FormErrors,
-} from './validation'
 
 export { error }
-
+export { arrayKeysFor } from './formState'
+export { make } from './formMake'
+export { view } from './formView'
 export type {
   AnyForm,
   ArrayBinding,
@@ -57,8 +37,11 @@ export type {
   FormClass,
   FormLiveConfig,
   FormManifest,
+  FormManifestReflection,
+  FormSchemaReflection,
   FormState,
   FormView,
+  FormVisitor,
   Inputs,
   Limitations,
   RuntimeConfig,
@@ -66,88 +49,43 @@ export type {
   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> {
-  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: 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 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 }),
-    })),
-    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 })),
-    swap: Event.make(`${name}/SwapItems`, S.Struct({ path: S.String, a: S.Number, b: S.Number })),
-  }
-  const reducer = Reducer.make(`${name}/FormReducer`, {
-    states: [state],
-    events: Object.values(events),
-  })
-  const runtimeConfig = Context.GenericTag<
-    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), () => ({})))
-  class FormImpl {
-    static readonly manifest = {
-      kind: 'Form' as const,
-      name,
-      schema: config.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 = <
-  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 +96,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 +112,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 +138,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 +172,7 @@ 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'

package/src/formMake.ts

@@ -0,0 +1,95 @@
+import { Context, Function as Fn, Option, Schema as S } from 'effect'
+import { Event, Reducer, State } from '@playfast/reform'
+import type {
+  DecodedOfSchema,
+  FormClass,
+  FormEvents,
+  FormManifest,
+  FormState,
+  FormVisitor,
+  InputRecord,
+  InputsObject,
+  RuntimeConfig,
+  ValuesOfSchema,
+} from './formTypes'
+
+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
+}
+
+export const make = <
+  const N extends string,
+  Schema extends S.Schema.AnyNoContext,
+  const Inputs extends InputRecord = {},
+>(
+  name: N,
+  config: MakeConfig<Schema, Inputs>,
+): FormClass<N, Schema, Inputs> => {
+  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 }),
+      }),
+    ),
+    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 }),
+    ),
+    swap: Event.make(`${name}/SwapItems`, S.Struct({ path: S.String, a: S.Number, b: S.Number })),
+  }
+  const reducer: FormClass<N, Schema, Inputs>['reducer'] = Reducer.make(`${name}/FormReducer`, {
+    states: [state],
+    events: Object.values(events),
+  })
+  const runtimeConfig = Context.GenericTag<
+    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), () => ({})),
+  )
+  class FormImpl {
+    static readonly manifest: FormManifest<N, Schema, Inputs> = {
+      kind: 'Form',
+      name,
+      schema: config.schema,
+      inputs,
+    }
+    static readonly state = state
+    static readonly config = runtimeConfig
+    static readonly events = events
+    static readonly reducer = reducer
+    static capture<Result>(visitor: FormVisitor<Result>): Result {
+      return visitor.visit(FormImpl)
+    }
+  }
+  return FormImpl
+}

package/src/formState.ts

@@ -16,12 +16,15 @@ export const arrayKeysFor = (source: unknown, path = ''): Record<string, Readonl
   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}]` }))
+      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}` }),
+      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}` }),
       )
     }
   }
@@ -41,8 +44,10 @@ export const initialState = <Values>(initial: Values): FormState<Values> => ({
   arrayKeys: arrayKeysFor(initial),
 })
 
-export const markTouched = (touched: Readonly<Record<string, boolean>>, path: string): Readonly<Record<string, boolean>> =>
-  ({ ...touched, [path]: true })
+export const markTouched = (
+  touched: Readonly<Record<string, boolean>>,
+  path: string,
+): Readonly<Record<string, boolean>> => ({ ...touched, [path]: true })
 
 interface ArrayLookup {
   readonly source: unknown
@@ -93,7 +98,8 @@ const updateKeys = (
   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())
+  const existing =
+    state.arrayKeys[path] ?? currentArray({ source: state.values, path }).map(() => makeArrayKey())
   return { ...state.arrayKeys, [path]: transform(existing) }
 }
 
@@ -105,7 +111,10 @@ export const appendAtPath = <Values>(input: SetPathInput<Values>): FormState<Val
   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()]),
+    arrayKeys: updateKeys(Fn.unsafeCoerce(input.state), input.path, (keys) => [
+      ...keys,
+      makeArrayKey(),
+    ]),
   }
 }
 
@@ -136,7 +145,9 @@ export const moveAtPath = <Values>(input: MovePathInput<Values>): FormState<Valu
   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)),
+    arrayKeys: updateKeys(Fn.unsafeCoerce(input.state), input.path, (keys) =>
+      moveAt(keys, input.from, input.to),
+    ),
   }
 }
 
@@ -151,7 +162,11 @@ export const swapAtPath = <Values>(input: SwapPathInput<Values>): FormState<Valu
   ) {
     return input.state
   }
-  const swapped = replaceAt(replaceAt(elements, input.first, elements[input.second]), input.second, elements[input.first])
+  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),

package/src/formTypes.ts

@@ -1,5 +1,10 @@
-import { Context, Effect, Option, Schema as S } from 'effect'
-import type { AnySource, Event, Reducer, Source, State } from '@playfast/reform'
+import type { Context, Effect, Option, Schema as S } from 'effect'
+import type { Event, Reducer, State } from '@playfast/reform'
+import type {
+  AnySource,
+  SourceName,
+  SourceValue as ReformSourceValue,
+} from '@playfast/reform/internal'
 import type {
   ArrayItem,
   ArrayPath,
@@ -10,9 +15,6 @@ import type {
 } from './path'
 import type { FormError, FormErrors } from './validation'
 
-export type AnyValue = S.Schema.Type<S.Schema.Any>
-
-// Wire-serialized UI knobs: ExternalApi postfix allows optional fields (Option would break the contract).
 export interface FieldLimitationsExternalApi<A = unknown> {
   readonly required?: boolean
   readonly disabled?: boolean
@@ -93,30 +95,25 @@ export interface FormView<Values, Inputs = {}> {
 
 export type InputRecord = Readonly<Record<string, AnySource>>
 
-// Structural `S['name']`: Source value param is invariant, so `Source<_, unknown>` erases keys to never.
-export type SourceName<S extends AnySource> = S['name']
-export type SourceValue<S> = S extends Source<string, infer A> ? A : never
-
 export type InputsObject<Inputs extends InputRecord> = {
-  readonly [K in keyof Inputs as SourceName<Inputs[K]>]: SourceValue<Inputs[K]>
+  readonly [K in keyof Inputs as SourceName<Inputs[K]>]: ReformSourceValue<Inputs[K]>
 }
 
 export type InputStores<Inputs extends InputRecord> = {
-  [K in keyof Inputs]: Inputs[K] extends { readonly store: Context.Tag<infer Service, AnyValue> }
+  [K in keyof Inputs]: Inputs[K] extends {
+    readonly store: Context.Tag<infer Service, infer _Store>
+  }
     ? Service
     : never
 }[keyof Inputs]
 
-export type ValuesOfSchema<S extends S.Schema.Any> = S.Schema.Encoded<S>
-export type DecodedOfSchema<S extends S.Schema.Any> = S.Schema.Type<S>
+export type ValuesOfSchema<Schema extends S.Schema.AnyNoContext> = S.Schema.Encoded<Schema>
+export 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 limit?: (ctx: { readonly values: Values; readonly inputs: Inputs }) => Limitations
   readonly validate: (ctx: {
     readonly values: Values
     readonly decoded: Decoded
@@ -132,10 +129,7 @@ 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
+  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
@@ -154,9 +148,22 @@ export interface FormLiveConfig<Values, Decoded, Inputs, R = never> {
   }) => void | Effect.Effect<unknown, unknown, R>
 }
 
-export interface FormManifest<N extends string, Schema extends S.Schema.Any, Inputs extends InputRecord> {
+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
 }
@@ -170,17 +177,40 @@ export interface FormEvents {
   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 }>
+  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.Any,
+  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>>,
@@ -193,19 +223,13 @@ export interface FormClass<
   >
 }
 
-// `any` inputs wildcard: config tag is invariant via InputsObject; InputRecord would reject concrete forms.
-export type AnyForm = FormClass<string, S.Schema.Any, AnyValue>
-
-export type Values<F extends AnyForm> = F extends FormClass<string, infer Schema, AnyValue>
-  ? ValuesOfSchema<Schema>
-  : never
+export type Values<F> =
+  F extends FormClass<infer _Name, infer Schema, infer _Inputs> ? ValuesOfSchema<Schema> : never
 
-export type Decoded<F extends AnyForm> = F extends FormClass<string, infer Schema, AnyValue>
-  ? DecodedOfSchema<Schema>
-  : never
+export type Decoded<F> =
+  F extends FormClass<infer _Name, infer Schema, infer _Inputs> ? DecodedOfSchema<Schema> : never
 
-export type Inputs<F extends AnyForm> = F extends FormClass<string, S.Schema.Any, infer Inputs>
-  ? InputsObject<Inputs>
-  : never
+export type Inputs<F> =
+  F extends FormClass<infer _Name, infer _Schema, infer Inputs> ? InputsObject<Inputs> : never
 
-export type View<F extends AnyForm> = FormView<Values<F>, Inputs<F>>
+export type View<F> = FormView<Values<F>, Inputs<F>>

package/src/formView.ts

@@ -1,4 +1,5 @@
 import {
+  Context,
   Effect,
   Either,
   Function as Fn,
@@ -7,49 +8,54 @@ import {
   Runtime,
   Schema as S,
 } from 'effect'
+import { Event, type Trigger } from '@playfast/reform'
 import {
+  type AnySource,
   Bus,
   CurrentTracker,
-  Event,
+  type SourceIdentifier,
+  type SourceValue as ReformSourceValue,
   type Store,
-  type Trigger,
-} from '@playfast/reform'
-import type { AnySource } from '@playfast/reform'
-import { currentArray } from './formState'
-import { getNestedValue, isPathOrParentDirty } from './path'
-import type { ArrayItem, ArrayPath, FieldPath, PathValue } from './path'
+} from '@playfast/reform/internal'
+import { State } from '@playfast/reform'
+import {
+  getNestedValue,
+  isPathOrParentDirty,
+  type ArrayItem,
+  type ArrayPath,
+  type FieldPath,
+  type PathValue,
+} from './path'
 import { errorsToRecord, firstError, routeParseError } from './validation'
+import { currentArray } from './formState'
 import type {
-  AnyForm,
   ArrayBinding,
-  Decoded,
-  FieldBinding,
+  DecodedOfSchema,
   FieldLimitations,
+  FieldBinding,
+  FormClass,
   FormState,
+  FormView,
   InputRecord,
-  Inputs,
   InputsObject,
   InputStores,
   Limitations,
   RuntimeConfig,
-  SourceValue,
-  Values,
-  View,
+  ValuesOfSchema,
 } from './formTypes'
 
-const readInput = <Source extends AnySource>(
-  source: Source,
-): 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 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,
@@ -57,32 +63,41 @@ const readInputs = <Inputs extends InputRecord>(
   Fn.unsafeCoerce(
     Effect.gen(function* () {
       const pairs = yield* Effect.forEach(Object.values(inputs), (source) =>
-        Effect.map(readInput(source), (snapshot) => [source.name, snapshot] as const),
+        Effect.map(readInput(source), (snapshot): readonly [string, unknown] => [
+          source.name,
+          snapshot,
+        ]),
       )
       return Record.fromEntries(pairs)
     }),
   )
 
-const limitationsFor = <A>(
-  limitations: Limitations,
-  path: string,
-): FieldLimitations<A> =>
+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
+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']>> =>
+// 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
-    // AnyForm erases inputs to `any`; restate at concrete F so R keeps declared input stores.
-    const inputs: Inputs<F> = Fn.unsafeCoerce(
-      yield* readInputs(Fn.unsafeCoerce<typeof form.manifest.inputs, InputRecord>(form.manifest.inputs)),
-    )
+    const inputs = yield* readInputs(form.manifest.inputs)
     const limitations = Option.getOrElse(
       Option.fromNullable(runtimeConfig.limit?.({ values: state.values, inputs })),
       () => ({}),
@@ -96,7 +111,7 @@ export const view = <F extends AnyForm>(
     const swap = yield* trigger(form.events.swap.trigger)
     const runtime = yield* Effect.runtime<Bus>()
 
-    const schema: S.Schema<Decoded<F>, Values<F>, never> = Fn.unsafeCoerce(form.manifest.schema)
+    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
 
@@ -108,15 +123,21 @@ export const view = <F extends AnyForm>(
         }
         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<Decoded<F>>()
+          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 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(Fn.unsafeCoerce<unknown, Decoded<F>>(decoded.right))
-          : Option.none<Decoded<F>>()
+          ? Option.some(decoded.right)
+          : Option.none<DecodedOfSchema<Schema>>()
       })
 
     const submit = () => {
@@ -128,7 +149,9 @@ export const view = <F extends AnyForm>(
           }
           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))),
+        }).pipe(
+          Effect.catchAllCause((cause) => Effect.logError('reform form submit failed', cause)),
+        ),
       )
     }
 
@@ -136,16 +159,21 @@ export const view = <F extends AnyForm>(
       Runtime.runFork(runtime)(runValidation(false))
     }
 
-    const field = <P extends FieldPath<Values<F>>>(path: P): FieldBinding<PathValue<Values<F>, P>> => {
-      const fieldValue: PathValue<Values<F>, P> = Fn.unsafeCoerce(getNestedValue(state.values, path))
+    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<Values<F>, P>) => PathValue<Values<F>, P>>(
-              next,
-            )
+            const updater = Fn.unsafeCoerce<
+              typeof next,
+              (prev: PathValue<ValuesOfSchema<Schema>, P>) => PathValue<ValuesOfSchema<Schema>, P>
+            >(next)
             setField({ path, value: updater(fieldValue) })
             return
           }
@@ -156,12 +184,14 @@ export const view = <F extends AnyForm>(
         dirty: isPathOrParentDirty(state.dirtyPaths, path),
         touched: state.touched[path] === true,
         validating: false,
-        limitations: limitationsFor<PathValue<Values<F>, P>>(limitations, path),
+        limitations: limitationsFor<PathValue<ValuesOfSchema<Schema>, P>>(limitations, path),
       }
     }
 
-    const array = <P extends ArrayPath<Values<F>>>(path: P): ArrayBinding<ArrayItem<Values<F>, P>> => {
-      const arrayValues: ReadonlyArray<ArrayItem<Values<F>, P>> = Fn.unsafeCoerce(
+    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}`)
@@ -178,11 +208,14 @@ export const view = <F extends AnyForm>(
         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<Values<F>, P>>>(limitations, path),
+        limitations: limitationsFor<ReadonlyArray<ArrayItem<ValuesOfSchema<Schema>, P>>>(
+          limitations,
+          path,
+        ),
       }
     }
 
-    const formView: View<F> = Fn.unsafeCoerce({
+    const formView: FormView<ValuesOfSchema<Schema>, InputsObject<FormInputs>> = Fn.unsafeCoerce({
       values: state.values,
       inputs,
       errors: state.errors,
@@ -200,3 +233,4 @@ export const view = <F extends AnyForm>(
     })
     return formView
   })
+

package/src/index.ts

@@ -16,13 +16,7 @@ export type {
   Values,
   View,
 } from './form'
-export {
-  arrayKeysFor as unsafeArrayKeysFor,
-  error,
-  live,
-  make,
-  view,
-} from './form'
+export { arrayKeysFor as unsafeArrayKeysFor, error, live, make, view } from './form'
 export type {
   ArrayItem,
   ArrayPath,

package/src/path.ts

@@ -24,52 +24,48 @@ type IsTagged<T> = T extends Tagged ? true : false
 export type FieldPath<T> = T extends Primitive
   ? never
   : {
-      readonly [K in StringKey<T>]:
-        T[K] extends ReadonlyArray<unknown>
+      readonly [K in StringKey<T>]: T[K] extends ReadonlyArray<unknown>
+        ? never
+        : IsTagged<T[K]> extends true
           ? never
-          : IsTagged<T[K]> extends true
-            ? never
-            : T[K] extends Primitive
-              ? K
-              : T[K] extends object
-                ? K | `${K}.${FieldPath<T[K]>}`
-                : K
+          : T[K] extends Primitive
+            ? K
+            : T[K] extends object
+              ? K | `${K}.${FieldPath<T[K]>}`
+              : K
     }[StringKey<T>]
 
 export type ArrayPath<T> = T extends Primitive
   ? never
   : {
-      readonly [K in StringKey<T>]:
-        T[K] extends ReadonlyArray<unknown>
-          ? K
-          : IsTagged<T[K]> extends true
-            ? never
-            : T[K] extends object
-              ? `${K}.${ArrayPath<T[K]>}`
-              : never
+      readonly [K in StringKey<T>]: T[K] extends ReadonlyArray<unknown>
+        ? K
+        : IsTagged<T[K]> extends true
+          ? never
+          : T[K] extends object
+            ? `${K}.${ArrayPath<T[K]>}`
+            : never
     }[StringKey<T>]
 
 export type VariantPath<T> = T extends Primitive
   ? never
   : {
-      readonly [K in StringKey<T>]:
-        IsTagged<T[K]> extends true
-          ? K
-          : T[K] extends ReadonlyArray<unknown>
-            ? never
-            : T[K] extends object
-              ? `${K}.${VariantPath<T[K]>}`
-              : never
+      readonly [K in StringKey<T>]: IsTagged<T[K]> extends true
+        ? K
+        : T[K] extends ReadonlyArray<unknown>
+          ? never
+          : T[K] extends object
+            ? `${K}.${VariantPath<T[K]>}`
+            : never
     }[StringKey<T>]
 
-export type PathValue<T, P extends string> =
-  P extends `${infer Head}.${infer Tail}`
-    ? Head extends keyof T
-      ? PathValue<T[Head], Tail>
-      : never
-    : P extends keyof T
-      ? T[P]
-      : never
+export type PathValue<T, P extends string> = P extends `${infer Head}.${infer Tail}`
+  ? Head extends keyof T
+    ? PathValue<T[Head], Tail>
+    : never
+  : P extends keyof T
+    ? T[P]
+    : never
 
 export type ArrayItem<T, P extends string> =
   PathValue<T, P> extends ReadonlyArray<infer Item> ? Item : never
@@ -196,7 +192,9 @@ export const recalculateDirtyPaths = (
     ) {
       const currentRecord = asRecord(current)
       const originalRecord = asRecord(original)
-      const keys = Array.from(new Set([...Record.keys(currentRecord), ...Record.keys(originalRecord)]))
+      const keys = Array.from(
+        new Set([...Record.keys(currentRecord), ...Record.keys(originalRecord)]),
+      )
       return keys.flatMap((key) =>
         visit({
           current: currentRecord[key],