Update bun minor+patch updates to v3.10.1

Fix
2026-05-01 12:01:09 +00:00 · 2026-05-01 01:12:24 +02:00 · 2026-05-01 01:02:48 +02:00 · 2026-04-30 23:45:14 +02:00 · 2026-04-30 02:28:04 +02:00 · 2026-04-30 02:21:47 +02:00
33 changed files with 930 additions and 1290 deletions
--- a/.codex
+++ b/.codex
--- a/bun.lock
+++ b/bun.lock
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "@effect-fc/monorepo",
-  "packageManager": "bun@1.3.11",
+  "packageManager": "bun@1.3.13",
  "private": true,
  "workspaces": [
    "./packages/*"
@@ -15,12 +15,12 @@
    "clean:modules": "turbo clean:modules && rm -rf node_modules"
  },
  "devDependencies": {
-    "@biomejs/biome": "^2.4.9",
-    "@effect/language-service": "^0.84.2",
-    "@types/bun": "^1.3.11",
-    "npm-check-updates": "^19.6.6",
+    "@biomejs/biome": "^2.4.13",
+    "@effect/language-service": "^0.85.1",
+    "@types/bun": "^1.3.13",
+    "npm-check-updates": "^22.0.1",
    "npm-sort": "^0.0.4",
-    "turbo": "^2.8.21",
-    "typescript": "^6.0.2"
+    "turbo": "^2.9.6",
+    "typescript": "^6.0.3"
  }
 }
--- a/packages/docs/package.json
+++ b/packages/docs/package.json
@@ -15,8 +15,8 @@
    "typecheck": "tsc"
  },
  "dependencies": {
-    "@docusaurus/core": "3.9.2",
-    "@docusaurus/preset-classic": "3.9.2",
+    "@docusaurus/core": "3.10.1",
+    "@docusaurus/preset-classic": "3.10.1",
    "@mdx-js/react": "^3.0.0",
    "clsx": "^2.0.0",
    "prism-react-renderer": "^2.3.0",
@@ -24,10 +24,10 @@
    "react-dom": "^19.0.0"
  },
  "devDependencies": {
-    "@docusaurus/module-type-aliases": "3.9.2",
-    "@docusaurus/tsconfig": "3.9.2",
-    "@docusaurus/types": "3.9.2",
-    "typescript": "~5.9.0"
+    "@docusaurus/module-type-aliases": "3.10.1",
+    "@docusaurus/tsconfig": "3.10.1",
+    "@docusaurus/types": "3.10.1",
+    "typescript": "~6.0.0"
  },
  "browserslist": {
    "production": [
--- a/packages/effect-fc/package.json
+++ b/packages/effect-fc/package.json
@@ -1,7 +1,7 @@
 {
  "name": "effect-fc",
  "description": "Write React function components with Effect",
-  "version": "0.2.4",
+  "version": "0.2.5",
  "type": "module",
  "files": [
    "./README.md",
@@ -46,6 +46,6 @@
    "react": "^19.2.0"
  },
  "dependencies": {
-    "effect-lens": "^0.1.4"
+    "effect-lens": "^0.1.5"
  }
 }
--- a/packages/effect-fc/src/Form.ts
+++ b/packages/effect-fc/src/Form.ts
@@ -1,11 +1,8 @@
-import { Array, Cause, Chunk, type Context, type Duration, Effect, Equal, Exit, Fiber, Function, identity, Option, ParseResult, Pipeable, Predicate, Schema, type Scope, Stream } from "effect"
+import { Array, type Cause, Chunk, type Duration, Effect, Equal, Function, identity, Option, type ParseResult, Pipeable, Predicate, type Scope, Stream, SubscriptionRef } from "effect"
 import type * as React from "react"
 import * as Component from "./Component.js"
 import * as Lens from "./Lens.js"
-import * as Mutation from "./Mutation.js"
-import * as Result from "./Result.js"
 import * as Subscribable from "./Subscribable.js"
-import * as SubscriptionRef from "./SubscriptionRef.js"


 export const FormTypeId: unique symbol = Symbol.for("@effect-fc/Form/Form")
@@ -20,8 +17,8 @@ extends Pipeable.Pipeable {
    readonly encodedValue: Lens.Lens<I, ER, EW, never, never>
    readonly issues: Subscribable.Subscribable<readonly ParseResult.ArrayFormatterIssue[], never, never>
    readonly isValidating: Subscribable.Subscribable<boolean, ER, never>
-    readonly canSubmit: Subscribable.Subscribable<boolean, never, never>
-    readonly isSubmitting: Subscribable.Subscribable<boolean, never, never>
+    readonly canCommit: Subscribable.Subscribable<boolean, never, never>
+    readonly isCommitting: Subscribable.Subscribable<boolean, never, never>
 }

 export class FormImpl<out P extends readonly PropertyKey[], in out A, in out I = A, in out ER = never, in out EW = never>
@@ -34,209 +31,15 @@ extends Pipeable.Class() implements Form<P, A, I, ER, EW> {
        readonly encodedValue: Lens.Lens<I, ER, EW, never, never>,
        readonly issues: Subscribable.Subscribable<readonly ParseResult.ArrayFormatterIssue[], never, never>,
        readonly isValidating: Subscribable.Subscribable<boolean, never, never>,
-        readonly canSubmit: Subscribable.Subscribable<boolean, never, never>,
-        readonly isSubmitting: Subscribable.Subscribable<boolean, never, never>,
+        readonly canCommit: Subscribable.Subscribable<boolean, never, never>,
+        readonly isCommitting: Subscribable.Subscribable<boolean, never, never>,
    ) {
        super()
    }
 }


-export const RootFormTypeId: unique symbol = Symbol.for("@effect-fc/Form/RootForm")
-export type RootFormTypeId = typeof RootFormTypeId
-
-export interface RootForm<in out A, in out I = A, in out R = never, in out MA = void, in out ME = never, in out MR = never, in out MP = never>
-extends Form<readonly [], A, I, never, never> {
-    readonly schema: Schema.Schema<A, I, R>
-    readonly context: Context.Context<Scope.Scope | R>
-    readonly mutation: Mutation.Mutation<
-        readonly [value: A, form: RootForm<A, I, R, unknown, unknown, unknown>],
-        MA, ME, MR, MP
-    >
-    readonly autosubmit: boolean
-
-    readonly validationFiber: Subscribable.Subscribable<Option.Option<Fiber.Fiber<A, ParseResult.ParseError>>, never, never>
-
-    readonly run: Effect.Effect<void>
-    readonly submit: Effect.Effect<Option.Option<Result.Final<MA, ME, MP>>, Cause.NoSuchElementException>
-}
-
-export class RootFormImpl<in out A, in out I = A, in out R = never, in out MA = void, in out ME = never, in out MR = never, in out MP = never>
-extends Pipeable.Class() implements RootForm<A, I, R, MA, ME, MR, MP> {
-    readonly [FormTypeId]: FormTypeId = FormTypeId
-    readonly [RootFormTypeId]: RootFormTypeId = RootFormTypeId
-
-    readonly path = [] as const
-
-    constructor(
-        readonly schema: Schema.Schema<A, I, R>,
-        readonly context: Context.Context<Scope.Scope | R>,
-        readonly mutation: Mutation.Mutation<
-            readonly [value: A, form: RootForm<A, I, R, unknown, unknown, unknown>],
-            MA, ME, MR, MP
-        >,
-        readonly autosubmit: boolean,
-
-        readonly value: Lens.Lens<Option.Option<A>, never, never, never, never>,
-        readonly encodedValue: Lens.Lens<I, never, never, never, never>,
-        readonly issues: Lens.Lens<readonly ParseResult.ArrayFormatterIssue[], never, never, never, never>,
-        readonly validationFiber: Lens.Lens<Option.Option<Fiber.Fiber<A, ParseResult.ParseError>>, never, never, never, never>,
-        readonly isValidating: Subscribable.Subscribable<boolean, never, never>,
-
-        readonly canSubmit: Subscribable.Subscribable<boolean, never, never>,
-        readonly isSubmitting: Subscribable.Subscribable<boolean, never, never>,
-
-        readonly runSemaphore: Effect.Semaphore,
-    ) {
-        super()
-    }
-
-    get run(): Effect.Effect<void> {
-        return this.runSemaphore.withPermits(1)(Stream.runForEach(
-            this.encodedValue.changes,
-
-            encodedValue => Lens.get(this.validationFiber).pipe(
-                Effect.andThen(Option.match({
-                    onSome: Fiber.interrupt,
-                    onNone: () => Effect.void,
-                })),
-                Effect.andThen(
-                    Effect.forkScoped(Effect.onExit(
-                        Schema.decode(this.schema, { errors: "all" })(encodedValue),
-                        exit => Effect.andThen(
-                            Exit.matchEffect(exit, {
-                                onSuccess: v => Effect.andThen(
-                                    Lens.set(this.value, Option.some(v)),
-                                    Lens.set(this.issues, Array.empty()),
-                                ),
-                                onFailure: c => Option.match(Chunk.findFirst(Cause.failures(c), e => e._tag === "ParseError"), {
-                                    onSome: e => Effect.flatMap(
-                                        ParseResult.ArrayFormatter.formatError(e),
-                                        v => Lens.set(this.issues, v),
-                                    ),
-                                    onNone: () => Effect.void,
-                                }),
-                            }),
-                            Lens.set(this.validationFiber, Option.none()),
-                        ),
-                    )).pipe(
-                        Effect.tap(fiber => Lens.set(this.validationFiber, Option.some(fiber))),
-                        Effect.andThen(Fiber.join),
-                        Effect.andThen(value => this.autosubmit
-                            ? Effect.asVoid(Effect.forkScoped(this.submitValue(value)))
-                            : Effect.void
-                        ),
-                        Effect.forkScoped,
-                    )
-                ),
-                Effect.provide(this.context),
-            ),
-        ))
-    }
-
-    get submit(): Effect.Effect<Option.Option<Result.Final<MA, ME, MP>>, Cause.NoSuchElementException> {
-        return Lens.get(this.value).pipe(
-            Effect.andThen(identity),
-            Effect.andThen(value => this.submitValue(value)),
-        )
-    }
-
-    submitValue(value: A): Effect.Effect<Option.Option<Result.Final<MA, ME, MP>>> {
-        return Effect.whenEffect(
-            Effect.tap(
-                this.mutation.mutate([value, this as any]),
-                result => Result.isFailure(result)
-                    ? Option.match(
-                        Chunk.findFirst(
-                            Cause.failures(result.cause as Cause.Cause<ParseResult.ParseError>),
-                            e => e._tag === "ParseError",
-                        ),
-                        {
-                            onSome: e => Effect.flatMap(
-                                ParseResult.ArrayFormatter.formatError(e),
-                                v => Lens.set(this.issues, v),
-                            ),
-                            onNone: () => Effect.void,
-                        },
-                    )
-                    : Effect.void
-            ),
-            this.canSubmit.get,
-        )
-    }
-}
-
-
 export const isForm = (u: unknown): u is Form<readonly PropertyKey[], unknown, unknown> => Predicate.hasProperty(u, FormTypeId)
-export const isRootForm = (u: unknown): u is RootForm<readonly PropertyKey[], unknown, unknown, unknown, unknown, unknown, unknown> => Predicate.hasProperty(u, RootFormTypeId)
-
-
-export declare namespace make {
-    export interface Options<in out A, in out I = A, in out R = never, in out MA = void, in out ME = never, in out MR = never, in out MP = never>
-    extends Mutation.make.Options<
-        readonly [value: NoInfer<A>, form: RootForm<NoInfer<A>, NoInfer<I>, NoInfer<R>, unknown, unknown, unknown>],
-        MA, ME, MR, MP
-    > {
-        readonly schema: Schema.Schema<A, I, R>
-        readonly initialEncodedValue: NoInfer<I>
-        readonly autosubmit?: boolean
-    }
-}
-
-export const make = Effect.fnUntraced(function* <A, I = A, R = never, MA = void, ME = never, MR = never, MP = never>(
-    options: make.Options<A, I, R, MA, ME, MR, MP>
-): Effect.fn.Return<
-    RootForm<A, I, R, MA, ME, Result.forkEffect.OutputContext<MR, MP>, MP>,
-    never,
-    Scope.Scope | R | Result.forkEffect.OutputContext<MR, MP>
-> {
-    const mutation = yield* Mutation.make(options)
-    const valueLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<A>()))
-    const issuesLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make<readonly ParseResult.ArrayFormatterIssue[]>(Array.empty()))
-    const validationFiberLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<Fiber.Fiber<A, ParseResult.ParseError>>()))
-
-    return new RootFormImpl(
-        options.schema,
-        yield* Effect.context<Scope.Scope | R>(),
-        mutation,
-        options.autosubmit ?? false,
-
-        valueLens,
-        Lens.fromSubscriptionRef(yield* SubscriptionRef.make(options.initialEncodedValue)),
-        issuesLens,
-        validationFiberLens,
-        Subscribable.map(validationFiberLens, Option.isSome),
-
-        Subscribable.map(
-            Subscribable.zipLatestAll(valueLens, issuesLens, validationFiberLens, mutation.result),
-            ([value, issues, validationFiber, result]) => (
-                Option.isSome(value) &&
-                Array.isEmptyReadonlyArray(issues) &&
-                Option.isNone(validationFiber) &&
-                !(Result.isRunning(result) || Result.hasRefreshingFlag(result))
-            ),
-        ),
-        Subscribable.map(mutation.result, result => Result.isRunning(result) || Result.hasRefreshingFlag(result)),
-
-        yield* Effect.makeSemaphore(1),
-    )
-})
-
-export declare namespace service {
-    export interface Options<in out A, in out I = A, in out R = never, in out MA = void, in out ME = never, in out MR = never, in out MP = never>
-    extends make.Options<A, I, R, MA, ME, MR, MP> {}
-}
-
-export const service = <A, I = A, R = never, MA = void, ME = never, MR = never, MP = never>(
-    options: service.Options<A, I, R, MA, ME, MR, MP>
-): Effect.Effect<
-    RootForm<A, I, R, MA, ME, Result.forkEffect.OutputContext<MR, MP>, MP>,
-    never,
-    Scope.Scope | R | Result.forkEffect.OutputContext<MR, MP>
-> => Effect.tap(
-    make(options),
-    form => Effect.forkScoped(form.run),
-)


 const filterIssuesByPath = (
@@ -246,7 +49,7 @@ const filterIssuesByPath = (
    issue.path.length >= path.length && Array.every(path, (p, i) => p === issue.path[i])
 )

-export const focusObjectField: {
+export const focusObjectOn: {
    <P extends readonly PropertyKey[], A extends object, I extends object, ER, EW, K extends keyof A & keyof I>(
        self: Form<P, A, I, ER, EW>,
        key: K,
@@ -264,11 +67,11 @@ export const focusObjectField: {
    return new FormImpl(
        path,
        Subscribable.mapOption(form.value, a => a[key]),
-        Lens.focusObjectField(form.encodedValue, key),
+        Lens.focusObjectOn(form.encodedValue, key),
        Subscribable.map(form.issues, issues => filterIssuesByPath(issues, path)),
        form.isValidating,
-        form.canSubmit,
-        form.isSubmitting,
+        form.canCommit,
+        form.isCommitting,
    )
 })

@@ -293,8 +96,8 @@ export const focusArrayAt: {
        Lens.focusArrayAt(form.encodedValue, index),
        Subscribable.map(form.issues, issues => filterIssuesByPath(issues, path)),
        form.isValidating,
-        form.canSubmit,
-        form.isSubmitting,
+        form.canCommit,
+        form.isCommitting,
    )
 })

@@ -319,8 +122,8 @@ export const focusTupleAt: {
        Lens.focusTupleAt(form.encodedValue, index),
        Subscribable.map(form.issues, issues => filterIssuesByPath(issues, path)),
        form.isValidating,
-        form.canSubmit,
-        form.isSubmitting,
+        form.canCommit,
+        form.isCommitting,
    )
 })

