@shivaedev/form 0.0.0-stage → 0.6.2

package/CHANGELOG.md

@@ -0,0 +1,109 @@
+# Changelog
+
+## 0.6.2 - 2026-10-24
+
+### Changed
+
+- Require Effect and its companion packages at exactly 4.0.5. Generated applications use the same versions.
+
+## 0.6.1 - 2026-10-24
+
+### Changed
+
+- Align published dependency and peer pins and the generated starter with React and React DOM 19.3.1, TanStack Router 1.170.45, Better Auth 1.7.10, happy-dom 21.0.3 and Vitest 5.0.5. The starter also uses pg-boss dashboard 1.12.1.
+
+## 0.6.0 - 2026-10-21
+
+### Breaking
+
+- Rename `make` to `form` in `@shivaedev/effect-form/form.ts`; change the named import and calls from `make` to `form`.
+- Move `emptyAsNull` from `@shivaedev/effect-form/optional.ts` to `@shivaedev/effect-form/emptyAsNull.ts`; change the import path and keep the `emptyAsNull` name.
+- Move `statusOf` from `@shivaedev/effect-form/status.ts` to `@shivaedev/effect-form/statusOf.ts`; change the import path and keep the `statusOf` name.
+
+## 0.5.0 - 2026-10-18
+
+### Fixed
+
+- Keep form and React hook type inference consistent when TypeScript enables the `source` condition by resolving private type aliases to the same declarations as public imports.
+
+### Breaking
+
+- Every module's import path is now its path under `src/`. The React entry moves from `react.ts` to `client/react.ts`.
+
+## 0.4.0 - 2026-10-13
+
+### Breaking
+
+- Requires stable Effect 4.0.4 in place of 4.0.0-rc.112. Effect 4.0.4 moves the former `effect/unstable/*` modules to `effect/*` and renames constructors such as `Config.string` to `Config.String`. Install `@effect/atom-react` 4.0.4 alongside it.
+
+## 0.3.0 - 2026-10-13
+
+### Added
+
+- Opt-in `Config.persistedDraft` stores encoded input and its baseline under an application key, bounded by age and size, while storage failures leave editing usable. Reload and refresh preserve edits, revert and successful submission clear accepted input, and later edits remain persisted.
+- `persistence.ts` exports `PersistedDraftConfig`, `DraftStorage`, `Persistence` and `persistence`; `draftSession.ts` exports `DraftSession` and `draftSession`. React exports `usePersistedDraft`, `BrowserDraftConfig` and `DraftSessionContext` to bind browser storage and session ownership.
+
+## 0.2.1 - 2026-10-12
+
+### Added
+
+- `submitter.fail` accepts nested path tuples, and `errorAt` shows typed handler rejections beside Schema messages for individual array elements.
+- Optional typed `arrayKeys` selectors keep element rejections with their keys through insertion, removal and reorder, including late save responses. Changed or removed inputs discard their rejection; arrays without selectors use index paths.
+- `Form.errorAt(path)` reads nested Schema feedback beneath a top-level field, including individual array entries, without adding nested field state. Top-level touch/submission controls visibility; `error(name)` retains aggregated Schema, handler and advisory messages. `messageAtPath(issue, path)` selects the first Schema message at or beneath a path; `schemaFeedback(decoded)` adapts a decoded result atom to aggregated and nested messages.
+
+### Changed
+
+- Document the package's purpose, form model, examples, API and boundaries; publish the README and `docs/` while keeping agent guidance out of the package.
+- Build package JavaScript, declarations and source maps with TypeScript 7.
+
+## 0.2.0 - 2026-10-04
+
+### Changed
+
+- Breaking: no root entry and no module that re-exports another. `exports` maps one `"./*.ts"` pattern to every module (`src` under the `source` condition, `dist` otherwise), so you import the module that defines a name, and a bundler sees only the modules you use. Where each name now lives:
+  - `@shivaedev/effect-form`: `@shivaedev/effect-form/form.ts` (`make`), `@shivaedev/effect-form/messages.ts` (`FieldMessages`), `@shivaedev/effect-form/optional.ts` (`emptyAsNull`), `@shivaedev/effect-form/shape.ts` (`Checks`, `Config`, `Decoded`, `Encoded`, `Fields`, `Form`, `Name`, `Services`, `Submitter`, `FieldFailure`, `Invalid`)
+  - `@shivaedev/effect-form/react`: `@shivaedev/effect-form/react.ts`
+
+## 0.1.2 - 2026-10-04
+
+### Changed
+
+- Imports that leave their folder go through `#` aliases declared in the `imports` field of `package.json`: `#*.ts` resolves to `src` under the `source` condition and to `dist` otherwise, and `#test/*` names a test file. The published modules and declarations name the package's own files through these aliases.
+
+- Consolidate duplicate test cases around observable package behavior.
+
+- Validate packed consumers and executable bins through the shared workspace gate.
+
+- Build with the `@shivaedev/quality` tsconfig presets, which target ESNext and allow only erasable TypeScript syntax.
+
+- Type-check with TypeScript 7 only. TypeScript 6 still builds the package.
+
+- Lint and format with the `@shivaedev/quality` Biome preset through `quality lint` at the repository root, which replaces the package's `check` script.
+
+- Run tests through the `@shivaedev/quality` Vitest projects, which take a test's environment from its file name. Type tests are named `*.typecheck.test.ts`.
+
+- Keep `package.json` in sort-package-json key order, checked by `quality lint`.
+
+## 0.1.1 - 2026-09-26
+
+### Changed
+
+- Pin the `react` peer dependency to exactly 19.2.8, the version the package is
+  tested against, instead of `^19.2.8`.
+
+## 0.1.0 - 2026-09-26
+
+### Added
+
+- Extract schema-derived form state, submission, field messages, draft
+  preservation, and optional React hooks into a reusable package.
+- Merge received values per field: untouched fields adopt refreshed server
+  values while edited fields keep local input.
+- Keep a refresh received during an in-flight save as the baseline instead of
+  replacing it with the older submitted values.
+- Show an async check message only while the field still holds the value it was
+  computed for.
+- Clear optional field values and notify subscribers when a received or reverted
+  baseline omits the field.
+- Allow submit handlers to use the native atom runtime's scope, registry, and
+  reactivity services.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ShivaeDev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,316 @@
-# Temporary Holding Version
+# @shivaedev/form
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Keep input values, decoded submissions and fresh server data in one form. Define fields with Effect Schema, submit domain values, and preserve local edits when a refresh or save finishes.
+
+## Why you want this
+
+An input gives you a string; your service needs a number. Meanwhile, fresh server data can arrive beside an unsaved edit. Repeating those conversions and merge rules in components makes every form another state machine. Here, the schema owns the conversion and the form owns the editing session:
+
+```ts
+const order = form(Schema.Struct({ name: Schema.String, quantity: Schema.NumberFromString }), {
+  initialValues: { name: "Paper", quantity: "300" },
+  onSubmit: Effect.succeed,
+  runtime,
+});
+
+order.change("name", "Copy paper");
+order.receive({ name: "Paper", quantity: "350" });
+```
+
+The name stays `"Copy paper"`; the untouched quantity becomes `"350"`. Submitting gives the handler quantity `350`, a number. The same form can be used through native atoms or small React hooks, so the component does not need another draft model.
+
+## Using it
+
+### How to think about it
+
+A form is one **editing session** over a `Schema.Struct`. Its fields hold the schema's **encoded values**, the values an input edits. Its handler receives **decoded values**, the domain values produced by Schema. For `Schema.NumberFromString`, that means a field holds `"350"` and the handler receives `350`.
+
+The **baseline** is the encoded value against which the form recognizes edits. It starts with `initialValues`, moves when the form receives server values, and normally moves to a successful submission's encoded snapshot. A **submission** captures the encoded values before decoding and saving. Editing can continue afterwards; those later edits are separate from that submission.
+
+Keep one form instance for one editing session. Use a new instance for a different entity or user session. Query acquisition, entity identity, normalized saved rows and create-reset orchestration can be composed with [`useEditor` and `useCreate`](https://github.com/ShivaeDev/platform/blob/main/packages/react/README.md) from `@shivaedev/react`.
+
+### Once per application: supply the runtime and registry
+
+`form` takes an atom runtime. Build its Layer from the services your submit handler and field checks need. A handler that reads a service outside that runtime's declared dependencies does not compile. The handler's type also permits the native `Scope`, `AtomRegistry` and `Reactivity` services.
+
+Use an `AtomRegistry` to mount and read atoms and write the submit atom. Own its lifetime at the application boundary. In React, provide that registry through `RegistryContext` from `@effect/atom-react`.
+
+### Once per feature: define fields and submission
+
+```ts
+import { Effect, Layer, Schema } from "effect";
+import * as Atom from "effect/reactivity/Atom";
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import { form } from "@shivaedev/form/form.ts";
+
+const runtime = Atom.runtime(Layer.empty);
+const fields = Schema.Struct({
+  name: Schema.NonEmptyString,
+  quantity: Schema.NumberFromString,
+});
+
+const order = form(fields, {
+  initialValues: { name: "Paper", quantity: "300" },
+  onSubmit: (values, submitter) =>
+    values.name === "reserved"
+      ? submitter.fail("name", "Choose another name")
+      : Effect.succeed(values),
+  runtime,
+});
+
+const registry = AtomRegistry.make();
+const release = registry.mount(order.dirty);
+
+try {
+  order.change("quantity", "350");
+  registry.set(order.submit, undefined);
+  const saved = await Effect.runPromise(
+    AtomRegistry.getResult(registry, order.submit, { suspendOnWaiting: true }),
+  );
+  console.log(saved);
+} finally {
+  release();
+  registry.dispose();
+}
+```
+
+The input quantity is a string; the successful result contains quantity `350`. Invalid input fails with `Invalid` before `onSubmit` runs. The handler can fail a named field with `submitter.fail`; changing that field clears the rejection, and another submission uses the new input.
+
+The handler has three arguments: decoded values, the submitter, and the submitted encoded snapshot. Use the third argument when coordinating work against what was submitted, rather than reading live fields after an asynchronous decode. The `react` create adapter uses that snapshot to preserve input typed while decoding.
+
+### In the UI: bind the same form
+
+```tsx
+import { RegistryContext } from "@effect/atom-react";
+import { Effect, Layer, Schema } from "effect";
+import * as Atom from "effect/reactivity/Atom";
+import * as AtomRegistry from "effect/reactivity/AtomRegistry";
+import { useState } from "react";
+import { createRoot } from "react-dom/client";
+import { form } from "@shivaedev/form/form.ts";
+import { useDirty, useField, useSubmit } from "@shivaedev/form/client/react.ts";
+
+const runtime = Atom.runtime(Layer.empty);
+const fields = Schema.Struct({ name: Schema.NonEmptyString, quantity: Schema.NumberFromString });
+
+function OrderEditor() {
+  const [order] = useState(() => form(fields, {
+    initialValues: { name: "Paper", quantity: "300" },
+    onSubmit: Effect.succeed,
+    runtime,
+  }));
+  const name = useField(order, "name");
+  const quantity = useField(order, "quantity");
+  const submit = useSubmit(order);
+  const dirty = useDirty(order);
+
+  return <form onSubmit={(event) => {
+    event.preventDefault();
+    if (!submit.submitting) submit.run();
+  }}>
+    <label>Name <input value={name.value} onBlur={name.onBlur}
+      onChange={(event) => name.onChange(event.target.value)} /></label>
+    {name.error && <p role="alert">{name.error}</p>}
+    <label>Quantity <input value={quantity.value} onBlur={quantity.onBlur}
+      onChange={(event) => quantity.onChange(event.target.value)} /></label>
+    {quantity.error && <p role="alert">{quantity.error}</p>}
+    <button disabled={submit.submitting}>Save</button>
+    <button type="button" onClick={order.revert}>Revert</button>
+    <p role="status">{submit.submitting ? "Saving…" : dirty ? "Unsaved changes" : "Saved"}</p>
+  </form>;
+}
+
+export function mountOrderEditor(container: HTMLElement) {
+  const registry = AtomRegistry.make();
+  const root = createRoot(container);
+  root.render(<RegistryContext.Provider value={registry}><OrderEditor /></RegistryContext.Provider>);
+  return () => {
+    root.unmount();
+    registry.dispose();
+  };
+}
+```
+
+`useState` creates the form once for this component's editing session. `useField` supplies the field's name, encoded value, `error`, `choices` and change/blur callbacks; `useSubmit` supplies the native result, a submit callback and waiting state; `useDirty` reads whether edits remain. The mount function supplies a registry and returns its cleanup.
+
+Render general submission failures from `submit.result` in the application's own words. A field rejection and schema failure are available there too; showing a field message does not replace handling the whole result.
+
+### Receive server values without losing edits
+
+Call `receive` with encoded values from a refreshed or saved row. Encode domain values before receiving them; for a numeric string field, receive `String(row.quantity)`.
+
+| Situation | What the form does |
+| --- | --- |
+| A field still equals its baseline | Receives the new value. |
+| A field was edited locally | Keeps that input; received values become the new baseline. |
+| A refresh omits an untouched optional key | Removes the key. |
+| An optional key was added locally | Keeps it when a refresh omits it; revert restores the received values. |
+| The handler succeeds | Accepts the submitted encoded values without replacing later edits. |
+| A refresh arrived during a successful save | Keeps that refresh as the baseline; values still equal to the accepted submission count as saved and adopt the next refresh. |
+| The handler fails | Keeps input; an intervening refresh remains the baseline. |
+| `revert()` is called | Restores the latest baseline, including omitted optional keys. |
+
+The form does not replace submitted encoded input with its decoded representation. A trimmed name can be accepted as saved while the input still contains its spaces. Receive the normalized saved row when the application wants that representation on screen. `useEditor` from `react` performs that composition.
+
+### Persist input across reloads
+
+Opt in with `persistedDraft`. The application chooses a key for one logical editing session. Keep that key stable across server revisions so a refresh can find the same draft; choose a new key when the encoded field shape changes. Stored input includes its baseline and edited field names, so edited fields survive reload while untouched fields adopt the latest received values.
+
+For a core form, supply the storage provider explicitly:
+
+```ts
+const order = form(fields, {
+  initialValues: { name: "Paper", quantity: "300" },
+  onSubmit: Effect.succeed,
+  persistedDraft: { key: "order:123", storage: () => window.localStorage },
+  runtime,
+});
+```
+
+For a React form, call `usePersistedDraft` before creating the form. It defaults to browser `localStorage` and attaches the current `SessionBoundary` draft owner:
+
+```tsx
+import { useState } from "react";
+import { usePersistedDraft } from "@shivaedev/form/client/react.ts";
+
+function OrderEditor() {
+  const persistedDraft = usePersistedDraft({ key: "order:123" });
+  const [order] = useState(() => form(fields, {
+    initialValues: { name: "Paper", quantity: "300" },
+    onSubmit: Effect.succeed,
+    persistedDraft,
+    runtime,
+  }));
+  return <OrderFields form={form} />;
+}
+```
+
+`OrderFields` is the application's field UI. Keep this component mounted for one record; remount it when its identity changes. `useEditor` and `useCreate` from `react` accept `persistedDraft: { key }` directly and attach the same owner. A committed `SessionBoundary` session replacement or sign-out drops its tracked drafts, including screens already unmounted, and disables writes from its old forms. A suspended replacement that is canceled preserves the visible session's stored draft and future persistence. Ordinary unmounts and React effect replay preserve stored drafts. A stored draft with a different session generation is discarded when read.
+
+Each stored record defaults to at most 256 KiB of UTF-8 JSON and seven days since its last write. Set `maxBytes` and `maxAgeMs` to finite positive limits to change those bounds. Oversized, expired, malformed or incompatible records are dropped when encountered. Persistence requires JSON-compatible encoded input; invalid input such as an empty required string or an unfinished numeric string still persists. Storage access, serialization and quota failures leave the form usable.
+
+Edits and received values update the stored draft. Revert removes it. A successful submit clears accepted input; edits made after the submitted snapshot remain persisted. A failed submit keeps the draft.
+
+Outside React, pass a `session` from `draftSession(id)` in `@shivaedev/form/draftSession.ts` and call its `drop()` when the application replaces that session. Core forms without a session owner use only the application's key. `DraftSessionContext` supplies the owner to React integrations.
+
+### Field feedback and advisory checks
+
+An untouched invalid field initially has no visible message. Invalid submission reveals schema messages, and editing a field updates its feedback. A server rejection clears on an edit; a rejection that arrives after the field has changed does not attach to the new value.
+
+For `Schema.NonEmptyString`, an empty input's message is `Required`. Longer minimum-length checks retain Schema's message.
+
+```ts
+const profile = form(Schema.Struct({ name: Schema.String }), {
+  checks: {
+    name: (value) => Effect.succeed(value === "taken" ? "Name is taken" : undefined),
+  },
+  debounce: "300 millis",
+  initialValues: { name: "" },
+  onSubmit: Effect.succeed,
+  runtime,
+});
+```
+
+This check produces advisory feedback after the configured debounce and completion. A message is shown only while its checked input is still the current field value. Pending checks, older results and a defective check do not show an earlier value's message. Checks can read services from the supplied runtime. Keep authoritative validation in the schema or handler.
+
+For a nested value held in one top-level field, `errorAt(["answers", index, "text"])` reads Schema feedback and handler rejections for that answer box. A blur or change of the top-level `answers` field, or a submission, reveals its nested messages. The path selects the first message at or beneath that path; a sibling message does not appear there. `error("answers")` retains the top-level summary. Advisory checks remain top-level. Nested values are still edited as a whole top-level field.
+
+### Errors on array elements
+
+Pass a path tuple to `submitter.fail` to reject one element or a property inside it. Paths use indices in the submitted encoded snapshot. Optional `arrayKeys` selectors receive encoded elements of top-level array fields and return their stable, unique keys:
+
+```ts
+const answers = form(Schema.Struct({
+  answers: Schema.Array(Schema.Struct({ id: Schema.String, text: Schema.NonEmptyString })),
+}), {
+  arrayKeys: { answers: answer => answer.id },
+  initialValues: { answers: [{ id: "question", text: "Yes" }] },
+  onSubmit: (_values, submitter) =>
+    submitter.fail(["answers", 0, "text"], "This answer is closed"),
+  runtime,
+});
+```
+
+`FieldFailure.path` keeps the top-level field name as a string. For a tuple rejection, optional `FieldFailure.segments` contains its submitted path.
+
+Read the message at the element's **current** index: in React, `useAtomValue(answers.errorAt(["answers", index, "text"]))` from `@effect/atom-react` renders it beside that answer. Schema messages update from current values. Keyed handler rejections follow insertion, removal and reorder, even when elements are recreated, and a late rejection follows its submitted key to the current index. Editing the rejected input or removing its element discards the rejection; editing a sibling or blurring the array preserves it. Duplicate keys cannot identify an element and discard its rejection.
+
+Without a selector for an array, handler errors fall back to index paths. They remain at that index while its input value matches, even if a different element with the same value moves there. Arrays nested inside an element also use index paths. Use immutable value updates and stable, unique keys for top-level arrays whose errors must follow elements.
+
+### Choices and nullable inputs
+
+```ts
+import { Schema } from "effect";
+import { emptyAsNull } from "@shivaedev/form/emptyAsNull.ts";
+
+const fields = Schema.Struct({
+  visibility: Schema.Literals(["private", "public"]),
+  quantity: emptyAsNull(Schema.NumberFromString),
+});
+```
+
+For a form made with these fields, `order.choices("visibility")` returns the encoded literals `"private"` and `"public"`. Choices also stay encoded when the field's codec transforms those literals. `emptyAsNull` decodes `""` to `null` and uses the inner codec for populated input; encoding `null` gives `""`.
+
+### API
+
+Import the module that defines a name; there is no root entry.
+
+| Module | Application-facing exports |
+| --- | --- |
+| `@shivaedev/form/form.ts` | `form(schema, config)` |
+| `@shivaedev/form/shape.ts` | `Form`, `Submitter`, `FieldFailure`, `Invalid` and the field types they use |
+| `@shivaedev/form/client/react.ts` | `useField`, `useSubmit`, `useDirty`, `usePersistedDraft`, `DraftSessionContext` |
+| `@shivaedev/form/draftSession.ts` | `draftSession(id)` |
+| `@shivaedev/form/emptyAsNull.ts` | `emptyAsNull` |
+
+`form` takes a `Schema.Struct` and this configuration:
+
+| Option | Type or role |
+| --- | --- |
+| `initialValues` | `Encoded<F>` |
+| `runtime` | Atom runtime for the handler/check services and schema decoding services |
+| `onSubmit` | `(values, submitter, submitted) => Effect<A, E, R>`; the three arguments are decoded values, field failure helper and encoded snapshot |
+| `checks` | Optional functions keyed by field, from encoded input to an Effect of `string \| undefined` |
+| `arrayKeys` | Optional `ArrayKeys<F>` selectors keyed by top-level array field, from encoded element to stable `PropertyKey`; retains nested feedback across reordering |
+| `debounce` | Optional Effect `Duration.Input` for checks |
+| `persistedDraft` | Optional `{ key, storage, maxBytes?, maxAgeMs?, session? }`; React's `usePersistedDraft` supplies storage and session ownership |
+
+The returned form exposes:
+
+| Member | Type or use |
+| --- | --- |
+| `values` | `AtomRef<Encoded<F>>` for the whole input |
+| `field(name)` | `AtomRef<Encoded<F>[K]>` for a field |
+| `change(name, value)` | Write encoded input through the form's editing operation |
+| `blur(name)` | Field blur operation, supplied as `useField(...).onBlur` |
+| `error(name)` | Atom of `string \| undefined` |
+| `errorAt([name, ...path])` | Atom of nested Schema feedback and handler rejections; visibility follows the top-level field |
+| `choices(name)` | Encoded choices or `undefined` |
+| `dirty` | Atom of `boolean` |
+| `receive(values)` | Merge received encoded values |
+| `revert()` | Restore the baseline |
+| `submit` | `AtomResultFn<void, A, E \| ER \| FieldFailure \| Invalid>` |
+| `submitting` | Atom of `boolean` for submission waiting state |
+
+`F` is the schema's fields, `A` and `E` are the handler's success and failure types, and `ER` is the atom runtime's failure type. `FieldFailure` contains the top-level string `path`, `message` and optional submitted path `segments`; `Invalid` contains `messages`, a `FieldMessages` record.
+
+The lower-level `draft.ts` (`draft`), `refs.ts` (`fromRef`, `propertyRef`) and `statusOf.ts` (`statusOf`) modules hold the machinery the form composes; the examples use the form API instead.
+
+### Install and limits
+
+```sh
+pnpm add @shivaedev/form effect@4.0.5
+```
+
+For React bindings:
+
+```sh
+pnpm add @effect/atom-react@4.0.5 react@19.3.0
+```
+
+The React mounting example also uses the application's `react-dom`. React and `@effect/atom-react` are optional peers; the core modules do not import them. The package needs Node 24 or newer.
+
+- Field names are top-level schema keys. There is no path-addressed field-array API.
+- Replace encoded values rather than mutating objects in place; use `change` for ordinary UI edits.
+- Keep the form and registry for their intended session, and clean up the registry when that session ends.
+- Decide in the application when to receive normalized rows and how to render general failures. Attach a draft owner when persisted input must end with the session.

package/dist/client/react.d.ts

@@ -0,0 +1,27 @@
+import type * as AsyncResult from "effect/reactivity/AsyncResult";
+import type { DraftSession } from "#draftSession.ts";
+import type { DraftStorage, PersistedDraftConfig } from "#persistence.ts";
+import type { Encoded, FieldFailure, Fields, Form, Invalid, Name } from "#shape.ts";
+export declare const DraftSessionContext: import("react").Context<DraftSession | undefined>;
+export interface BrowserDraftConfig extends Omit<PersistedDraftConfig, "storage"> {
+    readonly storage?: () => DraftStorage;
+}
+export declare function usePersistedDraft(config: BrowserDraftConfig): PersistedDraftConfig;
+export declare function usePersistedDraft(config: BrowserDraftConfig | undefined): PersistedDraftConfig | undefined;
+export interface Field<TFields extends Fields, TKey extends Name<TFields>> {
+    readonly choices: readonly Encoded<TFields>[TKey][] | undefined;
+    readonly error: string | undefined;
+    readonly name: TKey;
+    readonly onBlur: () => void;
+    readonly onChange: (value: Encoded<TFields>[TKey]) => void;
+    readonly value: Encoded<TFields>[TKey];
+}
+export declare function useField<TFields extends Fields, A, E, TRuntimeError, TKey extends Name<TFields>>(form: Form<TFields, A, E, TRuntimeError>, name: TKey): Field<TFields, TKey>;
+export interface Submit<A, E> {
+    readonly result: AsyncResult.AsyncResult<A, E>;
+    readonly run: () => void;
+    readonly submitting: boolean;
+}
+export declare function useSubmit<TFields extends Fields, A, E, TRuntimeError>(form: Form<TFields, A, E, TRuntimeError>): Submit<A, E | TRuntimeError | FieldFailure | Invalid>;
+export declare function useDirty<TFields extends Fields, A, E, TRuntimeError>(form: Form<TFields, A, E, TRuntimeError>): boolean;
+//# sourceMappingURL=react.d.ts.map

package/dist/client/react.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.d.ts","sourceRoot":"","sources":["../../src/client/react.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,WAAW,MAAM,+BAA+B,CAAC;AAElE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAC;AACrD,OAAO,KAAK,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,iBAAiB,CAAC;AAC1E,OAAO,KAAK,EAAE,OAAO,EAAE,YAAY,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AACpF,eAAO,MAAM,mBAAmB,mDAAqD,CAAC;AACtF,MAAM,WAAW,kBAAmB,SAAQ,IAAI,CAAC,oBAAoB,EAAE,SAAS,CAAC;IAChF,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,YAAY,CAAC;CACtC;AAID,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,GAAG,oBAAoB,CAAC;AACpF,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,kBAAkB,GAAG,SAAS,GAAG,oBAAoB,GAAG,SAAS,CAAC;AAK5G,MAAM,WAAW,KAAK,CAAC,OAAO,SAAS,MAAM,EAAE,IAAI,SAAS,IAAI,CAAC,OAAO,CAAC;IACxE,QAAQ,CAAC,OAAO,EAAE,SAAS,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,EAAE,GAAG,SAAS,CAAC;IAChE,QAAQ,CAAC,KAAK,EAAE,MAAM,GAAG,SAAS,CAAC;IACnC,QAAQ,CAAC,IAAI,EAAE,IAAI,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,MAAM,IAAI,CAAC;IAC5B,QAAQ,CAAC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,KAAK,IAAI,CAAC;IAC3D,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC;CACvC;AACD,wBAAgB,QAAQ,CAAC,OAAO,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,EAAE,IAAI,SAAS,IAAI,CAAC,OAAO,CAAC,EAC/F,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,EACxC,IAAI,EAAE,IAAI,GACR,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,CAOtB;AACD,MAAM,WAAW,MAAM,CAAC,CAAC,EAAE,CAAC;IAC3B,QAAQ,CAAC,MAAM,EAAE,WAAW,CAAC,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAC/C,QAAQ,CAAC,GAAG,EAAE,MAAM,IAAI,CAAC;IACzB,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;CAC7B;AACD,wBAAgB,SAAS,CAAC,OAAO,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,EACpE,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,GACtC,MAAM,CAAC,CAAC,EAAE,CAAC,GAAG,aAAa,GAAG,YAAY,GAAG,OAAO,CAAC,CAKvD;AACD,wBAAgB,QAAQ,CAAC,OAAO,SAAS,MAAM,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,EAAE,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,CAAC,EAAE,CAAC,EAAE,aAAa,CAAC,GAAG,OAAO,CAEvH"}

package/dist/client/react.js

@@ -0,0 +1,28 @@
+import { useAtomRef, useAtomSet, useAtomValue } from "@effect/atom-react";
+import { createContext, useCallback, useContext, useMemo } from "react";
+export const DraftSessionContext = createContext(undefined);
+function browserStorage() {
+    return globalThis.localStorage;
+}
+export function usePersistedDraft(config) {
+    const session = useContext(DraftSessionContext);
+    return config ? { ...config, session: session ?? config.session, storage: config.storage ?? browserStorage } : undefined;
+}
+export function useField(form, name) {
+    const value = useAtomRef(form.field(name));
+    const error = useAtomValue(form.error(name));
+    const onChange = useCallback((next) => form.change(name, next), [form, name]);
+    const onBlur = useCallback(() => form.blur(name), [form, name]);
+    const choices = useMemo(() => form.choices(name), [form, name]);
+    return { choices, error, name, onBlur, onChange, value };
+}
+export function useSubmit(form) {
+    const result = useAtomValue(form.submit);
+    const set = useAtomSet(form.submit);
+    const run = useCallback(() => set(), [set]);
+    return { result, run, submitting: result.waiting };
+}
+export function useDirty(form) {
+    return useAtomValue(form.dirty);
+}
+//# sourceMappingURL=react.js.map

package/dist/client/react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"react.js","sourceRoot":"","sources":["../../src/client/react.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAE1E,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,UAAU,EAAE,OAAO,EAAE,MAAM,OAAO,CAAC;AAIxE,MAAM,CAAC,MAAM,mBAAmB,GAAG,aAAa,CAA2B,SAAS,CAAC,CAAC;AAItF,SAAS,cAAc;IACtB,OAAO,UAAU,CAAC,YAAY,CAAC;AAChC,CAAC;AAGD,MAAM,UAAU,iBAAiB,CAAC,MAAsC;IACvE,MAAM,OAAO,GAAG,UAAU,CAAC,mBAAmB,CAAC,CAAC;IAChD,OAAO,MAAM,CAAC,CAAC,CAAC,EAAE,GAAG,MAAM,EAAE,OAAO,EAAE,OAAO,IAAI,MAAM,CAAC,OAAO,EAAE,OAAO,EAAE,MAAM,CAAC,OAAO,IAAI,cAAc,EAAE,CAAC,CAAC,CAAC,SAAS,CAAC;AAC1H,CAAC;AASD,MAAM,UAAU,QAAQ,CACvB,IAAwC,EACxC,IAAU;IAEV,MAAM,KAAK,GAAG,UAAU,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IAC3C,MAAM,KAAK,GAAG,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,CAAC;IAC7C,MAAM,QAAQ,GAAG,WAAW,CAAC,CAAC,IAA4B,EAAE,EAAE,CAAC,IAAI,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IACtG,MAAM,MAAM,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IAChE,MAAM,OAAO,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC;IAChE,OAAO,EAAE,OAAO,EAAE,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAC;AAC1D,CAAC;AAMD,MAAM,UAAU,SAAS,CACxB,IAAwC;IAExC,MAAM,MAAM,GAAG,YAAY,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACzC,MAAM,GAAG,GAAG,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IACpC,MAAM,GAAG,GAAG,WAAW,CAAC,GAAG,EAAE,CAAC,GAAG,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC;IAC5C,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,UAAU,EAAE,MAAM,CAAC,OAAO,EAAE,CAAC;AACpD,CAAC;AACD,MAAM,UAAU,QAAQ,CAA8C,IAAwC;IAC7G,OAAO,YAAY,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC;AACjC,CAAC"}

package/dist/draft.d.ts

@@ -0,0 +1,16 @@
+import * as Atom from "effect/reactivity/Atom";
+import * as AtomRef from "effect/reactivity/AtomRef";
+import type { Persistence } from "./persistence.ts";
+type Entries = Readonly<Record<string, unknown>>;
+export declare function draft<TValues extends Entries>(initial: TValues, persistence?: Persistence<TValues>): {
+    dirty: Atom.Atom<boolean>;
+    receive: (incoming: TValues) => void;
+    revert: () => void;
+    submission: () => {
+        accept: () => void;
+        values: TValues;
+    };
+    values: AtomRef.AtomRef<TValues>;
+};
+export {};
+//# sourceMappingURL=draft.d.ts.map

package/dist/draft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft.d.ts","sourceRoot":"","sources":["../src/draft.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,IAAI,MAAM,wBAAwB,CAAC;AAC/C,OAAO,KAAK,OAAO,MAAM,2BAA2B,CAAC;AACrD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAEpD,KAAK,OAAO,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;AAsCjD,wBAAgB,KAAK,CAAC,OAAO,SAAS,OAAO,EAAE,OAAO,EAAE,OAAO,EAAE,WAAW,CAAC,EAAE,WAAW,CAAC,OAAO,CAAC;IAuBjG,KAAK;IAIL,OAAO,aAAa,OAAO,KAAG,IAAI;IAOlC,MAAM,QAAM,IAAI;IAOhB,UAAU;QAGR,MAAM,QAAM,IAAI;QAKhB,MAAM;;IAGR,MAAM;EAEP"}

package/dist/draft.js

@@ -0,0 +1,80 @@
+import { Equal } from "effect";
+import * as Atom from "effect/reactivity/Atom";
+import * as AtomRef from "effect/reactivity/AtomRef";
+const none = {};
+function untouched({ baseline, current, settled }, name) {
+    return Equal.equals(current[name], baseline[name]) || (Object.hasOwn(settled, name) && Equal.equals(current[name], settled[name]));
+}
+function changed(held) {
+    return Object.keys({ ...held.baseline, ...held.current }).some((name) => !untouched(held, name));
+}
+function merged(held, incoming) {
+    const result = {};
+    for (const name of Object.keys({ ...held.current, ...incoming })) {
+        const source = untouched(held, name) ? incoming : held.current;
+        if (Object.hasOwn(source, name)) {
+            result[name] = source[name];
+        }
+    }
+    return result;
+}
+function matching(current, submitted) {
+    return Object.fromEntries(Object.keys({ ...current, ...submitted })
+        .filter((name) => Equal.equals(current[name], submitted[name]))
+        .map((name) => [name, submitted[name]]));
+}
+export function draft(initial, persistence) {
+    const restored = persistence?.read();
+    const loaded = {
+        baseline: restored?.baseline ?? initial,
+        current: restored?.values ?? initial,
+        settled: restored ? Object.fromEntries(Object.entries(restored.values).filter(([name]) => !restored.edited.includes(name))) : none,
+    };
+    const state = AtomRef.make({
+        baseline: initial,
+        current: restored ? merged(loaded, initial) : initial,
+        settled: none,
+    });
+    if (persistence) {
+        state.subscribe((value) => {
+            if (changed(value)) {
+                const edited = Object.keys({ ...value.baseline, ...value.current }).filter((name) => !untouched(value, name));
+                persistence.write({ ...value.baseline, ...value.settled }, value.current, edited);
+            }
+            else {
+                persistence.clear();
+            }
+        });
+    }
+    return {
+        dirty: Atom.readable((get) => {
+            get.addFinalizer(state.subscribe((value) => get.setSelf(changed(value))));
+            return changed(state.value);
+        }),
+        receive: (incoming) => {
+            state.update((held) => ({
+                baseline: incoming,
+                current: changed(held) ? merged(held, incoming) : incoming,
+                settled: none,
+            }));
+        },
+        revert: () => {
+            state.update((held) => ({
+                ...held,
+                current: held.baseline,
+                settled: none,
+            }));
+        },
+        submission: () => {
+            const { baseline, current: submitted } = state.value;
+            return {
+                accept: () => {
+                    state.update((held) => held.baseline === baseline ? { ...held, baseline: submitted, settled: none } : { ...held, settled: matching(held.current, submitted) });
+                },
+                values: submitted,
+            };
+        },
+        values: state.prop("current"),
+    };
+}
+//# sourceMappingURL=draft.js.map

package/dist/draft.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"draft.js","sourceRoot":"","sources":["../src/draft.ts"],"names":[],"mappings":"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"}

package/dist/draftSession.d.ts

@@ -0,0 +1,8 @@
+export interface DraftSession {
+    readonly active: boolean;
+    readonly drop: () => void;
+    readonly id: string;
+    readonly track: (key: string, clear: () => void) => void;
+}
+export declare function draftSession(id: string): DraftSession;
+//# sourceMappingURL=draftSession.d.ts.map

package/dist/draftSession.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"draftSession.d.ts","sourceRoot":"","sources":["../src/draftSession.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,YAAY;IAC5B,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,IAAI,CAAC;IAC1B,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IACpB,QAAQ,CAAC,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,IAAI,KAAK,IAAI,CAAC;CACzD;AAED,wBAAgB,YAAY,CAAC,EAAE,EAAE,MAAM,GAAG,YAAY,CAqBrD"}