Update actions/checkout action to v6

This PR contains the following updates:

| Package | Change | [Age](https://docs.renovatebot.com/merge-confidence/) | [Confidence](https://docs.renovatebot.com/merge-confidence/) |
|---|---|---|---|
| [@effect/language-service](https://github.com/Effect-TS/language-service) | [`^0.56.0` -> `^0.58.0`](https://renovatebot.com/diffs/npm/@effect%2flanguage-service/0.56.0/0.58.0) | ![age](https://developer.mend.io/api/mc/badges/age/npm/@effect%2flanguage-service/0.58.0?slim=true) | ![confidence](https://developer.mend.io/api/mc/badges/confidence/npm/@effect%2flanguage-service/0.56.0/0.58.0?slim=true) |

---

### Release Notes

<details>
<summary>Effect-TS/language-service (@&#8203;effect/language-service)</summary>

### [`v0.58.0`](https://github.com/Effect-TS/language-service/blob/HEAD/CHANGELOG.md#0580)

[Compare Source](https://github.com/Effect-TS/language-service/compare/v0.57.1...v0.58.0)

##### Minor Changes

- [#&#8203;505](https://github.com/Effect-TS/language-service/pull/505) [`31cff49`](31cff498b6) Thanks [@&#8203;clayroach](https://github.com/clayroach)! - Enhance `diagnostics` CLI command with new options for CI/CD integration and tooling:

  - **`--format`**: Output format selection (`json`, `pretty`, `text`, `github-actions`)

    - `json`: Machine-readable JSON output with structured diagnostics and summary
    - `pretty`: Colored output with context (default, original behavior)
    - `text`: Plain text output without colors
    - `github-actions`: GitHub Actions workflow commands for inline PR annotations

  - **`--strict`**: Treat warnings as errors (affects exit code)

  - **`--severity`**: Filter diagnostics by severity level (comma-separated: `error`, `warning`, `message`)

  - **Exit codes**: Returns exit code 1 when errors are found (or warnings in strict mode)

  Example usage:

  ```bash
  # JSON output for CI/CD pipelines
  effect-language-service diagnostics --project tsconfig.json --format json

  # GitHub Actions with inline annotations
  effect-language-service diagnostics --project tsconfig.json --format github-actions

  # Strict mode for CI (fail on warnings)
  effect-language-service diagnostics --project tsconfig.json --strict

  # Only show errors
  effect-language-service diagnostics --project tsconfig.json --severity error
  ```

  Closes Effect-TS/effect [#&#8203;5180](https://github.com/Effect-TS/language-service/issues/5180).

### [`v0.57.1`](https://github.com/Effect-TS/language-service/blob/HEAD/CHANGELOG.md#0571)

[Compare Source](https://github.com/Effect-TS/language-service/compare/v0.57.0...v0.57.1)

##### Patch Changes

- [#&#8203;503](https://github.com/Effect-TS/language-service/pull/503) [`857e43e`](857e43e258) Thanks [@&#8203;mattiamanzati](https://github.com/mattiamanzati)! - Add codefix to `runEffectInsideEffect` diagnostic that automatically transforms `Effect.run*` calls to use `Runtime.run*` when inside nested Effect contexts. The codefix will extract or reuse an existing Effect runtime and replace the direct Effect run call with the appropriate Runtime method.

  Example:

  ```typescript
  // Before
  Effect.gen(function* () {
    websocket.onmessage = (event) => {
      Effect.runPromise(check);
    };
  });

  // After applying codefix
  Effect.gen(function* () {
    const effectRuntime = yield* Effect.runtime<never>();

    websocket.onmessage = (event) => {
      Runtime.runPromise(effectRuntime, check);
    };
  });
  ```

### [`v0.57.0`](https://github.com/Effect-TS/language-service/blob/HEAD/CHANGELOG.md#0570)

[Compare Source](https://github.com/Effect-TS/language-service/compare/v0.56.0...v0.57.0)

##### Minor Changes

- [#&#8203;500](https://github.com/Effect-TS/language-service/pull/500) [`acc2d43`](acc2d43d62) Thanks [@&#8203;mattiamanzati](https://github.com/mattiamanzati)! - Add new `annotate` codegen that automatically adds type annotations to exported constants based on their initializer types. This codegen can be used by adding `// @&#8203;effect-codegens annotate` comments above variable declarations.

  Example:

  ```typescript
  // @&#8203;effect-codegens annotate
  export const test = Effect.gen(function* () {
    if (Math.random() < 0.5) {
      return yield* Effect.fail("error");
    }
    return 1 as const;
  });
  // Becomes:
  // @&#8203;effect-codegens annotate:5fce15f7af06d924
  export const test: Effect.Effect<1, string, never> = Effect.gen(function* () {
    if (Math.random() < 0.5) {
      return yield* Effect.fail("error");
    }
    return 1 as const;
  });
  ```

  The codegen automatically detects the type from the initializer and adds the appropriate type annotation, making code more explicit and type-safe.

- [#&#8203;497](https://github.com/Effect-TS/language-service/pull/497) [`b188b74`](b188b74204) Thanks [@&#8203;mattiamanzati](https://github.com/mattiamanzati)! - Add new diagnostic `unnecessaryFailYieldableError` that warns when using `yield* Effect.fail()` with yieldable error types. The diagnostic suggests yielding the error directly instead of wrapping it with `Effect.fail()`, as yieldable errors (like `Data.TaggedError` and `Schema.TaggedError`) can be yielded directly in Effect generators.

  Example:

  ```typescript
  // ❌ Unnecessary Effect.fail wrapper
  yield * Effect.fail(new DataTaggedError());

  // ✅ Direct yield of yieldable error
  yield * new DataTaggedError();
  ```

</details>

---

### Configuration

📅 **Schedule**: Branch creation - At any time (no schedule defined), Automerge - At any time (no schedule defined).

🚦 **Automerge**: Disabled by config. Please merge this manually once you are satisfied.

♻ **Rebasing**: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

🔕 **Ignore**: Close this PR and you won't be reminded about this update again.

---

 - [ ] <!-- rebase-check -->If you want to rebase/retry this PR, check this box

---

This PR has been generated by [Renovate Bot](https://github.com/renovatebot/renovate).
<!--renovate-debug:eyJjcmVhdGVkSW5WZXIiOiI0Mi4yNS4zIiwidXBkYXRlZEluVmVyIjoiNDIuMjcuNSIsInRhcmdldEJyYW5jaCI6Im5leHQiLCJsYWJlbHMiOltdfQ==-->

Reviewed-on: #25
Co-authored-by: Renovate Bot <renovate-bot@valverde.cloud>
Co-committed-by: Renovate Bot <renovate-bot@valverde.cloud>

bun.lock

@@ -6,7 +6,7 @@
       "name": "@effect-fc/monorepo",
       "devDependencies": {
         "@biomejs/biome": "^2.3.4",
-        "@effect/language-service": "^0.56.0",
+        "@effect/language-service": "^0.58.0",
         "@types/bun": "^1.3.2",
         "npm-check-updates": "^19.1.2",
         "npm-sort": "^0.0.4",
@@ -131,7 +131,7 @@
 
     "@effect-fc/example": ["@effect-fc/example@workspace:packages/example"],
 
-    "@effect/language-service": ["@effect/language-service@0.56.0", "", { "bin": { "effect-language-service": "cli.js" } }, "sha512-gvJaHoeXMHAoA6+Xyj9Vdq52yDCs+ECLbKpHvxHtdJP/C0D9b3JFEfLjdVuw37zoWcYS856um4rgEYHlW2LSEQ=="],
+    "@effect/language-service": ["@effect/language-service@0.58.0", "", { "bin": { "effect-language-service": "cli.js" } }, "sha512-M5T9zEEu6sLuzXOIp+bQ8B1pMcX3A9gyahTTWlv9idr+b2SlZOfydomwgXkod4vlXw7mYhLLcXgCsnHcBUz9rw=="],
 
     "@effect/platform": ["@effect/platform@0.93.0", "", { "dependencies": { "find-my-way-ts": "^0.1.6", "msgpackr": "^1.11.4", "multipasta": "^0.2.7" }, "peerDependencies": { "effect": "^3.19.0" } }, "sha512-VaIv0duA+Dk2h8XYDPxCLCXGbMyd6hwuHUQt9THL1ZEqv1C3Fypg/Gi2UkzRys6TQsSnC9fJbdpMb7haPURYkQ=="],
 

package.json

@@ -16,7 +16,7 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^2.3.4",
-    "@effect/language-service": "^0.56.0",
+    "@effect/language-service": "^0.58.0",
     "@types/bun": "^1.3.2",
     "npm-check-updates": "^19.1.2",
     "npm-sort": "^0.0.4",

packages/effect-fc/src/ErrorObserver.ts

@@ -18,7 +18,7 @@ extends Pipeable.Class() implements ErrorObserver<E> {
     readonly subscribe: Effect.Effect<Queue.Dequeue<Cause.Cause<E>>, never, Scope.Scope>
 
     constructor(
-        private readonly pubsub: PubSub.PubSub<Cause.Cause<E>>
+        readonly pubsub: PubSub.PubSub<Cause.Cause<E>>
     ) {
         super()
         this.subscribe = pubsub.subscribe
@@ -36,8 +36,9 @@ class ErrorObserverSupervisorImpl extends Supervisor.AbstractSupervisor<void> {
     }
 
     onEnd<A, E>(_value: Exit.Exit<A, E>): void {
-        if (Exit.isFailure(_value))
+        if (Exit.isFailure(_value)) {
             Effect.runSync(PubSub.publish(this.pubsub, _value.cause as Cause.Cause<never>))
+        }
     }
 }
 

packages/effect-fc/src/Form.ts

@@ -1,7 +1,7 @@
-import { Array, Cause, Chunk, type Duration, Effect, Equal, Exit, Fiber, flow, Hash, HashMap, identity, Option, ParseResult, Pipeable, Predicate, Ref, Schema, type Scope, Stream } from "effect"
-import type { NoSuchElementException } from "effect/Cause"
+import { Array, Cause, Chunk, type Context, type Duration, Effect, Equal, Exit, Fiber, flow, Hash, HashMap, identity, Option, ParseResult, Pipeable, Predicate, Ref, Schema, type Scope, Stream } from "effect"
 import type * as React from "react"
 import * as Component from "./Component.js"
+import * as Mutation from "./Mutation.js"
 import * as PropertyPath from "./PropertyPath.js"
 import * as Result from "./Result.js"
 import * as Subscribable from "./Subscribable.js"
@@ -12,214 +12,212 @@ import * as SubscriptionSubRef from "./SubscriptionSubRef.js"
 export const FormTypeId: unique symbol = Symbol.for("@effect-fc/Form/Form")
 export type FormTypeId = typeof FormTypeId
 
-export interface Form<in out A, in out I = A, out R = never, in out SA = void, in out SE = A, out SR = never, in out SP = never>
+export interface Form<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.Pipeable {
     readonly [FormTypeId]: FormTypeId
 
     readonly schema: Schema.Schema<A, I, R>
-    readonly onSubmit: (value: NoInfer<A>) => Effect.Effect<SA, SE, SR>
-    readonly initialSubmitProgress: SP
+    readonly context: Context.Context<Scope.Scope | R>
+    readonly mutation: Mutation.Mutation<
+        readonly [value: A, form: Form<A, I, R, unknown, unknown, unknown>],
+        MA, ME, MR, MP
+    >
     readonly autosubmit: boolean
     readonly debounce: Option.Option<Duration.DurationInput>
 
-    readonly fieldCacheRef: Ref.Ref<HashMap.HashMap<FormFieldKey, FormField<unknown, unknown>>>
-    readonly valueRef: SubscriptionRef.SubscriptionRef<Option.Option<A>>
-    readonly encodedValueRef: SubscriptionRef.SubscriptionRef<I>
-    readonly errorRef: SubscriptionRef.SubscriptionRef<Option.Option<ParseResult.ParseError>>
-    readonly validationFiberRef: SubscriptionRef.SubscriptionRef<Option.Option<Fiber.Fiber<A, ParseResult.ParseError>>>
-    readonly submitResultRef: SubscriptionRef.SubscriptionRef<Result.Result<SA, SE, SP>>
+    readonly value: Subscribable.Subscribable<Option.Option<A>>
+    readonly encodedValue: SubscriptionRef.SubscriptionRef<I>
+    readonly error: Subscribable.Subscribable<Option.Option<ParseResult.ParseError>>
+    readonly validationFiber: Subscribable.Subscribable<Option.Option<Fiber.Fiber<A, ParseResult.ParseError>>>
 
-    readonly canSubmitSubscribable: Subscribable.Subscribable<boolean>
+    readonly canSubmit: Subscribable.Subscribable<boolean>
+
+    field<const P extends PropertyPath.Paths<I>>(
+        path: P
+    ): Effect.Effect<FormField<PropertyPath.ValueFromPath<A, P>, PropertyPath.ValueFromPath<I, P>>>
+    readonly submit: Effect.Effect<Option.Option<Result.Final<MA, ME, MP>>, Cause.NoSuchElementException>
 }
 
-class FormImpl<in out A, in out I = A, out R = never, in out SA = void, in out SE = A, out SR = never, in out SP = never>
-extends Pipeable.Class() implements Form<A, I, R, SA, SE, SR, SP> {
+export class FormImpl<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 Form<A, I, R, MA, ME, MR, MP> {
     readonly [FormTypeId]: FormTypeId = FormTypeId
 
     constructor(
         readonly schema: Schema.Schema<A, I, R>,
-        readonly onSubmit: (value: NoInfer<A>) => Effect.Effect<SA, SE, SR>,
-        readonly initialSubmitProgress: SP,
+        readonly context: Context.Context<Scope.Scope | R>,
+        readonly mutation: Mutation.Mutation<
+            readonly [value: A, form: Form<A, I, R, unknown, unknown, unknown>],
+            MA, ME, MR, MP
+        >,
         readonly autosubmit: boolean,
         readonly debounce: Option.Option<Duration.DurationInput>,
 
-        readonly fieldCacheRef: Ref.Ref<HashMap.HashMap<FormFieldKey, FormField<unknown, unknown>>>,
-        readonly valueRef: SubscriptionRef.SubscriptionRef<Option.Option<A>>,
-        readonly encodedValueRef: SubscriptionRef.SubscriptionRef<I>,
-        readonly errorRef: SubscriptionRef.SubscriptionRef<Option.Option<ParseResult.ParseError>>,
-        readonly validationFiberRef: SubscriptionRef.SubscriptionRef<Option.Option<Fiber.Fiber<A, ParseResult.ParseError>>>,
-        readonly submitResultRef: SubscriptionRef.SubscriptionRef<Result.Result<SA, SE, SP>>,
+        readonly value: SubscriptionRef.SubscriptionRef<Option.Option<A>>,
+        readonly encodedValue: SubscriptionRef.SubscriptionRef<I>,
+        readonly error: SubscriptionRef.SubscriptionRef<Option.Option<ParseResult.ParseError>>,
+        readonly validationFiber: SubscriptionRef.SubscriptionRef<Option.Option<Fiber.Fiber<A, ParseResult.ParseError>>>,
 
-        readonly canSubmitSubscribable: Subscribable.Subscribable<boolean>,
+        readonly runSemaphore: Effect.Semaphore,
+        readonly fieldCache: Ref.Ref<HashMap.HashMap<FormFieldKey, FormField<unknown, unknown>>>,
     ) {
         super()
-    }
-}
 
-export const isForm = (u: unknown): u is Form<unknown, unknown, unknown, unknown, unknown, unknown> => Predicate.hasProperty(u, FormTypeId)
-
-export namespace make {
-    export interface Options<in out A, in out I, in out R, in out SA = void, in out SE = A, out SR = never, in out SP = never> {
-        readonly schema: Schema.Schema<A, I, R>
-        readonly initialEncodedValue: NoInfer<I>
-        readonly onSubmit: (
-            this: Form<NoInfer<A>, NoInfer<I>, NoInfer<R>, unknown, unknown, unknown>,
-            value: NoInfer<A>,
-        ) => Effect.Effect<SA, SE, Result.forkEffect.InputContext<SR, NoInfer<SP>>>
-        readonly initialSubmitProgress?: SP
-        readonly autosubmit?: boolean
-        readonly debounce?: Duration.DurationInput
-    }
-
-    export type Success<A, I, R, SA = void, SE = A, SR = never, SP = never> = (
-        Form<A, I, R, SA, SE, Exclude<SR, Result.Progress<any> | Result.Progress<never>>, SP>
-    )
-}
-
-export const make = Effect.fnUntraced(function* <A, I = A, R = never, SA = void, SE = A, SR = never, SP = never>(
-    options: make.Options<A, I, R, SA, SE, SR, SP>
-): Effect.fn.Return<make.Success<A, I, R, SA, SE, SR, SP>> {
-    const valueRef = yield* SubscriptionRef.make(Option.none<A>())
-    const errorRef = yield* SubscriptionRef.make(Option.none<ParseResult.ParseError>())
-    const validationFiberRef = yield* SubscriptionRef.make(Option.none<Fiber.Fiber<A, ParseResult.ParseError>>())
-    const submitResultRef = yield* SubscriptionRef.make<Result.Result<SA, SE, SP>>(Result.initial())
-
-    return new FormImpl(
-        options.schema,
-        options.onSubmit as any,
-        options.initialSubmitProgress as SP,
-        options.autosubmit ?? false,
-        Option.fromNullable(options.debounce),
-
-        yield* Ref.make(HashMap.empty<FormFieldKey, FormField<unknown, unknown>>()),
-        valueRef,
-        yield* SubscriptionRef.make(options.initialEncodedValue),
-        errorRef,
-        validationFiberRef,
-        submitResultRef,
-
-        Subscribable.map(
-            Subscribable.zipLatestAll(valueRef, errorRef, validationFiberRef, submitResultRef),
+        this.canSubmit = Subscribable.map(
+            Subscribable.zipLatestAll(this.value, this.error, this.validationFiber, this.mutation.result),
             ([value, error, validationFiber, submitResult]) => (
                 Option.isSome(value) &&
                 Option.isNone(error) &&
                 Option.isNone(validationFiber) &&
                 !(Result.isRunning(submitResult) || Result.isRefreshing(submitResult))
             ),
-        ),
+        )
+    }
+
+    field<const P extends PropertyPath.Paths<I>>(
+        path: P
+    ): Effect.Effect<FormField<PropertyPath.ValueFromPath<A, P>, PropertyPath.ValueFromPath<I, P>>> {
+        return this.fieldCache.pipe(
+            Effect.map(HashMap.get(new FormFieldKey(path))),
+            Effect.flatMap(Option.match({
+                onSome: v => Effect.succeed(v as FormField<PropertyPath.ValueFromPath<A, P>, PropertyPath.ValueFromPath<I, P>>),
+                onNone: () => Effect.tap(
+                    Effect.succeed(makeFormField(this as Form<A, I, R, MA, ME, MR, MP>, path)),
+                    v => Ref.update(this.fieldCache, HashMap.set(new FormFieldKey(path), v as FormField<unknown, unknown>)),
+                ),
+            })),
+        )
+    }
+
+    readonly canSubmit: Subscribable.Subscribable<boolean, never, never>
+
+    get submit(): Effect.Effect<Option.Option<Result.Final<MA, ME, MP>>, Cause.NoSuchElementException> {
+        return 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 => Ref.set(this.error, Option.some(e)),
+                            onNone: () => Effect.void,
+                        },
+                    )
+                    : Effect.void
+            ),
+            this.canSubmit.get,
+        )
+    }
+}
+
+export const isForm = (u: unknown): u is Form<unknown, unknown, unknown, unknown, unknown, unknown> => Predicate.hasProperty(u, FormTypeId)
+
+export 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: Form<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
+        readonly debounce?: Duration.DurationInput
+    }
+}
+
+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<
+    Form<A, I, R, MA, ME, Result.forkEffect.OutputContext<MA, ME, MR, MP>, MP>,
+    never,
+    Scope.Scope | R | Result.forkEffect.OutputContext<MA, ME, MR, MP>
+> {
+    return new FormImpl(
+        options.schema,
+        yield* Effect.context<Scope.Scope | R>(),
+        yield* Mutation.make(options),
+        options.autosubmit ?? false,
+        Option.fromNullable(options.debounce),
+
+        yield* SubscriptionRef.make(Option.none<A>()),
+        yield* SubscriptionRef.make(options.initialEncodedValue),
+        yield* SubscriptionRef.make(Option.none<ParseResult.ParseError>()),
+        yield* SubscriptionRef.make(Option.none<Fiber.Fiber<A, ParseResult.ParseError>>()),
+
+        yield* Effect.makeSemaphore(1),
+        yield* Ref.make(HashMap.empty<FormFieldKey, FormField<unknown, unknown>>()),
     )
 })
 
-export const run = <A, I, R, SA, SE, SR, SP>(
-    self: Form<A, I, R, SA, SE, SR, SP>
-): Effect.Effect<void, never, Scope.Scope | R | SR> => Stream.runForEach(
-    self.encodedValueRef.changes.pipe(
-        Option.isSome(self.debounce) ? Stream.debounce(self.debounce.value) : identity
-    ),
+export const run = <A, I, R, MA, ME, MR, MP>(
+    self: Form<A, I, R, MA, ME, MR, MP>
+): Effect.Effect<void> => {
+    const _self = self as FormImpl<A, I, R, MA, ME, MR, MP>
+    return _self.runSemaphore.withPermits(1)(Stream.runForEach(
+        _self.encodedValue.changes.pipe(
+            Option.isSome(_self.debounce) ? Stream.debounce(_self.debounce.value) : identity
+        ),
 
-    encodedValue => self.validationFiberRef.pipe(
-        Effect.andThen(Option.match({
-            onSome: Fiber.interrupt,
-            onNone: () => Effect.void,
-        })),
-        Effect.andThen(
-            Effect.forkScoped(Effect.onExit(
-                Schema.decode(self.schema, { errors: "all" })(encodedValue),
-                exit => Effect.andThen(
-                    Exit.matchEffect(exit, {
-                        onSuccess: v => Effect.andThen(
-                            Ref.set(self.valueRef, Option.some(v)),
-                            Ref.set(self.errorRef, Option.none()),
-                        ),
-                        onFailure: c => Option.match(Chunk.findFirst(Cause.failures(c), e => e._tag === "ParseError"), {
-                            onSome: e => Ref.set(self.errorRef, Option.some(e)),
-                            onNone: () => Effect.void,
+        encodedValue => _self.validationFiber.pipe(
+            Effect.andThen(Option.match({
+                onSome: Fiber.interrupt,
+                onNone: () => Effect.void,
+            })),
+            Effect.andThen(
+                Effect.forkScoped(Effect.onExit(
+                    Schema.decode(_self.schema, { errors: "all" })(encodedValue),
+                    exit => Effect.andThen(
+                        Exit.matchEffect(exit, {
+                            onSuccess: v => Effect.andThen(
+                                Ref.set(_self.value, Option.some(v)),
+                                Ref.set(_self.error, Option.none()),
+                            ),
+                            onFailure: c => Option.match(Chunk.findFirst(Cause.failures(c), e => e._tag === "ParseError"), {
+                                onSome: e => Ref.set(_self.error, Option.some(e)),
+                                onNone: () => Effect.void,
+                            }),
                         }),
-                    }),
-                    Ref.set(self.validationFiberRef, Option.none()),
-                ),
-            )).pipe(
-                Effect.tap(fiber => Ref.set(self.validationFiberRef, Option.some(fiber))),
-                Effect.andThen(Fiber.join),
-                Effect.andThen(() => self.autosubmit
-                    ? Effect.asVoid(Effect.forkScoped(submit(self)))
-                    : Effect.void
-                ),
-                Effect.forkScoped,
-            )
+                        Ref.set(_self.validationFiber, Option.none()),
+                    ),
+                )).pipe(
+                    Effect.tap(fiber => Ref.set(_self.validationFiber, Option.some(fiber))),
+                    Effect.andThen(Fiber.join),
+                    Effect.andThen(value => _self.autosubmit
+                        ? Effect.asVoid(Effect.forkScoped(_self.submitValue(value)))
+                        : Effect.void
+                    ),
+                    Effect.forkScoped,
+                )
+            ),
+            Effect.provide(_self.context),
         ),
-    ),
-)
-
-export const submit = <A, I, R, SA, SE, SR, SP>(
-    self: Form<A, I, R, SA, SE, SR, SP>
-): Effect.Effect<
-    Option.Option<Result.Result<SA, SE, SP>>,
-    NoSuchElementException,
-    Scope.Scope | SR
-> => Effect.whenEffect(
-    self.valueRef.pipe(
-        Effect.andThen(identity),
-        Effect.andThen(value => Result.unsafeForkEffect(
-            self.onSubmit(value),
-            { initialProgress: self.initialSubmitProgress },
-        )),
-        Effect.andThen(([sub]) => Effect.all([Effect.succeed(sub), sub.get])),
-        Effect.andThen(([sub, initial]) => Stream.runFoldEffect(
-            sub.changes,
-            initial,
-            (_, result) => Effect.as(Ref.set(self.submitResultRef, result), result),
-        )),
-        Effect.tap(result => Result.isFailure(result)
-            ? Option.match(
-                Chunk.findFirst(
-                    Cause.failures(result.cause as Cause.Cause<ParseResult.ParseError>),
-                    e => e._tag === "ParseError",
-                ),
-                {
-                    onSome: e => Ref.set(self.errorRef, Option.some(e)),
-                    onNone: () => Effect.void,
-                },
-            )
-            : Effect.void
-        ),
-    ),
-
-    self.canSubmitSubscribable.get,
-)
-
-export namespace service {
-    export interface Options<in out A, in out I, in out R, in out SA = void, in out SE = A, out SR = never, in out SP = never>
-    extends make.Options<A, I, R, SA, SE, SR, SP> {}
-
-    export type Return<A, I, R, SA = void, SE = A, SR = never, SP = never> = Effect.Effect<
-        Form<A, I, R, SA, SE, Exclude<SR, Result.Progress<any> | Result.Progress<never>>, SP>,
-        never,
-        Scope.Scope | R | Exclude<SR, Result.Progress<any> | Result.Progress<never>>
-    >
+    ))
 }
 
-export const service = <A, I = A, R = never, SA = void, SE = A, SR = never, SP = never>(
-    options: service.Options<A, I, R, SA, SE, SR, SP>
-): service.Return<A, I, R, SA, SE, SR, SP> => Effect.tap(
+export 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<
+    Form<A, I, R, MA, ME, Result.forkEffect.OutputContext<MA, ME, MR, MP>, MP>,
+    never,
+    Scope.Scope | R | Result.forkEffect.OutputContext<MA, ME, MR, MP>
+> => Effect.tap(
     make(options),
     form => Effect.forkScoped(run(form)),
 )
 
-export const field = <A, I, R, SA, SE, SR, SP, const P extends PropertyPath.Paths<NoInfer<I>>>(
-    self: Form<A, I, R, SA, SE, SR, SP>,
-    path: P,
-): Effect.Effect<FormField<PropertyPath.ValueFromPath<A, P>, PropertyPath.ValueFromPath<I, P>>> => self.fieldCacheRef.pipe(
-    Effect.map(HashMap.get(new FormFieldKey(path))),
-    Effect.flatMap(Option.match({
-        onSome: v => Effect.succeed(v as FormField<PropertyPath.ValueFromPath<A, P>, PropertyPath.ValueFromPath<I, P>>),
-        onNone: () => Effect.tap(
-            Effect.succeed(makeFormField(self, path)),
-            v => Ref.update(self.fieldCacheRef, HashMap.set(new FormFieldKey(path), v as FormField<unknown, unknown>)),
-        ),
-    })),
-)
-
 
 export const FormFieldTypeId: unique symbol = Symbol.for("@effect-fc/Form/FormField")
 export type FormFieldTypeId = typeof FormFieldTypeId
@@ -228,11 +226,11 @@ export interface FormField<in out A, in out I = A>
 extends Pipeable.Pipeable {
     readonly [FormFieldTypeId]: FormFieldTypeId
 
-    readonly valueSubscribable: Subscribable.Subscribable<Option.Option<A>, NoSuchElementException>
-    readonly encodedValueRef: SubscriptionRef.SubscriptionRef<I>
-    readonly issuesSubscribable: Subscribable.Subscribable<readonly ParseResult.ArrayFormatterIssue[]>
-    readonly isValidatingSubscribable: Subscribable.Subscribable<boolean>
-    readonly isSubmittingSubscribable: Subscribable.Subscribable<boolean>
+    readonly value: Subscribable.Subscribable<Option.Option<A>, Cause.NoSuchElementException>
+    readonly encodedValue: SubscriptionRef.SubscriptionRef<I>
+    readonly issues: Subscribable.Subscribable<readonly ParseResult.ArrayFormatterIssue[]>
+    readonly isValidating: Subscribable.Subscribable<boolean>
+    readonly isSubmitting: Subscribable.Subscribable<boolean>
 }
 
 class FormFieldImpl<in out A, in out I = A>
@@ -240,11 +238,11 @@ extends Pipeable.Class() implements FormField<A, I> {
     readonly [FormFieldTypeId]: FormFieldTypeId = FormFieldTypeId
 
     constructor(
-        readonly valueSubscribable: Subscribable.Subscribable<Option.Option<A>, NoSuchElementException>,
-        readonly encodedValueRef: SubscriptionRef.SubscriptionRef<I>,
-        readonly issuesSubscribable: Subscribable.Subscribable<readonly ParseResult.ArrayFormatterIssue[]>,
-        readonly isValidatingSubscribable: Subscribable.Subscribable<boolean>,
-        readonly isSubmittingSubscribable: Subscribable.Subscribable<boolean>,
+        readonly value: Subscribable.Subscribable<Option.Option<A>, Cause.NoSuchElementException>,
+        readonly encodedValue: SubscriptionRef.SubscriptionRef<I>,
+        readonly issues: Subscribable.Subscribable<readonly ParseResult.ArrayFormatterIssue[]>,
+        readonly isValidating: Subscribable.Subscribable<boolean>,
+        readonly isSubmitting: Subscribable.Subscribable<boolean>,
     ) {
         super()
     }
@@ -268,25 +266,28 @@ class FormFieldKey implements Equal.Equal {
 export const isFormField = (u: unknown): u is FormField<unknown, unknown> => Predicate.hasProperty(u, FormFieldTypeId)
 const isFormFieldKey = (u: unknown): u is FormFieldKey => Predicate.hasProperty(u, FormFieldKeyTypeId)
 
-export const makeFormField = <A, I, R, SA, SE, SR, SP, const P extends PropertyPath.Paths<NoInfer<I>>>(
-    self: Form<A, I, R, SA, SE, SR, SP>,
+export const makeFormField = <A, I, R, MA, ME, MR, MP, const P extends PropertyPath.Paths<NoInfer<I>>>(
+    self: Form<A, I, R, MA, ME, MR, MP>,
     path: P,
-): FormField<PropertyPath.ValueFromPath<A, P>, PropertyPath.ValueFromPath<I, P>> => new FormFieldImpl(
-    Subscribable.mapEffect(self.valueRef, Option.match({
-        onSome: v => Option.map(PropertyPath.get(v, path), Option.some),
-        onNone: () => Option.some(Option.none()),
-    })),
-    SubscriptionSubRef.makeFromPath(self.encodedValueRef, path),
-    Subscribable.mapEffect(self.errorRef, Option.match({
-        onSome: flow(
-            ParseResult.ArrayFormatter.formatError,
-            Effect.map(Array.filter(issue => PropertyPath.equivalence(issue.path, path))),
-        ),
-        onNone: () => Effect.succeed([]),
-    })),
-    Subscribable.map(self.validationFiberRef, Option.isSome),
-    Subscribable.map(self.submitResultRef, result => Result.isRunning(result) || Result.isRefreshing(result)),
-)
+): FormField<PropertyPath.ValueFromPath<A, P>, PropertyPath.ValueFromPath<I, P>> => {
+    const _self = self as FormImpl<A, I, R, MA, ME, MR, MP>
+    return new FormFieldImpl(
+        Subscribable.mapEffect(_self.value, Option.match({
+            onSome: v => Option.map(PropertyPath.get(v, path), Option.some),
+            onNone: () => Option.some(Option.none()),
+        })),
+        SubscriptionSubRef.makeFromPath(_self.encodedValue, path),
+        Subscribable.mapEffect(_self.error, Option.match({
+            onSome: flow(
+                ParseResult.ArrayFormatter.formatError,
+                Effect.map(Array.filter(issue => PropertyPath.equivalence(issue.path, path))),
+            ),
+            onNone: () => Effect.succeed([]),
+        })),
+        Subscribable.map(_self.validationFiber, Option.isSome),
+        Subscribable.map(_self.mutation.result, result => Result.isRunning(result) || Result.isRefreshing(result)),
+    )
+}
 
 
 export namespace useInput {
@@ -303,12 +304,12 @@ export namespace useInput {
 export const useInput = Effect.fnUntraced(function* <A, I>(
     field: FormField<A, I>,
     options?: useInput.Options,
-): Effect.fn.Return<useInput.Result<I>, NoSuchElementException, Scope.Scope> {
+): Effect.fn.Return<useInput.Result<I>, Cause.NoSuchElementException, Scope.Scope> {
     const internalValueRef = yield* Component.useOnChange(() => Effect.tap(
-        Effect.andThen(field.encodedValueRef, SubscriptionRef.make),
+        Effect.andThen(field.encodedValue, SubscriptionRef.make),
         internalValueRef => Effect.forkScoped(Effect.all([
             Stream.runForEach(
-                Stream.drop(field.encodedValueRef, 1),
+                Stream.drop(field.encodedValue, 1),
                 upstreamEncodedValue => Effect.whenEffect(
                     Ref.set(internalValueRef, upstreamEncodedValue),
                     Effect.andThen(internalValueRef, internalValue => !Equal.equals(upstreamEncodedValue, internalValue)),
@@ -321,7 +322,7 @@ export const useInput = Effect.fnUntraced(function* <A, I>(
                     Stream.changesWith(Equal.equivalence()),
                     options?.debounce ? Stream.debounce(options.debounce) : identity,
                 ),
-                internalValue => Ref.set(field.encodedValueRef, internalValue),
+                internalValue => Ref.set(field.encodedValue, internalValue),
             ),
         ], { concurrency: "unbounded" })),
     ), [field, options?.debounce])
@@ -344,10 +345,10 @@ export namespace useOptionalInput {
 export const useOptionalInput = Effect.fnUntraced(function* <A, I>(
     field: FormField<A, Option.Option<I>>,
     options: useOptionalInput.Options<I>,
-): Effect.fn.Return<useOptionalInput.Result<I>, NoSuchElementException, Scope.Scope> {
+): Effect.fn.Return<useOptionalInput.Result<I>, Cause.NoSuchElementException, Scope.Scope> {
     const [enabledRef, internalValueRef] = yield* Component.useOnChange(() => Effect.tap(
         Effect.andThen(
-            field.encodedValueRef,
+            field.encodedValue,
             Option.match({
                 onSome: v => Effect.all([SubscriptionRef.make(true), SubscriptionRef.make(v)]),
                 onNone: () => Effect.all([SubscriptionRef.make(false), SubscriptionRef.make(options.defaultValue)]),
@@ -356,7 +357,7 @@ export const useOptionalInput = Effect.fnUntraced(function* <A, I>(
 
         ([enabledRef, internalValueRef]) => Effect.forkScoped(Effect.all([
             Stream.runForEach(
-                Stream.drop(field.encodedValueRef, 1),
+                Stream.drop(field.encodedValue, 1),
 
                 upstreamEncodedValue => Effect.whenEffect(
                     Option.match(upstreamEncodedValue, {
@@ -384,7 +385,7 @@ export const useOptionalInput = Effect.fnUntraced(function* <A, I>(
                     Stream.changesWith(Equal.equivalence()),
                     options?.debounce ? Stream.debounce(options.debounce) : identity,
                 ),
-                ([enabled, internalValue]) => Ref.set(field.encodedValueRef, enabled ? Option.some(internalValue) : Option.none()),
+                ([enabled, internalValue]) => Ref.set(field.encodedValue, enabled ? Option.some(internalValue) : Option.none()),
             ),
         ], { concurrency: "unbounded" })),
     ), [field, options.debounce])

packages/effect-fc/src/Mutation.ts

@@ -0,0 +1,123 @@
+import { type Context, Effect, Equal, type Fiber, Option, Pipeable, Predicate, type Scope, Stream, type Subscribable, SubscriptionRef } from "effect"
+import * as Result from "./Result.js"
+
+
+export const MutationTypeId: unique symbol = Symbol.for("@effect-fc/Mutation/Mutation")
+export type MutationTypeId = typeof MutationTypeId
+
+export interface Mutation<in out K extends readonly any[], in out A, in out E = never, in out R = never, in out P = never>
+extends Pipeable.Pipeable {
+    readonly [MutationTypeId]: MutationTypeId
+
+    readonly context: Context.Context<Scope.Scope | R>
+    readonly f: (key: K) => Effect.Effect<A, E, R>
+    readonly initialProgress: P
+
+    readonly latestKey: Subscribable.Subscribable<Option.Option<K>>
+    readonly fiber: Subscribable.Subscribable<Option.Option<Fiber.Fiber<A, E>>>
+    readonly result: Subscribable.Subscribable<Result.Result<A, E, P>>
+
+    mutate(key: K): Effect.Effect<Result.Final<A, E, P>>
+    mutateSubscribable(key: K): Effect.Effect<Subscribable.Subscribable<Result.Result<A, E, P>>>
+}
+
+export class MutationImpl<in out K extends readonly any[], in out A, in out E = never, in out R = never, in out P = never>
+extends Pipeable.Class() implements Mutation<K, A, E, R, P> {
+    readonly [MutationTypeId]: MutationTypeId = MutationTypeId
+
+    constructor(
+        readonly context: Context.Context<Scope.Scope | NoInfer<R>>,
+        readonly f: (key: K) => Effect.Effect<A, E, R>,
+        readonly initialProgress: P,
+
+        readonly latestKey: SubscriptionRef.SubscriptionRef<Option.Option<K>>,
+        readonly fiber: SubscriptionRef.SubscriptionRef<Option.Option<Fiber.Fiber<A, E>>>,
+        readonly result: SubscriptionRef.SubscriptionRef<Result.Result<A, E, P>>,
+    ) {
+        super()
+    }
+
+    mutate(key: K): Effect.Effect<Result.Final<A, E, P>> {
+        return SubscriptionRef.set(this.latestKey, Option.some(key)).pipe(
+            Effect.andThen(Effect.provide(this.start(key), this.context)),
+            Effect.andThen(sub => this.watch(sub)),
+        )
+    }
+    mutateSubscribable(key: K): Effect.Effect<Subscribable.Subscribable<Result.Result<A, E, P>>> {
+        return Effect.andThen(
+            SubscriptionRef.set(this.latestKey, Option.some(key)),
+            Effect.provide(this.start(key), this.context)
+        )
+    }
+
+    start(key: K): Effect.Effect<
+        Subscribable.Subscribable<Result.Result<A, E, P>>,
+        never,
+        Scope.Scope | R
+    > {
+        return this.result.pipe(
+            Effect.map(previous => Result.isFinal(previous)
+                ? previous
+                : undefined
+            ),
+            Effect.andThen(previous => Result.unsafeForkEffect(
+                Effect.onExit(this.f(key), () => Effect.andThen(
+                    Effect.all([Effect.fiberId, this.fiber]),
+                    ([currentFiberId, fiber]) => Option.match(fiber, {
+                        onSome: v => Equal.equals(currentFiberId, v.id())
+                            ? SubscriptionRef.set(this.fiber, Option.none())
+                            : Effect.void,
+                        onNone: () => Effect.void,
+                    })
+                )),
+
+                {
+                    initialProgress: this.initialProgress,
+                    previous,
+                } as Result.unsafeForkEffect.Options<A, E, P>,
+            )),
+            Effect.tap(([, fiber]) => SubscriptionRef.set(this.fiber, Option.some(fiber))),
+            Effect.map(([sub]) => sub),
+        )
+    }
+
+    watch(
+        sub: Subscribable.Subscribable<Result.Result<A, E, P>>
+    ): Effect.Effect<Result.Final<A, E, P>> {
+        return Effect.andThen(
+            sub.get,
+            initial => Stream.runFoldEffect(
+                Stream.filter(sub.changes, Predicate.not(Result.isInitial)),
+                initial,
+                (_, result) => Effect.as(SubscriptionRef.set(this.result, result), result),
+            ),
+        ) as Effect.Effect<Result.Final<A, E, P>>
+    }
+}
+
+export const isMutation = (u: unknown): u is Mutation<unknown[], unknown, unknown, unknown, unknown> => Predicate.hasProperty(u, MutationTypeId)
+
+export declare namespace make {
+    export interface Options<K extends readonly any[] = never, A = void, E = never, R = never, P = never> {
+        readonly f: (key: K) => Effect.Effect<A, E, Result.forkEffect.InputContext<R, NoInfer<P>>>
+        readonly initialProgress?: P
+    }
+}
+
+export const make = Effect.fnUntraced(function* <const K extends readonly any[] = never, A = void, E = never, R = never, P = never>(
+    options: make.Options<K, A, E, R, P>
+): Effect.fn.Return<
+    Mutation<K, A, E, Result.forkEffect.OutputContext<A, E, R, P>, P>,
+    never,
+    Scope.Scope | Result.forkEffect.OutputContext<A, E, R, P>
+> {
+    return new MutationImpl(
+        yield* Effect.context<Scope.Scope | Result.forkEffect.OutputContext<A, E, R, P>>(),
+        options.f as any,
+        options.initialProgress as P,
+
+        yield* SubscriptionRef.make(Option.none<K>()),
+        yield* SubscriptionRef.make(Option.none<Fiber.Fiber<A, E>>()),
+        yield* SubscriptionRef.make(Result.initial<A, E, P>()),
+    )
+})

packages/effect-fc/src/Query.ts

@@ -1,14 +1,15 @@
-import { Effect, Fiber, Option, Pipeable, Predicate, type Scope, Stream, type Subscribable, SubscriptionRef } from "effect"
+import { type Cause, type Context, Effect, Fiber, identity, Option, Pipeable, Predicate, type Scope, Stream, type Subscribable, SubscriptionRef } from "effect"
 import * as Result from "./Result.js"
 
 
 export const QueryTypeId: unique symbol = Symbol.for("@effect-fc/Query/Query")
 export type QueryTypeId = typeof QueryTypeId
 
-export interface Query<in out K extends readonly any[], in out A, in out E = never, out R = never, in out P = never>
+export interface Query<in out K extends readonly any[], in out A, in out E = never, in out R = never, in out P = never>
 extends Pipeable.Pipeable {
     readonly [QueryTypeId]: QueryTypeId
 
+    readonly context: Context.Context<Scope.Scope | R>
     readonly key: Stream.Stream<K>
     readonly f: (key: K) => Effect.Effect<A, E, R>
     readonly initialProgress: P
@@ -16,13 +17,21 @@ extends Pipeable.Pipeable {
     readonly latestKey: Subscribable.Subscribable<Option.Option<K>>
     readonly fiber: Subscribable.Subscribable<Option.Option<Fiber.Fiber<A, E>>>
     readonly result: Subscribable.Subscribable<Result.Result<A, E, P>>
+
+    fetch(key: K): Effect.Effect<Result.Final<A, E, P>>
+    fetchSubscribable(key: K): Effect.Effect<Subscribable.Subscribable<Result.Result<A, E, P>>>
+    readonly refetch: Effect.Effect<Result.Final<A, E, P>, Cause.NoSuchElementException>
+    readonly refetchSubscribable: Effect.Effect<Subscribable.Subscribable<Result.Result<A, E, P>>, Cause.NoSuchElementException>
+    readonly refresh: Effect.Effect<Result.Final<A, E, P>, Cause.NoSuchElementException>
+    readonly refreshSubscribable: Effect.Effect<Subscribable.Subscribable<Result.Result<A, E, P>>, Cause.NoSuchElementException>
 }
 
-class QueryImpl<in out K extends readonly any[], in out A, in out E = never, out R = never, in out P = never>
+export class QueryImpl<in out K extends readonly any[], in out A, in out E = never, in out R = never, in out P = never>
 extends Pipeable.Class() implements Query<K, A, E, R, P> {
     readonly [QueryTypeId]: QueryTypeId = QueryTypeId
 
     constructor(
+        readonly context: Context.Context<Scope.Scope | NoInfer<R>>,
         readonly key: Stream.Stream<K>,
         readonly f: (key: K) => Effect.Effect<A, E, R>,
         readonly initialProgress: P,
@@ -30,6 +39,8 @@ extends Pipeable.Class() implements Query<K, A, E, R, P> {
         readonly latestKey: SubscriptionRef.SubscriptionRef<Option.Option<K>>,
         readonly fiber: SubscriptionRef.SubscriptionRef<Option.Option<Fiber.Fiber<A, E>>>,
         readonly result: SubscriptionRef.SubscriptionRef<Result.Result<A, E, P>>,
+
+        readonly runSemaphore: Effect.Semaphore,
     ) {
         super()
     }
@@ -41,15 +52,71 @@ extends Pipeable.Class() implements Query<K, A, E, R, P> {
         }))
     }
 
-    start(key: K): Effect.Effect<
+    fetch(key: K): Effect.Effect<Result.Final<A, E, P>> {
+        return this.interrupt.pipe(
+            Effect.andThen(SubscriptionRef.set(this.latestKey, Option.some(key))),
+            Effect.andThen(Effect.provide(this.start(key), this.context)),
+            Effect.andThen(sub => this.watch(sub)),
+        )
+    }
+    fetchSubscribable(key: K): Effect.Effect<Subscribable.Subscribable<Result.Result<A, E, P>>> {
+        return this.interrupt.pipe(
+            Effect.andThen(SubscriptionRef.set(this.latestKey, Option.some(key))),
+            Effect.andThen(Effect.provide(this.start(key), this.context)),
+        )
+    }
+    get refetch(): Effect.Effect<Result.Final<A, E, P>, Cause.NoSuchElementException> {
+        return this.interrupt.pipe(
+            Effect.andThen(this.latestKey),
+            Effect.andThen(identity),
+            Effect.andThen(key => Effect.provide(this.start(key), this.context)),
+            Effect.andThen(sub => this.watch(sub)),
+        )
+    }
+    get refetchSubscribable(): Effect.Effect<Subscribable.Subscribable<Result.Result<A, E, P>>, Cause.NoSuchElementException> {
+        return this.interrupt.pipe(
+            Effect.andThen(this.latestKey),
+            Effect.andThen(identity),
+            Effect.andThen(key => Effect.provide(this.start(key), this.context)),
+        )
+    }
+    get refresh(): Effect.Effect<Result.Final<A, E, P>, Cause.NoSuchElementException> {
+        return this.interrupt.pipe(
+            Effect.andThen(this.latestKey),
+            Effect.andThen(identity),
+            Effect.andThen(key => Effect.provide(this.start(key, true), this.context)),
+            Effect.andThen(sub => this.watch(sub)),
+        )
+    }
+    get refreshSubscribable(): Effect.Effect<Subscribable.Subscribable<Result.Result<A, E, P>>, Cause.NoSuchElementException> {
+        return this.interrupt.pipe(
+            Effect.andThen(this.latestKey),
+            Effect.andThen(identity),
+            Effect.andThen(key => Effect.provide(this.start(key, true), this.context)),
+        )
+    }
+
+    start(
+        key: K,
+        refresh?: boolean,
+    ): Effect.Effect<
         Subscribable.Subscribable<Result.Result<A, E, P>>,
         never,
         Scope.Scope | R
     > {
-        return Result.unsafeForkEffect(
-            Effect.onExit(this.f(key), () => SubscriptionRef.set(this.fiber, Option.none())),
-            { initialProgress: this.initialProgress },
-        ).pipe(
+        return this.result.pipe(
+            Effect.map(previous => Result.isFinal(previous)
+                ? previous
+                : undefined
+            ),
+            Effect.andThen(previous => Result.unsafeForkEffect(
+                Effect.onExit(this.f(key), () => SubscriptionRef.set(this.fiber, Option.none())),
+                {
+                    initialProgress: this.initialProgress,
+                    refresh: refresh && previous,
+                    previous,
+                } as Result.unsafeForkEffect.Options<A, E, P>,
+            )),
             Effect.tap(([, fiber]) => SubscriptionRef.set(this.fiber, Option.some(fiber))),
             Effect.map(([sub]) => sub),
         )
@@ -57,15 +124,15 @@ extends Pipeable.Class() implements Query<K, A, E, R, P> {
 
     watch(
         sub: Subscribable.Subscribable<Result.Result<A, E, P>>
-    ): Effect.Effect<Result.Result<A, E, P>> {
+    ): Effect.Effect<Result.Final<A, E, P>> {
         return Effect.andThen(
             sub.get,
             initial => Stream.runFoldEffect(
-                sub.changes,
+                Stream.filter(sub.changes, Predicate.not(Result.isInitial)),
                 initial,
                 (_, result) => Effect.as(SubscriptionRef.set(this.result, result), result),
             ),
-        )
+        ) as Effect.Effect<Result.Final<A, E, P>>
     }
 }
 
@@ -81,8 +148,13 @@ export declare namespace make {
 
 export const make = Effect.fnUntraced(function* <K extends readonly any[], A, E = never, R = never, P = never>(
     options: make.Options<K, A, E, R, P>
-): Effect.fn.Return<Query<K, A, E, Result.forkEffect.OutputContext<A, E, R, P>, P>> {
+): Effect.fn.Return<
+    Query<K, A, E, Result.forkEffect.OutputContext<A, E, R, P>, P>,
+    never,
+    Scope.Scope | Result.forkEffect.OutputContext<A, E, R, P>
+> {
     return new QueryImpl(
+        yield* Effect.context<Scope.Scope | Result.forkEffect.OutputContext<A, E, R, P>>(),
         options.key,
         options.f as any,
         options.initialProgress as P,
@@ -90,6 +162,8 @@ export const make = Effect.fnUntraced(function* <K extends readonly any[], A, E
         yield* SubscriptionRef.make(Option.none<K>()),
         yield* SubscriptionRef.make(Option.none<Fiber.Fiber<A, E>>()),
         yield* SubscriptionRef.make(Result.initial<A, E, P>()),
+
+        yield* Effect.makeSemaphore(1),
     )
 })
 
@@ -106,12 +180,13 @@ export const service = <K extends readonly any[], A, E = never, R = never, P = n
 
 export const run = <K extends readonly any[], A, E, R, P>(
     self: Query<K, A, E, R, P>
-): Effect.Effect<void, never, Scope.Scope | R> => Stream.runForEach(self.key, key =>
-    (self as QueryImpl<K, A, E, R, P>).interrupt.pipe(
-        Effect.andThen(SubscriptionRef.set((self as QueryImpl<K, A, E, R, P>).latestKey, Option.some(key))),
-        Effect.andThen((self as QueryImpl<K, A, E, R, P>).start(key)),
-        Effect.andThen(sub => Effect.forkScoped(
-            (self as QueryImpl<K, A, E, R, P>).watch(sub)
-        )),
-    )
-)
+): Effect.Effect<void> => {
+    const _self = self as QueryImpl<K, A, E, R, P>
+    return Stream.runForEach(_self.key, key => _self.interrupt.pipe(
+        Effect.andThen(SubscriptionRef.set(_self.latestKey, Option.some(key))),
+        Effect.andThen(_self.start(key)),
+        Effect.andThen(sub => Effect.forkScoped(_self.watch(sub))),
+        Effect.provide(_self.context),
+        _self.runSemaphore.withPermits(1),
+    ))
+}

packages/effect-fc/src/Result.ts

@@ -7,6 +7,10 @@ export type ResultTypeId = typeof ResultTypeId
 export type Result<A, E = never, P = never> = (
     | Initial
     | Running<P>
+    | Final<A, E, P>
+)
+
+export type Final<A, E = never, P = never> = (
     | Success<A>
     | (Success<A> & Refreshing<P>)
     | Failure<A, E>
@@ -96,6 +100,7 @@ const ResultPrototype = Object.freeze({
 
 
 export const isResult = (u: unknown): u is Result<unknown, unknown, unknown> => Predicate.hasProperty(u, ResultTypeId)
+export const isFinal = (u: unknown): u is Final<unknown, unknown, unknown> => isResult(u) && (isSuccess(u) || isFailure(u))
 export const isInitial = (u: unknown): u is Initial => isResult(u) && u._tag === "Initial"
 export const isRunning = (u: unknown): u is Running<unknown> => isResult(u) && u._tag === "Running"
 export const isSuccess = (u: unknown): u is Success<unknown> => isResult(u) && u._tag === "Success"
@@ -111,25 +116,27 @@ export const succeed = <A>(value: A): Success<A> => Object.setPrototypeOf({ _tag
 
 export const fail = <E, A = never>(
     cause: Cause.Cause<E>,
-    previousSuccess?: Success<A>,
+    previousSuccess?: Success<NoInfer<A>>,
 ): Failure<A, E> => Object.setPrototypeOf({
     _tag: "Failure",
     cause,
     previousSuccess: Option.fromNullable(previousSuccess),
 }, ResultPrototype)
+
 export const refreshing = <R extends Success<any> | Failure<any, any>, P = never>(
     result: R,
     progress?: P,
 ): Omit<R, keyof Refreshing<Result.Progress<R>>> & Refreshing<P> => Object.setPrototypeOf(
-    Object.assign({}, result, { progress }),
+    Object.assign({}, result, { refreshing: true, progress }),
     Object.getPrototypeOf(result),
 )
 
 export const fromExit = <A, E>(
-    exit: Exit.Exit<A, E>
+    exit: Exit.Exit<A, E>,
+    previousSuccess?: Success<NoInfer<A>>,
 ): Success<A> | Failure<A, E> => exit._tag === "Success"
     ? succeed(exit.value)
-    : fail(exit.cause)
+    : fail(exit.cause, previousSuccess)
 
 export const toExit = <A, E, P>(
     self: Result<A, E, P>
@@ -192,14 +199,23 @@ export const makeProgressLayer = <A, E, P = never>(): Layer.Layer<
 export namespace unsafeForkEffect {
     export type OutputContext<A, E, R, P> = Exclude<R, State<A, E, P> | Progress<P> | Progress<never>>
 
-    export interface Options<P> {
+    export type Options<A, E, P> = {
         readonly initialProgress?: P
-    }
+        readonly previous?: Final<A, E, P>
+    } & (
+        | {
+            readonly refresh: true
+            readonly previous: Final<A, E, P>
+        }
+        | {
+            readonly refresh?: false
+        }
+    )
 }
 
 export const unsafeForkEffect = <A, E, R, P = never>(
     effect: Effect.Effect<A, E, R>,
-    options?: unsafeForkEffect.Options<P>,
+    options?: unsafeForkEffect.Options<NoInfer<A>, NoInfer<E>, P>,
 ): Effect.Effect<
     readonly [result: Subscribable.Subscribable<Result<A, E, P>, never, never>, fiber: Fiber.Fiber<A, E>],
     never,
@@ -208,10 +224,13 @@ export const unsafeForkEffect = <A, E, R, P = never>(
     Effect.bind("ref", () => Ref.make(initial<A, E, P>())),
     Effect.bind("pubsub", () => PubSub.unbounded<Result<A, E, P>>()),
     Effect.bind("fiber", ({ ref, pubsub }) => Effect.forkScoped(State<A, E, P>().pipe(
-        Effect.andThen(state => state.set(running(options?.initialProgress)).pipe(
+        Effect.andThen(state => state.set(options?.refresh
+            ? refreshing(options.previous, options?.initialProgress) as Result<A, E, P>
+            : running(options?.initialProgress)
+        ).pipe(
             Effect.andThen(effect),
             Effect.onExit(exit => Effect.andThen(
-                state.set(fromExit(exit)),
+                state.set(fromExit(exit, (options?.previous && isSuccess(options.previous)) ? options.previous : undefined)),
                 Effect.forkScoped(PubSub.shutdown(pubsub)),
             )),
         )),
@@ -242,13 +261,13 @@ export const unsafeForkEffect = <A, E, R, P = never>(
 export namespace forkEffect {
     export type InputContext<R, P> = R extends Progress<infer X> ? [X] extends [P] ? R : never : R
     export type OutputContext<A, E, R, P> = unsafeForkEffect.OutputContext<A, E, R, P>
-    export interface Options<P> extends unsafeForkEffect.Options<P> {}
+    export type Options<A, E, P> = unsafeForkEffect.Options<A, E, P>
 }
 
 export const forkEffect: {
     <A, E, R, P = never>(
         effect: Effect.Effect<A, E, forkEffect.InputContext<R, NoInfer<P>>>,
-        options?: forkEffect.Options<P>,
+        options?: forkEffect.Options<NoInfer<A>, NoInfer<E>, P>,
     ): Effect.Effect<
         readonly [result: Subscribable.Subscribable<Result<A, E, P>, never, never>, fiber: Fiber.Fiber<A, E>],
         never,

packages/effect-fc/src/index.ts

@@ -3,6 +3,7 @@ export * as Component from "./Component.js"
 export * as ErrorObserver from "./ErrorObserver.js"
 export * as Form from "./Form.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"

packages/example/src/lib/form/TextFieldFormInput.tsx

@@ -29,9 +29,9 @@ export class TextFieldFormInput extends Component.makeUntraced("TextFieldFormInp
         : { optional: false, ...yield* Form.useInput(props.field, props) }
 
     const [issues, isValidating, isSubmitting] = yield* Subscribable.useSubscribables([
-        props.field.issuesSubscribable,
-        props.field.isValidatingSubscribable,
-        props.field.isSubmittingSubscribable,
+        props.field.issues,
+        props.field.isValidating,
+        props.field.isSubmitting,
     ])
 
     return (

packages/example/src/routes/form.tsx

@@ -54,9 +54,9 @@ class RegisterForm extends Effect.Service<RegisterForm>()("RegisterForm", {
         ),
 
         initialEncodedValue: { email: "", password: "", birth: Option.none() },
-        onSubmit: Effect.fnUntraced(function*(v) {
+        f: Effect.fnUntraced(function*([value]) {
             yield* Effect.sleep("500 millis")
-            return yield* Schema.decode(RegisterFormSubmitSchema)(v)
+            return yield* Schema.decode(RegisterFormSubmitSchema)(value)
         }),
         debounce: "500 millis",
     })
@@ -65,8 +65,8 @@ class RegisterForm extends Effect.Service<RegisterForm>()("RegisterForm", {
 class RegisterFormView extends Component.makeUntraced("RegisterFormView")(function*() {
     const form = yield* RegisterForm
     const [canSubmit, submitResult] = yield* Subscribable.useSubscribables([
-        form.canSubmitSubscribable,
-        form.submitResultRef,
+        form.canSubmit,
+        form.mutation.result,
     ])
 
     const runPromise = yield* Component.useRunPromise()
@@ -82,21 +82,21 @@ class RegisterFormView extends Component.makeUntraced("RegisterFormView")(functi
         <Container width="300">
             <form onSubmit={e => {
                 e.preventDefault()
-                void runPromise(Form.submit(form))
+                void runPromise(form.submit)
             }}>
                 <Flex direction="column" gap="2">
                     <TextFieldFormInputFC
-                        field={yield* Form.field(form, ["email"])}
+                        field={yield* form.field(["email"])}
                     />
 
                     <TextFieldFormInputFC
-                        field={yield* Form.field(form, ["password"])}
+                        field={yield* form.field(["password"])}
                     />
 
                     <TextFieldFormInputFC
                         optional
                         type="datetime-local"
-                        field={yield* Form.field(form, ["birth"])}
+                        field={yield* form.field(["birth"])}
                         defaultValue=""
                     />
 

packages/example/src/routes/query.tsx

@@ -1,8 +1,8 @@
 import { HttpClient, type HttpClientError } from "@effect/platform"
-import { Container, Heading, Slider, Text } from "@radix-ui/themes"
+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, Query, Subscribable, SubscriptionRef } from "effect-fc"
+import { Component, ErrorObserver, Mutation, Query, Result, Subscribable, SubscriptionRef } from "effect-fc"
 import { runtime } from "@/runtime"
 
 
@@ -14,7 +14,9 @@ const Post = Schema.Struct({
 })
 
 const ResultView = Component.makeUntraced("Result")(function*() {
-    const [idRef, query] = yield* Component.useOnMount(() => Effect.gen(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.zipLatest(Stream.make("posts" as const), idRef.changes)
 
@@ -28,11 +30,20 @@ const ResultView = Component.makeUntraced("Result")(function*() {
             ),
         })
 
-        return [idRef, query] as const
+        const mutation = yield* Mutation.make({
+            f: ([id]: readonly [id: number]) => HttpClient.HttpClient.pipe(
+                Effect.tap(Effect.sleep("500 millis")),
+                Effect.andThen(client => client.get(`https://jsonplaceholder.typicode.com/posts/${ id }`)),
+                Effect.andThen(response => response.json),
+                Effect.andThen(Schema.decodeUnknown(Post)),
+            ),
+        })
+
+        return [idRef, query, mutation] as const
     }))
 
     const [id, setId] = yield* SubscriptionRef.useSubscriptionRefState(idRef)
-    const [result] = yield* Subscribable.useSubscribables([query.result])
+    const [queryResult, mutationResult] = yield* Subscribable.useSubscribables([query.result, mutation.result])
 
     yield* Component.useOnMount(() => ErrorObserver.ErrorObserver<HttpClientError.HttpClientError>().pipe(
         Effect.andThen(observer => observer.subscribe),
@@ -51,22 +62,51 @@ const ResultView = Component.makeUntraced("Result")(function*() {
 
     return (
         <Container>
-            <Slider
-                value={[id]}
-                onValueChange={flow(Array.head, Option.getOrThrow, setId)}
-            />
+            <Flex direction="column" align="center" gap="2">
+                <Slider
+                    value={[id]}
+                    onValueChange={flow(Array.head, Option.getOrThrow, setId)}
+                />
 
-            {Match.value(result).pipe(
-                Match.tag("Running", () => <Text>Loading...</Text>),
-                Match.tag("Success", result => <>
-                    <Heading>{result.value.title}</Heading>
-                    <Text>{result.value.body}</Text>
-                </>),
-                Match.tag("Failure", result =>
-                    <Text>An error has occured: {result.cause.toString()}</Text>
-                ),
-                Match.orElse(() => <></>),
-            )}
+                <div>
+                    {Match.value(queryResult).pipe(
+                        Match.tag("Running", () => <Text>Loading...</Text>),
+                        Match.tag("Success", result => <>
+                            <Heading>{result.value.title}</Heading>
+                            <Text>{result.value.body}</Text>
+                            {Result.isRefreshing(result) && <Text>Refreshing...</Text>}
+                        </>),
+                        Match.tag("Failure", result =>
+                            <Text>An error has occured: {result.cause.toString()}</Text>
+                        ),
+                        Match.orElse(() => <></>),
+                    )}
+                </div>
+
+                <Flex direction="row" justify="center" align="center" gap="1">
+                    <Button onClick={() => runPromise(query.refresh)}>Refresh</Button>
+                    <Button onClick={() => runPromise(query.refetch)}>Refetch</Button>
+                </Flex>
+
+                <div>
+                    {Match.value(mutationResult).pipe(
+                        Match.tag("Running", () => <Text>Loading...</Text>),
+                        Match.tag("Success", result => <>
+                            <Heading>{result.value.title}</Heading>
+                            <Text>{result.value.body}</Text>
+                            {Result.isRefreshing(result) && <Text>Refreshing...</Text>}
+                        </>),
+                        Match.tag("Failure", result =>
+                            <Text>An error has occured: {result.cause.toString()}</Text>
+                        ),
+                        Match.orElse(() => <></>),
+                    )}
+                </div>
+
+                <Flex direction="row" justify="center" align="center" gap="1">
+                    <Button onClick={() => runPromise(Effect.andThen(idRef, id => mutation.mutate([id])))}>Mutate</Button>
+                </Flex>
+            </Flex>
         </Container>
     )
 })

packages/example/src/todo/Todo.tsx

@@ -54,17 +54,15 @@ export class Todo extends Component.makeUntraced("Todo")(function*(props: TodoPr
                     Match.exhaustive,
                 )
             ),
-            onSubmit: function(todo) {
-                return 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 => Ref.set(this.encodedValueRef, v)),
-                    )),
-                    Match.tag("edit", ({ id }) => Ref.set(state.getElementRef(id), todo)),
-                    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 => Ref.set(form.encodedValue, v)),
+                )),
+                Match.tag("edit", ({ id }) => Ref.set(state.getElementRef(id), todo)),
+                Match.exhaustive,
+            ),
             autosubmit: props._tag === "edit",
             debounce: "250 millis",
         })
@@ -72,15 +70,15 @@ export class Todo extends Component.makeUntraced("Todo")(function*(props: TodoPr
         return [
             indexRef,
             form,
-            yield* Form.field(form, ["content"]),
-            yield* Form.field(form, ["completedAt"]),
+            yield* form.field(["content"]),
+            yield* form.field(["completedAt"]),
         ] as const
     }), [props._tag, props._tag === "edit" ? props.id : undefined])
 
     const [index, size, canSubmit] = yield* Subscribable.useSubscribables([
         indexRef,
         state.sizeSubscribable,
-        form.canSubmitSubscribable,
+        form.canSubmit,
     ])
 
     const runSync = yield* Component.useRunSync()
@@ -103,7 +101,7 @@ export class Todo extends Component.makeUntraced("Todo")(function*(props: TodoPr
                         />
 
                         {props._tag === "new" &&
-                            <Button disabled={!canSubmit} onClick={() => void runPromise(Form.submit(form))}>
+                            <Button disabled={!canSubmit} onClick={() => void runPromise(form.submit)}>
                                 Add
                             </Button>
                         }