File List

Here is a list of all documented files with brief descriptions:

morph
client
args.hpp	The generic client's command line: which source it opens and how it starts. Spec 4 §3
shell.hpp	What the generic client mounts once its source is open: the library's ShellFrame (the sidebar with the navigator, the top bar, the page) with a Workspace of tabs in its page, each a screen mounted through the library's DocumentScreenHost; and the application host a shell of an application's own mounts with
source.hpp	Where the generic client's screens and models come from: a server (remote) or an application linked in-process (local). Spec 4 §3
transport.hpp	The transport a remote client connects with, chosen by the frontend it runs under (spec 4 §3)
core
detail
change_coalescer.hpp	What RemoteServer has queued for one connection's next changes event
completion_awaiter.hpp	The awaiter behind Completion<T>::operator co_await
instance_directory.hpp
owned_state.hpp	OwnedState: a component's state, and the one executor it is touched on
owner_affinity.hpp	"Am I on my owner?" for a component that belongs to one executor
owner_probe.hpp	The check every loop-owned body makes on entry: "am I on my owner?"
reply_router.hpp	The callId-multiplexed execute reply router, shared by every backend that talks to a RemoteServer over a real (or simulated) connection
result_walker.hpp	Where an action's result holds which reflected types
subscription_registry.hpp	A Bridge's instance subscriptions: at most one callback per (binding, result type), matched at publish time on the binding's current instance, so a re-pointed handler's subscriptions follow it; entries whose binding is gone are pruned
task_handler.hpp	What drives a model's Task handler: the driver coroutine that starts and finishes it, the per-instance gate that keeps actions from overlapping, and the trait that tells a Task handler from an ordinary one. The resumer its resumptions go through is strand.hpp's
watch_table.hpp	The topics each connection watches, as RemoteServer keeps them
async.hpp	The asynchronous primitives, on their own — the cheap include
backend.hpp
bridge.hpp
callback_scope.hpp
change_types.hpp
changes.hpp
completion.hpp
connection_writer.hpp	What a transport hands RemoteServer to write to one connection, and the backlog bounds both sides apply
coroutine.hpp	Coroutines on core::async::Task: awaiting a Completion, starting a detached flow on a morph executor, and waiting on a timer
effects.hpp
envelope_transport.hpp	IEnvelopeTransport: a transport that sends a request envelope of a kind its backend verbs do not build, such as the UI service's ui-* kinds, and settles with the peer's reply
executor.hpp
file_io_ops.hpp
io_loop.hpp
logger.hpp
model.hpp
model_key.hpp
observability.hpp
owner_strand.hpp	OwnerStrand: one core-cpp strand over a morph executor, which is itself a morph executor — the owner a component's state belongs to
payload_schema.hpp	Structural fingerprint of an action payload's JSON shape
payload_shape_tag.hpp	Opt-in, compiler-independent shape tag for a type with a custom Glaze codec
profiler.hpp	Compile-time profiler instrumentation: Tracy zones, plots, messages and thread names, behind morph's own macro names
records.hpp
registry.hpp
remote.hpp
strand.hpp	Morph's strands: one per model instance, from core-cpp's core::async::KeyedStrands, over a morph executor
timeout_scheduler.hpp
wire.hpp
detail
fixed_string.hpp	Shared compile-time, NTTP-capable fixed string
quantity_equation.hpp	Quantity::equation() renderer (provenance builds only)
reflected_member.hpp	The value glaze reads and writes under a reflected key
forms
detail
schema_name.hpp	Compile-time $defs keys for the forms layer's field wrappers
session_common.hpp	Machinery shared by the two form session types: morph::flows::FlowSession (ordered wizard steps) and morph::forms::SectionSet (unordered sections)
engine
detail
text.hpp	Exact text helpers the forms engine shares: JSON quoting and reading, canonical decimal comparison and digit arithmetic, decimal rendering of a Rational, and ISO-8601 wall-clock conversion
collection.hpp	Collections, headless: a v-* view document as a reactive list of rows, the table source the table engine sorts and filters, row and collection actions, the confirm step and the row editor
collection_view.hpp	collectionView: a CollectionSession rendered as a view tree (ui::Node): the title and collection actions, a table of the rows with their actions, the confirm dialog and the row editor, as a dialog or beside the table
field_layout.hpp	morph::forms::FieldLayout: where a form's cell puts a field's caption. The forms engine and the authoring API share it. Specified in docs/spec/forms/engine.md, "Rendering"
field_model.hpp	FormModel: the immutable runtime model of one action's form, read from the schema JSON schemaJson<A>() emits (or any document in that vocabulary)
form_session.hpp	FormSession: the reactive state of one form over a FormModel — drafts, encoded values, readiness, presentation rules, Choice options and submission. A controller in the sense of docs/spec/reactive/control.md: no toolkit, testable headless
form_view.hpp	formView: a FormSession rendered as a view tree (ui::Node), so one form draws on every frontend
handler_submitter.hpp	Submitters and choice fetchers bound to an application's own BridgeHandlers
overrides.hpp	Overrides: an application's replacements for the control formView draws for a field, chosen by field path, widget hint, unit or kind; FieldView, what a replacement is handed
rules.hpp	x-rules read into RuleExpr trees, translated into the UI document's expression language (expr/1) and evaluated by its one evaluator, three-valued and exactly
typed_form.hpp	Form<A>: a FormSession over schemaJson<A>(), with typed access at the edges
values.hpp	The forms engine's encoders and decoders: a field's draft text to its exact wire literal, a wire value back to the draft a control shows, exact unit conversion, and Choice option rows
wizard.hpp	Wizards, headless: a w-* document as one FormSession per step, sequenced by successful submissions, with each step's prefill taken from what earlier steps resolved
wizard_view.hpp	wizardView: a WizardSession rendered as a view tree (ui::Node): the title and step indicator, the current step's form, and Back and Next
app.hpp	App-shell descriptor: menu -> screens (form / wizard / view refs)
blank_as.hpp	morph::forms::BlankAs: what a blank string field submits
choice.hpp	Fields whose value is picked from a list served by another action
field_errors.hpp
flows.hpp	Multi-step wizards: an ordered sequence of registered actions that share a "flow draft" spanning the whole sequence
forms.hpp	JSON-Forms-style schema generation for morph actions
i18n.hpp	Stable, schema-derived message-key vocabulary for renderer i18n
instance_constraints.hpp	Per-*instance* constraints on a form field: the seam by which data that lives in a database row — not in a template parameter — reaches the framework-meaningful keys of a served schema, and is checked against a submitted value by the same declaration that served it
layout.hpp	Visual structure (sections, tabs, accordions, column spans) layered over an action's flat field list
sections.hpp	Unordered sections: N independently editable action drafts on one screen, each with its own readiness gate and no sequencing
views.hpp	View-schema generation: composes a registered query action's result rows with an optional row-opener action and row/collection action buttons into a list/table or master-detail screen descriptor
widget_hints.hpp	Typed wrappers that carry rendering-control intent for a form field
journal
action_log.hpp
action_log_json.hpp	The LogEntry JSON codec, kept apart from action_log.hpp
file_action_log.hpp
journal.hpp
outbox.hpp
net
detail
sha1.hpp
tcp_socket.hpp
ws_connection.hpp	One WebSocket connection on an I/O loop: its socket, the frames waiting to be written, and the two flows that move bytes
ws_frame.hpp
ws_handshake.hpp
socket_backend.hpp
socket_server.hpp
offline
file_offline_queue.hpp
network_monitor.hpp
offline_queue.hpp
reconnect_coordinator.hpp
replay_ledger.hpp
sqlite_offline_queue.hpp
sync_worker.hpp
qt
detail
outbound_ledger.hpp	Which frames handed to a socket it has written, told from the socket's own byte counts
qt_executor.hpp
qt_tls.hpp
qt_websocket_backend.hpp
qt_websocket_server.hpp
qt_quick
backend.hpp	morph::qt_quick::Backend: the view tree's widgets as Qt Quick items
browser_history.hpp	BrowserHistory: the browser's session history as an ui::IHistory, on WebAssembly only (spec 3 §10)
components.hpp	morph::qt_quick::Components: the application's own QML components, by name, and the restyle map
frontend.hpp	morph::qt_quick::Frontend: a morph application in a Qt Quick window
inspector.hpp	morph::qt_quick::InspectorWindow: the development inspector's window (spec 6 §21), opened with Ctrl+Shift+I over the focused screen
scheduler.hpp	morph::qt_quick::QtScheduler: reactive::Scheduler on Qt's timers
theme.hpp	applyTheme: the ui-theme/1 token values set on an engine's MorphUi Theme singleton, which every built-in component and every host component in that engine reads
reactive
detail
graph.hpp	The reactive graph's internals: node colours and links, the tracking frame, batching and the flush queue
testing
manual_scheduler.hpp	morph::reactive::testing::ManualScheduler: a scheduler whose time moves only when a test says so
control.hpp	Declarative control: Query, Mutation and Subscription turn server interaction into reactive state, so a controller states what it depends on and what a write invalidates instead of sequencing calls by hand
runtime.hpp	morph::reactive::Runtime: the owner, batching and flush scheduling of a signal graph
scheduler.hpp	morph::reactive::Scheduler: timers a frontend runs on the runtime's owner executor
scope.hpp	morph::reactive::Scope: owns reactive nodes and objects, and destroys them in reverse
signal.hpp	Signal<T>, Computed<T> and Effect: the nodes of a reactive graph
store.hpp	morph::reactive::Store: user-intent view state, changed only by exhaustive messages
render
i18n.hpp	The renderer-side translation-catalog seam over morph's derived message keys (morph::forms::i18n, forms/i18n.hpp)
locale_format.hpp	Locale numeric-entry normalisation for the control edge
session
session.hpp
session_auth.hpp	Opt-in authenticated sessions: signed bearer tokens and a verifying IAuthorizer so a RemoteServer can trust the caller's identity
table
data_source.hpp	The rows a table engine reads, and the services it is given
edits.hpp	Committing edited cells: one row's edits in order, stale and error state per cell, and the row patched with the server's reply
engine.hpp	The table engine: sort, filter and view mapping, on and off the owner
filter.hpp	Filter specs as data, compiled once and evaluated column at a time
query.hpp	TableQuery, Page and table::apply: a table's sort, filter and page as a request body, and the server's reference implementation
selection.hpp	A table's selection and activation, kept by row key
sort.hpp	Typed sort keys and the chunked, stoppable merge sort over them
view_change.hpp	What changed between two view orders, as list-model operations
testing
owner_probe_recorder.hpp	morph::testing::OwnerProbeRecorder: observes the owner checks a test's code makes, instead of letting a debug build assert on them
step_executor.hpp	morph::testing::StepExecutor: an executor whose posted tasks run only when a test steps it
tui
backend.hpp	morph::tui::Backend: the terminal implementation of ui::IViewBackend
frontend.hpp	morph::tui::Frontend: a morph application in a terminal
loop_executor.hpp	morph::tui::LoopExecutor: a morph executor whose tasks run in turns of a core-cpp event loop
ui
testing
backend_conformance.hpp	The scripted cases every IViewBackend must pass, and the probe a backend author implements to run them
memory_history.hpp	MemoryHistory: an IHistory held in memory, which a test moves through as a user moves through a browser's history
recording_backend.hpp	morph::ui::testing::RecordingBackend: a headless widget tree with an operation log, a golden dump and user-interaction helpers — the test double and the reference for every real backend
agent.hpp
alignment.hpp	morph::ui::Align and morph::ui::Justify: where a container places its children across its axis and along it. The view tree, the authoring API and the backends share them. Specified in docs/spec/ui/backend_contract.md, "The cross axis"
author.hpp	Server-side authoring of UI documents (spec 5 §11): typed builders that write a screen's JSON, and the registration that validates it once — loadDocument with the builders' catalog facts, then the accessibility rules
author_forms.hpp
backend.hpp	The backend contract: the retained widgets a mount drives, and the factory that makes them
bundle.hpp	What the UI service's client and server share (spec 5 §12): content hashes, the bundle's manifest, and the bodies of the ui-hello, ui-catalog and ui-fetch envelopes, with their bounds and their parsers
button_emphasis.hpp	morph::ui::ButtonEmphasis: how much a button stands out. The view tree, the authoring API and the backends share it. Specified in docs/spec/ui/backend_contract.md
button_style.hpp	morph::ui::ButtonStyle: whether a button is drawn as a push button or as an entry of a list. The view tree, the authoring API and the backends share it. Specified in docs/spec/ui/backend_contract.md
catalogue.hpp	Message catalogues (spec 6 §19): a bundle's messages files read into a TranslationProvider that t resolves through, and the search that matches a title in every locale the bundle has
dev_reload.hpp	Development reload (spec 5 §12): which documents a changed bundle changed, and remounting the mounted screens that show them, keeping their state
dev_tools.hpp	morph::ui::DevelopmentTools: whether a client runs in development mode (spec 6 §21). The tools are in every build; this decides at run time whether they are on. Specified in docs/spec/ui/inspector.md
document.hpp	The UI document (spec 5 §3): its model — declarations, commands, view nodes, components and customization points — and loadDocument, which parses a document and runs its load-time validation
explorer.hpp	The app explorer: what a morph application is made of — its screens, the models they use with every action, and for one action its facts, its fields, the places that use it and the widget the framework builds for it, mounted live
expression.hpp	The expr/1 expression language of the UI document: parsing a JSON expression into an Expr tree, checking it against the names a document declares, and evaluating it
file_store.hpp	The file side channel's store (files/1, spec 6 §18): uploads in chunks, and files a principal may read by a capability reference
frontend.hpp	The frontend seam: main picks a frontend at runtime, and the frontend runs whatever an AppSource opens
host.hpp	The host contract (spec 6 §4): how a host mounts UI documents and closes them, whether it owns its own shell or is the framework's workspace shell, and DocumentScreenHost, the framework's host over documents
host_vocabulary.hpp	HostVocabulary: the commands and values only the client application has (host/1, spec 6 §14), registered with their types and versions, run with checked arguments behind a trust gate, and declared to the server in ui-hello
inspector.hpp	morph::ui::Inspector: the development inspector's read-only view of a mounted screen (spec 6 §21)
interpreter.hpp	The UI document interpreter: Interpreter::mount turns a loaded Document into reactive state and a view tree, mounts it through Mounted on any IViewBackend, and runs its queries, mutations, relations and commands. Model calls go through a Dispatcher (the bridge's model-free seams in an application, a scripted fake in a test); what only the application can do goes through an InterpreterHost; what screens share — the query cache, the principal's permissions, the formatting facts — is a Session
message.hpp	The MessageFormat 2 subset ui/1 accepts for t(key, fallback, args), and the CLDR plural rules its .match on a :number selects by
mount.hpp	morph::ui::Mounted: builds a view tree's widgets through a backend once, and keeps them current through reactive bindings
navigator.hpp	The workspace's navigator and pins (spec 6 §7): the catalog listed by module and group, searched by title, with the person's pinned shortcuts
preference_sync.hpp	PreferenceSync: the client side of the preferences model. It loads a mounted screen's stored choices into Screen::setPreference, and writes what InterpreterHost::preferenceChanged and resetPrefs report
preferences.hpp	Per-person storage of customization choices (spec 5 §12b, spec 6 §8): the IPreferencesStore seam, the framework's in-memory store, and the server's preferences model, which keys every entry by the person the verified session names
queueing_dispatcher.hpp
route.hpp	Routes (spec 6 §20): the string form of a screen instance, <screen id>?<param>=<value>&…, written from a screen's declared params and read back against them
route_history.hpp	Route history (spec 3 §10, spec 6 §20): the route of the screen a shell shows, kept in a history the user moves through with back and forward, such as a browser's
service.hpp	The server side of the UI service (spec 5 §12, §12b, §13): UiRegistry collects an application's screens and files and builds a ServedBundle; UiService answers ui-hello, ui-catalog and ui-fetch from it as a RemoteServer envelope service
service_client.hpp	The client side of the UI service (spec 5 §12, "Content addressing"): UiClient runs ui-hello, ui-catalog and ui-fetch over a transport the caller supplies, verifies every file against the manifest and the manifest against the ui-hello digest, and keeps what it verified in a VerifiedCache
shell_frame.hpp	morph::ui::ShellFrame: the frame a client shows its screens in — a sidebar with the navigator, a top bar, and the page the workspace's tabs sit on. Built from backend widgets, so every frontend shows it
theme.hpp	Theme tokens (ui-theme/1, spec 6 §6): DTCG 2025.10 token files read and checked, layered into a variant, their aliases resolved, and the closed ui-theme/1 set filled from them with its defaults. No toolkit: the Qt Quick renderer applies the result (qt_quick::applyTheme)
value.hpp	The UI document's typed values (ui::Value), its types (ui::Type), their JSON form, and ui::Refusal, the error every load-time check of the document layer returns
view.hpp	The toolkit-agnostic view tree: props, node kinds and their builders
workspace.hpp	The workspace shell (spec 6 §7, §15): tabs over screens, mounted through a DocumentScreenHost
workspace_model.hpp	The workspace's tab logic with no widgets (spec 6 §7, §15): what an application's own tab strip binds to, and what ui::Workspace draws as a tab bar
util
datetime.hpp	UTC timestamps for morph actions
quantity.hpp	Unit-tagged, optionally-empty exact values with a derivation trail
rational.hpp	Exact rational arithmetic for morph model/action values
tagged.hpp	Tagged<T, "Name"> — an opaque, type-safe newtype for protocol scalars that serializes transparently as its underlying T
attributes.hpp
version.hpp