Rename packages

packages/example/README.md

@@ -1,50 +1,10 @@
-# React + TypeScript + Vite
+# Effect FC Next Example
 
-This template provides a minimal setup to get React working in Vite with HMR and some ESLint rules.
+Minimal React example for `effect-fc-next`, Effect V4, and `effect-lens@2`.
 
-Currently, two official plugins are available:
-
-- [@vitejs/plugin-react](https://github.com/vitejs/vite-plugin-react/blob/main/packages/plugin-react/README.md) uses [Babel](https://babeljs.io/) for Fast Refresh
-- [@vitejs/plugin-react-swc](https://github.com/vitejs/vite-plugin-react-swc) uses [SWC](https://swc.rs/) for Fast Refresh
-
-## Expanding the ESLint configuration
-
-If you are developing a production application, we recommend updating the configuration to enable type aware lint rules:
-
-- Configure the top-level `parserOptions` property like this:
-
-```js
-export default tseslint.config({
-  languageOptions: {
-    // other options...
-    parserOptions: {
-      project: ['./tsconfig.node.json', './tsconfig.app.json'],
-      tsconfigRootDir: import.meta.dirname,
-    },
-  },
-})
+```bash
+bun run dev
 ```
 
-- Replace `tseslint.configs.recommended` to `tseslint.configs.recommendedTypeChecked` or `tseslint.configs.strictTypeChecked`
-- Optionally add `...tseslint.configs.stylisticTypeChecked`
-- Install [eslint-plugin-react](https://github.com/jsx-eslint/eslint-plugin-react) and update the config:
-
-```js
-// eslint.config.js
-import react from 'eslint-plugin-react'
-
-export default tseslint.config({
-  // Set the react version
-  settings: { react: { version: '18.3' } },
-  plugins: {
-    // Add the react plugin
-    react,
-  },
-  rules: {
-    // other rules...
-    // Enable its recommended rules
-    ...react.configs.recommended.rules,
-    ...react.configs['jsx-runtime'].rules,
-  },
-})
-```
+The counter demonstrates a V4 `SubscriptionRef` exposed as an Effect Lens and
+rendered through an Effect-FC component.

packages/example/package.json

@@ -1,9 +1,10 @@
 {
-  "name": "@effect-fc/example",
+  "name": "@effect-view/example",
   "version": "0.0.0",
   "type": "module",
   "private": true,
   "scripts": {
+    "build": "tsc -b && vite build",
     "dev": "vite",
     "lint:tsc": "tsc -b --noEmit",
     "lint:biome": "biome lint",
@@ -13,6 +14,7 @@
     "clean:modules": "rm -rf node_modules"
   },
   "devDependencies": {
+    "@effect-view/vite-plugin": "workspace:*",
     "@tanstack/react-router": "^1.170.10",
     "@tanstack/react-router-devtools": "^1.167.0",
     "@tanstack/router-plugin": "^1.168.13",
@@ -22,21 +24,18 @@
     "globals": "^17.6.0",
     "react": "^19.2.6",
     "react-dom": "^19.2.6",
-    "type-fest": "^5.7.0",
     "vite": "^8.0.16"
   },
   "dependencies": {
-    "@effect/platform": "^0.96.1",
-    "@effect/platform-browser": "^0.76.0",
+    "@effect/platform-browser": "4.0.0-beta.98",
     "@radix-ui/themes": "^3.3.0",
-    "@typed/id": "^0.17.2",
-    "effect": "^3.21.2",
-    "effect-fc": "workspace:*",
+    "effect": "4.0.0-beta.98",
+    "effect-fc-next": "workspace:*",
     "react-icons": "^5.6.0"
   },
   "overrides": {
     "@types/react": "^19.2.15",
-    "effect": "^3.21.2",
+    "effect": "4.0.0-beta.98",
     "react": "^19.2.6"
   }
 }

packages/example/public/vite.svg

@@ -1 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink" aria-hidden="true" role="img" class="iconify iconify--logos" width="31.88" height="32" preserveAspectRatio="xMidYMid meet" viewBox="0 0 256 257"><defs><linearGradient id="IconifyId1813088fe1fbc01fb466" x1="-.828%" x2="57.636%" y1="7.652%" y2="78.411%"><stop offset="0%" stop-color="#41D1FF"></stop><stop offset="100%" stop-color="#BD34FE"></stop></linearGradient><linearGradient id="IconifyId1813088fe1fbc01fb467" x1="43.376%" x2="50.316%" y1="2.242%" y2="89.03%"><stop offset="0%" stop-color="#FFEA83"></stop><stop offset="8.333%" stop-color="#FFDD35"></stop><stop offset="100%" stop-color="#FFA800"></stop></linearGradient></defs><path fill="url(#IconifyId1813088fe1fbc01fb466)" d="M255.153 37.938L134.897 252.976c-2.483 4.44-8.862 4.466-11.382.048L.875 37.958c-2.746-4.814 1.371-10.646 6.827-9.67l120.385 21.517a6.537 6.537 0 0 0 2.322-.004l117.867-21.483c5.438-.991 9.574 4.796 6.877 9.62Z"></path><path fill="url(#IconifyId1813088fe1fbc01fb467)" d="M185.432.063L96.44 17.501a3.268 3.268 0 0 0-2.634 3.014l-5.474 92.456a3.268 3.268 0 0 0 3.997 3.378l24.777-5.718c2.318-.535 4.413 1.507 3.936 3.838l-7.361 36.047c-.495 2.426 1.782 4.5 4.151 3.78l15.304-4.649c2.372-.72 4.652 1.36 4.15 3.788l-11.698 56.621c-.732 3.542 3.979 5.473 5.943 2.437l1.313-2.028l72.516-144.72c1.215-2.423-.88-5.186-3.54-4.672l-25.505 4.922c-2.396.462-4.435-1.77-3.759-4.114l16.646-57.705c.677-2.35-1.37-4.583-3.769-4.113Z"></path></svg>

packages/example/src/domain/Todo.ts

@@ -1,20 +0,0 @@
-import { Schema } from "effect"
-import { assertEncodedJsonifiable } from "@/lib/schema"
-
-
-export class Todo extends Schema.Class<Todo>("Todo")({
-    _tag: Schema.tag("Todo"),
-    id: Schema.String,
-    content: Schema.String,
-    completedAt: Schema.OptionFromSelf(Schema.DateTimeUtcFromSelf),
-}) {}
-
-
-export const TodoFromJsonStruct = Schema.Struct({
-    ...Todo.fields,
-    completedAt: Schema.Option(Schema.DateTimeUtc),
-}).pipe(
-    assertEncodedJsonifiable
-)
-
-export const TodoFromJson = Schema.compose(TodoFromJsonStruct, Todo)

packages/example/src/domain/index.ts

@@ -1 +0,0 @@
-export * as Todo from "./Todo"

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

@@ -1,6 +1,6 @@
 import { Callout, Flex, Spinner, TextField } from "@radix-ui/themes"
 import { Array, Option, Struct } from "effect"
-import { Component, Form, Subscribable } from "effect-fc"
+import { Component, Form, View } from "effect-fc-next"
 import type * as React from "react"
 
 
@@ -17,7 +17,7 @@ export const TextFieldFormInputView = Component.make("TextFieldFormInputView")(f
     props: TextFieldFormInputView.Props<readonly PropertyKey[], any, any, any>
 ) {
     const input = yield* Form.useInput(props.form, props)
-    const [issues, isValidating, isCommitting] = yield* Subscribable.useAll([
+    const [issues, isValidating, isCommitting] = yield* View.useAll([
         props.form.issues,
         props.form.isValidating,
         props.form.isCommitting,
@@ -29,7 +29,7 @@ export const TextFieldFormInputView = Component.make("TextFieldFormInputView")(f
                 value={input.value}
                 onChange={e => input.setValue(e.target.value)}
                 disabled={isCommitting}
-                {...Struct.omit(props, "form")}
+                {...Struct.omit(props, ["form"])}
             >
                 {isValidating &&
                     <TextField.Slot side="right">

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

@@ -1,6 +1,6 @@
 import { Callout, Flex, Spinner, Switch, TextField } from "@radix-ui/themes"
 import { Array, Option, Struct } from "effect"
-import { Component, Form, Subscribable } from "effect-fc"
+import { Component, Form, View } from "effect-fc-next"
 import type * as React from "react"
 
 
@@ -17,7 +17,7 @@ export const TextFieldOptionalFormInputView = Component.make("TextFieldOptionalF
     props: TextFieldOptionalFormInputView.Props<readonly PropertyKey[], any, any, any>
 ) {
     const input = yield* Form.useOptionalInput(props.form, props)
-    const [issues, isValidating, isCommitting] = yield* Subscribable.useAll([
+    const [issues, isValidating, isCommitting] = yield* View.useAll([
         props.form.issues,
         props.form.isValidating,
         props.form.isCommitting,
@@ -29,7 +29,7 @@ export const TextFieldOptionalFormInputView = Component.make("TextFieldOptionalF
                 value={input.value}
                 onChange={e => input.setValue(e.target.value)}
                 disabled={!input.enabled || isCommitting}
-                {...Struct.omit(props, "form", "defaultValue")}
+                {...Struct.omit(props, ["form", "defaultValue"])}
             >
                 <TextField.Slot side="left">
                     <Switch

packages/example/src/lib/schema/datetime.ts

@@ -1,38 +0,0 @@
-import { DateTime, Effect, Option, ParseResult, Schema } from "effect"
-
-
-export class DateTimeUtcFromZoned extends Schema.transformOrFail(
-    Schema.DateTimeZonedFromSelf,
-    Schema.DateTimeUtcFromSelf,
-    {
-        strict: true,
-        encode: DateTime.setZoneCurrent,
-        decode: i => ParseResult.succeed(DateTime.toUtc(i)),
-    },
-) {}
-
-export class DateTimeZonedFromUtc extends Schema.transformOrFail(
-    Schema.DateTimeUtcFromSelf,
-    Schema.DateTimeZonedFromSelf,
-    {
-        strict: true,
-        encode: a => ParseResult.succeed(DateTime.toUtc(a)),
-        decode: DateTime.setZoneCurrent,
-    },
-) {}
-
-export class DateTimeUtcFromZonedInput extends Schema.transformOrFail(
-    Schema.String,
-    DateTimeUtcFromZoned,
-    {
-        strict: true,
-        encode: a => ParseResult.succeed(DateTime.formatIsoZoned(a).slice(0, 16)),
-        decode: (i, _, ast) => Effect.flatMap(
-            DateTime.CurrentTimeZone,
-            timeZone => Option.match(DateTime.makeZoned(i, { timeZone, adjustForTimeZone: true }), {
-                onSome: ParseResult.succeed,
-                onNone: () => ParseResult.fail(new ParseResult.Type(ast, i, `Unable to decode ${JSON.stringify(i)} into a DateTime.Zoned`)),
-            }),
-        ),
-    },
-) {}

packages/example/src/lib/schema/index.ts

@@ -1,2 +0,0 @@
-export * from "./datetime"
-export * from "./json"

packages/example/src/lib/schema/json.ts

@@ -1,6 +0,0 @@
-import type { Schema } from "effect"
-import type { JsonValue } from "type-fest"
-
-
-export const assertEncodedJsonifiable = <S extends Schema.Schema<A, I, R>, A, I extends JsonValue, R>(schema: S & Schema.Schema<A, I, R>): S => schema
-export const assertTypeJsonifiable = <S extends Schema.Schema<A, I, R>, A extends JsonValue, I, R>(schema: S & Schema.Schema<A, I, R>): S => schema

packages/example/src/main.tsx

@@ -1,24 +1,21 @@
 import { createRouter, RouterProvider } from "@tanstack/react-router"
-import { ReactRuntime } from "effect-fc"
+import { ReactRuntime } from "effect-fc-next"
 import { StrictMode } from "react"
 import { createRoot } from "react-dom/client"
 import { routeTree } from "./routeTree.gen"
 import { runtime } from "./runtime"
 
-
 const router = createRouter({ routeTree })
 
 declare module "@tanstack/react-router" {
-    interface Register {
-        router: typeof router
-    }
+    interface Register { router: typeof router }
 }
 
-// biome-ignore lint/style/noNonNullAssertion: React entrypoint
+// biome-ignore lint/style/noNonNullAssertion: the Vite template provides this element
 createRoot(document.getElementById("root")!).render(
     <StrictMode>
         <ReactRuntime.Provider runtime={runtime}>
             <RouterProvider router={router} />
         </ReactRuntime.Provider>
-    </StrictMode>
+    </StrictMode>,
 )

packages/example/src/routeTree.gen.ts

@@ -9,33 +9,16 @@
 // Additionally, you should also exclude this file from your linter and/or formatter to prevent it from being checked or modified.
 
 import { Route as rootRouteImport } from './routes/__root'
-import { Route as ResultRouteImport } from './routes/result'
-import { Route as QueryRouteImport } from './routes/query'
-import { Route as FormRouteImport } from './routes/form'
-import { Route as BlankRouteImport } from './routes/blank'
-import { Route as AsyncRouteImport } from './routes/async'
 import { Route as IndexRouteImport } from './routes/index'
-import { Route as DevMemoRouteImport } from './routes/dev/memo'
-import { Route as DevContextRouteImport } from './routes/dev/context'
+import { Route as AsyncRouteImport } from './routes/async'
+import { Route as BlankRouteImport } from './routes/blank'
+import { Route as FormRouteImport } from './routes/form'
+import { Route as LensformRouteImport } from './routes/lensform'
+import { Route as QueryRouteImport } from './routes/query'
 
-const ResultRoute = ResultRouteImport.update({
-  id: '/result',
-  path: '/result',
-  getParentRoute: () => rootRouteImport,
-} as any)
-const QueryRoute = QueryRouteImport.update({
-  id: '/query',
-  path: '/query',
-  getParentRoute: () => rootRouteImport,
-} as any)
-const FormRoute = FormRouteImport.update({
-  id: '/form',
-  path: '/form',
-  getParentRoute: () => rootRouteImport,
-} as any)
-const BlankRoute = BlankRouteImport.update({
-  id: '/blank',
-  path: '/blank',
+const IndexRoute = IndexRouteImport.update({
+  id: '/',
+  path: '/',
   getParentRoute: () => rootRouteImport,
 } as any)
 const AsyncRoute = AsyncRouteImport.update({
@@ -43,19 +26,24 @@ const AsyncRoute = AsyncRouteImport.update({
   path: '/async',
   getParentRoute: () => rootRouteImport,
 } as any)
-const IndexRoute = IndexRouteImport.update({
-  id: '/',
-  path: '/',
+const BlankRoute = BlankRouteImport.update({
+  id: '/blank',
+  path: '/blank',
   getParentRoute: () => rootRouteImport,
 } as any)
-const DevMemoRoute = DevMemoRouteImport.update({
-  id: '/dev/memo',
-  path: '/dev/memo',
+const FormRoute = FormRouteImport.update({
+  id: '/form',
+  path: '/form',
   getParentRoute: () => rootRouteImport,
 } as any)
-const DevContextRoute = DevContextRouteImport.update({
-  id: '/dev/context',
-  path: '/dev/context',
+const LensformRoute = LensformRouteImport.update({
+  id: '/lensform',
+  path: '/lensform',
+  getParentRoute: () => rootRouteImport,
+} as any)
+const QueryRoute = QueryRouteImport.update({
+  id: '/query',
+  path: '/query',
   getParentRoute: () => rootRouteImport,
 } as any)
 
@@ -64,20 +52,16 @@ export interface FileRoutesByFullPath {
   '/async': typeof AsyncRoute
   '/blank': typeof BlankRoute
   '/form': typeof FormRoute
+  '/lensform': typeof LensformRoute
   '/query': typeof QueryRoute
-  '/result': typeof ResultRoute
-  '/dev/context': typeof DevContextRoute
-  '/dev/memo': typeof DevMemoRoute
 }
 export interface FileRoutesByTo {
   '/': typeof IndexRoute
   '/async': typeof AsyncRoute
   '/blank': typeof BlankRoute
   '/form': typeof FormRoute
+  '/lensform': typeof LensformRoute
   '/query': typeof QueryRoute
-  '/result': typeof ResultRoute
-  '/dev/context': typeof DevContextRoute
-  '/dev/memo': typeof DevMemoRoute
 }
 export interface FileRoutesById {
   __root__: typeof rootRouteImport
@@ -85,42 +69,15 @@ export interface FileRoutesById {
   '/async': typeof AsyncRoute
   '/blank': typeof BlankRoute
   '/form': typeof FormRoute
+  '/lensform': typeof LensformRoute
   '/query': typeof QueryRoute
-  '/result': typeof ResultRoute
-  '/dev/context': typeof DevContextRoute
-  '/dev/memo': typeof DevMemoRoute
 }
 export interface FileRouteTypes {
   fileRoutesByFullPath: FileRoutesByFullPath
-  fullPaths:
-    | '/'
-    | '/async'
-    | '/blank'
-    | '/form'
-    | '/query'
-    | '/result'
-    | '/dev/context'
-    | '/dev/memo'
+  fullPaths: '/' | '/async' | '/blank' | '/form' | '/lensform' | '/query'
   fileRoutesByTo: FileRoutesByTo
-  to:
-    | '/'
-    | '/async'
-    | '/blank'
-    | '/form'
-    | '/query'
-    | '/result'
-    | '/dev/context'
-    | '/dev/memo'
-  id:
-    | '__root__'
-    | '/'
-    | '/async'
-    | '/blank'
-    | '/form'
-    | '/query'
-    | '/result'
-    | '/dev/context'
-    | '/dev/memo'
+  to: '/' | '/async' | '/blank' | '/form' | '/lensform' | '/query'
+  id: '__root__' | '/' | '/async' | '/blank' | '/form' | '/lensform' | '/query'
   fileRoutesById: FileRoutesById
 }
 export interface RootRouteChildren {
@@ -128,40 +85,17 @@ export interface RootRouteChildren {
   AsyncRoute: typeof AsyncRoute
   BlankRoute: typeof BlankRoute
   FormRoute: typeof FormRoute
+  LensformRoute: typeof LensformRoute
   QueryRoute: typeof QueryRoute
-  ResultRoute: typeof ResultRoute
-  DevContextRoute: typeof DevContextRoute
-  DevMemoRoute: typeof DevMemoRoute
 }
 
 declare module '@tanstack/react-router' {
   interface FileRoutesByPath {
-    '/result': {
-      id: '/result'
-      path: '/result'
-      fullPath: '/result'
-      preLoaderRoute: typeof ResultRouteImport
-      parentRoute: typeof rootRouteImport
-    }
-    '/query': {
-      id: '/query'
-      path: '/query'
-      fullPath: '/query'
-      preLoaderRoute: typeof QueryRouteImport
-      parentRoute: typeof rootRouteImport
-    }
-    '/form': {
-      id: '/form'
-      path: '/form'
-      fullPath: '/form'
-      preLoaderRoute: typeof FormRouteImport
-      parentRoute: typeof rootRouteImport
-    }
-    '/blank': {
-      id: '/blank'
-      path: '/blank'
-      fullPath: '/blank'
-      preLoaderRoute: typeof BlankRouteImport
+    '/': {
+      id: '/'
+      path: '/'
+      fullPath: '/'
+      preLoaderRoute: typeof IndexRouteImport
       parentRoute: typeof rootRouteImport
     }
     '/async': {
@@ -171,25 +105,32 @@ declare module '@tanstack/react-router' {
       preLoaderRoute: typeof AsyncRouteImport
       parentRoute: typeof rootRouteImport
     }
-    '/': {
-      id: '/'
-      path: '/'
-      fullPath: '/'
-      preLoaderRoute: typeof IndexRouteImport
+    '/blank': {
+      id: '/blank'
+      path: '/blank'
+      fullPath: '/blank'
+      preLoaderRoute: typeof BlankRouteImport
       parentRoute: typeof rootRouteImport
     }
-    '/dev/memo': {
-      id: '/dev/memo'
-      path: '/dev/memo'
-      fullPath: '/dev/memo'
-      preLoaderRoute: typeof DevMemoRouteImport
+    '/form': {
+      id: '/form'
+      path: '/form'
+      fullPath: '/form'
+      preLoaderRoute: typeof FormRouteImport
       parentRoute: typeof rootRouteImport
     }
-    '/dev/context': {
-      id: '/dev/context'
-      path: '/dev/context'
-      fullPath: '/dev/context'
-      preLoaderRoute: typeof DevContextRouteImport
+    '/lensform': {
+      id: '/lensform'
+      path: '/lensform'
+      fullPath: '/lensform'
+      preLoaderRoute: typeof LensformRouteImport
+      parentRoute: typeof rootRouteImport
+    }
+    '/query': {
+      id: '/query'
+      path: '/query'
+      fullPath: '/query'
+      preLoaderRoute: typeof QueryRouteImport
       parentRoute: typeof rootRouteImport
     }
   }
@@ -200,10 +141,8 @@ const rootRouteChildren: RootRouteChildren = {
   AsyncRoute: AsyncRoute,
   BlankRoute: BlankRoute,
   FormRoute: FormRoute,
+  LensformRoute: LensformRoute,
   QueryRoute: QueryRoute,
-  ResultRoute: ResultRoute,
-  DevContextRoute: DevContextRoute,
-  DevMemoRoute: DevMemoRoute,
 }
 export const routeTree = rootRouteImport
   ._addFileChildren(rootRouteChildren)

packages/example/src/routes/__root.tsx

@@ -7,7 +7,7 @@ import "../index.css"
 
 
 export const Route = createRootRoute({
-    component: Root
+    component: Root,
 })
 
 function Root() {
@@ -17,6 +17,10 @@ function Root() {
                 <Flex direction="row" justify="center" align="center" gap="2">
                     <Link to="/">Index</Link>
                     <Link to="/blank">Blank</Link>
+                    <Link to="/async">Async</Link>
+                    <Link to="/query">Query</Link>
+                    <Link to="/form">Form</Link>
+                    <Link to="/lensform">LensForm</Link>
                 </Flex>
             </Container>
 

packages/example/src/routes/async.tsx

@@ -1,30 +1,35 @@
-import { HttpClient } from "@effect/platform"
 import { Container, Flex, Heading, Slider, Text, TextField } from "@radix-ui/themes"
 import { createFileRoute } from "@tanstack/react-router"
-import { Array, Effect, flow, Option, Schema } from "effect"
-import { Async, Component, Memoized } from "effect-fc"
+import { Console, Effect } from "effect"
+import { Async, Component, Memoized } from "effect-fc-next"
 import * as React from "react"
 import { runtime } from "@/runtime"
 
 
-const Post = Schema.Struct({
-    userId: Schema.Int,
-    id: Schema.Int,
-    title: Schema.String,
-    body: Schema.String,
-})
+const fetchPost = (id: number) => Effect.sleep("500 millis").pipe(
+    Effect.as({
+        title: `Post ${id}`,
+        body: `This is the content of post ${id}.`,
+    }),
+)
+
 
 interface AsyncFetchPostViewProps {
     readonly id: number
 }
 
-class AsyncFetchPostView extends Component.make("AsyncFetchPostView")(function*(props: AsyncFetchPostViewProps) {
-    const post = yield* Component.useOnChange(() => HttpClient.HttpClient.pipe(
-        Effect.tap(Effect.sleep("500 millis")),
-        Effect.andThen(client => client.get(`https://jsonplaceholder.typicode.com/posts/${ props.id }`)),
-        Effect.andThen(response => response.json),
-        Effect.andThen(Schema.decodeUnknown(Post)),
-    ), [props.id])
+const AsyncFetchPostView = Component.make("AsyncFetchPostView")(function*(
+    props: AsyncFetchPostViewProps,
+) {
+    yield* Component.useOnMount(() => Effect.gen(function*() {
+        yield* Effect.addFinalizer(() => Console.log("AsyncFetchPostView unmounted"))
+        yield* Console.log("AsyncFetchPostView mounted")
+    }))
+
+    const post = yield* Component.useOnChange(
+        () => fetchPost(props.id),
+        [props.id],
+    )
 
     return (
         <div>
@@ -34,10 +39,9 @@ class AsyncFetchPostView extends Component.make("AsyncFetchPostView")(function*(
     )
 }).pipe(
     Async.async,
-    Async.withOptions({ defaultFallback: <Text>Default fallback</Text> }),
+    Async.withOptions({ defaultFallback: <Text>Loading post...</Text> }),
     Memoized.memoized,
-) {}
-
+)
 
 const AsyncRouteComponent = Component.make("AsyncRouteView")(function*() {
     const [text, setText] = React.useState("Typing here should not trigger a refetch of the post")
@@ -50,20 +54,22 @@ const AsyncRouteComponent = Component.make("AsyncRouteView")(function*() {
             <Flex direction="column" align="stretch" gap="2">
                 <TextField.Root
                     value={text}
-                    onChange={e => setText(e.currentTarget.value)}
+                    onChange={event => setText(event.currentTarget.value)}
                 />
 
                 <Slider
                     value={[id]}
-                    onValueChange={flow(Array.head, Option.getOrThrow, setId)}
+                    min={1}
+                    max={10}
+                    onValueChange={([value]) => setId(value ?? 1)}
                 />
 
-                <AsyncFetchPost id={id} fallback={<Text>Loading post...</Text>} />
+                <AsyncFetchPost id={id} />
             </Flex>
         </Container>
     )
 }).pipe(
-    Component.withRuntime(runtime.context)
+    Component.withContext(runtime.context),
 )
 
 export const Route = createFileRoute("/async")({

packages/example/src/routes/dev/context.tsx

@@ -1,42 +0,0 @@
-import { Container, Flex, Text, TextField } from "@radix-ui/themes"
-import { createFileRoute } from "@tanstack/react-router"
-import { Console, Effect } from "effect"
-import { Component } from "effect-fc"
-import * as React from "react"
-import { runtime } from "@/runtime"
-
-
-class SubService extends Effect.Service<SubService>()("SubService", {
-    effect: (value: string) => Effect.succeed({ value })
-}) {}
-
-const SubComponent = Component.makeUntraced("SubComponent")(function*() {
-    const service = yield* SubService
-    yield* Component.useOnMount(() => Effect.gen(function*() {
-        yield* Effect.addFinalizer(() => Console.log("SubComponent unmounted"))
-        yield* Console.log("SubComponent mounted")
-    }))
-
-    return <Text>{service.value}</Text>
-})
-
-const ContextView = Component.makeUntraced("ContextView")(function*() {
-    const [serviceValue, setServiceValue] = React.useState("test")
-    const SubServiceLayer = React.useMemo(() => SubService.Default(serviceValue), [serviceValue])
-    const SubComponentFC = yield* Effect.provide(SubComponent.use, yield* Component.useLayer(SubServiceLayer))
-
-    return (
-        <Container>
-            <Flex direction="column" align="center">
-                <TextField.Root value={serviceValue} onChange={e => setServiceValue(e.target.value)} />
-                <SubComponentFC />
-            </Flex>
-        </Container>
-    )
-}).pipe(
-    Component.withRuntime(runtime.context)
-)
-
-export const Route = createFileRoute("/dev/context")({
-    component: ContextView
-})

packages/example/src/routes/dev/memo.tsx

@@ -1,37 +0,0 @@
-import { Flex, Text, TextField } from "@radix-ui/themes"
-import { createFileRoute } from "@tanstack/react-router"
-import { GetRandomValues, makeUuid4 } from "@typed/id"
-import { Effect } from "effect"
-import { Component, Memoized } from "effect-fc"
-import * as React from "react"
-import { runtime } from "@/runtime"
-
-
-const RouteComponent = Component.makeUntraced("RouteComponent")(function*() {
-    const [value, setValue] = React.useState("")
-
-    return (
-        <Flex direction="column" gap="2">
-            <TextField.Root
-                value={value}
-                onChange={e => setValue(e.target.value)}
-            />
-
-            {yield* Effect.map(SubComponent.use, FC => <FC />)}
-            {yield* Effect.map(MemoizedSubComponent.use, FC => <FC />)}
-        </Flex>
-    )
-}).pipe(
-    Component.withRuntime(runtime.context)
-)
-
-class SubComponent extends Component.makeUntraced("SubComponent")(function*() {
-    const id = yield* makeUuid4.pipe(Effect.provide(GetRandomValues.CryptoRandom))
-    return <Text>{id}</Text>
-}) {}
-
-class MemoizedSubComponent extends Memoized.memoized(SubComponent) {}
-
-export const Route = createFileRoute("/dev/memo")({
-    component: RouteComponent,
-})

packages/example/src/routes/form.tsx

@@ -1,143 +1,82 @@
 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 { Console, Effect, Schema } from "effect"
+import { Component, Form, MutationForm, View } from "effect-fc-next"
 import { TextFieldFormInputView } from "@/lib/form/TextFieldFormInputView"
-import { TextFieldOptionalFormInputView } from "@/lib/form/TextFieldOptionalFormInputView"
-import { DateTimeUtcFromZonedInput } from "@/lib/schema"
 import { runtime } from "@/runtime"
 
 
-const email = Schema.pattern<typeof Schema.String>(
-    /^(?!\.)(?!.*\.\.)([A-Z0-9_+-.]*)[A-Z0-9_+-]@([A-Z0-9][A-Z0-9-]*\.)+[A-Z]{2,}$/i,
-
-    {
-        identifier: "email",
-        title: "email",
-        message: () => "Not an email address",
-    },
-)
-
-const RegisterFormSchema = Schema.Struct({
-    email: Schema.String.pipe(email),
-    password: Schema.String.pipe(Schema.minLength(3)),
-    birth: Schema.OptionFromSelf(DateTimeUtcFromZonedInput),
-})
-
-const RegisterFormSubmitSchema = Schema.Struct({
-    email: Schema.transformOrFail(
-        Schema.String,
-        Schema.String,
-        {
-            decode: (input, _options, ast) => input !== "admin@admin.com"
-                ? ParseResult.succeed(input)
-                : ParseResult.fail(new ParseResult.Type(ast, input, "This email is already in use.")),
-            encode: ParseResult.succeed,
-        },
+const RegisterSchema = Schema.Struct({
+    email: Schema.String.check(
+        Schema.isPattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/, {
+            message: "Enter a valid email address",
+        }),
+    ),
+    password: Schema.String.check(
+        Schema.isMinLength(5, {
+            message: "Password must be at least 5 characters long",
+        }),
     ),
-    password: Schema.String,
-    birth: Schema.OptionFromSelf(Schema.DateTimeUtcFromSelf),
 })
 
-class RegisterFormService extends Effect.Service<RegisterFormService>()("RegisterFormService", {
-    scoped: Effect.gen(function*() {
-        const form = yield* SubmittableForm.service({
-            schema: RegisterFormSchema.pipe(
-                Schema.compose(
-                    Schema.transformOrFail(
-                        Schema.typeSchema(RegisterFormSchema),
-                        Schema.typeSchema(RegisterFormSchema),
-                        {
-                            decode: v => Effect.andThen(Effect.sleep("500 millis"), ParseResult.succeed(v)),
-                            encode: ParseResult.succeed,
-                        },
-                    ),
-                ),
-            ),
+const RegisterRouteComponent = Component.make("RegisterRouteView")(function*() {
+    yield* Component.useOnMount(() => Effect.gen(function*() {
+        yield* Effect.addFinalizer(() => Console.log("Form route unmounted"))
+        yield* Console.log("Form route mounted")
+    }))
 
-            initialEncodedValue: { email: "", password: "", birth: Option.none() },
-            f: Effect.fnUntraced(function*([value]) {
-                yield* Effect.sleep("500 millis")
-                return yield* Schema.decode(RegisterFormSubmitSchema)(value)
-            }),
+    const [form, emailField, passwordField] = yield* Component.useOnMount(() => Effect.gen(function*() {
+        const form = yield* MutationForm.service({
+            schema: RegisterSchema,
+            initialEncodedValue: { email: "", password: "" },
+            f: ([value]) => Effect.log(`Registered ${value.email}`),
         })
 
-        return {
-            form,
-            emailField: Form.focusObjectOn(form, "email"),
-            passwordField: Form.focusObjectOn(form, "password"),
-            birthField: Form.focusObjectOn(form, "birth"),
-        } as const
-    })
-}) {}
+        const emailField = Form.focusObjectOn(form, "email")
+        const passwordField = Form.focusObjectOn(form, "password")
 
-class RegisterFormView extends Component.make("RegisterFormView")(function*() {
-    const form = yield* RegisterFormService
-    const [canCommit, submitResult] = yield* Subscribable.useAll([
-        form.form.canCommit,
-        form.form.mutation.result,
+        return [form, emailField, passwordField] as const
+    }))
+
+    const [canCommit, isCommitting] = yield* View.useAll([
+        form.canCommit,
+        form.isCommitting,
     ])
 
-    const runPromise = yield* Component.useRunPromise()
     const TextFieldFormInput = yield* TextFieldFormInputView.use
-    const TextFieldOptionalFormInput = yield* TextFieldOptionalFormInputView.use
-
-    yield* Component.useOnMount(() => Effect.gen(function*() {
-        yield* Effect.addFinalizer(() => Console.log("RegisterFormView unmounted"))
-        yield* Console.log("RegisterFormView mounted")
-    }))
+    const runPromise = yield* Component.useRunPromise()
 
 
     return (
         <Container width="300">
-            <form onSubmit={e => {
-                e.preventDefault()
-                void runPromise(form.form.submit)
+            <form onSubmit={event => {
+                event.preventDefault()
+                void runPromise(form.submit)
             }}>
                 <Flex direction="column" gap="2">
                     <TextFieldFormInput
-                        form={form.emailField}
+                        form={emailField}
+                        placeholder="Email"
                         debounce="250 millis"
                     />
-
                     <TextFieldFormInput
-                        form={form.passwordField}
+                        form={passwordField}
+                        placeholder="Password"
+                        type="password"
                         debounce="250 millis"
                     />
-
-                    <TextFieldOptionalFormInput
-                        type="datetime-local"
-                        form={form.birthField}
-                        defaultValue=""
-                    />
-
-                    <Button disabled={!canCommit}>Submit</Button>
+                    <Button disabled={!canCommit || isCommitting}>
+                        {isCommitting ? "Submitting…" : "Submit"}
+                    </Button>
                 </Flex>
             </form>
-
-            {Match.value(submitResult).pipe(
-                Match.tag("Initial", () => <></>),
-                Match.tag("Running", () => <Text>Submitting...</Text>),
-                Match.tag("Success", () => <Text>Submitted successfully!</Text>),
-                Match.tag("Failure", e => <Text>Error: {e.cause.toString()}</Text>),
-                Match.exhaustive,
-            )}
+            <Text size="2">A MutationForm validates local input, then submits it.</Text>
         </Container>
     )
-}) {}
-
-const RegisterPage = Component.make("RegisterPageView")(function*() {
-    const RegisterForm = yield* Effect.provide(
-        RegisterFormView.use,
-        yield* Component.useLayer(RegisterFormService.Default),
-    )
-
-    return <RegisterForm />
 }).pipe(
-    Component.withRuntime(runtime.context)
+    Component.withContext(runtime.context),
 )
 
-
 export const Route = createFileRoute("/form")({
-    component: RegisterPage
+    component: RegisterRouteComponent,
 })

packages/example/src/routes/index.tsx

@@ -1,24 +1,56 @@
+import { Button, Container, Flex, Text, TextField } from "@radix-ui/themes"
 import { createFileRoute } from "@tanstack/react-router"
-import { Effect } from "effect"
-import { Component } from "effect-fc"
+import { Effect, SubscriptionRef } from "effect"
+import { Component, Lens, View } from "effect-fc-next"
 import { runtime } from "@/runtime"
-import { TodosState } from "@/todo/TodosState"
-import { TodosView } from "@/todo/TodosView"
 
 
-const TodosStateLive = TodosState.Default("todos")
+const TodoRouteComponent = Component.make("TodoRouteView")(function*() {
+    const todosLens = yield* Component.useOnMount(() => Effect.map(
+        SubscriptionRef.make<readonly string[]>([]),
+        Lens.fromSubscriptionRef,
+    ))
+    const draftLens = yield* Component.useOnMount(() => Effect.map(
+        SubscriptionRef.make(""),
+        Lens.fromSubscriptionRef,
+    ))
 
-const Index = Component.make("IndexView")(function*() {
-    const Todos = yield* Effect.provide(
-        TodosView.use,
-        yield* Component.useLayer(TodosStateLive),
+    const [todos] = yield* View.useAll([todosLens])
+    const [draft, setDraft] = yield* Lens.useState(draftLens)
+    const runPromise = yield* Component.useRunPromise()
+
+    const addTodo = Lens.update(todosLens, todos =>
+        draft.trim() === ""
+            ? todos
+            : [...todos, draft.trim()],
+    ).pipe(
+        Effect.andThen(Lens.set(draftLens, "")),
     )
 
-    return <Todos />
+    return (
+        <Container width="480">
+            <Flex direction="column" gap="3">
+                <Text size="2">A small Effect v4 todo state example backed by a Lens.</Text>
+
+                <Flex gap="2">
+                    <TextField.Root
+                        value={draft}
+                        onChange={event => setDraft(event.currentTarget.value)}
+                    />
+
+                    <Button onClick={() => void runPromise(addTodo)}>
+                        Add
+                    </Button>
+                </Flex>
+
+                {todos.map(todo => <Text key={todo}>• {todo}</Text>)}
+            </Flex>
+        </Container>
+    )
 }).pipe(
-    Component.withRuntime(runtime.context)
+    Component.withContext(runtime.context),
 )
 
 export const Route = createFileRoute("/")({
-    component: Index
+    component: TodoRouteComponent,
 })

packages/example/src/routes/lensform.tsx

@@ -0,0 +1,112 @@
+import { Container, Flex } from "@radix-ui/themes"
+import { createFileRoute } from "@tanstack/react-router"
+import { Console, Context, Effect, Layer, Schema, Stream, SubscriptionRef } from "effect"
+import { Component, Form, Lens, LensForm } from "effect-fc-next"
+import { TextFieldFormInputView } from "@/lib/form/TextFieldFormInputView"
+import { runtime } from "@/runtime"
+
+
+const UserProfileSchema = Schema.Struct({
+    email: Schema.String.check(
+        Schema.isPattern(/^[^\s@]+@[^\s@]+\.[^\s@]+$/, {
+            message: "Enter a valid email address",
+        }),
+    ),
+    password: Schema.String.check(
+        Schema.isMinLength(5, {
+            message: "Password must be at least 5 characters long",
+        }),
+    ),
+})
+
+const AppStateSchema = Schema.Struct({
+    currentUser: UserProfileSchema,
+})
+
+class AppState extends Context.Service<AppState, {
+    readonly lens: Lens.Lens<typeof AppStateSchema.Type>
+}>()("AppState") {
+    static readonly layer = Layer.effect(AppState, Effect.gen(function*() {
+        return {
+            lens: Lens.fromSubscriptionRef(
+                yield* SubscriptionRef.make<typeof AppStateSchema.Type>({
+                    currentUser: {
+                        email: "",
+                        password: "",
+                    },
+                })
+            ),
+        }
+    }))
+}
+
+
+const LensFormPageView = Component.make("LensFormPageView")(function*() {
+    yield* Component.useOnMount(() => Effect.gen(function*() {
+        yield* Effect.addFinalizer(() => Console.log("LensForm route unmounted"))
+        yield* Console.log("LensForm route mounted")
+    }))
+
+    const context = yield* Component.useLayer(AppState.layer)
+    const UserProfileEditor = yield* Effect.provide(UserProfileEditorView.use, context)
+
+    return <UserProfileEditor />
+})
+
+
+const UserProfileEditorView = Component.make("UserProfileEditorView")(function*() {
+    const appState = yield* AppState
+
+    const [
+        emailField,
+        passwordField,
+    ] = yield* Component.useOnMount(() => Effect.gen(function*() {
+        yield* Effect.forkScoped(
+            Stream.runForEach(Lens.changes(appState.lens), Console.log)
+        )
+
+        const form = yield* LensForm.service({
+            schema: UserProfileSchema,
+            target: Lens.focusObjectOn(appState.lens, "currentUser"),
+            initialEncodedValue: {
+                email: "",
+                password: "",
+            },
+        })
+
+        const emailField = Form.focusObjectOn(form, "email")
+        const passwordField = Form.focusObjectOn(form, "password")
+
+        return [emailField, passwordField] as const
+    }))
+
+    const TextFieldFormInput = yield* TextFieldFormInputView.use
+
+
+    return (
+        <Container width="300">
+            <form onSubmit={event => {
+                event.preventDefault()
+            }}>
+                <Flex direction="column" gap="2">
+                    <TextFieldFormInput
+                        form={emailField}
+                        placeholder="Email"
+                        debounce="250 millis"
+                    />
+                    <TextFieldFormInput
+                        form={passwordField}
+                        placeholder="Password"
+                        type="password"
+                        debounce="250 millis"
+                    />
+                </Flex>
+            </form>
+        </Container>
+    )
+})
+
+
+export const Route = createFileRoute("/lensform")({
+    component: Component.withContext(LensFormPageView, runtime.context),
+})

packages/example/src/routes/query.tsx

@@ -1,8 +1,9 @@
-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, SubscriptionRef } from "effect"
-import { Component, ErrorObserver, Lens, Mutation, Query, Result, Subscribable } from "effect-fc"
+import { Effect, Schema, SubscriptionRef } from "effect"
+import { HttpClient } from "effect/unstable/http"
+import { AsyncResult } from "effect/unstable/reactivity"
+import { Component, Lens, Mutation, Query, View } from "effect-fc-next"
 import { runtime } from "@/runtime"
 
 
@@ -13,30 +14,45 @@ const Post = Schema.Struct({
     body: Schema.String,
 })
 
-const ResultView = Component.make("ResultView")(function*() {
-    const runPromise = yield* Component.useRunPromise()
 
+interface PostResultViewProps {
+    readonly result: AsyncResult.AsyncResult<typeof Post.Type, Error>
+}
+
+const PostResultView = (props: PostResultViewProps) => AsyncResult.match(props.result, {
+    onInitial: result => result.waiting
+        ? <Text>Loading...</Text>
+        : <Text>No data.</Text>,
+    onFailure: result => <Text>Request failed: { result.cause.toString() }</Text>,
+    onSuccess: result => <>
+        {result.waiting && <Text>Refreshing...</Text>}
+        <Heading>{result.value.title}</Heading>
+        <Text>{result.value.body}</Text>
+    </>,
+})
+
+const QueryRouteComponent = Component.make("QueryRouteView")(function*() {
     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 keyLens = Lens.fromSubscriptionRef(yield* SubscriptionRef.make(["post", 1 as number] as const))
+        const idLens = Lens.focusTupleAt(keyLens, 1)
 
         const query = yield* Query.service({
-            key,
-            f: ([id]) => HttpClient.HttpClient.pipe(
-                Effect.tap(Effect.sleep("500 millis")),
+            key: keyLens,
+            f: ([, id]) => HttpClient.HttpClient.pipe(
+                Effect.tap(Effect.sleep("1 second")),
                 Effect.andThen(client => client.get(`https://jsonplaceholder.typicode.com/posts/${ id }`)),
                 Effect.andThen(response => response.json),
-                Effect.andThen(Schema.decodeUnknown(Post)),
+                Effect.andThen(Schema.decodeUnknownEffect(Post)),
             ),
             staleTime: "10 seconds",
         })
 
         const mutation = yield* Mutation.make({
-            f: ([id]: readonly [id: number]) => HttpClient.HttpClient.pipe(
-                Effect.tap(Effect.sleep("500 millis")),
+            f: ([id]: [id: number]) => HttpClient.HttpClient.pipe(
+                Effect.tap(Effect.sleep("1 second")),
                 Effect.andThen(client => client.get(`https://jsonplaceholder.typicode.com/posts/${ id }`)),
                 Effect.andThen(response => response.json),
-                Effect.andThen(Schema.decodeUnknown(Post)),
+                Effect.andThen(Schema.decodeUnknownEffect(Post)),
             ),
         })
 
@@ -44,74 +60,43 @@ const ResultView = Component.make("ResultView")(function*() {
     }))
 
     const [id, setId] = yield* Lens.useState(idLens)
-    const [queryResult, mutationResult] = yield* Subscribable.useAll([query.result, mutation.result])
+    const [queryState, mutationState] = yield* View.useAll([query.state, mutation.state])
 
-    yield* Component.useOnMount(() => ErrorObserver.ErrorObserver<HttpClientError.HttpClientError>().pipe(
-        Effect.andThen(observer => observer.subscribe),
-        Effect.andThen(Stream.fromQueue),
-        Stream.unwrapScoped,
-        Stream.runForEach(flow(
-            Cause.failures,
-            Chunk.findFirst(e => e._tag === "RequestError" || e._tag === "ResponseError"),
-            Option.match({
-                onSome: e => Console.log("ResultView HttpClient error", e),
-                onNone: () => Effect.void,
-            }),
-        )),
-        Effect.forkScoped,
-    ))
+    const runSync = yield* Component.useRunSync()
 
     return (
         <Container>
             <Flex direction="column" align="center" gap="2">
                 <Slider
                     value={[id]}
-                    onValueChange={flow(Array.head, Option.getOrThrow, setId)}
+                    min={1}
+                    max={10}
+                    onValueChange={([value]) => setId(value ?? 1)}
                 />
 
-                <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.hasRefreshingFlag(result) && <Text>Refreshing...</Text>}
-                        </>),
-                        Match.tag("Failure", result =>
-                            <Text>An error has occured: {result.cause.toString()}</Text>
-                        ),
-                        Match.orElse(() => <></>),
-                    )}
-                </div>
+                <PostResultView result={queryState.result} />
 
                 <Flex direction="row" justify="center" align="center" gap="1">
-                    <Button onClick={() => runPromise(query.refresh)}>Refresh</Button>
-                    <Button onClick={() => runPromise(query.invalidateCache)}>Invalidate cache</Button>
+                    <Button onClick={() => runSync(query.refreshView)}>
+                        Refresh
+                    </Button>
+                    <Button onClick={() => runSync(query.invalidateCache)}>
+                        Invalidate cache
+                    </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.hasRefreshingFlag(result) && <Text>Refreshing...</Text>}
-                        </>),
-                        Match.tag("Failure", result =>
-                            <Text>An error has occured: {result.cause.toString()}</Text>
-                        ),
-                        Match.orElse(() => <></>),
-                    )}
-                </div>
+                <PostResultView result={mutationState} />
 
-                <Flex direction="row" justify="center" align="center" gap="1">
-                    <Button onClick={() => runPromise(Effect.andThen(Lens.get(idLens), id => mutation.mutate([id])))}>Mutate</Button>
-                </Flex>
+                <Button onClick={() => runSync(mutation.mutateView([id]))}>
+                    Mutate
+                </Button>
             </Flex>
         </Container>
     )
-})
+}).pipe(
+    Component.withContext(runtime.context),
+)
 
 export const Route = createFileRoute("/query")({
-    component: Component.withRuntime(ResultView, runtime.context)
+    component: QueryRouteComponent,
 })

packages/example/src/routes/result.tsx

@@ -1,60 +0,0 @@
-import { HttpClient, type HttpClientError } from "@effect/platform"
-import { Container, Heading, Text } from "@radix-ui/themes"
-import { createFileRoute } from "@tanstack/react-router"
-import { Cause, Chunk, Console, Effect, flow, Match, Option, Schema, Stream } from "effect"
-import { Component, ErrorObserver, Result, Subscribable } from "effect-fc"
-import { runtime } from "@/runtime"
-
-
-const Post = Schema.Struct({
-    userId: Schema.Int,
-    id: Schema.Int,
-    title: Schema.String,
-    body: Schema.String,
-})
-
-const ResultView = Component.makeUntraced("Result")(function*() {
-    const [resultSubscribable] = yield* Component.useOnMount(() => HttpClient.HttpClient.pipe(
-        Effect.andThen(client => client.get("https://jsonplaceholder.typicode.com/posts/1")),
-        Effect.andThen(response => response.json),
-        Effect.andThen(Schema.decodeUnknown(Post)),
-        Effect.tap(Effect.sleep("250 millis")),
-        Result.forkEffect,
-    ))
-    const [result] = yield* Subscribable.useAll([resultSubscribable])
-
-    yield* Component.useOnMount(() => ErrorObserver.ErrorObserver<HttpClientError.HttpClientError>().pipe(
-        Effect.andThen(observer => observer.subscribe),
-        Effect.andThen(Stream.fromQueue),
-        Stream.unwrapScoped,
-        Stream.runForEach(flow(
-            Cause.failures,
-            Chunk.findFirst(e => e._tag === "RequestError" || e._tag === "ResponseError"),
-            Option.match({
-                onSome: e => Console.log("ResultView HttpClient error", e),
-                onNone: () => Effect.void,
-            }),
-        )),
-        Effect.forkScoped,
-    ))
-
-    return (
-        <Container>
-            {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(() => <></>),
-            )}
-        </Container>
-    )
-})
-
-export const Route = createFileRoute("/result")({
-    component: Component.withRuntime(ResultView, runtime.context)
-})

packages/example/src/runtime.ts

@@ -1,10 +1,11 @@
-import { FetchHttpClient } from "@effect/platform"
 import { Clipboard, Geolocation, Permissions } from "@effect/platform-browser"
 import { DateTime, Layer } from "effect"
-import { ReactRuntime } from "effect-fc"
+import { FetchHttpClient } from "effect/unstable/http"
+import { QueryClient, ReactRuntime } from "effect-fc-next"
 
 
-export const AppLive = Layer.empty.pipe(
+export const layer = Layer.empty.pipe(
+    Layer.provideMerge(QueryClient.layer()),
     Layer.provideMerge(DateTime.layerCurrentZoneLocal),
     Layer.provideMerge(Clipboard.layer),
     Layer.provideMerge(Geolocation.layer),
@@ -12,4 +13,4 @@ export const AppLive = Layer.empty.pipe(
     Layer.provideMerge(FetchHttpClient.layer),
 )
 
-export const runtime = ReactRuntime.make(AppLive)
+export const runtime = ReactRuntime.make(layer)

packages/example/src/todo/EditTodoView.tsx

@@ -1,88 +0,0 @@
-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>
-    )
-}) {}

packages/example/src/todo/NewTodoView.tsx

@@ -1,78 +0,0 @@
-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>
-    )
-}) {}

packages/example/src/todo/TodoFormSchema.ts

@@ -1,9 +0,0 @@
-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)

packages/example/src/todo/TodosState.ts

@@ -1,96 +0,0 @@
-import { KeyValueStore } from "@effect/platform"
-import { BrowserKeyValueStore } from "@effect/platform-browser"
-import { Chunk, Console, Effect, Option, Schema, Stream, SubscriptionRef } from "effect"
-import { Lens, Subscribable } from "effect-fc"
-import { Todo } from "@/domain"
-
-
-export class TodosState extends Effect.Service<TodosState>()("TodosState", {
-    scoped: Effect.fnUntraced(function*(key: string) {
-        const kv = yield* KeyValueStore.KeyValueStore
-
-        const readFromLocalStorage = Console.log("Reading todos from local storage...").pipe(
-            Effect.andThen(kv.get(key)),
-            Effect.andThen(Option.match({
-                onSome: Schema.decode(
-                    Schema.parseJson(Schema.Chunk(Todo.TodoFromJson))
-                ),
-                onNone: () => Effect.succeed(Chunk.empty()),
-            }))
-        )
-        const saveToLocalStorage = (todos: Chunk.Chunk<Todo.Todo>) => Effect.andThen(
-            Console.log("Saving todos to local storage..."),
-            Chunk.isNonEmpty(todos)
-                ? Effect.andThen(
-                    Schema.encode(
-                        Schema.parseJson(Schema.Chunk(Todo.TodoFromJson))
-                    )(todos),
-                    v => kv.set(key, v),
-                )
-                : kv.remove(key)
-        )
-
-        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(() => Lens.get(lens).pipe(
-            Effect.andThen(saveToLocalStorage),
-            Effect.ignore,
-        ))
-
-        const sizeSubscribable = Subscribable.map(lens, Chunk.size)
-
-        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)),
-            Effect.andThen(({ todo, index, previous }) => index > 0
-                ? todos.pipe(
-                    Chunk.replace(index, previous),
-                    Chunk.replace(index - 1, todo),
-                )
-                : todos
-            ),
-        ))
-        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)),
-            Effect.andThen(({ todo, index, next }) => index < Chunk.size(todos) - 1
-                ? todos.pipe(
-                    Chunk.replace(index, next),
-                    Chunk.replace(index + 1, todo),
-                )
-                : todos
-            ),
-        ))
-        const remove = (id: string) => Lens.updateEffect(lens, todos => Effect.andThen(
-            Chunk.findFirstIndex(todos, v => v.id === id),
-            index => Chunk.remove(todos, index),
-        ))
-
-        return {
-            lens,
-            sizeSubscribable,
-            getElementLens,
-            getIndexSubscribable,
-            moveLeft,
-            moveRight,
-            remove,
-        } as const
-    }),
-
-    dependencies: [BrowserKeyValueStore.layerLocalStorage],
-}) {}