@@ -345,8 +148,8 @@ export const focusChunkAt: {
        Lens.focusChunkAt(form.encodedValue, index),
        Subscribable.map(form.issues, issues => filterIssuesByPath(issues, path)),
        form.isValidating,
-        form.canSubmit,
-        form.isSubmitting,
+        form.canCommit,
+        form.isCommitting,
    )
 })

@@ -389,7 +192,7 @@ export const useInput = Effect.fnUntraced(function* <P extends readonly Property
                ),
                internalValue => Lens.set(form.encodedValue, internalValue),
            ),
-        ], { concurrency: "unbounded" }))
+        ], { concurrency: "unbounded", discard: true }))

        return internalValueLens
    }), [form, options?.debounce])
--- a/packages/effect-fc/src/Lens.ts
+++ b/packages/effect-fc/src/Lens.ts
@@ -1,9 +1,8 @@
-import { Effect, Equivalence, Stream } from "effect"
+import { Effect, Equivalence, Stream, SubscriptionRef } from "effect"
 import { Lens } from "effect-lens"
 import * as React from "react"
 import * as Component from "./Component.js"
 import * as SetStateAction from "./SetStateAction.js"
-import * as SubscriptionRef from "./SubscriptionRef.js"


 export * from "effect-lens/Lens"
@@ -38,15 +37,15 @@ export const useState = Effect.fnUntraced(function* <A, ER, EW, RR, RW>(
    return [reactStateValue, setValue]
 })

