[{"name":"Rad","comment":" elm-rad — reactive cell DSL.\n\n@docs Cell\n@docs cellKey, cellId, cellEncodedInitial, cellCodec, cellFromInternal\n@docs DebouncedCell, withDebounced\n@docs raw, settled, synced, commit, revert\n@docs ValidatedCell, withValidated, Validator, sync, async, compose, input, validation, validate, resetValidation, Validation, validationCodec, runSyncOnly, validationReactions\n@docs internalValidationReactionGuts\n@docs CellBuilder, build, with, runBuilder\n@docs Codec\n@docs boolCodec, floatCodec, intCodec, listCodec, maybeCodec, stringCodec\n@docs Remote, remoteCodec\n@docs Source, toSource, readSource, derive\n@docs Action, set, modify, copy, batch, applyAction, noAction, persistNow\n@docs Request, noRequest, mapRequestError, andThenRequest\n@docs AppDef, AppModel, PersistConfig, run\n@docs ComponentDef, defineComponent, withInstance, embed, include\n@docs Reaction, on\n\n","unions":[{"name":"Cell","comment":" A reactive state cell holding a value of type `a`.\n","args":["a"],"cases":[]},{"name":"ComponentDef","comment":" A reusable bundle of cells, computed values, a view, and reactions. Build\nvia `defineComponent`, mount via `withInstance`, render via `embed`, and\ncompose reactions via `include`. Opaque.\n\nThe `model` type parameter carries through to the `Reaction model` values the\ncomponent produces. At use sites, `model` unifies with the outer app's model\ntype.\n\n","args":["model","view","cells","computed"],"cases":[]},{"name":"Remote","comment":" A remote resource in one of four states.\n","args":["err","a"],"cases":[["Idle",[]],["Loading",[]],["Failed",["err"]],["Done",["a"]]]},{"name":"Validation","comment":" The validation lifecycle state.\n","args":["err","a"],"cases":[["Dormant",[]],["Checking",[]],["Valid",["a"]],["Invalid",["List.List err"]]]}],"aliases":[{"name":"Action","comment":" A synchronous action against the cell registry. Phantom `model` parameter\nreserves type-level differentiation for later layers.\n","args":["model"],"type":"Rad.Internal.Action.Action model"},{"name":"AppDef","comment":" An application definition.\n\n  - `init` — the cell builder; produces the initial model + registry.\n  - `computed` — derived values rebuilt on every render.\n  - `view` — turns the model + computed values into a view.\n  - `reactions` — async effects rebuilt on every render.\n  - `persist` — opt-in localStorage persistence; `Nothing` means no save/restore.\n\n","args":["view","model","computed"],"type":"{ init : Rad.CellBuilder model, computed : model -> computed, view : model -> computed -> view, reactions : model -> computed -> List.List (Rad.Reaction model), persist : Maybe.Maybe (Rad.PersistConfig (Rad.Internal.Engine.Msg model)) }"},{"name":"AppModel","comment":" A public alias for the runtime's internal model record. Used as the model\ntype of a `Program` so user code does not have to name `Rad.Internal.Registry`.\n\nThe `dirtyCounter` field is a monotonic counter bumped on every registry\nmutation so the runtime's debounced-save flow can detect stale timers.\n\n","args":["model"],"type":"{ model : model, registry : Rad.Internal.Registry.Registry, reactions : Rad.Internal.Reaction.ReactionState, dirtyCounter : Basics.Int }"},{"name":"CellBuilder","comment":" An applicative builder for constructing a model made of cells.\n","args":["ctor"],"type":"Rad.Internal.CellBuilder.CellBuilder ctor"},{"name":"Codec","comment":" A pair of encoder and decoder for serializing cell values.\n","args":["a"],"type":"{ encode : a -> Json.Decode.Value, decode : Json.Decode.Decoder a }"},{"name":"DebouncedCell","comment":" A cell with settle semantics. Holds two observable values — `raw` (updates\non every keystroke or `fromDebouncedInput`) and `settled` (updates on commit,\nrevert, or after a timer). Constructed via `withDebounced`. Opaque.\n","args":["a"],"type":"Rad.Internal.Debounced.DebouncedCell a"},{"name":"PersistConfig","comment":" Configuration for opt-in localStorage persistence. Pass via\n`AppDef.persist`. The `save` field is a user-supplied port.\n\n    port persistSave : ( String, String ) -> Cmd msg\n\n    persist =\n        Just { key = \"myapp\", version = 1, save = persistSave }\n\n","args":["msg"],"type":"{ key : String.String, version : Basics.Int, save : ( String.String, String.String ) -> Platform.Cmd.Cmd msg }"},{"name":"Reaction","comment":" A reaction — a rule that says \"when this source's value changes, run\nthis request and store the result in this cell.\" Constructed via `on`.\nOpaque.\n","args":["model"],"type":"Rad.Internal.Reaction.Reaction model"},{"name":"Request","comment":" An asynchronous request produced by an effect library (e.g., `Rad.Http`).\nOpaque; Layer 2 constructors are `noRequest` and values returned by\neffect-library functions like `Rad.Http.httpGet`.\n","args":["err","a"],"type":"Rad.Internal.Request.Request err a"},{"name":"Source","comment":" Anything readable. Cells, derived values, and later debounced/validated\naccessors all convert to `Source`. The constructor is not re-exported from\n`Rad`, keeping the type opaque to user code.\n","args":["a"],"type":"Rad.Internal.Source.Source a"},{"name":"ValidatedCell","comment":" A cell with a reactive validation lifecycle. Holds a writable input value\nand a derived `Validation err a` state. Constructed via `withValidated`.\nOpaque.\n","args":["err","a"],"type":"Rad.Internal.Validated.ValidatedCell err a"},{"name":"Validator","comment":" Opaque validator. Build via `sync`, `async`, or `compose`.\n","args":["err","a"],"type":"Rad.Internal.Validated.Validator err a"}],"values":[{"name":"andThenRequest","comment":" Transform a Request's success value via a function that may itself\nshort-circuit to the error channel.\n\nUseful for chaining a sync check after an async request. Example: an HTTP\nresponse whose body indicates whether the action succeeded at the domain\nlevel:\n\n    Http.httpGet handler url decoder\n        |> mapRequestError (\\netErr -> [ NetworkError netErr ])\n        |> andThenRequest\n            (\\resp ->\n                if resp.ok then\n                    Ok resp.value\n\n                else\n                    Err [ DomainFailure ]\n            )\n\n","type":"(a -> Result.Result err b) -> Rad.Request err a -> Rad.Request err b"},{"name":"applyAction","comment":" Apply an action to a registry. Exposed for tests and the runtime.\n","type":"Rad.Action model -> Rad.Internal.Registry.Registry -> Rad.Internal.Registry.Registry"},{"name":"async","comment":" An asynchronous validator. Builds a `Request` whose success value is the\nvalid `a`; failure is a list of errors. HTTP-backed validators typically\nbuild via `Rad.Http.httpGet` + `mapRequestError`.\n","type":"(a -> Rad.Request (List.List err) a) -> Rad.Validator err a"},{"name":"batch","comment":" Combine a sequence of actions, applied in list order.\n","type":"List.List (Rad.Action model) -> Rad.Action model"},{"name":"boolCodec","comment":" ","type":"Rad.Codec Basics.Bool"},{"name":"build","comment":" Start a CellBuilder from a model constructor.\n","type":"ctor -> Rad.CellBuilder ctor"},{"name":"cellCodec","comment":" Inspect a cell's codec. For low-level integration; most users won't need it.\n","type":"Rad.Cell a -> Rad.Codec a"},{"name":"cellEncodedInitial","comment":" Inspect a cell's initial value, already encoded via its codec. Used by\n`Rad.Form` to capture pristine snapshot values without exposing the codec.\n","type":"Rad.Cell a -> Json.Decode.Value"},{"name":"cellFromInternal","comment":" Internal helper for builder modules outside `Rad.elm` (`Rad.Form`'s\n`withState`). Constructs a `Cell` from an already-resolved id, key, codec,\nand initial. Most users have no reason to call this — use `with`,\n`withDebounced`, `withValidated`, or `Form.withState` instead.\n","type":"{ id : Basics.Int, key : String.String, codec : Rad.Codec a, initial : a } -> Rad.Cell a"},{"name":"cellId","comment":" Inspect a cell's runtime ID. Useful for low-level integration (Form\nmembership, persistence keying). Most users won't need this.\n","type":"Rad.Cell a -> Basics.Int"},{"name":"cellKey","comment":" Inspect a cell's persistence key. The key is the user-supplied string,\nprefixed with any namespace segments introduced by `withInstance`. Useful for\nLayer 7 persistence integration and testing.\n","type":"Rad.Cell a -> String.String"},{"name":"commit","comment":" Commit a debounced cell's raw value to its settled value (copies raw →\nsettled). A pure `Action`; does not touch the timer sequence, so any in-flight\ntimer will fire harmlessly (raw and settled already match).\n","type":"Rad.DebouncedCell a -> Rad.Action model"},{"name":"compose","comment":" A composed validator. Runs the validators left-to-right; if any one\nreturns `Invalid`, subsequent validators are skipped. `Valid` propagates the\n(possibly transformed) value to the next validator.\n","type":"List.List (Rad.Validator err a) -> Rad.Validator err a"},{"name":"copy","comment":" Copy the current value of a source into a cell.\n\nIf the source and target have different codecs for the same value type, the\ntarget's codec is used for encoding.\n\n","type":"Rad.Source a -> Rad.Cell a -> Rad.Action model"},{"name":"defineComponent","comment":" Build a `ComponentDef` from its parts.\n\n    tagPicker : { endpoint : String } -> ComponentDef model (SimpleView model) TagPickerCells {}\n    tagPicker config =\n        defineComponent\n            { init = build TagPickerCells |> with \"query\" \"\" stringCodec |> ...\n            , computed = \\_ -> {}\n            , view = \\c _ -> ...\n            , reactions = \\c _ -> [ ... ]\n            }\n\nRecommended pattern: bind parameterized `ComponentDef` values at module level\nand reference them by name to avoid reconstructing at every use site\n(`withInstance`, `embed`, `include`).\n\n","type":"{ init : Rad.CellBuilder cells, computed : cells -> computed, view : cells -> computed -> view, reactions : cells -> computed -> List.List (Rad.Reaction model) } -> Rad.ComponentDef model view cells computed"},{"name":"derive","comment":" Turn a `Read` into a `Source`. The resulting source recomputes its value\nfrom the registry on every read, and carries the supplied codec so the runtime\ncan encode derived values (for trigger-change detection).\n","type":"Rad.Codec a -> Rad.Read.Read a -> Rad.Source a"},{"name":"embed","comment":" Render a component instance's view. Reads the component's cells via\n`def.view cells (def.computed cells)`.\n","type":"Rad.ComponentDef model view cells computed -> cells -> view"},{"name":"floatCodec","comment":" ","type":"Rad.Codec Basics.Float"},{"name":"include","comment":" Collect a component instance's reactions. Returns the list produced by\n`def.reactions cells (def.computed cells)`. Concatenate with other reactions\nin the parent's `reactions` function.\n","type":"Rad.ComponentDef model view cells computed -> cells -> List.List (Rad.Reaction model)"},{"name":"input","comment":" The writable input cell of a validated cell. Use with `set`, `modify`,\n`copy`, or view bindings (`bind (input vcell)`).\n","type":"Rad.ValidatedCell err a -> Rad.Cell a"},{"name":"intCodec","comment":" ","type":"Rad.Codec Basics.Int"},{"name":"internalValidationReactionGuts","comment":" Internal: produces the raw fields of a validated cell's reaction. Used by\n`Rad.Form` to compose `Form.reactions`. Not part of the supported public API.\n","type":"Rad.ValidatedCell err a -> Rad.Internal.Reaction.Guts"},{"name":"listCodec","comment":" ","type":"Rad.Codec a -> Rad.Codec (List.List a)"},{"name":"mapRequestError","comment":" Transform a Request's error type. Useful for mapping a library-defined\nerror (e.g., `Rad.Http.RequestError`) into a domain error type.\n","type":"(e -> f) -> Rad.Request e a -> Rad.Request f a"},{"name":"maybeCodec","comment":" ","type":"Rad.Codec a -> Rad.Codec (Maybe.Maybe a)"},{"name":"modify","comment":" Apply a function to the current value of a cell.\n","type":"Rad.Cell a -> (a -> a) -> Rad.Action model"},{"name":"noAction","comment":" The identity Action — does nothing to the registry. Useful as a default\nor a no-op placeholder.\n","type":"Rad.Action model"},{"name":"noRequest","comment":" A Request that does nothing. Returned from the `a -> Request err r`\ntransform in a reaction to signal \"don't dispatch for this trigger value.\"\n","type":"Rad.Request err a"},{"name":"on","comment":" Build a reaction.\n\n    reactions =\n        \\_ _ ->\n            [ on (toSource model.tick) (\\_ -> Rad.Http.httpGet handler \"/api/joke\" jokeDecoder) model.joke\n            ]\n\n","type":"Rad.Source a -> (a -> Rad.Request err r) -> Rad.Cell (Rad.Remote err r) -> Rad.Reaction model"},{"name":"persistNow","comment":" Action that triggers an immediate persist save, bypassing the 500ms\nauto-save debounce. Use as an `onClick` payload like any other Action.\n\n    button { label = \"Save now\", onClick = Rad.persistNow }\n\nA pending debounced timer becomes stale once `persistNow` saves — when the\ntimer eventually fires its counter check rejects it, so there's no\ndouble-save. No-op when `AppDef.persist` is `Nothing`.\n\n","type":"Rad.Action model"},{"name":"raw","comment":" A `Source` for the raw value of a debounced cell — updates on every\n`fromDebouncedInput` (or keystroke via a view binding) and via `revert`.\n","type":"Rad.DebouncedCell a -> Rad.Source a"},{"name":"readSource","comment":" Read a source against a registry. Exposed for tests and for the runtime.\n","type":"Rad.Source a -> Rad.Internal.Registry.Registry -> a"},{"name":"remoteCodec","comment":" A codec for `Remote err a` given codecs for the error and value types.\n\nThe wire format is a tagged object: `{\"tag\":\"Idle\"}`, `{\"tag\":\"Loading\"}`,\n`{\"tag\":\"Failed\",\"value\":<errEncoded>}`, `{\"tag\":\"Done\",\"value\":<valueEncoded>}`.\n\n","type":"Rad.Codec err -> Rad.Codec a -> Rad.Codec (Rad.Remote err a)"},{"name":"resetValidation","comment":" Reset validation to `Dormant`. Writes `Dormant` to the validation state\nand resets the activation sequence to 0. Any in-flight async validator's\nresult is discarded by the validation reaction (it sees `SkipRequest`).\n","type":"Rad.ValidatedCell err a -> Rad.Action model"},{"name":"revert","comment":" Revert a debounced cell's raw value to its settled value (copies settled\n→ raw). Dual of `commit`. Does not touch the timer sequence.\n","type":"Rad.DebouncedCell a -> Rad.Action model"},{"name":"run","comment":" Run an application. Wraps `Browser.element` so later layers can add\neffects without changing the harness.\n","type":"Rad.Internal.Engine.ViewEngine view model -> Rad.AppDef view model computed -> Platform.Program Json.Decode.Value (Rad.AppModel model) (Rad.Internal.Engine.Msg model)"},{"name":"runBuilder","comment":" Extract the finished model and the initial registry.\n","type":"Rad.CellBuilder model -> ( model, Rad.Internal.Registry.Registry )"},{"name":"runSyncOnly","comment":" Run the sync portions of a validator without dispatching any async work.\nReturns `Just settled` if a final state is reachable (all Sync, with or\nwithout short-circuiting Compose), or `Nothing` if an Async must run.\n\nThis is exposed primarily for tests and for a potential future sync fast-path\nin the runtime.\n\n","type":"Rad.Validator err a -> a -> Maybe.Maybe (Rad.Validation err a)"},{"name":"set","comment":" Set a cell to a given value.\n","type":"Rad.Cell a -> a -> Rad.Action model"},{"name":"settled","comment":" A `Source` for the settled value of a debounced cell — updates on\n`commit`, `revert`, or after the debounce timer fires.\n","type":"Rad.DebouncedCell a -> Rad.Source a"},{"name":"stringCodec","comment":" ","type":"Rad.Codec String.String"},{"name":"sync","comment":" A synchronous validator. Returns `Ok a` if valid; `Err errs` with a list\nof errors otherwise.\n","type":"(a -> Result.Result (List.List err) a) -> Rad.Validator err a"},{"name":"synced","comment":" A derived `Source Bool` reporting whether a debounced cell's raw and\nsettled values are equal. Uses JSON-encoded equality via the cell's codec,\nconsistent with Layer 2 trigger-change detection.\n","type":"Rad.DebouncedCell a -> Rad.Source Basics.Bool"},{"name":"toSource","comment":" Convert a cell into a readable source.\n","type":"Rad.Cell a -> Rad.Source a"},{"name":"validate","comment":" Activate validation. Bumps the activation sequence counter; the\nvalidation reaction re-fires with the current input, transitioning from\n`Dormant` through `Checking` to `Valid` / `Invalid`. Repeated calls bump\nthe counter again, forcing re-validation even if the input is unchanged.\n","type":"Rad.ValidatedCell err a -> Rad.Action model"},{"name":"validation","comment":" A `Source` for the validation state of a validated cell.\n","type":"Rad.ValidatedCell err a -> Rad.Source (Rad.Validation err a)"},{"name":"validationCodec","comment":" A codec for `Validation err a` given codecs for the error and value types.\n\nThe wire format is a tagged object: `{\"tag\":\"Dormant\"}`, `{\"tag\":\"Checking\"}`,\n`{\"tag\":\"Valid\",\"value\":<valueEncoded>}`,\n`{\"tag\":\"Invalid\",\"errors\":[<errEncoded>, ...]}`.\n\n","type":"Rad.Codec err -> Rad.Codec a -> Rad.Codec (Rad.Validation err a)"},{"name":"validationReactions","comment":" The reaction(s) powering a validated cell's lifecycle. Returns a\nsingle-element list so users can concatenate multiple validated cells'\nreactions with their own:\n\n    reactions =\n        \\model _ ->\n            validationReactions model.name\n                ++ validationReactions model.email\n                ++ [ myOtherReaction ]\n\n","type":"Rad.ValidatedCell err a -> List.List (Rad.Reaction model)"},{"name":"with","comment":" Add one cell to the builder, consuming one argument of the constructor.\n","type":"String.String -> a -> Rad.Codec a -> Rad.CellBuilder (Rad.Cell a -> rest) -> Rad.CellBuilder rest"},{"name":"withDebounced","comment":" Add a debounced cell to the builder. Allocates three Registry slots\n(raw, settled, and a per-cell timer sequence counter) seeded from `initial`.\n","type":"String.String -> Basics.Float -> a -> Rad.Codec a -> Rad.CellBuilder (Rad.DebouncedCell a -> rest) -> Rad.CellBuilder rest"},{"name":"withInstance","comment":" Mount a component instance under the given namespace. Inside the\nparent's `init` pipeline:\n\n    build Model\n        |> withInstance \"primary\" tagPicker\n        |> withInstance \"secondary\" tagPicker\n\nEach call extends the persistence-key prefix for the component's cells\n(`\"primary.selected\"`, `\"secondary.selected\"`) and advances the parent's ID\ncounter past the component's cells.\n\nWorks inside another component's `init` too — nested components compose the\nprefix (`\"outer.inner.field\"`).\n\n","type":"String.String -> Rad.ComponentDef model view cells computed -> Rad.CellBuilder (cells -> rest) -> Rad.CellBuilder rest"},{"name":"withValidated","comment":" Add a validated cell to the builder. Allocates three Registry slots\n(input, validation state, activation sequence counter) seeded from `initial`\nand Dormant.\n","type":"String.String -> a -> Rad.Codec a -> Rad.Codec err -> Rad.Internal.Validated.Validator err a -> Rad.CellBuilder (Rad.ValidatedCell err a -> rest) -> Rad.CellBuilder rest"}],"binops":[]},{"name":"Rad.Form","comment":" Layer 5 — Forms. Designed for `import Rad.Form as Form`.\n\n\n# Types\n\n@docs Form, Member, State, stateCodec\n\n\n# Builder\n\n@docs withState\n\n\n# Use-site construction\n\n@docs over, field, validatedField\n\n\n# Behaviors\n\n@docs dirty, submit, reset\n\n\n# Reactions\n\n@docs reactions\n\n\n# Submit gating\n\n@docs onSubmit, onValid\n\n\n# Status\n\n@docs Status, status, canSubmit, submitPending, invalid, checking\n\n\n# Inspection\n\n@docs memberCount\n\n\n# ValidatedGroup\n\n@docs ValidatedGroup, validators1, validators2, validators3, validators4\n@docs validators5, validators6, validators7, validators8, mapValidated, readGroup\n\n","unions":[{"name":"Status","comment":" Bundled snapshot of the form's UI state. Suitable for rendering a submit\nbutton. See `status` for precedence.\n","args":[],"cases":[["Pristine",[]],["Editable",[]],["HasErrors",[]],["Validating",[]],["Submitting",[]]]}],"aliases":[{"name":"Form","comment":" Opaque transaction boundary over a cells record.\n","args":["fields"],"type":"Rad.Internal.Form.Form fields"},{"name":"Member","comment":" Opaque membership record. Constructed by `field` / `validatedField`.\n","args":[],"type":"Rad.Internal.Form.Member"},{"name":"State","comment":" The persisted state of a form: snapshot blob + submit-lifecycle counters.\n","args":[],"type":"Rad.Internal.Form.State"},{"name":"ValidatedGroup","comment":" Typed bundle of validators in a form, used to gate submission.\n","args":["fields","clean"],"type":"Rad.Internal.ValidatedGroup.ValidatedGroup fields clean"}],"values":[{"name":"canSubmit","comment":" dirty AND not invalid AND not checking AND not submitPending.\n","type":"Rad.Form.Form fields -> Rad.Source Basics.Bool"},{"name":"checking","comment":" `True` iff any ValidatedMember's validation slot decodes to Checking.\n","type":"Rad.Form.Form fields -> Rad.Source Basics.Bool"},{"name":"dirty","comment":" `True` iff any member's current registry value differs from the form's\npristine reference (snapshot when non-null, otherwise each member's initial).\n","type":"Rad.Form.Form fields -> Rad.Source Basics.Bool"},{"name":"field","comment":" Mark a plain `Cell` as a form field.\n","type":"Rad.Cell a -> Rad.Form.Member"},{"name":"invalid","comment":" `True` iff any ValidatedMember's validation slot decodes to Invalid.\n","type":"Rad.Form.Form fields -> Rad.Source Basics.Bool"},{"name":"mapValidated","comment":" Transform a group's clean type. Useful for packing tuples into records.\n","type":"(a -> b) -> Rad.Form.ValidatedGroup fields a -> Rad.Form.ValidatedGroup fields b"},{"name":"memberCount","comment":" Number of members in the form. For tests.\n","type":"Rad.Form.Form fields -> Basics.Int"},{"name":"onSubmit","comment":" A reaction that fires a `Request` when the form is submitted and all\nvalidators in the group are `Valid`. On success, advances the form's\nsnapshot and `lastResolvedSubmitSeq`. The target cell is `Cell (Remote err r)`.\n","type":"Rad.Form.Form fields -> Rad.Form.ValidatedGroup fields clean -> (clean -> Rad.Request err r) -> Rad.Cell (Rad.Remote err r) -> Rad.Reaction model"},{"name":"onValid","comment":" Like `onSubmit`, but runs an Action instead of dispatching a Request. On\neach fire (when the gate passes), bumps `lastResolvedSubmitSeq` to\n`submitSeq` and advances the snapshot.\n","type":"Rad.Form.Form fields -> Rad.Form.ValidatedGroup fields clean -> (clean -> Rad.Action model) -> Rad.Reaction model"},{"name":"over","comment":" Construct a `Form fields` value bundling state cell, fields, and members.\nPure — call per render.\n","type":"Rad.Cell Rad.Form.State -> fields -> List.List Rad.Form.Member -> Rad.Form.Form fields"},{"name":"reactions","comment":" One reaction per ValidatedMember; PlainMembers contribute nothing.\nConcatenate with the user's other reactions in `AppDef.reactions`.\n","type":"Rad.Form.Form fields -> List.List (Rad.Reaction model)"},{"name":"readGroup","comment":" Read a group's clean values from registry. Returns `Just clean` iff every\nvalidator is `Valid`. Mostly for tests.\n","type":"Rad.Form.ValidatedGroup fields clean -> fields -> Rad.Internal.Registry.Registry -> Maybe.Maybe clean"},{"name":"reset","comment":" Restores all members to pristine value (snapshot or initial), zeros each\nValidatedMember's activation seq, sets validation slot to Dormant. Does NOT\nmodify submitSeq / lastResolvedSubmitSeq.\n","type":"Rad.Form.Form fields -> Rad.Action model"},{"name":"stateCodec","comment":" Codec for `State`, useful at persistence boundaries and in tests.\n","type":"Rad.Codec Rad.Form.State"},{"name":"status","comment":" Bundled `Status`. Precedence: invalid → HasErrors; submitPending+checking\n→ Validating; submitPending → Submitting; dirty → Editable; else Pristine.\n","type":"Rad.Form.Form fields -> Rad.Source Rad.Form.Status"},{"name":"submit","comment":" Bumps `submitSeq` and dispatches `validate` to each ValidatedMember.\n","type":"Rad.Form.Form fields -> Rad.Action model"},{"name":"submitPending","comment":" `True` iff submitSeq > lastResolvedSubmitSeq.\n","type":"Rad.Form.Form fields -> Rad.Source Basics.Bool"},{"name":"validatedField","comment":" Mark a `ValidatedCell` as a form field. Captures input/validation/\nactivation-seq ids and the member's validation reaction.\n","type":"Rad.ValidatedCell err a -> Rad.Form.Member"},{"name":"validators1","comment":" Group with a single validator. `clean` is the input type of the field.\n","type":"(fields -> Rad.ValidatedCell err a) -> Rad.Form.ValidatedGroup fields a"},{"name":"validators2","comment":" Group with two validators. `clean` = `(a, b)`.\n","type":"(fields -> Rad.ValidatedCell err1 a) -> (fields -> Rad.ValidatedCell err2 b) -> Rad.Form.ValidatedGroup fields ( a, b )"},{"name":"validators3","comment":" Group with three validators.\n","type":"(fields -> Rad.ValidatedCell err1 a) -> (fields -> Rad.ValidatedCell err2 b) -> (fields -> Rad.ValidatedCell err3 c) -> Rad.Form.ValidatedGroup fields ( a, b, c )"},{"name":"validators4","comment":" Group with four validators. The packer function receives the four clean\nvalues in order and returns the typed `clean` type (typically a record).\n\n    validators4 (\\name email age role -> { name = name, email = email, age = age, role = role })\n        .name\n        .email\n        .age\n        .role\n\n","type":"(a -> b -> c -> d -> clean) -> (fields -> Rad.ValidatedCell err1 a) -> (fields -> Rad.ValidatedCell err2 b) -> (fields -> Rad.ValidatedCell err3 c) -> (fields -> Rad.ValidatedCell err4 d) -> Rad.Form.ValidatedGroup fields clean"},{"name":"validators5","comment":" Group with five validators. The packer function receives the five clean\nvalues in order and returns the typed `clean` type (typically a record).\n\n    validators5 (\\name email age role active -> { name = name, email = email, age = age, role = role, active = active })\n        .name\n        .email\n        .age\n        .role\n        .active\n\n","type":"(a -> b -> c -> d -> e -> clean) -> (fields -> Rad.ValidatedCell err1 a) -> (fields -> Rad.ValidatedCell err2 b) -> (fields -> Rad.ValidatedCell err3 c) -> (fields -> Rad.ValidatedCell err4 d) -> (fields -> Rad.ValidatedCell err5 e) -> Rad.Form.ValidatedGroup fields clean"},{"name":"validators6","comment":" Group with six validators. The packer function receives the six clean\nvalues in order and returns the typed `clean` type (typically a record).\n\n    validators6 (\\a b c d e f -> { fieldA = a, fieldB = b, fieldC = c, fieldD = d, fieldE = e, fieldF = f })\n        .fieldA\n        .fieldB\n        .fieldC\n        .fieldD\n        .fieldE\n        .fieldF\n\n","type":"(a -> b -> c -> d -> e -> f -> clean) -> (fields -> Rad.ValidatedCell err1 a) -> (fields -> Rad.ValidatedCell err2 b) -> (fields -> Rad.ValidatedCell err3 c) -> (fields -> Rad.ValidatedCell err4 d) -> (fields -> Rad.ValidatedCell err5 e) -> (fields -> Rad.ValidatedCell err6 f) -> Rad.Form.ValidatedGroup fields clean"},{"name":"validators7","comment":" Group with seven validators. The packer function receives the seven clean\nvalues in order and returns the typed `clean` type (typically a record).\n\n    validators7 (\\a b c d e f g -> { fieldA = a, fieldB = b, fieldC = c, fieldD = d, fieldE = e, fieldF = f, fieldG = g })\n        .fieldA\n        .fieldB\n        .fieldC\n        .fieldD\n        .fieldE\n        .fieldF\n        .fieldG\n\n","type":"(a -> b -> c -> d -> e -> f -> g -> clean) -> (fields -> Rad.ValidatedCell err1 a) -> (fields -> Rad.ValidatedCell err2 b) -> (fields -> Rad.ValidatedCell err3 c) -> (fields -> Rad.ValidatedCell err4 d) -> (fields -> Rad.ValidatedCell err5 e) -> (fields -> Rad.ValidatedCell err6 f) -> (fields -> Rad.ValidatedCell err7 g) -> Rad.Form.ValidatedGroup fields clean"},{"name":"validators8","comment":" Group with eight validators. The packer function receives the eight clean\nvalues in order and returns the typed `clean` type (typically a record).\n\n    validators8 (\\a b c d e f g h -> { fieldA = a, fieldB = b, fieldC = c, fieldD = d, fieldE = e, fieldF = f, fieldG = g, fieldH = h })\n        .fieldA\n        .fieldB\n        .fieldC\n        .fieldD\n        .fieldE\n        .fieldF\n        .fieldG\n        .fieldH\n\n","type":"(a -> b -> c -> d -> e -> f -> g -> h -> clean) -> (fields -> Rad.ValidatedCell err1 a) -> (fields -> Rad.ValidatedCell err2 b) -> (fields -> Rad.ValidatedCell err3 c) -> (fields -> Rad.ValidatedCell err4 d) -> (fields -> Rad.ValidatedCell err5 e) -> (fields -> Rad.ValidatedCell err6 f) -> (fields -> Rad.ValidatedCell err7 g) -> (fields -> Rad.ValidatedCell err8 h) -> Rad.Form.ValidatedGroup fields clean"},{"name":"withState","comment":" Allocate a Form's persisted state cell. Initial value\n`{ snapshot = null, submitSeq = 0, lastResolvedSubmitSeq = 0 }`.\n\n    init =\n        build Model\n            |> with \"name\" \"\" stringCodec\n            |> Form.withState \"profile-form\"\n\n","type":"String.String -> Rad.Internal.CellBuilder.CellBuilder (Rad.Cell Rad.Form.State -> rest) -> Rad.Internal.CellBuilder.CellBuilder rest"}],"binops":[]},{"name":"Rad.Http","comment":" HTTP effect library for `elm-rad`. Core `Rad` has no HTTP dependency;\nthis module owns `elm/http` entirely.\n\n\n## Handler\n\n@docs Handler, prodHandler\n\n\n## Errors\n\n@docs RequestError, requestErrorCodec\n\n\n## Requests\n\n@docs httpGet, httpPost\n\n","unions":[{"name":"RequestError","comment":" Errors surfaced by `Rad.Http` request builders.\n","args":[],"cases":[["Timeout",[]],["NetworkError",[]],["BadStatus",["Basics.Int"]],["BadBody",["String.String"]]]}],"aliases":[{"name":"Handler","comment":" A handler abstracts over how HTTP requests are actually made, so tests can\ninject mock responses without touching `elm/http`.\n","args":[],"type":"{ httpGet : String.String -> Task.Task Rad.Http.RequestError String.String, httpPost : String.String -> Json.Encode.Value -> Task.Task Rad.Http.RequestError String.String }"}],"values":[{"name":"httpGet","comment":" Build a GET request. The decoder is applied to the response body.\n","type":"Rad.Http.Handler -> String.String -> Json.Decode.Decoder a -> Rad.Request Rad.Http.RequestError a"},{"name":"httpPost","comment":" Build a POST request. The body is sent as JSON; the decoder is applied\nto the response.\n","type":"Rad.Http.Handler -> String.String -> Json.Encode.Value -> Json.Decode.Decoder a -> Rad.Request Rad.Http.RequestError a"},{"name":"prodHandler","comment":" The production handler — delegates to `elm/http`.\n","type":"Rad.Http.Handler"},{"name":"requestErrorCodec","comment":" A codec for `RequestError`. Useful as a default error codec when wrapping\nHTTP results in `Remote err a`.\n","type":"Rad.Codec Rad.Http.RequestError"}],"binops":[]},{"name":"Rad.Internal.Engine","comment":" Engine-author API. App authors never import this module.\n\n@docs Msg, ViewEngine, fromAction, fromDebouncedInput, applyMsg\n\n","unions":[],"aliases":[{"name":"Msg","comment":" The runtime message type. Opaque. Engines construct values via\n`fromAction` or `fromDebouncedInput`; the runtime may add internal variants\nwithout breaking engines.\n","args":["model"],"type":"Rad.Internal.Msg.Msg model"},{"name":"ViewEngine","comment":" A view engine transforms the engine's view type into `Html (Msg model)`.\n","args":["view","model"],"type":"{ toHtml : Rad.Internal.Registry.Registry -> view -> Html.Html (Rad.Internal.Engine.Msg model) }"}],"values":[{"name":"applyMsg","comment":" Apply a runtime message to the registry. Used by the Layer 0-1 runtime\nwrapper; reaction and debounced messages are handled by the runtime directly.\n","type":"Rad.Internal.Engine.Msg model -> Rad.Internal.Registry.Registry -> Rad.Internal.Registry.Registry"},{"name":"fromAction","comment":" Convert a user-level action into a runtime message that engines can\nattach to event handlers.\n","type":"Rad.Internal.Action.Action model -> Rad.Internal.Engine.Msg model"},{"name":"fromDebouncedInput","comment":" Construct a runtime message that writes `value` to a debounced cell's\nraw slot and schedules a `Process.sleep` timer that commits raw → settled\nafter the cell's configured delay. Used by view engines on `onInput` for\ndebounced bindings.\n\nEngines that want a raw write without scheduling a timer should use\n`Rad.View.bindDebouncedWith` with a trigger list that excludes `OnTimeout`\n(that binding dispatches a plain Action instead).\n\n","type":"Rad.Internal.Debounced.DebouncedCell a -> a -> Rad.Internal.Engine.Msg model"}],"binops":[]},{"name":"Rad.Read","comment":" A read-only view into the cell registry. Values in `Read` are evaluated\nat render time by the runtime and by `Rad.derive`.\n\n@docs Read, read, map, map2, run\n\n","unions":[{"name":"Read","comment":" A deferred read against a registry.\n","args":["a"],"cases":[]}],"aliases":[],"values":[{"name":"map","comment":" Map a pure function over a `Read`.\n","type":"(a -> b) -> Rad.Read.Read a -> Rad.Read.Read b"},{"name":"map2","comment":" Combine two `Read`s with a pure function.\n","type":"(a -> b -> c) -> Rad.Read.Read a -> Rad.Read.Read b -> Rad.Read.Read c"},{"name":"read","comment":" Lift a source into a `Read`.\n","type":"Rad.Internal.Source.Source a -> Rad.Read.Read a"},{"name":"run","comment":" Evaluate a `Read` against a registry. Used by the runtime, tests, and\n`Rad.derive`.\n","type":"Rad.Read.Read a -> Rad.Internal.Registry.Registry -> a"}],"binops":[]},{"name":"Rad.View","comment":" The HTML view engine and its primitives.\n\n@docs Attribute, HtmlView\n@docs CommitTrigger\n@docs bind, bindDebounced, bindDebouncedWith, onClick\n@docs button, col, input, text, watch\n@docs htmlEngine\n\n","unions":[{"name":"Attribute","comment":" An attribute applied to an HTML primitive. Encodes reactive intent (bind,\nbindDebounced, onClick) that `htmlEngine` wires into real `Html.Attribute`s\nat render time.\n","args":["model"],"cases":[]},{"name":"CommitTrigger","comment":" A commit trigger for debounced bindings.\n","args":[],"cases":[["OnEnter",[]],["OnBlur",[]],["OnTimeout",[]]]},{"name":"HtmlView","comment":" The HTML view value.\n","args":["model"],"cases":[]}],"aliases":[],"values":[{"name":"bind","comment":" Two-way bind an input's value to a `Cell String`.\n","type":"Rad.Cell String.String -> Rad.View.Attribute model"},{"name":"bindDebounced","comment":" Bind an input to a `DebouncedCell String` with all commit triggers\nenabled (`OnEnter`, `OnBlur`, `OnTimeout`) — the common debounce case.\n","type":"Rad.DebouncedCell String.String -> Rad.View.Attribute model"},{"name":"bindDebouncedWith","comment":" Bind an input to a `DebouncedCell String` with a custom set of commit\ntriggers. The empty list is a valid escape hatch: no view trigger commits;\nthe only paths to settled are explicit `commit` / `revert` actions.\n","type":"List.List Rad.View.CommitTrigger -> Rad.DebouncedCell String.String -> Rad.View.Attribute model"},{"name":"button","comment":" An HTML `<button>`.\n","type":"List.List (Rad.View.Attribute model) -> List.List (Rad.View.HtmlView model) -> Rad.View.HtmlView model"},{"name":"col","comment":" A vertical stack.\n","type":"List.List (Rad.View.Attribute model) -> List.List (Rad.View.HtmlView model) -> Rad.View.HtmlView model"},{"name":"htmlEngine","comment":" The shipped HTML engine.\n","type":"Rad.Internal.Engine.ViewEngine (Rad.View.HtmlView model) model"},{"name":"input","comment":" An HTML `<input>`.\n","type":"List.List (Rad.View.Attribute model) -> List.List (Rad.View.HtmlView model) -> Rad.View.HtmlView model"},{"name":"onClick","comment":" Dispatch an action when an element is clicked.\n","type":"Rad.Action model -> Rad.View.Attribute model"},{"name":"text","comment":" Plain text.\n","type":"String.String -> Rad.View.HtmlView model"},{"name":"watch","comment":" Subscribe a view region to a source.\n","type":"Rad.Source a -> (a -> Rad.View.HtmlView model) -> Rad.View.HtmlView model"}],"binops":[]}]