packages/example/src/todo/TodosView.tsx

@@ -1,34 +0,0 @@
-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"
-
-
-export class TodosView extends Component.make("TodosView")(function*() {
-    const state = yield* TodosState
-    const [todos] = yield* Subscribable.useAll([state.lens])
-
-    yield* Component.useOnMount(() => Effect.andThen(
-        Console.log("Todos mounted"),
-        Effect.addFinalizer(() => Console.log("Todos unmounted")),
-    ))
-
-    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">
-                <NewTodo />
-
-                {Chunk.map(todos, todo =>
-                    <EditTodo key={todo.id} id={todo.id} />
-                )}
-            </Flex>
-        </Container>
-    )
-}) {}

packages/example/vite.config.ts

@@ -1,5 +1,6 @@
 import { tanstackRouter } from "@tanstack/router-plugin/vite"
 import react from "@vitejs/plugin-react"
+import { effectViewPlugin } from "@effect-view/vite-plugin"
 import path from "node:path"
 import { defineConfig } from "vite"
 
@@ -7,6 +8,7 @@ import { defineConfig } from "vite"
 // https://vite.dev/config/
 export default defineConfig({
     plugins: [
+        effectViewPlugin(),
         tanstackRouter({
             target: "react",
             autoCodeSplitting: true,