-export declare namespace useFromState {
+export declare namespace useFromReactState {
    export interface Options<A> {
        readonly equivalence?: Equivalence.Equivalence<A>
    }
 }

-export const useFromState = Effect.fnUntraced(function* <A>(
+export const useFromReactState = Effect.fnUntraced(function* <A>(
    [value, setValue]: readonly [A, React.Dispatch<React.SetStateAction<A>>],
-    options?: useFromState.Options<NoInfer<A>>,
+    options?: useFromReactState.Options<NoInfer<A>>,
 ): Effect.fn.Return<Lens.Lens<A, never, never, never, never>> {
    const lens = yield* Component.useOnMount(() => Effect.map(
        SubscriptionRef.make(value),
--- a/packages/effect-fc/src/Mutation.ts
+++ b/packages/effect-fc/src/Mutation.ts
@@ -99,8 +99,10 @@ extends Pipeable.Class() implements Mutation<K, A, E, R, P> {
    }
 }

+
 export const isMutation = (u: unknown): u is Mutation<readonly unknown[], unknown, unknown, unknown, unknown> => Predicate.hasProperty(u, MutationTypeId)

+
 export declare namespace make {
    export interface Options<K extends Mutation.AnyKey = never, A = void, E = never, R = never, P = never> {
        readonly f: (key: K) => Effect.Effect<A, E, Result.forkEffect.InputContext<R, NoInfer<P>>>
--- a/packages/effect-fc/src/PropertyPath.test.ts
+++ b/packages/effect-fc/src/PropertyPath.test.ts
@@ -1,67 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Option } from "effect"
-import * as PropertyPath from "./PropertyPath.js"
-
-
-describe("immutableSet with arrays", () => {
-    test("sets a top-level array element", () => {
-        const arr = [1, 2, 3]
-        const result = PropertyPath.immutableSet(arr, [1], 99)
-        expect(result).toEqual(Option.some([1, 99, 3]))
-    })
-
-    test("does not mutate the original array", () => {
-        const arr = [1, 2, 3]
-        PropertyPath.immutableSet(arr, [0], 42)
-        expect(arr).toEqual([1, 2, 3])
-    })
-
-    test("sets the first element of an array", () => {
-        const arr = ["a", "b", "c"]
-        const result = PropertyPath.immutableSet(arr, [0], "z")
-        expect(result).toEqual(Option.some(["z", "b", "c"]))
-    })
-
-    test("sets the last element of an array", () => {
-        const arr = [10, 20, 30]
-        const result = PropertyPath.immutableSet(arr, [2], 99)
-        expect(result).toEqual(Option.some([10, 20, 99]))
-    })
-
-    test("sets a nested array element inside an object", () => {
-        const obj = { tags: ["foo", "bar", "baz"] }
-        const result = PropertyPath.immutableSet(obj, ["tags", 1], "qux")
-        expect(result).toEqual(Option.some({ tags: ["foo", "qux", "baz"] }))
-    })
-
-    test("sets a deeply nested value inside an array of objects", () => {
-        const obj = { items: [{ name: "alice" }, { name: "bob" }] }
-        const result = PropertyPath.immutableSet(obj, ["items", 0, "name"], "charlie")
-        expect(result).toEqual(Option.some({ items: [{ name: "charlie" }, { name: "bob" }] }))
-    })
-
-    test("sets a value in a nested array", () => {
-        const matrix = [[1, 2], [3, 4]]
-        const result = PropertyPath.immutableSet(matrix, [1, 0], 99)
-        expect(result).toEqual(Option.some([[1, 2], [99, 4]]))
-    })
-
-    test("returns Option.none() for an out-of-bounds index", () => {
-        const arr = [1, 2, 3]
-        const result = PropertyPath.immutableSet(arr, [5], 99)
-        expect(result).toEqual(Option.none())
-    })
-
-    test("returns Option.none() for a non-numeric key on an array", () => {
-        const arr = [1, 2, 3]
-        // @ts-expect-error intentionally wrong key type
-        const result = PropertyPath.immutableSet(arr, ["length"], 0)
-        expect(result).toEqual(Option.none())
-    })
-
-    test("empty path returns Option.some of the value itself", () => {
-        const arr = [1, 2, 3]
-        const result = PropertyPath.immutableSet(arr, [], [9, 9, 9] as any)
-        expect(result).toEqual(Option.some([9, 9, 9]))
-    })
-})
--- a/packages/effect-fc/src/PropertyPath.ts
+++ b/packages/effect-fc/src/PropertyPath.ts
@@ -1,98 +0,0 @@
-import { Array, Equivalence, Function, Option, Predicate } from "effect"
-
-
-export type PropertyPath = readonly PropertyKey[]
-
-type Prev = readonly [never, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
-
-export type Paths<T, D extends number = 5, Seen = never> = readonly [] | (
-    D extends never ? readonly [] :
-    T extends Seen ? readonly [] :
-    T extends readonly any[] ? {
-        [K in keyof T as K extends number ? K : never]:
-            | readonly [K]
-            | readonly [K, ...Paths<T[K], Prev[D], Seen | T>]
-    } extends infer O
-        ? O[keyof O]
-        : never
-    :
-    T extends object ? {
-        [K in keyof T as K extends string | number | symbol ? K : never]-?:
-            NonNullable<T[K]> extends infer V
-                ? readonly [K] | readonly [K, ...Paths<V, Prev[D], Seen>]
-                : never
-    } extends infer O
-        ? O[keyof O]
-        : never
-    :
-    never
-)
-
-export type ValueFromPath<T, P extends readonly any[]> = P extends readonly [infer Head, ...infer Tail]
-    ? Head extends keyof T
-        ? ValueFromPath<T[Head], Tail>
-        : T extends readonly any[]
-            ? Head extends number
-                ? ValueFromPath<T[number], Tail>
-                : never
-            : never
-    : T
-
-
-export const equivalence: Equivalence.Equivalence<PropertyPath> = Equivalence.array(Equivalence.strict())
-
-export const unsafeGet: {
-    <T, const P extends Paths<T>>(path: P): (self: T) => ValueFromPath<T, P>
-    <T, const P extends Paths<T>>(self: T, path: P): ValueFromPath<T, P>
-} = Function.dual(2, <T, const P extends Paths<T>>(self: T, path: P): ValueFromPath<T, P> =>
-    path.reduce((acc: any, key: any) => acc?.[key], self)
-)
-
-export const get: {
-    <T, const P extends Paths<T>>(path: P): (self: T) => Option.Option<ValueFromPath<T, P>>
-    <T, const P extends Paths<T>>(self: T, path: P): Option.Option<ValueFromPath<T, P>>
-} = Function.dual(2, <T, const P extends Paths<T>>(self: T, path: P): Option.Option<ValueFromPath<T, P>> =>
-    path.reduce(
-        (acc: Option.Option<any>, key: any): Option.Option<any> => Option.isSome(acc)
-            ? Predicate.hasProperty(acc.value, key)
-                ? Option.some(acc.value[key])
-                : Option.none()
-            : acc,
-
-        Option.some(self),
-    )
-)
-
-export const immutableSet: {
-    <T, const P extends Paths<T>>(path: P, value: ValueFromPath<T, P>): (self: T) => Option.Option<T>
-    <T, const P extends Paths<T>>(self: T, path: P, value: ValueFromPath<T, P>): Option.Option<T>
-} = Function.dual(3, <T, const P extends Paths<T>>(self: T, path: P, value: ValueFromPath<T, P>): Option.Option<T> => {
-    const key = Array.head(path as PropertyPath)
-    if (Option.isNone(key))
-        return Option.some(value as T)
-    if (!Predicate.hasProperty(self, key.value))
-        return Option.none()
-
-    const child = immutableSet<any, any>(self[key.value], Option.getOrThrow(Array.tail(path as PropertyPath)), value)
-    if (Option.isNone(child))
-        return child
-
-    if (Array.isArray(self))
-        return typeof key.value === "number"
-            ? Option.some([
-                ...self.slice(0, key.value),
-                child.value,
-                ...self.slice(key.value + 1),
-            ] as T)
-            : Option.none()
-
-    if (typeof self === "object")
-        return Option.some(
-            Object.assign(
-                Object.create(Object.getPrototypeOf(self)),
-                { ...self, [key.value]: child.value },
-            )
-        )
-
-    return Option.none()
-})
--- a/packages/effect-fc/src/PubSub.ts
+++ b/packages/effect-fc/src/PubSub.ts
@@ -3,7 +3,7 @@ import type * as React from "react"
 import * as Component from "./Component.js"


-export const usePubSubFromReactiveValues = Effect.fnUntraced(function* <const A extends React.DependencyList>(
+export const useFromReactiveValues = Effect.fnUntraced(function* <const A extends React.DependencyList>(
    values: A
 ): Effect.fn.Return<PubSub.PubSub<A>, never, Scope.Scope> {
    const pubsub = yield* Component.useOnMount(() => Effect.acquireRelease(PubSub.unbounded<A>(), PubSub.shutdown))
--- a/packages/effect-fc/src/Query.ts
+++ b/packages/effect-fc/src/Query.ts
@@ -266,8 +266,10 @@ extends Pipeable.Class() implements Query<K, A, KE, KR, E, R, P> {
    }
 }

+
 export const isQuery = (u: unknown): u is Query<readonly unknown[], unknown> => Predicate.hasProperty(u, QueryTypeId)

+
 export declare namespace make {
    export interface Options<K extends Query.AnyKey, A, KE = never, KR = never, E = never, R = never, P = never> {
        readonly key: Stream.Stream<K, KE, KR>
--- a/packages/effect-fc/src/Result.ts
+++ b/packages/effect-fc/src/Result.ts
@@ -1,4 +1,4 @@
-import { Cause, Context, Data, Effect, Equal, Exit, type Fiber, Hash, Layer, Match, pipe, Pipeable, Predicate, PubSub, Ref, type Scope, Stream, type Subscribable, SynchronizedRef } from "effect"
+import { Cause, Context, Data, Effect, Equal, Exit, type Fiber, Hash, Layer, Match, Pipeable, Predicate, PubSub, pipe, Ref, type Scope, Stream, type Subscribable, SynchronizedRef } from "effect"
 import { Lens } from "effect-lens"


--- a/packages/effect-fc/src/Stream.ts
+++ b/packages/effect-fc/src/Stream.ts
@@ -3,7 +3,7 @@ import * as React from "react"
 import * as Component from "./Component.js"


-export const useStream: {
+export const use: {
    <A, E, R>(
        stream: Stream.Stream<A, E, R>
    ): Effect.Effect<Option.Option<A>, never, R>
--- a/packages/effect-fc/src/SubmittableForm.ts
+++ b/packages/effect-fc/src/SubmittableForm.ts
@@ -0,0 +1,196 @@
+import { Array, Cause, Chunk, type Context, Effect, Exit, Fiber, identity, Option, ParseResult, Pipeable, Predicate, Schema, type Scope, Stream, SubscriptionRef } from "effect"
+import * as Form from "./Form.js"
+import * as Lens from "./Lens.js"
+import * as Mutation from "./Mutation.js"
+import * as Result from "./Result.js"
+import * as Subscribable from "./Subscribable.js"
+
+
+export const SubmittableFormTypeId: unique symbol = Symbol.for("@effect-fc/Form/SubmittableForm")
+export type SubmittableFormTypeId = typeof SubmittableFormTypeId
+
+export interface SubmittableForm<in out A, in out I = A, in out R = never, in out MA = void, in out ME = never, in out MR = never, in out MP = never>
+extends Form.Form<readonly [], A, I, never, never> {
+    readonly [SubmittableFormTypeId]: SubmittableFormTypeId
+
+    readonly schema: Schema.Schema<A, I, R>
+    readonly context: Context.Context<Scope.Scope | R>
+    readonly mutation: Mutation.Mutation<
+        readonly [value: A, form: SubmittableForm<A, I, R, unknown, unknown, unknown>],
+        MA, ME, MR, MP
+    >
+    readonly validationFiber: Subscribable.Subscribable<Option.Option<Fiber.Fiber<A, ParseResult.ParseError>>, never, never>
+
+    readonly run: Effect.Effect<void>
+    readonly submit: Effect.Effect<Option.Option<Result.Final<MA, ME, MP>>, Cause.NoSuchElementException>
+}
+
+export class SubmittableFormImpl<in out A, in out I = A, in out R = never, in out MA = void, in out ME = never, in out MR = never, in out MP = never>
+extends Pipeable.Class() implements SubmittableForm<A, I, R, MA, ME, MR, MP> {
+    readonly [Form.FormTypeId]: Form.FormTypeId = Form.FormTypeId
+    readonly [SubmittableFormTypeId]: SubmittableFormTypeId = SubmittableFormTypeId
+
+    readonly path = [] as const
+
+    constructor(
+        readonly schema: Schema.Schema<A, I, R>,
+        readonly context: Context.Context<Scope.Scope | R>,
+        readonly mutation: Mutation.Mutation<
+            readonly [value: A, form: SubmittableForm<A, I, R, unknown, unknown, unknown>],
+            MA, ME, MR, MP
+        >,
+        readonly value: Lens.Lens<Option.Option<A>, never, never, never, never>,
+        readonly encodedValue: Lens.Lens<I, never, never, never, never>,
+        readonly issues: Lens.Lens<readonly ParseResult.ArrayFormatterIssue[], never, never, never, never>,
+        readonly validationFiber: Lens.Lens<Option.Option<Fiber.Fiber<A, ParseResult.ParseError>>, never, never, never, never>,
+        readonly isValidating: Subscribable.Subscribable<boolean, never, never>,
+
+        readonly canCommit: Subscribable.Subscribable<boolean, never, never>,
+        readonly isCommitting: Subscribable.Subscribable<boolean, never, never>,
+
+        readonly runSemaphore: Effect.Semaphore,
+    ) {
+        super()
+    }
+
+    get run(): Effect.Effect<void> {
+        return this.runSemaphore.withPermits(1)(Effect.provide(
+            Stream.runForEach(
+                this.encodedValue.changes,
+
+                encodedValue => Lens.get(this.validationFiber).pipe(
+                    Effect.andThen(Option.match({
+                        onSome: Fiber.interrupt,
+                        onNone: () => Effect.void,
+                    })),
+                    Effect.andThen(
+                        Effect.forkScoped(Effect.onExit(
+                            Schema.decode(this.schema, { errors: "all" })(encodedValue),
+                            exit => Effect.andThen(
+                                Exit.matchEffect(exit, {
+                                    onSuccess: v => Effect.andThen(
+                                        Lens.set(this.value, Option.some(v)),
+                                        Lens.set(this.issues, Array.empty()),
+                                    ),
+                                    onFailure: c => Option.match(Chunk.findFirst(Cause.failures(c), e => e._tag === "ParseError"), {
+                                        onSome: e => Effect.flatMap(
+                                            ParseResult.ArrayFormatter.formatError(e),
+                                            v => Lens.set(this.issues, v),
+                                        ),
+                                        onNone: () => Effect.void,
+                                    }),
+                                }),
+                                Lens.set(this.validationFiber, Option.none()),
+                            ),
+                        ))
+                    ),
+                    Effect.tap(fiber => Lens.set(this.validationFiber, Option.some(fiber))),
+                    Effect.andThen(Fiber.join),
+                    Effect.ignore,
+                ),
+            ),
+
+            this.context,
+        ))
+    }
+
+    get submit(): Effect.Effect<Option.Option<Result.Final<MA, ME, MP>>, Cause.NoSuchElementException> {
+        return Lens.get(this.value).pipe(
+            Effect.andThen(identity),
+            Effect.andThen(value => this.submitValue(value)),
+        )
+    }
+
+    submitValue(value: A): Effect.Effect<Option.Option<Result.Final<MA, ME, MP>>> {
+        return Effect.whenEffect(
+            Effect.tap(
+                this.mutation.mutate([value, this as any]),
+                result => Result.isFailure(result)
+                    ? Option.match(
+                        Chunk.findFirst(
+                            Cause.failures(result.cause as Cause.Cause<ParseResult.ParseError>),
+                            e => e._tag === "ParseError",
+                        ),
+                        {
+                            onSome: e => Effect.flatMap(
+                                ParseResult.ArrayFormatter.formatError(e),
+                                v => Lens.set(this.issues, v),
+                            ),
+                            onNone: () => Effect.void,
+                        },
+                    )
+                    : Effect.void
+            ),
+            this.canCommit.get,
+        )
+    }
+}
+
+
+export const isSubmittableForm = (u: unknown): u is SubmittableForm<unknown, unknown, unknown, unknown, unknown, unknown, unknown> => Predicate.hasProperty(u, SubmittableFormTypeId)
+
+
+export declare namespace make {
+    export interface Options<in out A, in out I = A, in out R = never, in out MA = void, in out ME = never, in out MR = never, in out MP = never>
+    extends Mutation.make.Options<
+        readonly [value: NoInfer<A>, form: SubmittableForm<NoInfer<A>, NoInfer<I>, NoInfer<R>, unknown, unknown, unknown>],
+        MA, ME, MR, MP
+    > {
+        readonly schema: Schema.Schema<A, I, R>
+        readonly initialEncodedValue: NoInfer<I>
+    }
+}
+
+export const make = Effect.fnUntraced(function* <A, I = A, R = never, MA = void, ME = never, MR = never, MP = never>(
+    options: make.Options<A, I, R, MA, ME, MR, MP>
+): Effect.fn.Return<
+    SubmittableForm<A, I, R, MA, ME, Result.forkEffect.OutputContext<MR, MP>, MP>,
+    never,
+    Scope.Scope | R | Result.forkEffect.OutputContext<MR, MP>
+> {
+    const mutation = yield* Mutation.make(options)
+    const valueLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<A>()))
+    const issuesLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make<readonly ParseResult.ArrayFormatterIssue[]>(Array.empty()))
+    const validationFiberLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<Fiber.Fiber<A, ParseResult.ParseError>>()))
+
+    return new SubmittableFormImpl(
+        options.schema,
+        yield* Effect.context<Scope.Scope | R>(),
+        mutation,
+
+        valueLens,
+        Lens.fromSubscriptionRef(yield* SubscriptionRef.make(options.initialEncodedValue)),
+        issuesLens,
+        validationFiberLens,
+        Subscribable.map(validationFiberLens, Option.isSome),
+
+        Subscribable.map(
+            Subscribable.zipLatestAll(valueLens, issuesLens, validationFiberLens, mutation.result),
+            ([value, issues, validationFiber, result]) => (
+                Option.isSome(value) &&
+                Array.isEmptyReadonlyArray(issues) &&
+                Option.isNone(validationFiber) &&
+                !(Result.isRunning(result) || Result.hasRefreshingFlag(result))
+            ),
+        ),
+        Subscribable.map(mutation.result, result => Result.isRunning(result) || Result.hasRefreshingFlag(result)),
+
+        yield* Effect.makeSemaphore(1),
+    )
+})
+
+export declare namespace service {
+    export interface Options<in out A, in out I = A, in out R = never, in out MA = void, in out ME = never, in out MR = never, in out MP = never>
+    extends make.Options<A, I, R, MA, ME, MR, MP> {}
+}
+
+export const service = <A, I = A, R = never, MA = void, ME = never, MR = never, MP = never>(
+    options: service.Options<A, I, R, MA, ME, MR, MP>
+): Effect.Effect<
+    SubmittableForm<A, I, R, MA, ME, Result.forkEffect.OutputContext<MR, MP>, MP>,
+    never,
+    Scope.Scope | R | Result.forkEffect.OutputContext<MR, MP>
+> => Effect.tap(
+    make(options),
+    form => Effect.forkScoped(form.run),
+)
--- a/packages/effect-fc/src/Subscribable.ts
+++ b/packages/effect-fc/src/Subscribable.ts
@@ -19,7 +19,7 @@ export const zipLatestAll = <const T extends readonly Subscribable.Subscribable<
    changes: Stream.zipLatestAll(...elements.map(v => v.changes)),
 }) as any

-export declare namespace useSubscribables {
+export declare namespace useAll {
    export type Success<T extends readonly Subscribable.Subscribable<any, any, any>[]> = [T[number]] extends [never]
        ? never
        : { [K in keyof T]: T[K] extends Subscribable.Subscribable<infer A, infer _E, infer _R> ? A : never }
@@ -29,11 +29,11 @@ export declare namespace useSubscribables {
    }
 }

-export const useSubscribables = Effect.fnUntraced(function* <const T extends readonly Subscribable.Subscribable<any, any, any>[]>(
+export const useAll = Effect.fnUntraced(function* <const T extends readonly Subscribable.Subscribable<any, any, any>[]>(
    elements: T,
-    options?: useSubscribables.Options<useSubscribables.Success<NoInfer<T>>>,
+    options?: useAll.Options<useAll.Success<NoInfer<T>>>,
 ): Effect.fn.Return<
-    useSubscribables.Success<T>,
+    useAll.Success<T>,
    [T[number]] extends [never] ? never : T[number] extends Subscribable.Subscribable<infer _A, infer E, infer _R> ? E : never,
    [T[number]] extends [never] ? never : T[number] extends Subscribable.Subscribable<infer _A, infer _E, infer R> ? R : never
 > {
--- a/packages/effect-fc/src/SubscriptionRef.ts
+++ b/packages/effect-fc/src/SubscriptionRef.ts
@@ -1,61 +0,0 @@
-import { Effect, Equivalence, Ref, Stream, SubscriptionRef } from "effect"
-import * as React from "react"
-import * as Component from "./Component.js"
-import * as SetStateAction from "./SetStateAction.js"
-
-
-export declare namespace useSubscriptionRefState {
-    export interface Options<A> {
-        readonly equivalence?: Equivalence.Equivalence<A>
-    }
-}
-
-export const useSubscriptionRefState = Effect.fnUntraced(function* <A>(
-    ref: SubscriptionRef.SubscriptionRef<A>,
-    options?: useSubscriptionRefState.Options<NoInfer<A>>,
-): Effect.fn.Return<readonly [A, React.Dispatch<React.SetStateAction<A>>]> {
-    const [reactStateValue, setReactStateValue] = React.useState(yield* Component.useOnMount(() => ref))
-
-    yield* Component.useReactEffect(() => Effect.forkScoped(
-        Stream.runForEach(
-            Stream.changesWith(ref.changes, options?.equivalence ?? Equivalence.strict()),
-            v => Effect.sync(() => setReactStateValue(v)),
-        )
-    ), [ref])
-
-    const setValue = yield* Component.useCallbackSync(
-        (setStateAction: React.SetStateAction<A>) => Effect.andThen(
-            Ref.updateAndGet(ref, prevState => SetStateAction.value(setStateAction, prevState)),
-            v => setReactStateValue(v),
-        ),
-        [ref],
-    )
-
-    return [reactStateValue, setValue]
-})
-
-export declare namespace useSubscriptionRefFromState {
-    export interface Options<A> {
-        readonly equivalence?: Equivalence.Equivalence<A>
-    }
-}
-
-export const useSubscriptionRefFromState = Effect.fnUntraced(function* <A>(
-    [value, setValue]: readonly [A, React.Dispatch<React.SetStateAction<A>>],
-    options?: useSubscriptionRefFromState.Options<NoInfer<A>>,
-): Effect.fn.Return<SubscriptionRef.SubscriptionRef<A>> {
-    const ref = yield* Component.useOnChange(() => Effect.tap(
-        SubscriptionRef.make(value),
-        ref => Effect.forkScoped(
-            Stream.runForEach(
-                Stream.changesWith(ref.changes, options?.equivalence ?? Equivalence.strict()),
-                v => Effect.sync(() => setValue(v)),
-            )
-        ),
-    ), [setValue])
-
-    yield* Component.useReactEffect(() => Ref.set(ref, value), [value])
-    return ref
-})
-
-export * from "effect/SubscriptionRef"
--- a/packages/effect-fc/src/SubscriptionSubRef.test.ts
+++ b/packages/effect-fc/src/SubscriptionSubRef.test.ts
@@ -1,183 +0,0 @@
-import { describe, expect, test } from "bun:test"
-import { Chunk, Effect, Ref, SubscriptionRef } from "effect"
-import * as SubscriptionSubRef from "./SubscriptionSubRef.js"
-
-
-describe("SubscriptionSubRef with array refs", () => {
-    test("creates a subref for a single array element using path", async () => {
-        const value = await Effect.runPromise(
-            Effect.flatMap(
-                SubscriptionRef.make([{ name: "alice" }, { name: "bob" }, { name: "charlie" }]),
-                parent => {
-                    const subref = SubscriptionSubRef.makeFromPath(parent, [1, "name"])
-                    return subref.get
-                },
-            ),
-        )
-
-        expect(value).toBe("bob")
-    })
-
-    test("modifies a single array element via subref", async () => {
-        const result = await Effect.runPromise(
-            Effect.flatMap(
-                SubscriptionRef.make([{ name: "alice" }, { name: "bob" }, { name: "charlie" }]),
-                parent => {
-                    const subref = SubscriptionSubRef.makeFromPath(parent, [1, "name"])
-                    return Effect.flatMap(
-                        Ref.set(subref, "bob-updated"),
-                        () => Ref.get(parent),
-                    )
-                },
-            ),
-        )
-
-        expect(result).toEqual([{ name: "alice" }, { name: "bob-updated" }, { name: "charlie" }])
-    })
-
-    test("modifies array element at index 0", async () => {
-        const result = await Effect.runPromise(
-            Effect.flatMap(
-                SubscriptionRef.make([10, 20, 30]),
-                parent => {
-                    const subref = SubscriptionSubRef.makeFromPath(parent, [0])
-                    return Effect.flatMap(
-                        Ref.set(subref, 99),
-                        () => Ref.get(parent),
-                    )
-                },
-            ),
-        )
-
-        expect(result).toEqual([99, 20, 30])
-    })
-
-    test("modifies array element at last index", async () => {
-        const result = await Effect.runPromise(
-            Effect.flatMap(
-                SubscriptionRef.make(["a", "b", "c"]),
-                parent => {
-                    const subref = SubscriptionSubRef.makeFromPath(parent, [2])
-                    return Effect.flatMap(
-                        Ref.set(subref, "z"),
-                        () => Ref.get(parent),
-                    )
-                },
-            ),
-        )
-
-        expect(result).toEqual(["a", "b", "z"])
-    })
-
-    test("modifies nested array element", async () => {
-        const result = await Effect.runPromise(
-            Effect.flatMap(
-                SubscriptionRef.make([[1, 2], [3, 4], [5, 6]]),
-                parent => {
-                    const subref = SubscriptionSubRef.makeFromPath(parent, [1, 0])
-                    return Effect.flatMap(
-                        Ref.set(subref, 99),
-                        () => Ref.get(parent),
-                    )
-                },
-            ),
-        )
-
-        expect(result).toEqual([[1, 2], [99, 4], [5, 6]])
-    })
-
-    test("uses modifyEffect to transform array element", async () => {
-        const result = await Effect.runPromise(
-            Effect.flatMap(
-                SubscriptionRef.make([{ count: 1 }, { count: 2 }, { count: 3 }]),
-                parent => {
-                    const subref = SubscriptionSubRef.makeFromPath(parent, [1, "count"])
-                    return Effect.flatMap(
-                        Ref.update(subref, count => count + 100),
-                        () => Effect.map(Ref.get(parent), parentValue => ({ result: 102, parentValue })),
-                    )
-                },
-            ),
-        )
-
-        expect(result.result).toBe(102) // count + 100
-        expect(result.parentValue).toEqual([{ count: 1 }, { count: 102 }, { count: 3 }]) // count + 100
-    })
-
-    test("uses modify to transform array element", async () => {
-        const result = await Effect.runPromise(
-            Effect.flatMap(
-                SubscriptionRef.make([10, 20, 30]),
-                parent => {
-                    const subref = SubscriptionSubRef.makeFromPath(parent, [1])
-                    return Effect.flatMap(
-                        Ref.update(subref, x => x + 5),
-                        () => Effect.map(Ref.get(parent), parentValue => ({ result: 25, parentValue })),
-                    )
-                },
-            ),
-        )
-
-        expect(result.result).toBe(25) // 20 + 5
-        expect(result.parentValue).toEqual([10, 25, 30]) // 20 + 5
-    })
-
-    test("makeFromChunkIndex modifies chunk element", async () => {
-        const result = await Effect.runPromise(
-            Effect.flatMap(
-                SubscriptionRef.make(Chunk.make(100, 200, 300)),
-                parent => {
-                    const subref = SubscriptionSubRef.makeFromChunkIndex(parent, 1)
-                    return Effect.flatMap(
-                        Ref.set(subref, 999),
-                        () => Ref.get(parent),
-                    )
-                },
-            ),
-        )
-
-        expect(Chunk.toReadonlyArray(result)).toEqual([100, 999, 300])
-    })
-
-    test("makeFromGetSet with custom getter/setter for array element", async () => {
-        const result = await Effect.runPromise(
-            Effect.flatMap(
-                SubscriptionRef.make([{ id: 1, value: "a" }, { id: 2, value: "b" }]),
-                parent => {
-                    const subref = SubscriptionSubRef.makeFromGetSet(parent, {
-                        get: arr => arr[0].value,
-                        set: (arr, newValue) => [
-                            { ...arr[0], value: newValue },
-                            ...arr.slice(1),
-                        ],
-                    })
-                    return Effect.flatMap(
-                        Ref.set(subref, "updated"),
-                        () => Ref.get(parent),
-                    )
-                },
-            ),
-        )
-
-        expect(result).toEqual([{ id: 1, value: "updated" }, { id: 2, value: "b" }])
-    })
-
-    test("does not mutate original array when modifying via subref", async () => {
-        const original = [{ name: "alice" }, { name: "bob" }]
-        const result = await Effect.runPromise(
-            Effect.flatMap(
-                SubscriptionRef.make(original),
-                parent => {
-                    const subref = SubscriptionSubRef.makeFromPath(parent, [0, "name"])
-                    return Effect.flatMap(
-                        Ref.set(subref, "alice-updated"),
-                        () => Ref.get(parent),
-                    )
-                },
-            ),
-        )
-
-        expect(original).toEqual([{ name: "alice" }, { name: "bob" }]) // original unchanged
-        expect(result).toEqual([{ name: "alice-updated" }, { name: "bob" }]) // new value in ref
-    })
-})
--- a/packages/effect-fc/src/SubscriptionSubRef.ts
+++ b/packages/effect-fc/src/SubscriptionSubRef.ts
@@ -1,186 +0,0 @@
-import { Chunk, Effect, Effectable, Option, Predicate, Readable, Ref, Stream, Subscribable, SubscriptionRef, SynchronizedRef, type Types, type Unify } from "effect"
-import * as PropertyPath from "./PropertyPath.js"
-
-
-export const SubscriptionSubRefTypeId: unique symbol = Symbol.for("@effect-fc/SubscriptionSubRef/SubscriptionSubRef")
-export type SubscriptionSubRefTypeId = typeof SubscriptionSubRefTypeId
-
-export interface SubscriptionSubRef<in out A, in out B extends SubscriptionRef.SubscriptionRef<any>>
-extends SubscriptionSubRef.Variance<A, B>, SubscriptionRef.SubscriptionRef<A> {
-    readonly parent: B
-
-    readonly [Unify.typeSymbol]?: unknown
-    readonly [Unify.unifySymbol]?: SubscriptionSubRefUnify<this>
-    readonly [Unify.ignoreSymbol]?: SubscriptionSubRefUnifyIgnore
-}
-
-export declare namespace SubscriptionSubRef {
-    export interface Variance<in out A, in out B> {
-        readonly [SubscriptionSubRefTypeId]: {
-            readonly _A: Types.Invariant<A>
-            readonly _B: Types.Invariant<B>
-        }
-    }
-}
-
-export interface SubscriptionSubRefUnify<A extends { [Unify.typeSymbol]?: any }> extends SubscriptionRef.SubscriptionRefUnify<A> {
-    SubscriptionSubRef?: () => Extract<A[Unify.typeSymbol], SubscriptionSubRef<any, any>>
-}
-
-export interface SubscriptionSubRefUnifyIgnore extends SubscriptionRef.SubscriptionRefUnifyIgnore {
-    SubscriptionRef?: true
-}
-
-
-const refVariance = { _A: (_: any) => _ }
-const synchronizedRefVariance = { _A: (_: any) => _ }
-const subscriptionRefVariance = { _A: (_: any) => _ }
-const subscriptionSubRefVariance = { _A: (_: any) => _, _B: (_: any) => _ }
-
-class SubscriptionSubRefImpl<in out A, in out B extends SubscriptionRef.SubscriptionRef<any>>
-extends Effectable.Class<A> implements SubscriptionSubRef<A, B> {
-    readonly [Readable.TypeId]: Readable.TypeId = Readable.TypeId
-    readonly [Subscribable.TypeId]: Subscribable.TypeId = Subscribable.TypeId
-    readonly [Ref.RefTypeId] = refVariance
-    readonly [SynchronizedRef.SynchronizedRefTypeId] = synchronizedRefVariance
-    readonly [SubscriptionRef.SubscriptionRefTypeId] = subscriptionRefVariance
-    readonly [SubscriptionSubRefTypeId] = subscriptionSubRefVariance
-
-    readonly get: Effect.Effect<A>
-
-    constructor(
-        readonly parent: B,
-        readonly getter: (parentValue: Effect.Effect.Success<B>) => A,
-        readonly setter: (parentValue: Effect.Effect.Success<B>, value: A) => Effect.Effect.Success<B>,
-    ) {
-        super()
-        this.get = Effect.map(this.parent, this.getter)
-    }
-
-    commit() {
-        return this.get
-    }
-
-    get changes(): Stream.Stream<A> {
-        return Stream.unwrap(
-            Effect.map(this.get, a => Stream.concat(
-                Stream.make(a),
-                Stream.map(this.parent.changes, this.getter),
-            ))
-        )
-    }
-
-    modify<C>(f: (a: A) => readonly [C, A]): Effect.Effect<C> {
-        return this.modifyEffect(a => Effect.succeed(f(a)))
-    }
-
-    modifyEffect<C, E, R>(f: (a: A) => Effect.Effect<readonly [C, A], E, R>): Effect.Effect<C, E, R> {
-        return Effect.Do.pipe(
-            Effect.bind("b", (): Effect.Effect<Effect.Effect.Success<B>> => this.parent),
-            Effect.bind("ca", ({ b }) => f(this.getter(b))),
-            Effect.tap(({ b, ca: [, a] }) => SubscriptionRef.set(this.parent, this.setter(b, a))),
-            Effect.map(({ ca: [c] }) => c),
-        )
-    }
-}
-
-
-export const isSubscriptionSubRef = (u: unknown): u is SubscriptionSubRef<unknown, SubscriptionRef.SubscriptionRef<unknown>> => Predicate.hasProperty(u, SubscriptionSubRefTypeId)
-
-export const makeFromGetSet = <A, B extends SubscriptionRef.SubscriptionRef<any>>(
-    parent: B,
-    options: {
-        readonly get: (parentValue: Effect.Effect.Success<B>) => A
-        readonly set: (parentValue: Effect.Effect.Success<B>, value: A) => Effect.Effect.Success<B>
-    },
-): SubscriptionSubRef<A, B> => new SubscriptionSubRefImpl(parent, options.get, options.set)
-
-export const makeFromPath = <
-    B extends SubscriptionRef.SubscriptionRef<any>,
-    const P extends PropertyPath.Paths<Effect.Effect.Success<B>>,
->(
-    parent: B,
-    path: P,
-): SubscriptionSubRef<PropertyPath.ValueFromPath<Effect.Effect.Success<B>, P>, B> => new SubscriptionSubRefImpl(
-    parent,
-    parentValue => Option.getOrThrow(PropertyPath.get(parentValue, path)),
-    (parentValue, value) => Option.getOrThrow(PropertyPath.immutableSet(parentValue, path, value)),
-)
-
-export const makeFromChunkIndex: {
-    <B extends SubscriptionRef.SubscriptionRef<Chunk.NonEmptyChunk<any>>>(
-        parent: B,
-        index: number,
-    ): SubscriptionSubRef<
-        Effect.Effect.Success<B> extends Chunk.NonEmptyChunk<infer A> ? A : never,
-        B
-    >
-    <B extends SubscriptionRef.SubscriptionRef<Chunk.Chunk<any>>>(
-        parent: B,
-        index: number,
-    ): SubscriptionSubRef<
-        Effect.Effect.Success<B> extends Chunk.Chunk<infer A> ? A : never,
-        B
-    >
-} = (
-    parent: SubscriptionRef.SubscriptionRef<Chunk.Chunk<any>>,
-    index: number,
-) => new SubscriptionSubRefImpl(
-    parent,
-    parentValue => Chunk.unsafeGet(parentValue, index),
-    (parentValue, value) => Chunk.replace(parentValue, index, value),
-) as any
-
-export const makeFromChunkFindFirst: {
-    <B extends SubscriptionRef.SubscriptionRef<Chunk.NonEmptyChunk<any>>>(
-        parent: B,
-        findFirstPredicate: Predicate.Predicate<Effect.Effect.Success<B> extends Chunk.NonEmptyChunk<infer A> ? A : never>,
-    ): SubscriptionSubRef<
-        Effect.Effect.Success<B> extends Chunk.NonEmptyChunk<infer A> ? A : never,
-        B
-    >
-    <B extends SubscriptionRef.SubscriptionRef<Chunk.Chunk<any>>>(
-        parent: B,
-        findFirstPredicate: Predicate.Predicate<Effect.Effect.Success<B> extends Chunk.Chunk<infer A> ? A : never>,
-    ): SubscriptionSubRef<
-        Effect.Effect.Success<B> extends Chunk.Chunk<infer A> ? A : never,
-        B
-    >
-} = (
-    parent: SubscriptionRef.SubscriptionRef<Chunk.Chunk<never>>,
-    findFirstPredicate: Predicate.Predicate.Any,
-) => new SubscriptionSubRefImpl(
-    parent,
-    parentValue => Option.getOrThrow(Chunk.findFirst(parentValue, findFirstPredicate)),
-    (parentValue, value) => Option.getOrThrow(Option.andThen(
-        Chunk.findFirstIndex(parentValue, findFirstPredicate),
-        index => Chunk.replace(parentValue, index, value),
-    )),
-) as any
-
-export const makeFromChunkFindLast: {
-    <B extends SubscriptionRef.SubscriptionRef<Chunk.NonEmptyChunk<any>>>(
-        parent: B,
-        findLastPredicate: Predicate.Predicate<Effect.Effect.Success<B> extends Chunk.NonEmptyChunk<infer A> ? A : never>,
-    ): SubscriptionSubRef<
-        Effect.Effect.Success<B> extends Chunk.NonEmptyChunk<infer A> ? A : never,
-        B
-    >
-    <B extends SubscriptionRef.SubscriptionRef<Chunk.Chunk<any>>>(
-        parent: B,
-        findLastPredicate: Predicate.Predicate<Effect.Effect.Success<B> extends Chunk.Chunk<infer A> ? A : never>,
-    ): SubscriptionSubRef<
-        Effect.Effect.Success<B> extends Chunk.Chunk<infer A> ? A : never,
-        B
-    >
-} = (
-    parent: SubscriptionRef.SubscriptionRef<Chunk.Chunk<never>>,
-    findLastPredicate: Predicate.Predicate.Any,
-) => new SubscriptionSubRefImpl(
-    parent,
-    parentValue => Option.getOrThrow(Chunk.findLast(parentValue, findLastPredicate)),
-    (parentValue, value) => Option.getOrThrow(Option.andThen(
-        Chunk.findLastIndex(parentValue, findLastPredicate),
-        index => Chunk.replace(parentValue, index, value),
-    )),
-) as any
--- a/packages/effect-fc/src/SynchronizedForm.ts
+++ b/packages/effect-fc/src/SynchronizedForm.ts
@@ -0,0 +1,239 @@
+import { Array, Cause, Chunk, type Context, Effect, Exit, Fiber, Option, ParseResult, Pipeable, Predicate, Schema, type Scope, SubscriptionRef } from "effect"
+import * as Form from "./Form.js"
+import * as Lens from "./Lens.js"
+import * as Subscribable from "./Subscribable.js"
+
+
+export const SynchronizedFormTypeId: unique symbol = Symbol.for("@effect-fc/Form/SynchronizedForm")
+export type SynchronizedFormTypeId = typeof SynchronizedFormTypeId
+
+export interface SynchronizedForm<
+    in out A,
+    in out I = A,
+    in out R = never,
+    in out TER = never,
+    in out TEW = never,
+    in out TRR = never,
+    in out TRW = never,
+> extends Form.Form<readonly [], A, I, never, never> {
+    readonly [SynchronizedFormTypeId]: SynchronizedFormTypeId
+
+    readonly schema: Schema.Schema<A, I, R>
+    readonly context: Context.Context<Scope.Scope | R | TRR | TRW>
+    readonly target: Lens.Lens<A, TER, TEW, TRR, TRW>
+    readonly validationFiber: Subscribable.Subscribable<Option.Option<Fiber.Fiber<A, ParseResult.ParseError>>, never, never>
+
+    readonly run: Effect.Effect<void, TER>
+}
+
+export class SynchronizedFormImpl<
+    in out A,
+    in out I = A,
+    in out R = never,
+    in out TER = never,
+    in out TEW = never,
+    in out TRR = never,
+    in out TRW = never,
+> extends Pipeable.Class() implements SynchronizedForm<A, I, R, TER, TEW, TRR, TRW> {
+    readonly [Form.FormTypeId]: Form.FormTypeId = Form.FormTypeId
+    readonly [SynchronizedFormTypeId]: SynchronizedFormTypeId = SynchronizedFormTypeId
+
+    readonly path = [] as const
+    readonly encodedValue: Lens.Lens<I, never, never, never, never>
+
+    constructor(
+        readonly schema: Schema.Schema<A, I, R>,
+        readonly context: Context.Context<Scope.Scope | R | TRR | TRW>,
+        readonly target: Lens.Lens<A, TER, TEW, TRR, TRW>,
+
+        readonly value: Lens.Lens<Option.Option<A>, never, never, never, never>,
+        readonly internalEncodedValue: Lens.Lens<I, never, never, never, never>,
+        readonly issues: Lens.Lens<readonly ParseResult.ArrayFormatterIssue[], never, never, never, never>,
+        readonly validationFiber: Lens.Lens<Option.Option<Fiber.Fiber<A, ParseResult.ParseError>>, never, never, never, never>,
+        readonly isValidating: Subscribable.Subscribable<boolean, never, never>,
+
+        readonly canCommit: Subscribable.Subscribable<boolean, never, never>,
+        readonly isCommitting: Lens.Lens<boolean, never, never>,
+
+        readonly runSemaphore: Effect.Semaphore,
+    ) {
+        super()
+        this.encodedValue = makeEncodedValueLens(this)
+    }
+
+    synchronizeEncodedValue(encodedValue: I): Effect.Effect<void, never, never> {
+        return Lens.get(this.validationFiber).pipe(
+            Effect.andThen(Option.match({
+                onSome: Fiber.interrupt,
+                onNone: () => Effect.void,
+            })),
+            Effect.andThen(
+                Effect.forkScoped(Effect.onExit(
+                    Schema.decode(this.schema, { errors: "all" })(encodedValue),
+                    exit => Effect.andThen(
+                        Exit.matchEffect(exit, {
+                            onSuccess: v => Effect.andThen(
+                                Lens.set(this.value, Option.some(v)),
+                                Lens.set(this.issues, Array.empty()),
+                            ),
+                            onFailure: c => Option.match(
+                                Chunk.findFirst(Cause.failures(c), e => e._tag === "ParseError"),
+                                {
+                                    onSome: e => Effect.flatMap(
+                                        ParseResult.ArrayFormatter.formatError(e),
+                                        v => Lens.set(this.issues, v),
+                                    ),
+                                    onNone: () => Effect.void,
+                                },
+                            ),
+                        }),
+                        Lens.set(this.validationFiber, Option.none()),
+                    ),
+                ))
+            ),
+            Effect.tap(fiber => Lens.set(this.validationFiber, Option.some(fiber))),
+            Effect.andThen(Fiber.join),
+            Effect.tap(value => Effect.onExit(
+                Effect.andThen(
+                    Lens.set(this.isCommitting, true),
+                    Lens.set(this.target, value),
+                ),
+                () => Lens.set(this.isCommitting, false),
+            )),
+
+            Effect.ignore,
+            Effect.provide(this.context),
+        )
+    }
+
+    get run(): Effect.Effect<void, TER> {
+        return Effect.void
+        // return this.runSemaphore.withPermits(1)(Effect.provide(
+        //     Effect.andThen(
+        //         Effect.flatMap(
+        //             Lens.get(this.internalEncodedValue),
+        //             encodedValue => this.synchronizeEncodedValue(encodedValue),
+        //         ),
+        //         Stream.runForEach(
+        //             Stream.drop(this.target.changes, 1),
+
+        //             targetValue => Schema.encode(this.schema, { errors: "all" })(targetValue).pipe(
+        //                 Effect.flatMap(encodedValue => Effect.andThen(
+        //                     Effect.whenEffect(
+        //                         Lens.set(this.internalEncodedValue, encodedValue),
+        //                         Effect.map(
+        //                             Lens.get(this.internalEncodedValue),
+        //                             currentEncodedValue => !Equal.equals(encodedValue, currentEncodedValue),
+        //                         ),
+        //                     ),
+        //                     Effect.andThen(
+        //                         Lens.set(this.value, Option.some(targetValue)),
+        //                         Lens.set(this.issues, Array.empty()),
+        //                     ),
+        //                 )),
+        //                 Effect.ignore,
+        //             ),
+        //         ),
+        //     ),
+
+        //     this.context,
+        // ))
+    }
+}
+
+const makeEncodedValueLens = <A, I, R, TER, TEW, TRR, TRW>(
+    self: SynchronizedFormImpl<A, I, R, TER, TEW, TRR, TRW>
+): Lens.Lens<I, never, never, never, never> => Lens.make({
+    get get() { return self.internalEncodedValue.get },
+    get changes() { return self.internalEncodedValue.changes },
+    modify: f => self.internalEncodedValue.modify(
+        encodedValue => Effect.map(
+            f(encodedValue),
+            ([b, nextEncodedValue]) => [
+                [b, nextEncodedValue] as const,
+                nextEncodedValue,
+            ] as const
+        )
+    ).pipe(
+        Effect.tap(([, nextEncodedValue]) =>
+            self.synchronizeEncodedValue(nextEncodedValue).pipe(
+                Effect.forkScoped,
+                Effect.provide(self.context),
+            )
+        ),
+        Effect.map(([b]) => b),
+    ),
+})
+
+
+export const isSynchronizedForm = (u: unknown): u is SynchronizedForm<unknown, unknown, unknown, unknown, unknown, unknown, unknown> => Predicate.hasProperty(u, SynchronizedFormTypeId)
+
+
+export declare namespace make {
+    export interface Options<in out A, in out I = A, in out R = never, in out TER = never, in out TEW = never, in out TRR = never, in out TRW = never> {
+        readonly schema: Schema.Schema<A, I, R>
+        readonly target: Lens.Lens<A, TER, TEW, TRR, TRW>
+        readonly initialEncodedValue?: NoInfer<I>
+    }
+}
+
+export const make = Effect.fnUntraced(function* <A, I = A, R = never, TER = never, TEW = never, TRR = never, TRW = never>(
+    options: make.Options<A, I, R, TER, TEW, TRR, TRW>
+): Effect.fn.Return<
+    SynchronizedForm<A, I, R, TER, TEW, TRR, TRW>,
+    ParseResult.ParseError | TER,
+    Scope.Scope | R | TRR | TRW
+> {
+    const valueLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<A>()))
+    const issuesLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make<readonly ParseResult.ArrayFormatterIssue[]>(Array.empty()))
+    const validationFiberLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(Option.none<Fiber.Fiber<A, ParseResult.ParseError>>()))
+    const isCommittingLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(false))
+
+    const initialEncodedValue = options.initialEncodedValue !== undefined
+        ? options.initialEncodedValue
+        : yield* Effect.flatMap(
+            Lens.get(options.target),
+            Schema.encode(options.schema, { errors: "all" }),
+        )
+
+    return new SynchronizedFormImpl(
+        options.schema,
+        yield* Effect.context<Scope.Scope | R | TRR | TRW>(),
+        options.target,
+
+        valueLens,
+        Lens.fromSubscriptionRef(yield* SubscriptionRef.make(initialEncodedValue)),
+        issuesLens,
+        validationFiberLens,
+        Subscribable.map(validationFiberLens, Option.isSome),
+
+        Subscribable.map(
+            Subscribable.zipLatestAll(valueLens, issuesLens, validationFiberLens, isCommittingLens),
+            ([value, issues, validationFiber, isCommitting]) => (
+                Option.isSome(value) &&
+                Array.isEmptyReadonlyArray(issues) &&
+                Option.isNone(validationFiber) &&
+                !isCommitting
+            ),
+        ),
+        isCommittingLens,
+
+        yield* Effect.makeSemaphore(1),
+    )
+})
+
+export declare namespace service {
+    export interface Options<in out A, in out I = A, in out R = never, in out TER = never, in out TEW = never, in out TRR = never, in out TRW = never>
+    extends make.Options<A, I, R, TER, TEW, TRR, TRW> {}
+}
+
+export const service = <A, I = A, R = never, TER = never, TEW = never, TRR = never, TRW = never>(
+    options: service.Options<A, I, R, TER, TEW, TRR, TRW>
+): Effect.Effect<
+    SynchronizedForm<A, I, R, TER, TEW, TRR, TRW>,
+    ParseResult.ParseError | TER,
+    Scope.Scope | R | TRR | TRW
+> => Effect.tap(
+    make(options),
+    form => Effect.forkScoped(form.run),
+)
--- a/packages/effect-fc/src/index.ts
+++ b/packages/effect-fc/src/index.ts
@@ -5,7 +5,6 @@ export * as Form from "./Form.js"
 export * as Lens from "./Lens.js"
 export * as Memoized from "./Memoized.js"
 export * as Mutation from "./Mutation.js"
-export * as PropertyPath from "./PropertyPath.js"
 export * as PubSub from "./PubSub.js"
 export * as Query from "./Query.js"
 export * as QueryClient from "./QueryClient.js"
@@ -13,6 +12,6 @@ export * as ReactRuntime from "./ReactRuntime.js"
 export * as Result from "./Result.js"
 export * as SetStateAction from "./SetStateAction.js"
 export * as Stream from "./Stream.js"
+export * as SubmittableForm from "./SubmittableForm.js"
 export * as Subscribable from "./Subscribable.js"
-export * as SubscriptionRef from "./SubscriptionRef.js"
-export * as SubscriptionSubRef from "./SubscriptionSubRef.js"
+export * as SynchronizedForm from "./SynchronizedForm.js"
--- a/packages/example/package.json
+++ b/packages/example/package.json
@@ -13,30 +13,30 @@
    "clean:modules": "rm -rf node_modules"
  },
  "devDependencies": {
-    "@tanstack/react-router": "^1.168.3",
-    "@tanstack/react-router-devtools": "^1.166.11",
-    "@tanstack/router-plugin": "^1.167.4",
+    "@tanstack/react-router": "^1.168.26",
+    "@tanstack/react-router-devtools": "^1.166.13",
+    "@tanstack/router-plugin": "^1.167.29",
    "@types/react": "^19.2.14",
    "@types/react-dom": "^19.2.3",
    "@vitejs/plugin-react": "^6.0.1",
-    "globals": "^17.4.0",
-    "react": "^19.2.4",
-    "react-dom": "^19.2.4",
-    "type-fest": "^5.5.0",
-    "vite": "^8.0.2"
+    "globals": "^17.5.0",
+    "react": "^19.2.5",
+    "react-dom": "^19.2.5",
+    "type-fest": "^5.6.0",
+    "vite": "^8.0.10"
  },
  "dependencies": {
-    "@effect/platform": "^0.96.0",
+    "@effect/platform": "^0.96.1",
    "@effect/platform-browser": "^0.76.0",
    "@radix-ui/themes": "^3.3.0",
    "@typed/id": "^0.17.2",
-    "effect": "^3.21.0",
+    "effect": "^3.21.2",
    "effect-fc": "workspace:*",
    "react-icons": "^5.6.0"
  },
  "overrides": {
    "@types/react": "^19.2.14",
-    "effect": "^3.21.0",
-    "react": "^19.2.4"
+    "effect": "^3.21.2",
+    "react": "^19.2.5"
  }
 }
--- a/packages/example/src/lib/form/TextFieldFormInputView.tsx
+++ b/packages/example/src/lib/form/TextFieldFormInputView.tsx
@@ -13,10 +13,10 @@ export class TextFieldFormInputView extends Component.make("TextFieldFormInputVi
    props: TextFieldFormInputView.Props
 ) {
    const input = yield* Form.useInput(props.form, props)
-    const [issues, isValidating, isSubmitting] = yield* Subscribable.useSubscribables([
+    const [issues, isValidating, isCommitting] = yield* Subscribable.useAll([
        props.form.issues,
        props.form.isValidating,
-        props.form.isSubmitting,
+        props.form.isCommitting,
    ])

    return (
@@ -24,7 +24,7 @@ export class TextFieldFormInputView extends Component.make("TextFieldFormInputVi
            <TextField.Root
                value={input.value}
                onChange={e => input.setValue(e.target.value)}
-                disabled={isSubmitting}
+                disabled={isCommitting}
                {...Struct.omit(props, "form")}
            >
                {isValidating &&
--- a/packages/example/src/lib/form/TextFieldOptionalFormInputView.tsx
+++ b/packages/example/src/lib/form/TextFieldOptionalFormInputView.tsx
@@ -13,10 +13,10 @@ export class TextFieldOptionalFormInputView extends Component.make("TextFieldOpt
    props: TextFieldOptionalFormInputView.Props
 ) {
    const input = yield* Form.useOptionalInput(props.form, props)
-    const [issues, isValidating, isSubmitting] = yield* Subscribable.useSubscribables([
+    const [issues, isValidating, isCommitting] = yield* Subscribable.useAll([
        props.form.issues,
        props.form.isValidating,
-        props.form.isSubmitting,
+        props.form.isCommitting,
    ])

    return (
@@ -24,7 +24,7 @@ export class TextFieldOptionalFormInputView extends Component.make("TextFieldOpt
            <TextField.Root
                value={input.value}
                onChange={e => input.setValue(e.target.value)}
-                disabled={!input.enabled || isSubmitting}
+                disabled={!input.enabled || isCommitting}
                {...Struct.omit(props, "form", "defaultValue")}
            >
                <TextField.Slot side="left">
--- a/packages/example/src/routes/form.tsx
+++ b/packages/example/src/routes/form.tsx
@@ -1,11 +1,11 @@
+import { Button, Container, Flex, Text } from "@radix-ui/themes"
+import { createFileRoute } from "@tanstack/react-router"
+import { Console, Effect, Match, Option, ParseResult, Schema } from "effect"
+import { Component, Form, SubmittableForm, Subscribable } from "effect-fc"
 import { TextFieldFormInputView } from "@/lib/form/TextFieldFormInputView"
 import { TextFieldOptionalFormInputView } from "@/lib/form/TextFieldOptionalFormInputView"
 import { DateTimeUtcFromZonedInput } from "@/lib/schema"
 import { runtime } from "@/runtime"
-import { Button, Container, Flex, Text } from "@radix-ui/themes"
-import { createFileRoute } from "@tanstack/react-router"
-import { Console, Effect, Match, Option, ParseResult, Schema } from "effect"
-import { Component, Form, Subscribable } from "effect-fc"


 const email = Schema.pattern<typeof Schema.String>(
@@ -41,7 +41,7 @@ const RegisterFormSubmitSchema = Schema.Struct({

 class RegisterFormService extends Effect.Service<RegisterFormService>()("RegisterFormService", {
    scoped: Effect.gen(function*() {
-        const form = yield* Form.service({
+        const form = yield* SubmittableForm.service({
            schema: RegisterFormSchema.pipe(
                Schema.compose(
                    Schema.transformOrFail(
@@ -64,17 +64,17 @@ class RegisterFormService extends Effect.Service<RegisterFormService>()("Registe

        return {
            form,
-            emailField: Form.focusObjectField(form, "email"),
-            passwordField: Form.focusObjectField(form, "password"),
-            birthField: Form.focusObjectField(form, "birth"),
+            emailField: Form.focusObjectOn(form, "email"),
+            passwordField: Form.focusObjectOn(form, "password"),
+            birthField: Form.focusObjectOn(form, "birth"),
        } as const
    })
 }) {}

 class RegisterFormView extends Component.make("RegisterFormView")(function*() {
    const form = yield* RegisterFormService
-    const [canSubmit, submitResult] = yield* Subscribable.useSubscribables([
-        form.form.canSubmit,
+    const [canCommit, submitResult] = yield* Subscribable.useAll([
+        form.form.canCommit,
        form.form.mutation.result,
    ])

@@ -111,7 +111,7 @@ class RegisterFormView extends Component.make("RegisterFormView")(function*() {
                        defaultValue=""
                    />

-                    <Button disabled={!canSubmit}>Submit</Button>
+                    <Button disabled={!canCommit}>Submit</Button>
                </Flex>
            </form>

--- a/packages/example/src/routes/query.tsx
+++ b/packages/example/src/routes/query.tsx
@@ -1,8 +1,8 @@
 import { HttpClient, type HttpClientError } from "@effect/platform"
 import { Button, Container, Flex, Heading, Slider, Text } from "@radix-ui/themes"
 import { createFileRoute } from "@tanstack/react-router"
-import { Array, Cause, Chunk, Console, Effect, flow, Match, Option, Schema, Stream } from "effect"
-import { Component, ErrorObserver, Mutation, Query, Result, Subscribable, SubscriptionRef } from "effect-fc"
+import { Array, Cause, Chunk, Console, Effect, flow, Match, Option, Schema, Stream, SubscriptionRef } from "effect"
+import { Component, ErrorObserver, Lens, Mutation, Query, Result, Subscribable } from "effect-fc"
 import { runtime } from "@/runtime"


@@ -16,9 +16,9 @@ const Post = Schema.Struct({
 const ResultView = Component.make("ResultView")(function*() {
    const runPromise = yield* Component.useRunPromise()

-    const [idRef, query, mutation] = yield* Component.useOnMount(() => Effect.gen(function*() {
-        const idRef = yield* SubscriptionRef.make(1)
-        const key = Stream.map(idRef.changes, id => [id] as const)
+    const [idLens, query, mutation] = yield* Component.useOnMount(() => Effect.gen(function*() {
+        const idLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(1))
+        const key = Stream.map(idLens.changes, id => [id] as const)

        const query = yield* Query.service({
            key,
@@ -40,11 +40,11 @@ const ResultView = Component.make("ResultView")(function*() {
            ),
        })

-        return [idRef, query, mutation] as const
+        return [idLens, query, mutation] as const
    }))

-    const [id, setId] = yield* SubscriptionRef.useSubscriptionRefState(idRef)
-    const [queryResult, mutationResult] = yield* Subscribable.useSubscribables([query.result, mutation.result])
+    const [id, setId] = yield* Lens.useState(idLens)
+    const [queryResult, mutationResult] = yield* Subscribable.useAll([query.result, mutation.result])

    yield* Component.useOnMount(() => ErrorObserver.ErrorObserver<HttpClientError.HttpClientError>().pipe(
        Effect.andThen(observer => observer.subscribe),
@@ -105,7 +105,7 @@ const ResultView = Component.make("ResultView")(function*() {
                </div>

                <Flex direction="row" justify="center" align="center" gap="1">
-                    <Button onClick={() => runPromise(Effect.andThen(idRef, id => mutation.mutate([id])))}>Mutate</Button>
+                    <Button onClick={() => runPromise(Effect.andThen(Lens.get(idLens), id => mutation.mutate([id])))}>Mutate</Button>
                </Flex>
            </Flex>
        </Container>
--- a/packages/example/src/routes/result.tsx
+++ b/packages/example/src/routes/result.tsx
@@ -21,7 +21,7 @@ const ResultView = Component.makeUntraced("Result")(function*() {
        Effect.tap(Effect.sleep("250 millis")),
        Result.forkEffect,
    ))
-    const [result] = yield* Subscribable.useSubscribables([resultSubscribable])
+    const [result] = yield* Subscribable.useAll([resultSubscribable])

    yield* Component.useOnMount(() => ErrorObserver.ErrorObserver<HttpClientError.HttpClientError>().pipe(
        Effect.andThen(observer => observer.subscribe),
--- a/packages/example/src/todo/EditTodoView.tsx
+++ b/packages/example/src/todo/EditTodoView.tsx
@@ -0,0 +1,88 @@
+import { Box, Flex, IconButton } from "@radix-ui/themes"
+import { Effect } from "effect"
+import { Component, Form, Subscribable, SynchronizedForm } from "effect-fc"
+import { FaArrowDown, FaArrowUp } from "react-icons/fa"
+import { FaDeleteLeft } from "react-icons/fa6"
+import { TextFieldFormInputView } from "@/lib/form/TextFieldFormInputView"
+import { TextFieldOptionalFormInputView } from "@/lib/form/TextFieldOptionalFormInputView"
+import { TodoFormSchema } from "./TodoFormSchema"
+import { TodosState } from "./TodosState"
+
+
+export interface EditTodoViewProps {
+    readonly id: string
+}
+
+export class EditTodoView extends Component.make("TodoView")(function*(props: EditTodoViewProps) {
+    const state = yield* TodosState
+
+    const [
+        indexSubscribable,
+        contentField,
+        completedAtField,
+    ] = yield* Component.useOnChange(() => Effect.gen(function*() {
+        const indexSubscribable = state.getIndexSubscribable(props.id)
+
+        const form = yield* SynchronizedForm.service({
+            schema: TodoFormSchema,
+            target: state.getElementLens(props.id),
+        })
+
+        return [
+            indexSubscribable,
+            Form.focusObjectOn(form, "content"),
+            Form.focusObjectOn(form, "completedAt"),
+        ] as const
+    }), [props.id])
+
+    const [index, size] = yield* Subscribable.useAll([
+        indexSubscribable,
+        state.sizeSubscribable,
+    ])
+
+    const runSync = yield* Component.useRunSync()
+    const TextFieldFormInput = yield* TextFieldFormInputView.use
+    const TextFieldOptionalFormInput = yield* TextFieldOptionalFormInputView.use
+
+
+    return (
+        <Flex direction="row" align="center" gap="2">
+            <Box flexGrow="1">
+                <Flex direction="column" align="stretch" gap="2">
+                    <TextFieldFormInput
+                        form={contentField}
+                        debounce="250 millis"
+                    />
+
+                    <Flex direction="row" justify="center" align="center" gap="2">
+                        <TextFieldOptionalFormInput
+                            form={completedAtField}
+                            type="datetime-local"
+                            defaultValue=""
+                        />
+                    </Flex>
+                </Flex>
+            </Box>
+
+            <Flex direction="column" justify="center" align="center" gap="1">
+                <IconButton
+                    disabled={index <= 0}
+                    onClick={() => runSync(state.moveLeft(props.id))}
+                >
+                    <FaArrowUp />
+                </IconButton>
+
+                <IconButton
+                    disabled={index >= size - 1}
+                    onClick={() => runSync(state.moveRight(props.id))}
+                >
+                    <FaArrowDown />
+                </IconButton>
+
+                <IconButton onClick={() => runSync(state.remove(props.id))}>
+                    <FaDeleteLeft />
+                </IconButton>
+            </Flex>
+        </Flex>
+    )
+}) {}
--- a/packages/example/src/todo/NewTodoView.tsx
+++ b/packages/example/src/todo/NewTodoView.tsx
@@ -0,0 +1,78 @@
+import { Box, Button, Flex } from "@radix-ui/themes"
+import { GetRandomValues, makeUuid4 } from "@typed/id"
+import { Chunk, type DateTime, Effect, Option, Schema } from "effect"
+import { Component, Form, Lens, SubmittableForm, Subscribable } from "effect-fc"
+import * as Domain from "@/domain"
+import { TextFieldFormInputView } from "@/lib/form/TextFieldFormInputView"
+import { TextFieldOptionalFormInputView } from "@/lib/form/TextFieldOptionalFormInputView"
+import { TodoFormSchema } from "./TodoFormSchema"
+import { TodosState } from "./TodosState"
+
+
+const makeTodo = makeUuid4.pipe(
+    Effect.map(id => Domain.Todo.Todo.make({
+        id,
+        content: "",
+        completedAt: Option.none(),
+    })),
+    Effect.provide(GetRandomValues.CryptoRandom),
+)
+
+
+export class NewTodoView extends Component.make("NewTodoView")(function*() {
+    const state = yield* TodosState
+
+    const [
+        form,
+        contentField,
+        completedAtField,
+    ] = yield* Component.useOnMount(() => Effect.gen(function*() {
+        const form = yield* SubmittableForm.service({
+            schema: TodoFormSchema,
+            initialEncodedValue: yield* Schema.encode(TodoFormSchema)(yield* makeTodo),
+            f: ([todo, form]) => Lens.update(state.lens, Chunk.prepend(todo)).pipe(
+                Effect.andThen(makeTodo),
+                Effect.andThen(Schema.encode(TodoFormSchema)),
+                Effect.andThen(v => Lens.set(form.encodedValue, v)),
+            ),
+        })
+
+        return [
+            form,
+            Form.focusObjectOn(form, "content"),
+            Form.focusObjectOn(form, "completedAt"),
+        ] as const
+    }))
+
+    const [canCommit] = yield* Subscribable.useAll([form.canCommit])
+
+    const runPromise = yield* Component.useRunPromise<DateTime.CurrentTimeZone>()
+    const TextFieldFormInput = yield* TextFieldFormInputView.use
+    const TextFieldOptionalFormInput = yield* TextFieldOptionalFormInputView.use
+
+
+    return (
+        <Flex direction="row" align="center" gap="2">
+            <Box flexGrow="1">
+                <Flex direction="column" align="stretch" gap="2">
+                    <TextFieldFormInput
+                        form={contentField}
+                        debounce="250 millis"
+                    />
+
+                    <Flex direction="row" justify="center" align="center" gap="2">
+                        <TextFieldOptionalFormInput
+                            form={completedAtField}
+                            type="datetime-local"
+                            defaultValue=""
+                        />
+
+                        <Button disabled={!canCommit} onClick={() => void runPromise(form.submit)}>
+                            Add
+                        </Button>
+                    </Flex>
+                </Flex>
+            </Box>
+        </Flex>
+    )
+}) {}
--- a/packages/example/src/todo/TodoFormSchema.ts
+++ b/packages/example/src/todo/TodoFormSchema.ts
@@ -0,0 +1,9 @@
+import { Schema } from "effect"
+import * as Domain from "@/domain"
+import { DateTimeUtcFromZonedInput } from "@/lib/schema"
+
+
+export const TodoFormSchema = Schema.compose(Schema.Struct({
+    ...Domain.Todo.Todo.fields,
+    completedAt: Schema.OptionFromSelf(DateTimeUtcFromZonedInput),
+}), Domain.Todo.Todo)
--- a/packages/example/src/todo/TodoView.tsx
+++ b/packages/example/src/todo/TodoView.tsx
@@ -1,138 +0,0 @@
-import * as Domain from "@/domain"
-import { TextFieldFormInputView } from "@/lib/form/TextFieldFormInputView"
-import { TextFieldOptionalFormInputView } from "@/lib/form/TextFieldOptionalFormInputView"
-import { DateTimeUtcFromZonedInput } from "@/lib/schema"
-import { Box, Button, Flex, IconButton } from "@radix-ui/themes"
-import { GetRandomValues, makeUuid4 } from "@typed/id"
-import { Chunk, type DateTime, Effect, Match, Option, Ref, Schema, Stream } from "effect"
-import { Component, Form, Lens, Subscribable } from "effect-fc"
-import { FaArrowDown, FaArrowUp } from "react-icons/fa"
-import { FaDeleteLeft } from "react-icons/fa6"
-import { TodosState } from "./TodosState"
-
-
-const TodoFormSchema = Schema.compose(Schema.Struct({
-    ...Domain.Todo.Todo.fields,
-    completedAt: Schema.OptionFromSelf(DateTimeUtcFromZonedInput),
-}), Domain.Todo.Todo)
-
-const makeTodo = makeUuid4.pipe(
-    Effect.map(id => Domain.Todo.Todo.make({
-        id,
-        content: "",
-        completedAt: Option.none(),
-    })),
-    Effect.provide(GetRandomValues.CryptoRandom),
-)
-
-
-export type TodoProps = (
-    | { readonly _tag: "new" }
-    | { readonly _tag: "edit", readonly id: string }
-)
-
-export class TodoView extends Component.make("TodoView")(function*(props: TodoProps) {
-    const state = yield* TodosState
-
-    const [
-        indexRef,
-        form,
-        contentField,
-        completedAtField,
-    ] = yield* Component.useOnChange(() => Effect.gen(function*() {
-        const indexRef = Match.value(props).pipe(
-            Match.tag("new", () => Subscribable.make({ get: Effect.succeed(-1), changes: Stream.make(-1) })),
-            Match.tag("edit", ({ id }) => state.getIndexSubscribable(id)),
-            Match.exhaustive,
-        )
-
-        const form = yield* Form.service({
-            schema: TodoFormSchema,
-            initialEncodedValue: yield* Schema.encode(TodoFormSchema)(
-                yield* Match.value(props).pipe(
-                    Match.tag("new", () => makeTodo),
-                    Match.tag("edit", ({ id }) => state.getElementRef(id)),
-                    Match.exhaustive,
-                )
-            ),
-            f: ([todo, form]) => Match.value(props).pipe(
-                Match.tag("new", () => Ref.update(state.ref, Chunk.prepend(todo)).pipe(
-                    Effect.andThen(makeTodo),
-                    Effect.andThen(Schema.encode(TodoFormSchema)),
-                    Effect.andThen(v => Lens.set(form.encodedValue, v)),
-                )),
-                Match.tag("edit", ({ id }) => Ref.set(state.getElementRef(id), todo)),
-                Match.exhaustive,
-            ),
-            autosubmit: props._tag === "edit",
-        })
-
-        return [
-            indexRef,
-            form,
-            Form.focusObjectField(form, "content"),
-            Form.focusObjectField(form, "completedAt"),
-        ] as const
-    }), [props._tag, props._tag === "edit" ? props.id : undefined])
-
-    const [index, size, canSubmit] = yield* Subscribable.useSubscribables([
-        indexRef,
-        state.sizeSubscribable,
-        form.canSubmit,
-    ])
-
-    const runSync = yield* Component.useRunSync()
-    const runPromise = yield* Component.useRunPromise<DateTime.CurrentTimeZone>()
-    const TextFieldFormInput = yield* TextFieldFormInputView.use
-    const TextFieldOptionalFormInput = yield* TextFieldOptionalFormInputView.use
-
-
-    return (
-        <Flex direction="row" align="center" gap="2">
-            <Box flexGrow="1">
-                <Flex direction="column" align="stretch" gap="2">
-                    <TextFieldFormInput
-                        form={contentField}
-                        debounce="250 millis"
-                    />
-
-                    <Flex direction="row" justify="center" align="center" gap="2">
-                        <TextFieldOptionalFormInput
-                            form={completedAtField}
-                            type="datetime-local"
-                            defaultValue=""
-                        />
-
-                        {props._tag === "new" &&
-                            <Button disabled={!canSubmit} onClick={() => void runPromise(form.submit)}>
-                                Add
-                            </Button>
-                        }
-                    </Flex>
-                </Flex>
-            </Box>
-
-            {props._tag === "edit" &&
-                <Flex direction="column" justify="center" align="center" gap="1">
-                    <IconButton
-                        disabled={index <= 0}
-                        onClick={() => runSync(state.moveLeft(props.id))}
-                    >
-                        <FaArrowUp />
-                    </IconButton>
-
-                    <IconButton
-                        disabled={index >= size - 1}
-                        onClick={() => runSync(state.moveRight(props.id))}
-                    >
-                        <FaArrowDown />
-                    </IconButton>
-
-                    <IconButton onClick={() => runSync(state.remove(props.id))}>
-                        <FaDeleteLeft />
-                    </IconButton>
-                </Flex>
-            }
-        </Flex>
-    )
-}) {}
--- a/packages/example/src/todo/TodosState.ts
+++ b/packages/example/src/todo/TodosState.ts
@@ -1,7 +1,7 @@
 import { KeyValueStore } from "@effect/platform"
 import { BrowserKeyValueStore } from "@effect/platform-browser"
 import { Chunk, Console, Effect, Option, Schema, Stream, SubscriptionRef } from "effect"
-import { Subscribable, SubscriptionSubRef } from "effect-fc"
+import { Lens, Subscribable } from "effect-fc"
 import { Todo } from "@/domain"


@@ -30,27 +30,29 @@ export class TodosState extends Effect.Service<TodosState>()("TodosState", {
                : kv.remove(key)
        )

-        const ref = yield* SubscriptionRef.make(yield* readFromLocalStorage)
-        yield* Effect.forkScoped(ref.changes.pipe(
+        const lens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(yield* readFromLocalStorage))
+        yield* Effect.forkScoped(lens.changes.pipe(
            Stream.debounce("500 millis"),
            Stream.runForEach(saveToLocalStorage),
        ))
-        yield* Effect.addFinalizer(() => ref.pipe(
+        yield* Effect.addFinalizer(() => Lens.get(lens).pipe(
            Effect.andThen(saveToLocalStorage),
            Effect.ignore,
        ))

-        const sizeSubscribable = Subscribable.make({
-            get: Effect.andThen(ref, Chunk.size),
-            get changes() { return Stream.map(ref.changes, Chunk.size) },
-        })
-        const getElementRef = (id: string) => SubscriptionSubRef.makeFromChunkFindFirst(ref, v => v.id === id)
-        const getIndexSubscribable = (id: string) => Subscribable.make({
-            get: Effect.flatMap(ref, Chunk.findFirstIndex(v => v.id === id)),
-            get changes() { return Stream.flatMap(ref.changes, Chunk.findFirstIndex(v => v.id === id)) },
-        })
+        const sizeSubscribable = Subscribable.map(lens, Chunk.size)

-        const moveLeft = (id: string) => SubscriptionRef.updateEffect(ref, todos => Effect.Do.pipe(
+        const getElementLens = (id: string) => Lens.mapEffect(
+            lens,
+            Chunk.findFirst(v => v.id === id),
+            (a, b) => Effect.flatMap(
+                Chunk.findFirstIndex(a, v => v.id === id),
+                i => Chunk.replaceOption(a, i, b),
+            )
+        )
+        const getIndexSubscribable = (id: string) => Subscribable.mapEffect(lens, Chunk.findFirstIndex(v => v.id === id))
+
+        const moveLeft = (id: string) => Lens.updateEffect(lens, todos => Effect.Do.pipe(
            Effect.bind("index", () => Chunk.findFirstIndex(todos, v => v.id === id)),
            Effect.bind("todo", ({ index }) => Chunk.get(todos, index)),
            Effect.bind("previous", ({ index }) => Chunk.get(todos, index - 1)),
@@ -62,7 +64,7 @@ export class TodosState extends Effect.Service<TodosState>()("TodosState", {
                : todos
            ),
        ))
-        const moveRight = (id: string) => SubscriptionRef.updateEffect(ref, todos => Effect.Do.pipe(
+        const moveRight = (id: string) => Lens.updateEffect(lens, todos => Effect.Do.pipe(
            Effect.bind("index", () => Chunk.findFirstIndex(todos, v => v.id === id)),
            Effect.bind("todo", ({ index }) => Chunk.get(todos, index)),
            Effect.bind("next", ({ index }) => Chunk.get(todos, index + 1)),
@@ -74,15 +76,15 @@ export class TodosState extends Effect.Service<TodosState>()("TodosState", {
                : todos
            ),
        ))
-        const remove = (id: string) => SubscriptionRef.updateEffect(ref, todos => Effect.andThen(
+        const remove = (id: string) => Lens.updateEffect(lens, todos => Effect.andThen(
            Chunk.findFirstIndex(todos, v => v.id === id),
            index => Chunk.remove(todos, index),
        ))

        return {
-            ref,
+            lens,
            sizeSubscribable,
-            getElementRef,
+            getElementLens,
            getIndexSubscribable,
            moveLeft,
            moveRight,
--- a/packages/example/src/todo/TodosView.tsx
+++ b/packages/example/src/todo/TodosView.tsx
@@ -1,30 +1,32 @@
 import { Container, Flex, Heading } from "@radix-ui/themes"
 import { Chunk, Console, Effect } from "effect"
 import { Component, Subscribable } from "effect-fc"
+import { EditTodoView } from "./EditTodoView"
+import { NewTodoView } from "./NewTodoView"
 import { TodosState } from "./TodosState"
-import { TodoView } from "./TodoView"


 export class TodosView extends Component.make("TodosView")(function*() {
    const state = yield* TodosState
-    const [todos] = yield* Subscribable.useSubscribables([state.ref])
+    const [todos] = yield* Subscribable.useAll([state.lens])

    yield* Component.useOnMount(() => Effect.andThen(
        Console.log("Todos mounted"),
        Effect.addFinalizer(() => Console.log("Todos unmounted")),
    ))

-    const Todo = yield* TodoView.use
+    const NewTodo = yield* NewTodoView.use
+    const EditTodo = yield* EditTodoView.use

    return (
        <Container>
            <Heading align="center">Todos</Heading>

            <Flex direction="column" align="stretch" gap="2" mt="2">
-                <Todo _tag="new" />
+                <NewTodo />

                {Chunk.map(todos, todo =>
-                    <Todo key={todo.id} _tag="edit" id={todo.id} />
+                    <EditTodo key={todo.id} id={todo.id} />
                )}
            </Flex>
        </Container>