Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

Nmorph
Napp
CMenuEntry	One app-menu entry: a label and the screen-id it routes to
CFormScreen	A screen backed by one registered action's form
CWizardScreen	A screen backed by a registered morph::flows::Wizard
CApp	The app-shell descriptor: a title, an ordered menu, and the screens it routes to
CAppTraits	Traits specialisation mapping an App type to its string type-id
Nasync
CCallbackScope	Owned lifetime-and-stop gate for asynchronous callbacks — a data member, not a base class
CCallbackToken	Weak, copyable observer of a CallbackScope — the half a callback captures
CCompletion	Move-only handle representing the eventual result of an asynchronous operation
CPromise	Producer-side handle paired with a Completion<T> by makeSettleable()
CDelayAwaiter	The awaiter delay() returns: suspends until a TimeoutScheduler entry fires, or until a stop withdraws it
Nbackend
CBackendChangedError	Thrown to in-flight Completions when Bridge::switchBackend() runs
CBridgeDestroyedError	Thrown to in-flight Completions when Bridge is destroyed
CClientTimeoutError	Thrown to a pending Completion when Bridge::setExecuteDeadline's duration elapses before any reply arrives — a frame silently dropped by QtWebSocketServerConfig::messagesPerSecond, or a genuinely hung server, either way
CConnectionFacts	What a RemoteServer knows about one connection that a service, not core, decides: handed to IEnvelopeService::handle with each envelope
CConnectionWriter	A transport's outbound side of one connection, for what the server sends unasked: events
CDisconnectedError	Thrown to in-flight Completions when a transport drops mid-call (e.g. a Qt WebSocket disconnect). The framework retries the call on reconnect if the backend supports it; otherwise the GUI's .onError(...) runs
CHandlerDestroyedError	Thrown to every call a BridgeHandler still holds for its bind when the handler is destroyed before the bind settles
CHealthStatus	Snapshot of a RemoteServer's current health
CIEnvelopeService	Envelope kinds a RemoteServer answers through an extension, such as the UI service's ui-* kinds
CIEnvelopeTransport	What a wire transport offers beside IBackend: one request, one reply, matched by callId
CLimitPolicy	Opt-in, connection-agnostic resource limits enforced by RemoteServer
CLocalBackend	In-process backend that executes model actions on a thread pool strand
CRemoteServer	Server-side message handler that owns model instances and dispatches actions
CServerConfig	Everything about a RemoteServer that is configured rather than learned: given once, at construction, and never changed
CSimulatedRemoteBackend	IBackend adapter that routes all calls through a RemoteServer as wire Envelope messages
CSynchronousBackendAdapter	Makes a blocking backend reach its caller without blocking it — and without touching the backend
CTimeoutError	Thrown to a pending Completion when the server-side morph::backend::LimitPolicy::executeTimeout elapses before the model's action replies
Nbridge
CActionExecuteRegistry	Type-erased, JSON-in/JSON-out execute path for actions whose concrete C++ type is only known by its registered string id at the call site (e.g. a schema-driven GUI that reads action names out of a JSON Schema at runtime)
CBridge	Central dispatcher that routes typed actions to an IBackend
CNoSharing	BridgeHandler sharing policy: private, one instance per handler
CAllowShared	BridgeHandler sharing policy: joins the shared instance directory
CBridgeHandler	RAII wrapper that binds a single model type to a Bridge
CRawHandler	A handler for a model known only by its registered type id
Nclient
CApplicationHost	The application's side of the commands a document host does not answer itself (spec 6): sign-in and sign-out, which install a principal into the source, and the file commands, which read a picked file from disk and save a downloaded one, moving the bytes over the source's file side channel or inline
CArgs	What the generic client reads from its command line
CLocalApp	An application the client links and runs in-process
CLocalSetup	What a local application is set up with
CLocalSource	Runs a linked application in-process (--app): its models over a LocalBackend, its bundle answered by a UiService in the same process, and verified by the same client as a remote one
CRemoteSource	Fetches the screens from a server (--server), over the transport the frontend calls for
CRemoteTransport	A connection to a server: the bridge's backend and its request verb, which are one object
CShellOptions	What a client shell reports, and how it starts
CSignedIn	What a sign-in installs: the principal, and the session token its server needs (empty for none)
CSource	An AppSource that also hands the shell what it mounts screens with, once it delivered a bundle
CTransport	What a concrete source opens with: the bridge's backend and the exchange the UI service is reached by
Ncore
CFileIoOps	The raw file-I/O primitives morph::journal::FileActionLog and morph::offline::FileOfflineQueue both call, as an injectable strategy. Every member defaults to the real syscall/stdlib call it stands in for, so a default-constructed FileIoOps is byte-for-byte what both classes called directly before this seam existed — no behavior change for a normal caller
Ndetail
CFixedString	A structural, NTTP-capable compile-time string
Neffects
Ndetail
CDeclaredEffect	One effect as a registrar records it: the record still a type, not yet a name
CEffectOf	Maps an effect tag type to its DeclaredEffect
CResolved	The matched and validated registries: what every read is answered from
CActionRecord	A record an action's result holds, and where
CChanges	What one successful execute changed
Cchanges	Effect: the action may create, remove or change rows of record R, which its result need not carry
CchangesInstance	Effect: the state of the instance the action ran on changed
CEffect	One effect of an action, with its record resolved to a wire name
CInstanceChange	A change to the state of one model instance
Cnone	Effect: the action changes nothing, declared explicitly
CRecordChange	A change to the rows of one record type
Cupdates	Effect: the action edits existing rows of record R, and its result carries them
Nexec
CIExecutor	Abstract executor interface
CIoLoop	Owns a core::net::PlatformLoop and, for IoLoopDriver::OwnThread natively, the one thread that runs it
CWeak	A non-owning handle that posts to the loop only while it exists
CMainThreadExecutor	Single-thread executor intended for use on the calling (main) thread
COwnerStrand	One strand over a morph executor, usable wherever a morph executor is: the owner a component's state belongs to
CThreadPoolExecutor	Multi-threaded executor backed by a fixed-size thread pool
Nflows
CWizardStep	One step of a Wizard: a registered action, a display title, and zero or more Bind prefill declarations
CWizard	An ordered sequence of WizardSteps sharing one flow
CWizardTraits	Traits specialisation mapping a Wizard type to its string type-id
CFlowSession	Sequences an ordered list of registered actions (Steps...) as one multi-step flow sharing captured values across steps
Nforms
CAnd	Compound condition: all of Conds... hold. Nests to any depth — each Cond may itself be a leaf (Engaged, Equals, a comparison, …) or another And/Or/Not. Usable both as a nested when clause and directly as a top-level formRules entry (it declares isPresentation and test() exactly like every other validation rule), which is what lets a single rule carry a compound condition tree instead of factoring the composition into multiple single-condition rules
CAtLeastOneOf	Rule: at least one of the listed fields is engaged
CBind	One field -> "<ActionTypeId>.<field>" prefill binding declared on a wizard step or an unordered section
CChoice	An optionally-empty value selected from options served by another action
CChoiceOption	One selectable value of an Enum or a Choice
CChoiceSpec	Where a Choice's options come from (x-optionsAction and its companions)
CCollectionAction	One v-rowAction or v-actions entry
CCollectionChrome	Replacements for the parts of a collection view a host draws from its own UI kit. Each one left empty keeps the built-in part
CCollectionColumn	One v-columns entry
CCollectionModel	The immutable model of a v-* view document
CCollectionRow	One listed row
CCollectionSession	The reactive state of one collection: the list, the table source, the actions, the confirm step and the row editor. A controller in the sense of docs/spec/reactive/control.md; it draws nothing
CCollectionViewOptions	How collectionView draws a collection and labels its chrome
CConflictingOptionsError	Thrown by schema generation when a Choice<…> member's FieldMeta also sets optionsAction: the member's type already names where its options come from, and two sources cannot both hold
CConstraintViolation	One violation: which field, and which declared key it broke
CEngaged	Condition: field is engaged (has a value). One of the closed condition kinds a requiredWhen / visibleWhen / readonlyWhen rule's when clause accepts
CEquals	Condition: field's engaged value equals literal. An unengaged field is not vacuously satisfied here (unlike the comparison kinds) — a field with no value cannot equal anything, so equals returns false while the field is unengaged
CExactlyOneOf	Rule: exactly one of the listed fields is engaged
CFieldConstraint	The per-instance constraint declared for one field of an action
CFieldError	Why a draft does not encode: a stable code and the message shown beside the field
CFieldGroup	One named group of fields in an action's formLayout
CFieldGroupSpec	One x-layout group, or the implicit group of the fields no group names
CFieldMeta	Per-field presentation overrides and scalar bounds: label, help, placeholder, read-only, hidden, minimum/maximum/multipleOf, and a plain member's display unit/decimals (docs/spec/forms/forms.md, "Field metadata")
CFieldOverlay	What a document (or an application) changes about one top-level field before the session is built: a form node's fields entry (spec 6 §10). An unset member keeps the schema's
CFieldSpan	A field's declared column span in a grid renderer
CFieldSpec	Everything the engine knows about one field, from its schema property
CFieldState	The reactive state of one field: its draft and everything derived from it
CFieldView	A field's spec and state, handed to an override: what it shows (the value, the draft, the errors, the options) and what it writes (the draft). Copyable; valid while the session lives
CForm	A form over action A: a FormSession built from schemaJson<A>(), submitting through a BridgeHandler, with typed set<>, value() and lastResult()
CFormModel	The immutable runtime model of one action's form
CFormSession	The reactive state of one form: a controller over a FormModel
CFormSessionOptions	How a session reads numbers, dates and text
CFormViewOptions	How formView lays a form out and labels its chrome
CGreater	Rule/condition: *lhs > *rhs when both operands are engaged; vacuously satisfied when either is unengaged (a form still being filled in must not fail this comparison prematurely — see forms.md). Compares the operands' engaged values (operator*()) directly — e.g. the underlying math::Rational for Quantity, or DateTime for Timestamp — never the field type's own (possibly throwing, for Quantity) operator<=>
CGreaterOrEqual	Rule/condition: *lhs >= *rhs when both operands are engaged; vacuously satisfied when either is unengaged. See Greater for the exact-value / vacuous-operand rationale
CIncompleteOptionsError	Thrown by schema generation when a FieldMeta sets optionsAction without both valueField and labelField, or either of those without optionsAction: options need the action, the value field and the label field together
CInstanceConstraints	A set of per-field constraints sourced from one instance (a database row, a tenant record, a catalogue version) — the single declaration that both decorates a served schema and checks a submitted value
CLess	Rule/condition: *lhs < *rhs when both operands are engaged; vacuously satisfied when either is unengaged. See Greater for the exact-value / vacuous-operand rationale
CLessOrEqual	Rule/condition: *lhs <= *rhs when both operands are engaged; vacuously satisfied when either is unengaged. See Greater for the exact-value / vacuous-operand rationale
CMultiline	A string field edited as a multi-line text area
CMutuallyExclusive	Rule: at most one of the listed fields is engaged
CNot	Compound condition: the nested condition does not hold. Nests to any depth, and is usable directly as a top-level formRules entry, exactly like And/Or
CNotEngaged	Condition: field is not engaged. The complement of engaged
COr	Compound condition: at least one of Conds... holds. Nests to any depth, and is usable directly as a top-level formRules entry, exactly like And
COverrides	Replacement controls, resolved per field in the order field path, widget hint, unit, kind, else the built-in control
CPendingConfirm	A confirm-guarded action waiting for an answer
CQuantityDecodeError	Thrown when a decoded action has a Quantity field whose engaged value falls outside its unit's declared bounds (UnitTraits<E>::bounds)
CRanged	A bounded numeric field edited as a slider
CReadonlyWhen	Presentation rule: the listed field is editable only while Cond does not hold (the field is read-only while when holds). Never gates allRulesSatisfied, exactly like VisibleWhen
CRequiredWhen	Rule: field must be engaged whenever Cond holds; vacuously satisfied (not required) while the condition does not hold
CRowState	One collection row: the element's member fields
CRuleExpr	One x-rules entry, or a condition inside one, and its translation into expr/1
CRuleList	Composed list of an action's declared cross-field rules — the value of A::formRules. Built by ruleList(...); never constructed directly
CRuleOperand	What a rule reads of one field
CSchemaError	Why a schema does not read as a form: where, and why
CSection	One section of a SectionGroup: a registered action, a display title, and zero or more Bind prefill declarations
CSectionGroup	An unordered set of Sections sharing one screen
CSectionGroupTraits	Traits specialisation mapping a SectionGroup type to its string type-id
CSectionSet	Drives N independently editable action drafts on one screen
CUnitOption	One unit a Quantity can be entered in; the first of a field's units is canonical
CUnsatisfiableFormError	Thrown by schemaJson<A>() when A's declared formRules contradict A's own derived required array so completely that no submission could satisfy both
CValueContext	The session options a value conversion reads
CVisibleWhen	Presentation rule: the listed field is shown only while Cond holds. Never gates allRulesSatisfied — while hidden, the field's current draft value still travels in the payload (hiding never clears it), exactly like a static x-hidden field
CWireValue	One field's encoded value
CWizardChrome	Replacements for the parts of a wizard view a host draws from its own UI kit. Each one left empty keeps the built-in part
CWizardModel	The immutable model of a w-* wizard document
CWizardSession	The reactive state of one wizard: its steps' sessions, the position, and what each step resolved
CWizardStepSpec	One w-steps entry
CWizardViewOptions	How wizardView draws a wizard and labels its chrome
Njournal
Ndetail
CEscapingWriteOpts	Write options that escape ASCII control bytes as \\uXXXX sequences
CScopedReplayFlag	RAII helper that sets the thread-local replay flag for its scope, restoring the previous value on destruction
CFileActionLog	Append-only, newline-delimited-JSON IActionLog backed by a local file
CIActionLog	Interface for durable storage of executed-action entries
CInMemoryActionLog	In-memory implementation of IActionLog, owned by one executor
CLogEntry	One recorded execution of an action against a model instance
CNullSinkError	Thrown by OutboxRelay::relay() when sink is null
COutboxRelay	Moves committed-but-unrelayed rows from a model's own outbox table to a durable IActionLog, then marks them relayed in the model's own store
COutboxRelayResult	Outcome of one OutboxRelay::relay() call
CPayloadMigrationRegistry	Registry of payload migrations, keyed by (actionType, fromSchema)
CSchemaMismatchError	Thrown by replay() when a recorded entry's payload fingerprint (LogEntry::schema) disagrees with the fingerprint this build computes for the same action, and no migration covers the pair
CScopedActionLog	RAII helper that installs a default action log for its lifetime and restores the previous one on destruction
CSerializationError	Thrown by toJson/fromJson when LogEntry (de)serialisation fails
CSessionLog	Full-fidelity, in-memory log of one model instance's executed actions
Nlog
CScopedLoggerOverride	RAII helper that swaps the global logger and level for the lifetime of the object, and restores them in the destructor
Nmath
CDecimalPlaces	Strong type for a decimal-precision count
CNumerator	Strong type for a Rational numerator
CDenominator	Strong type for a Rational denominator
CWireClampScope	Observes whether any Rational had to be clamped while decoding inside this scope
CRational	Exact rational number with a runtime decimal-precision tag
CWire	Flat JSON representation used by the Glaze codec below
Nmodel
CActionKeyTraits	Declares where an action's model key comes from
CActionLogPolicy	Per-action policy deciding how repeated executions are checkpointed into a durable action log
CActionRecordingError	Thrown when an action executed and its mutation committed, but the framework could not finish reporting that success
CActionTraits	Traits specialisation that maps an action type to its id, JSON codec, and result type
CActionValidator	Per-action readiness predicate deciding whether an action may execute
CDuplicateRegistrationError	Thrown when a model id, or a model's action id, is registered for a type other than the one that already holds it
CEffectsRegistrationError	Thrown on a read of the effects or record registry when the registered configuration is invalid
CHandlerResult	The result an action handler's return type stands for: R for a core::async::Task<R> handler, the type itself for any other
CHandlerResult<::core::async::Task< R > >	HandlerResult for a Task handler
CModelKeyTraits	The key type of a model, when one has been declared for it
CModelTraits	Traits specialisation that maps a model type to its string type-id
CPayloadShapeTag	Declares a stable shape tag for a type T whose JSON shape payloadShape cannot decompose
CPayloadShapeTag< morph::math::Rational >	Stable shape tag for Rational, so a payload fingerprint can tell a Rational field from a Timestamp or a Quantity one
CPayloadShapeTag< morph::time::DateTime >	Stable shape tag for DateTime
CPayloadShapeTag< morph::time::Timestamp >	Stable shape tag for Timestamp
CPayloadShapeTag< morph::units::Quantity< U, Dec > >	Stable shape tag for Quantity<U, Dec>, carrying the unit's ascii id and the declared decimals
CPayloadShapeTag< morph::util::Tagged< T, Tag > >	Stable shape tag for Tagged<T, Tag>, carrying both the tag text and the wrapped type's own shape
CValidationError	Thrown when a decoded action fails ActionValidator<Action>::ready(...) on a server-side or local execution path, before Model::execute runs
Nnet
CSocketBackend	IBackend implementation that communicates with a RemoteServer over a raw-socket RFC 6455 WebSocket connection — no Qt, no GUI event loop required
CSocketBackendConfig	Reconnect tuning for SocketBackend
CSocketServer	Raw-socket WebSocket server front for morph::backend::RemoteServer
CSocketServerConfig	Configuration for SocketServer
Nobserve
CMetricEvent	One metric observation delivered to the installed MetricSink
CTraceSink	Host-supplied hooks bracketing one dispatch, for distributed tracing
CScopedObserveOverride	RAII helper that snapshots the global metric and trace sinks and restores them in the destructor
Noffline
CAttempts	A replay attempt count, as a type distinct from a queue item id
CFileOfflineQueue	Reference append-only, NDJSON-backed IOfflineQueue that persists payload, idempotencyKey, and attempts across process restarts with no third-party dependency
CFileOfflineQueueError	Thrown by FileOfflineQueue when a non-trailing line of its on-disk NDJSON is malformed (via detail::throwOnGlazeError). Note the "cannot be opened" paths throw plain std::runtime_error, not this type — see the constructor's own exception documentation
CInMemoryOfflineQueue	In-memory implementation of IOfflineQueue, owned by one executor
CInMemoryReplayLedger	In-memory implementation of IReplayLedger, owned by one executor
CIOfflineQueue	Interface for durable storage of actions that could not be delivered
CIReplayLedger	Interface for an op-id-keyed exactly-once replay ledger
CNetworkMonitor	Connectivity monitor that calls a probe on a timer and fires callbacks on state changes
CNetworkMonitorConfig	Configuration for NetworkMonitor
COfflineQueueFullError	Thrown by enqueue() when the queue is at its configured maxDepth()
CQueueItem	An item stored in the offline queue
CReconnectCoordinator	Sequences reconnect → activate → bind → replay when connectivity returns
CDeps	Injected, host-supplied side effects. None may be null. Each is called on the offline strand
CReconnectCoordinatorConfig	Tuning parameters for ReconnectCoordinator
CSqliteOfflineQueue	Reference SQLite-backed IOfflineQueue: persists payload, idempotencyKey, and attempts across process restarts
CSqliteOfflineQueueError	Thrown when a SQLite operation used by SqliteOfflineQueue fails
CSyncResult	Aggregated result returned by SyncWorker::run()
CSyncWorker	Replays queued actions from an IOfflineQueue on reconnect
Nqt
CQtExecutor	IExecutor implementation that posts tasks to a Qt event loop
CQtWebSocketBackend	IBackend implementation that communicates with a RemoteServer over WebSocket
CQtWebSocketBackendConfig	Reconnect tuning for QtWebSocketBackend
CQtWebSocketServer	Qt WebSocket server that bridges incoming connections to a RemoteServer
CQtWebSocketServerConfig	Per-connection resource limits and bind/exposure policy enforced by QtWebSocketServer
Nqt_quick
CBackend	ui::IViewBackend over Qt Quick: each widget is a Qt Quick item made from its kind's MorphUi component, or from the component the restyle map names for that kind
CBackendOptions	What a Backend is made with beside its engine and host item
CComponentFailure	Why a component could not be loaded; reported once per component and reason
CComponents	The QML components a client renders beside the built-in kinds (spec 5 §10)
CCustomRequest	What IViewBackend::createCustom asks for
CCustomWidget	A component a renderer loaded in a custom node's place (spec 5 §10): a bundle's verified QML or a host component, given the props the document binds and handing back the events it raises
CFrontend	Runs a morph application in a Qt Quick window, on the calling thread
CFrontendConfig	What a qt_quick::Frontend runs with
CInspectorWindow	A window that shows the focused screen's mounted nodes with their evaluated properties, its queries and mutations with a refetch button each, its command log and the reactive counters
CQtScheduler	reactive::Scheduler on QTimers, for a runtime whose owner is the Qt event loop's thread
Nreactive
Ndetail
CBatchScope	Opens a batch for its lifetime
CEqualityUsable	Whether == is usable for T: declared, and its element types usable too
CEqualityUsable< std::optional< T > >	An optional is usable when its value type is
CEqualityUsable< std::pair< First, Second > >	A pair is usable when both its types are
CEqualityUsable< std::tuple< Ts... > >	A tuple is usable when every element type is
CEqualityUsable< std::variant< Ts... > >	A variant is usable when every alternative is
CEqualityUsable< T >	A range is usable when it declares == and its element type is usable. A range whose element is itself (std::filesystem::path) is checked as a plain type
CFlushBounds	The bounds a flush keeps, as RuntimeOptions sets them
CNode	A graph node: a source (Signal), an observer (Effect), or both (Computed)
CRuntimeCore	State shared by one Runtime and every node made from it
CTrackingFrame	Collects the sources one tracked run reads, and restores the previous frame when it ends
CUpdateCoversAll	Whether Update handles every alternative of the variant Msg
CUpdateCoversAll< Update, ViewState, std::variant< Alts... > >	Whether Update handles every alternative of std::variant<Alts...>
CUpdateFrame	One update in progress, on the stack of the send() running it
CUpdateGuard	Marks a Store as inside its update for the guard's lifetime
CWidgetEventScope	Marks a widget callback for its lifetime
Ntesting
CManualScheduler	A deterministic Scheduler: its clock moves only in advance(), which fires what falls due on the calling thread
CComputed	A derived value: computed lazily on first read, cached, and recomputed only after a source it read really changed
CEffect	A side effect: runs once on construction, then in a flush after any source it read changed
CInvalidationLink	A query's registration with the mutations that invalidate it
CMutation	A command: issues a write and tracks it, then refetches what the write invalidates
CMutationOptions	How a Mutation sequences its runs, and what a success invalidates
CQuery	A derived async resource: the result of fetching whatever its tracked key names
CQueryOptions	How a Query refreshes besides key changes, and how long it lets a key settle
CRefetchable	Something a Mutation can tell to fetch again after it succeeds
CRuntime	The owner of a signal graph: every node takes one, and every operation runs on its owner
CRuntimeOptions	How a Runtime bounds and reports its flushes
CRuntimeStats	What a Runtime has counted since it was made: its flushes, the Effects they ran, its batches and the misuses it reported. A development tool reads it (spec 6 §21); counting costs a few increments per flush
CScheduler	Runs callbacks after a delay or on a period, on the runtime's owner executor
CScope	Owns effects, computeds and adopted objects; destroys them in reverse creation order
CSignal	A source value. Reading it with get() inside a tracked run subscribes that run
CStore	User-intent view state — what is selected, typed, open — changed only by messages
CSubscription	The latest R the bridge published on a handler's instance, as reactive state
CTimerHandle	Owns one scheduled timer and cancels it when destroyed. Move-only
Nrecord
Ndetail
CKeyOption	Detects a key<> option and exposes its member pointer
CIsDerivedFrom	Detects a derivedFrom<> option
CMemberType	The type of the data member a member pointer names
Ckey	Option for BRIDGE_REGISTER_RECORD: the record's key is the named member instead of id
Ckeyless	Option for BRIDGE_REGISTER_RECORD: the record has no key
CderivedFrom	Option for BRIDGE_REGISTER_RECORD: a change to any of S is a change to this record type
CprivateKeys	Option for BRIDGE_REGISTER_RECORD: the record's keys must not reach other principals
CRecordInfo	What one BRIDGE_REGISTER_RECORD declared
Nrender
Ndetail
CCodePoint	One decoded UTF-8 code point: its value and how many bytes it took
CDigitMatch	A digit matched at the start of an entry
CSignMatch	A sign matched at the start of an entry: how much of the text it occupies, and what it contributes to the canonical output
CNumericLocale	The locale facts both control-edge conversions need, in one designated-initialisable aggregate
Nsession
Ndetail
CEscapingWriteOpts	Write options that escape ASCII control bytes as \\uXXXX sequences
CScopedContext	RAII helper that sets the thread-local Context for its scope
CAllowAllAuthorizer	Default authorizer that permits everything
CContext	Per-call session context carried through the bridge to the model
CIAuthorizer	Authorizes incoming actions on a RemoteServer
CAdmission	What admit decides about one call: whether it may run, and under which verified principal
CPrincipal	The signed-in user's verified identity, readable outside a dispatch
CSessionToken	Verified claims carried by a session token
CSigningAuthorizer	IAuthorizer that authenticates via a signed Context::token
CTokenIssuanceError	Thrown by TokenIssuer::issue if serialising the claims fails
CTokenIssuer	Mints signed bearer tokens from claims using a shared secret
CTokenVerifier	Verifies signed bearer tokens against a shared secret
Ntable
Ndetail
CIsOptional	true for std::optional<T>
CIsOptional< std::optional< T > >	true for std::optional<T>
CJobInput	Everything one view job reads. Immutable once the job starts
CJobResult	What a finished job hands back to the owner
CListeners	A source's listeners, notified so that a listener may unsubscribe itself or another, or destroy the source, from inside a notification
CRawEntry	The operator an entry sets and its operand text
CSlotCounter	A Fenwick tree of slot occupancy: how many occupied slots precede a slot
CViewJob	One recomputation of a view, runnable in steps
CViewPositions	Where each identity sits in each view
CApplyOptions	How apply runs
CCellEdits	Commits cell edits row by row, in order
CChangeListener	Receives a DataSource's change notifications, on the owner thread
CChunkedMergeSort	A bottom-up merge sort over row indices that can stop and resume
CCodePointCollator	The default collator: code-point order, with ASCII and Latin-1 letters case-folded. It does not fold accents
CColumnFilter	The filter on one column
CColumnInfo	A column's identity and kind
CColumnLayout	Column order and visibility, kept apart from the engine's view
CColumnSink	Receives a run of one column's cells
CCompiledFilter	A filter compiled against a table's columns: every value parsed
CEntry	One compiled condition
CColumn	One column's compiled filter
CGroup	One compiled group: per column, the entries that apply to it
CDataSource	The rows of a table, as the engine reads them
CDateParser	Parses text to dates and date-times for Date and DateTime columns that hold text, and for filter values on those columns
CEditRequest	One edited cell to commit
CEngine	Sorts, filters and maps the view of one table
CEngineOptions	How an engine runs and what it is given
CEngineStats	Counters for tests, benchmarks and profiler plots
CFieldError	A server's refusal of an edit, attached to the cell
CFilterEntry	One filter condition. Exactly one operator member is set
CFilterRun	Evaluates a compiled filter over a candidate list, column at a time, in steps that yield at a deadline or a stop request
CFilterSpec	A table's whole filter
CGroupFilter	A filter over several columns: a row matches when the entries match on any of them, which is what a quick-search box needs
CIsoDateParser	The default date parser: ISO 8601 only, whatever the format
CKeyColumn	One column's keys, built once and shared, immutable, between jobs
CPage	One page of a list action's reply
CPageFetch	A request a PageWindow asks the client to send, tagged with the query it belongs to
CPageRequest	Which rows of the view a request wants
CPageRows	The rows of one page, as source row indices
CPageWindow	The pages a server-mode table holds: those around the visible rows, up to a bound, plus the request state and the last error
CProgressSink	Receives progress of a long sort or filter, on the owner thread
CQuantityCell	A quantity in its own unit, with the factor that converts it to the column's canonical unit
CQueryLimits	The bounds a server applies to every TableQuery, an untrusted body
CRowChange	One change notification
CRowOrder	A sort chain resolved to key columns: the comparator of a sort
CKey	One resolved key
CRowPatcher	Replaces a row by key; what a committed cell edit patches
CRowSnapshot	An immutable view of a table's rows at one moment
CRowsSnapshot	A snapshot over a shared, immutable vector of typed rows
CRowsSource	A DataSource over typed rows: one column per key glaze writes, its kind inferred from the value's type
CSelection	A table's selected keys and active key
CSelectionOptions	A selection's configuration
CServices	The services an engine sorts and filters with. A null member is replaced by its default
CSortKey	One key of a sort chain
CTableCounts	The counts a status line shows
CTableError	The error every fallible table call returns
CTableQuery	A table's sort, filters and page, as a list action's body carries them
CTableSnapshot	A RowSnapshot that stores rows in shared, immutable chunks
CTextCollator	Orders and matches text. The renderer injects the toolkit's collator for the user's locale; CodePointCollator is the default
CVectorSource	A DataSource over rows held in memory, for tests, servers and sources that cannot share their own storage
CViewChange	The operations that turn one view order into another
CViewOp	One list-model operation
Ntesting
COwnerProbeRecorder	Records every owner check a loop-owned body makes while this object is alive (morph::exec::detail::noteOwner), and what the calling thread's executor scope said at that moment
CSeen	One owner check
CStepExecutor	IExecutor that queues every posted task and runs them only when the test explicitly asks, one at a time
Ntime
CDateTime	A UTC instant with millisecond precision
CScopedNowOverride	RAII helper that fixes DateTime::now() to a constant instant (or a custom callable) for its lifetime and restores the previous override on destruction
CTimestamp	An optionally-empty timestamp field
Ntui
CBackend	Builds every widget of a mounted view tree as a core::tui::Component on one Screen
CFrontend	Runs a morph application in a terminal, on one thread
CFrontendConfig	What a tui::Frontend runs on
CLoopExecutor	Runs every posted task in a later turn of one core::net::EventLoop, with this executor current
Nui
Nauthor
Ndetail
CIsOptional	Whether a type is a std::optional
CIsOptional< std::optional< T > >	A std::optional is one
CUnwrapped	A type with one std::optional removed
CUnwrapped< std::optional< T > >	The engaged type of a std::optional
CIsVector	Whether a type is a std::vector
CIsVector< std::vector< T, Alloc > >	A std::vector is one
CIsHandle	Whether a type is a Handle
CIsHandle< Handle< T > >	A Handle is one
CLiteralOf	The value type a constant stands for
CLiteralOf< char[N]>	Text is a std::string
CLiteralOf< char const * >	A C string is a std::string
CLiteralOf< std::string_view >	A string view is a std::string
CValueOf	The value type of an operand: a handle's value type, or the type its constant stands for
CValueOf< Handle< T > >	A handle's value type
CNodeWriter	Builds a node's JSON key by key, leaving out what is absent
CAny	The value type of a handle whose value the screen cannot know when it is written: a query result read by name, an element value, an event payload
CAuthoringError	What a builder throws when it is given something a document cannot say, such as a field read from a value that has no name. Registration turns it into a Refusal at the document's root
CModelFacts	Catalog facts of a model type that its C++ type does not show. Specialise it for a model whose shared singleton is equivalent to a private instance
CActionFacts	Catalog facts of an action that its C++ type does not show. Specialise it for an action whose reply rows carry server-calculated fields, whose reply carries a secret, or which sends a credential
CCatalogFacts	The catalog facts the builders gathered from the model and action types a screen names
CHandle	An expression of a document, typed by the C++ value it evaluates to (spec 5 §11)
CElement	An element of the view, named by its id, whose live values relations read (spec 5 §6)
CSelf	The dialog or drawer a command list runs in, for close
CQueryRef	A query of a scope, without its action type: what refetch, prefetch and optimistic name
CMutationRef	A mutation of a scope, without its action type: what signIn, upload and can name
CQueryHandle	A query declared by a scope
CResultHandle	A mutation's result: a Handle with no field reads
CMutationHandle	A mutation declared by a scope
CBodyField	One field of an action body: a member of the action, and the expression that fills it
CBody	An action body: the action's members with expressions in place of values (spec 5 §11). C++ cannot synthesise the action's struct with its members retyped, so a body lists {&Action::member, value} pairs
CModelHandle	A model alias of a scope
CBorrow	The opener's binding of an alias, for a screen opened as a dialog ({"from": alias})
CInstanceSpec	A model alias's instance: a binding mode, a key expression, or a borrowed binding
CModelOptions	Options of a model alias
CQueryOptions	Options of a query (spec 5 §5)
COptimistic	An optimistic write: the row a mutation run predicts before its reply
CCommands	A command list, run as one batch
CCommand	One command of ui/1 (spec 5 §8, spec 6)
CMutationOptions	Options of a mutation (spec 5 §5)
CCheckOptions	A validation across elements (spec 5 §6)
CNodes	A list of view nodes
CNode	A view node (spec 5 §9). The kind's own properties come from its builder's options; the properties every node takes come from the member functions, each of which returns a copy with the property set
CDeclScope	A scope's declarations (spec 5 §3): model aliases, state, let, queries, mutations, watches and checks. A row, a dialog, a drawer and a switch case declare theirs on the scope their builder hands over
CComponentOptions	A custom or host component (spec 5 §10)
CComponentRef	A declared component, for custom nodes
CPoint	A customization point (spec 5 §12b)
CHeadBadgeOptions	A status badge of the screen's head (screen.status)
CActionButtonOptions	A button of a screen's head (screen.action), or of a dialog's or drawer's footer
CScope	The screen's own scope: its declarations, params, lifecycle keys, components and customization points
CRunOptions	Options of run
CNavigateOptions	Options of navigate
CUploadOptions	Options of upload
CTextOptions	Options of text
CButtonOptions	Options of button
CTextInputOptions	Options of textInput
CCheckboxOptions	Options of checkbox
CSelectOptions	Options of select
CMenuItem	An item of a menu; items nests a submenu
CContainerOptions	Options of column, row and grid
CPanelOptions	Options of panel
CCase	A case of a switch node, a scope of its own
CTab	A page of a tabs node
CDialogOptions	Options of dialog and drawer
CForEachOptions	Options of forEach
CTableColumn	A column of a table
CTableOptions	Options of table and dataTable
CDateTimeInputOptions	Options of dateTimeInput
CSliderOptions	Options of slider
CFilePickerOptions	Options of filePicker
CActionPart	The action of a banner or emptyState
CBannerOptions	Options of banner
CEmptyStateOptions	Options of emptyState
CCollapsibleOptions	Options of collapsible
CDropZoneOptions	Options of dropZone
CFieldSettings	An overlay on one field of a form (spec 6 §10), applied to the parsed form model
CFieldOverlay	One field of a form's fields overlay, by member pointer
CFormPresentation	How a form, collection or wizard presents its forms: the keys every one of them takes
CFormOptions	Options of form
CCustomOptions	Options of custom
CEmitted	A screen's emitted document: its JSON, the text that is served, and the catalog facts of its types
CScreen	A screen definition: an id and the builder that writes the document
CRegisteredScreen	A registered screen: the text that is served and the document it loads as
CScreenRegistry	The screens of an application, each validated once when it is registered
Ndetail
Ncatalogue
CTitleParts	A catalog title's parts: a plain string, or the message key of a {"t": …} reference and its fallback
Nhost
CParamsEnv	The environment identityOf evaluates in: the params, and nothing else. Reading anything else marks it unknown
CActionModel	An actionButton part, lowered in the scope of the list it belongs to: what a screen's head shows and an overlay's footer draws as buttons
CAliasResolver	Resolves tokens' aliases, depth first, each token once
CArrangedChild	One child of an arranged container, as the user's choice places it
CBadgeModel	A headBadge part, lowered in the screen scope
CBinding	A name bound for the expressions of one place: a command's event, a step's as, result in a patch, body in an optimistic, props in a fallback, boundary in a boundary's error
CBoundaryRuntime	A boundary at run time: the queries it owns (spec 5 §9)
CCacheEntry	One entry of the session's query cache (spec 5 §5): one request in flight, one value, one error
CCheckContext	Where an expression or command is checked: its scope and what is valid there
CCheckRuntime	One check at run time
CCommandCtx	Where a command list runs: its scope, the names bound there, and what it may answer
CCommandLineChoice	The command line's choice of frontend, and the arguments that made it
CDateReading	What a date input reads from a value: the instant it shows, and whether the value names one at all
CDetachedLower	A lowering context whose scope is held weakly: what an Effect the scope itself owns may keep, so the scope does not keep itself alive
CDocumentActions	Collects the actions and model types a loaded document names, resolving each query's, mutation's and model-bound node's alias through the enclosing scopes
CDocumentParser	Turns the JSON of a document into its model, refusing what does not parse
CDocumentRefused	The exception the loader throws inside itself; loadDocument turns it into its result
CDocumentValidator	Checks a parsed document against its own names and the catalog: every load-time rule that needs more than one place in the document
CElementState	An element's live values (spec 5 §6)
CEvaluator	Evaluates expressions against an environment, with the comprehension variables in scope
CExprChecker	Walks an expression once, resolving names and checking the statically known types
CExprParser	Reads one JSON expression tree into Expr nodes, counting them against the size bound
CFormKeys	The keys a form may carry beside its own
CForEachModel	A ForEach's row source, key function and row view, with the row type erased
CForEachSession	One mount's use of a ForEach: the latest snapshot of the rows, and a way to make row slots from it
CFunctionSpec	The signature of a library function
CIsSlotBinding	Whether a type is a SlotBinding: false here, true for the specialisation below
CIsSlotBinding< SlotBinding< F > >	A SlotBinding is one
CKeyedRow	One mounted row of a ForEach or Table
CKeyedRows	The mounted rows of one ForEach or Table, in their container's order
CKeySpec	One key of a kind
CKindSpec	A node kind or part kind: its keys and its element values
CLowerCtx	Where a node is lowered: its scope, the names bound there and the boundary that owns its queries
CMarks	The entries one change marks stale, each once, in the order they were found
CMessageReader	A recursive-descent reader over one message's text
CModelAlias	One model alias at run time: the instance it names, and the channel bound to it
CMounter	Builds widgets for nodes and wires their props and callbacks
CMutationRuntime	A mutation at run time (spec 5 §5): concurrency, optimistic writes and the reply's effects
CNameEntry	One declared name of a scope
CNameRef	One declared name of a run-time scope
CNumber	A number taken apart for arithmetic: its exact value, whether it is an int, and its unit
COptimisticLayer	One optimistic write still waiting for its reply
CPages	Where one Tabs keeps its pages: a slot per tab, made the first time the tab is selected and kept, hidden, after
CPluralOperands	CLDR's plural operands of a number as it is shown
CQueryRuntime	A query at run time (spec 5 §5): a key over the scope, an entry of the session's cache, latest wins
CRowSlot	One mounted row of a ForEach or a Table: the row's signal, and the view built from it once
CRtScope	One document scope at run time: the screen, a dialog's or drawer's content, a switch case or a row
CScopeEnv	The Environment the evaluator reads through: a scope chain and the names bound at one place
CScopeInfo	One scope during validation: its names and its parent
CScopeResolver	Resolves an expression's names against a scope chain and a context
CScreenCore	One mounted screen's interpreter: its document, diagnostics, slots and preferences, and the code that declares scopes, lowers nodes and runs commands
CKeptState	A state of the screen this one replaces: its declared type's name and its value
CLoweredNode	A node as it was lowered, which the inspector lists while its scope lives
CStateSlot	One state declaration at run time
CTransferHold	A transfer's share of its screen's pending count
CTransferState	The values of an upload transfer id (spec 6 §18)
CTypedForEach	The typed model behind forEach<RowT> and table<RowT>
CVisibleRange	What the backend's own scroll position asks a virtualized table to realize next
Ntesting
Ndetail
CCallbacks	The handlers a widget was given, which the interaction helpers call
CChecks	Collects a case's checks and keeps the first failure, so a case reads top to bottom
CEntry	A row of the ForEach and Table cases
CFakeBadge	A fake BadgeWidget: properties tone, text, icon
CFakeBanner	A fake BannerWidget: properties tone, text, actionLabel, dismissible
CFakeBusy	A fake BusyWidget: properties active, label
CFakeButton	A fake ButtonWidget: properties label, emphasis, icon, style and selected
CFakeCheckbox	A fake CheckboxWidget: properties label, checked
CFakeCollapsible	A fake CollapsibleWidget: properties title, header (the header child's id), open
CFakeContainer	The ContainerWidget half of every fake container
CFakeCustom	A fake loaded CustomWidget: property component, and each prop as prop.<name>
CFakeDateTimeInput	A fake DateTimeInputWidget: properties mode, offset, value, caption, captionShown
CFakeDialog	A fake DialogWidget: properties open, title; a Footer child once its footer is asked for
CFakeDrawer	A fake DrawerWidget: properties side, open, title; a Footer child once its footer is asked for
CFakeDropZone	A fake DropZoneWidget: properties accept ([.ext,…]), multiple
CFakeEmptyState	A fake EmptyStateWidget: properties title, text, icon, actionLabel
CFakeField	The FieldWidget half of every fake field: properties readonly, required, errors, stale
CFakeFilePicker	A fake FilePickerWidget: properties mode, path
CFakeGrid	A fake GridWidget: properties columns, gap, align, and span on a child
CFakeKeyValue	A fake KeyValueWidget: property items ([label:value,…])
CFakeLeaf	The Widget half of every fake: records itself on construction, records Common's setters, and records its destruction
CFakeMenu	A fake MenuWidget: property items
CFakeOverlay	A fake overlay's footer: a Footer child, made when it is first asked for, so an overlay that never shows actions logs none
CFakePanel	A fake PanelWidget: properties title, header (the child's id), padding, collapsible, collapsed
CFakeProgress	A fake ProgressWidget: properties value (as formatFraction gives it), label
CFakeSelect	A fake SelectWidget: properties style, options, selected, caption, captionShown
CFakeSlider	A fake SliderWidget: properties range (minimum..maximum/step), value
CFakeSplitter	A fake SplitterWidget: properties axis, sizes ([n,…])
CFakeStack	A fake StackWidget, of kind Column or Row: properties gap, align, justify
CFakeSteps	A fake StepsWidget: properties steps ([label:State,…]), current (a position, or none)
CFakeTable	A fake TableWidget: properties columns, selectionMode, selection, and rowKey on a row
CFakeTabs	A fake TabsWidget: properties tabs, selected, barShown
CFakeText	A fake TextWidget: properties text, role
CFakeTextInput	A fake TextInputWidget: properties mode, text, placeholder, unit, decimals, icon, caption, captionShown, the field state, and a text cursor
CFakeToast	A fake ToastWidget: properties text, tone, and shown (incremented on every show, so a test can tell a replace from a no-op)
CGeometry	Reads where the layout cases' widgets are drawn, and fails a case whose probe reads no geometry
CHandlerLife	What LifeSentinel reports about the handler that holds it
CLifeSentinel	Captured by value in a handler, tells whether the backend destroyed the handler while it ran
CMeasured	The container a case measures, the one child of the mounted root, and its children in order
CRecord	One fake widget's state
CRecordStore	The records, the roots and the operation log that every fake widget of one backend writes to
CConformanceCase	One scripted case
CConformanceProbe	How the conformance cases read and drive one backend under test
CMemoryHistory	A history of routes in memory: the entries, the current one, and back, forward and an edited address
CRecordingBackend	A headless IViewBackend: fake widgets that record every operation, a golden dump of the live tree, and helpers that act as the user would
CWidgetBounds	Where a widget is drawn, in its backend's own units (a cell on the terminal; Theme.unitWidth and Theme.unitHeight on Qt Quick), from the top left of the window or screen
CAccessibility	What assistive technology announces for a node
CActionBar	A row of buttons in the footer of the dialog or drawer whose content holds it: what a document's overlay actions lower to. The mount refuses one anywhere else
CActionButton	A button inside another kind, such as a banner's action: its caption beside its handler
CActionEffect	One effect an action declares, as the catalog states it
CActionField	One field of an action, as the explorer lists it
CActionInfo	What the catalog says about an action
CActionRecordInfo	A record an action's result holds, as the catalog states it
CActionRef	An action a document names, with the model type it runs on: what the authoriser is asked about
CActionUse	One place a document names an action
CAppContext	What a frontend lends the source it opens and the screens it mounts
CApplicationInfo	The application a bundle belongs to, as ui-hello names it
CAppRoot	The app document mounted as the root scope every screen of the session shares (spec 6 §5)
CAppSource	Where the screens and the models are: a server (remote) or the application linked in-process (local)
CBackend	The application's opaque handle for one of its backends. Its name is what {"env": "backend"} reads
CBadge	A short label marking a state, such as a count or a status
CBadgeWidget	A short label marking a state
CBanner	A message across the top of a region, with an optional action and an optional dismissal
CBannerWidget	A message across the top of a region, with an optional action button and an optional dismissal
CBorrowedModel	A model the opener lends to a screen whose alias says {"from": alias} (spec 6 §16)
CBridgeDispatcher	A Dispatcher over the bridge's model-free seams: bindByType, executeRaw and the string-keyed attach, through RawHandler
CBundle	What an open source hands the frontend: the application's screens, verified
CBundleFile	A file of the bundle that is not a screen, as UiRegistry::addFile takes it
CBusy	A progress indicator
CBusyWidget	A progress indicator
CButton	A push button
CButtonWidget	A push button
CCallOptions	How one model call is sent
CCatalog	The facts load-time validation needs from the application's catalog. Local mode answers them from the model registry in-process, the server at registration, a remote client from the UI service's catalog
CCatalogEntry	One catalog entry (spec 6 §8)
CCatalogReply	The body of a ui-catalog reply: the catalog filtered for the principal, and the facts a client's load-time validation reads (ui::Catalog)
CCatalogue	One locale's messages, by key, with the patterns already parsed
CCheckbox	A labelled check box
CCheckboxWidget	A labelled check box
CCheckDecl	A validation across elements (spec 5 §6)
CCollapsible	A titled section the user opens and closes. Its header stays usable while it is closed
CCollapsibleWidget	A titled section the user opens and closes. A new collapsible is open
CColumn	Children stacked top to bottom
CCommand	One command. Which members a kind uses is listed with each member
CCommandLogEntry	One command list as it ran: the event that ran it, its commands, and the reactive batch they ran in
CCommon	The part every node carries: visibility, enablement, layout, drag-and-drop, accessibility, test identity, tooltip, surface, keyboard chords and autofocus
CComponent	A custom component declaration (spec 5 §10)
CConnectError	Why a source could not be opened
CContainerWidget	A widget with children. A factory given this container appends the new widget as its last child
CCustom	A component the backend may load (spec 5 §10), with the built-in nodes shown when it does not
CCustomizePoint	A customization point (spec 5 §12b)
CCustomProp	One prop a loaded custom component is given
CCustomRequest	What IViewBackend::createCustom asks for
CCustomWidget	A component a renderer loaded in a custom node's place (spec 5 §10): a bundle's verified QML or a host component, given the props the document binds and handing back the events it raises
CDateTimeInput	A date, or a date and time, edited in a display zone and reported as an instant
CDateTimeInputWidget	A date or date-and-time field, in the mode and display zone fixed at creation
CDecimal	An exact decimal: a math::Rational whose DecimalPlaces are the value's declared places
CDialog	A modal overlay; its content is mounted only while it is open
CDialogWidget	A modal overlay around its children, with a focus trap while open. A new dialog is closed
CDispatcher	The interpreter's view of the bridge: binds a model by its type id, privately or to a shared instance
CDocNode	A view node of the document (spec 5 §9), or a structured part of one (a table column, a tab, a switch case, a menu item, an a11y, drag, drop or action record, a form field overlay)
CDocument	A loaded and validated UI document: a screen, or the app document (id app, spec 6 §5)
CDocumentScreenHost	The framework's ScreenHost over UI documents: it mounts them through an Interpreter, closes them by the protocol of spec 6 §3, and hands a document's navigate to onNavigate, which the deriving host implements
CDocumentScreenHostOptions	How a DocumentScreenHost finds documents and mounts them
CDownloadedFile	A file a download brought back
CDrawer	A panel that slides in from one edge over the content: a Dialog with a side, and the same rules
CDrawerWidget	A panel over the content that slides in from the side fixed at creation; it follows a dialog's rules. A new drawer is closed
CDropZone	A region that takes files dropped from the operating system
CDropZoneWidget	A region that takes files dropped from the operating system
CEmptyState	What a region shows when it has nothing to show: a title, an explanation and an optional action
CEmptyStateWidget	What a region shows when it has nothing to show
CEnvironment	What an evaluated expression reads: the interpreter implements it over its reactive values
CEvaluateReply	The body of a ui-evaluate reply: what ActionDispatcher::evaluate answered
CExplorer	The app explorer, as a host screen (spec 6 §15): a splitter with the list — a search, the catalog's screens, and every model the catalog names with every action of it — and the chosen action's sections: its facts, its fields, the places that use it, and "Try it", the widget the framework builds for it, mounted live
CExplorerOptions	What an Explorer shows, and what it reports
CExpr	One node of a parsed expression. Immutable once parsed; shared between the document and its readers
CFetchRequest	The body of a ui-fetch request
CFieldState	The state of a value a user edits or reads: whether it may be changed, must be given, is wrong, or is being recomputed
CFieldWidget	A widget that shows a value: text, or an input. A new field is editable, not required, without errors and not stale
CFileInfo	What a file is, as its uploader described it
CFilePicker	A file path, typed or chosen in the platform's file dialog
CFilePickerWidget	A file path field, in the mode fixed at creation
CFileReply	The body of a ui-file reply: the members its op answers, the others absent
CFileRequest	The body of a ui-file request: one step of an upload or a download, named by op
CFileSlice	A slice of a stored file
CFileTransfer	The client of the file side channel (files/1, spec 6 §18): uploads and downloads through ui-file, one chunk of at most kMaxFileChunkBytes in flight at a time, reporting progress after each
CForEach	One widget per row of a keyed collection, updated in place when a row with the same key changes
CFormatContext	What the display functions and t format with: the client's locale and its formatting facts
CFormattedMessage	A formatted message, and the variables it could not format
CFrontend	A frontend: owns an event loop and a renderer, and runs one source's screens
CFrontendError	Why no frontend was selected
CFrontendOption	One frontend a binary was built with
CGrid	Cells laid out row-major in a fixed number of columns
CGridCell	One cell of a Grid
CGridWidget	Children laid out row-major in columns
CHeadAction	An action of a screen's head, as its handle answers it
CHeadBadge	A status badge of a screen's head, as its handle answers it
CHelloReply	The body of a ui-hello reply
CHelloRequest	The body of a ui-hello request: what the client speaks and carries
CHostArg	One argument of a host command
CHostCommand	A command the application registers, such as restartApp or openPath
CHostCommandResult	What running a host command (host/1) did
CHostCommands	The client's host commands, as a session runs them (spec 6 §14)
CHostValue	A value the application registers, such as sync.needsYouCount
CHostVocabulary	The client's host vocabulary: what it registered, and whether its documents came over a verified connection
CIBundleStore	Where a client keeps verified files between runs, by content hash, and the digest of each application's last verified bundle
CIFileStore	Where uploaded and issued files live. Every call names the principal it is made for, and an upload id or a file reference works only for the principal it was made for
CIHistory	A history of routes: a browser's session history, or a test's
CInlineFile	A file whose bytes a document moves inline: download from bytes, upload into bytes
CInspectedNode	A mounted node as the inspector lists it
CInspectedQuery	A query or mutation as the inspector lists it
CInspector	The development inspector over one mounted screen: its mounted nodes, its queries and mutations, the command lists it ran, and the reactive runtime's counters
CInterpreter	Mounts UI documents (spec 5): one per client process or window, over a session and a dispatcher
CInterpreterHost	What the application answers for the commands a document cannot carry out alone (spec 6). Every default answers "not supported", which the interpreter reports as a diagnostic
CInterpreterOptions	What an Interpreter is built with
CIPreferencesStore	Stores customization choices as JSON text, by PrefKey
CIViewBackend	Makes widgets. Each factory appends the new widget to parent, or makes a root when it is null, and never returns null, except createCustom, whose null shows a custom node's fallback
CKeyBinding	A keyboard chord a node handles while focus is inside it
CKeyValue	Captions beside their values, one pair per row
CKeyValueItem	One row of a KeyValue list
CKeyValueWidget	Captions beside their values
CLayoutHints	A widget's size request in both dimensions, and the bounds its extent is clamped into
CLetDecl	A derived value (let)
CLoadedBundle	A bundle the client verified: what the shell mounts, and what it was verified against
CLoadOptions	Options of loadDocument
CLoadWarning	A finding of load-time validation that does not refuse the document
CLoggedCommand	One command of a command list the inspector's log shows (spec 6 §21)
CManifest	A bundle's manifest: every file the application serves, by its hash (spec 5 §12, "Content addressing")
CManifestFile	One file of a manifest
CMcpAdapter	Serves MCP's tools over one server connection (spec 8 §11)
CMcpOptions	What an McpAdapter is built with
CMemoryBundleStore	An IBundleStore in memory: it lasts as long as the process. Safe to call from any thread
CMemoryFileStore	An IFileStore in memory: bounded per file and per principal; an upload that stalls expires
CMemoryFileStoreOptions	How much a MemoryFileStore keeps
CMemoryPreferencesStore	The framework's store: a map held in memory, on its own strand
CMenu	A vertical list of commands
CMenuEntry	One entry of a menu as a MenuWidget shows it
CMenuItem	One entry of a Menu: its label and its handler in one place, so there are no parallel lists
CMenuWidget	A menu of commands, with nested submenus
CMessageCatalogues	The message catalogues of one bundle, by locale, and the provider t resolves through
CMessageLocale	The locale a message is formatted for
CMessagePart	One part of a pattern: literal text, or a placeholder of a variable
CMessagePattern	A parsed message in the ui/1 subset of MessageFormat 2
CMessageVariant	One variant of a .match: a key per selector (* is the catch-all) and its pattern
CModelChannel	One bound model alias: the instance a document's alias names, and the calls made through it
CModelDecl	A model alias
CModelInfo	What the catalog says about a model type
CMounted	A view tree mounted on a backend: its widgets, built once, and the bindings that keep them current
CMountedScreen	A mounted screen a reload may remount
CMountedShell	What a frontend mounts once its source is open: the app shell and its screens, or a view of why the source did not open. Destroying it unmounts all of it
CMountError	Why a screen could not be mounted
CMountOptions	What Interpreter::mount is given beside the document
CMutationDecl	A mutation (spec 5 §5)
CNameResolver	What an expression's names resolve to, for checkExpression: the document's scopes implement it
CNavigateRequest	What navigate asks the host to open (spec 6 §16, §20)
CNavigator	The catalog as a list a person opens screens from, with a title search and pinned shortcuts
CNavigatorOptions	How a Navigator lists the catalog and what it reports
CNodeData	What a Node points at: exactly one node kind
COptimisticDecl	An optimistic write: the row a mutation run predicts before its reply
CPanel	A titled frame around one child; a collapsible one is an accordion section
CPanelWidget	A titled frame around its children, optionally collapsible
CPermissiveResolver	A resolver that accepts every name as any: for an expression checked outside a document
CPreferencesLoaded	What loading a screen's choices did
CPreferencesModel	The server's preferences model: reads and writes the calling person's choices through a store
CPreferencesOptions	The preferences model's bounds
CPreferenceSync	Talks to the server's preferences model (morph.preferences) for one application, through the interpreter's Dispatcher
CPrefKey	Where one choice is stored
CPrefLoad	load: the stored choices of a screen's points. A request carries no person
CPrefRemove	remove: forgets one choice. A request carries no person
CPrefRemoved	What remove answers
CPrefSet	set: stores one choice. A request carries no person
CPrefStored	What set answers
CPrefValues	What load answers
CProgress	A progress bar
CProgressWidget	A progress bar
CProp	A node property: a constant, or a slot — a reactive read, with a stable id when it was given one
CQuantity	An exact decimal with a unit: the id of a unit of the server's unit systems (x-unitAlternatives)
CQueryDecl	A query (spec 5 §5)
CQueueingDispatcher	A Dispatcher that holds a queued call the server cannot be reached for, and replays it on reconnect
CRefusal	Why a document, an expression or a value was refused: where, and the reason
CReloadOutcome	What reloadDocuments did
CRgba	A colour, 8 bits per channel
CRoute	A route read back: the screen and its params
CRouteHistory	Keeps the route of the screen a shell shows in a history, and opens the route of an entry the user moves to (spec 3 §10)
CRow	Children laid out left to right
CScopeDecl	The declarations of one scope, in declaration order
CScreen	A mounted screen: its scopes, its view mounted through Mounted, and what its host asks of it
CScreenHandle	One mounted screen, as its host sees it
CScreenHead	A screen's head beside its title: the subtitle, the status badges and the actions a shell shows above the screen (the document's subtitle, status and actions)
CScreenHost	What mounts screens for a host that owns its own shell; the workspace shell is one
CScreenHostRegistry	The host screens an application registers by name: what a catalog entry's host names instead of a document
CScroll	A scrollable viewport around one child
CScrollWidget	A scrollable viewport, on the axis fixed at creation, that keeps the focused child visible
CSelect	A choice of one option
CSelectOption	One option of a Select
CSelectWidget	A choice of one keyed option
CServedBundle	An application's bundle, built and immutable: what UiService serves
CServedFile	One file a bundle serves, with every manifest entry whose bytes it is
CHolder	One manifest entry that names the file
CServedScreen	A screen as the bundle serves it
CSession	What screens of one client session share (spec 5 §5, §12b): the query cache, the mounted queries, the principal's permitted actions, the formatting facts and the client's env, session and host values
CSessionOptions	What a Session is built with
CShellFrame	The frame around a client's screens
CShellFrameOptions	What a ShellFrame shows and reports
CSizing	How much space a widget asks for along one dimension, in backend units (a character cell on the TUI)
CSlider	An integer chosen on a range
CSliderWidget	An integer on a range
CSlotBinding	A slot's read together with its id, as ui::slot makes it; a Prop made from it is a slot with that id
CSlotWidget	A container that shows its children and nothing else: the host of a Switch's case and of a Tabs page
CSpacer	Empty space that takes what its layout hints ask for
CSpacerWidget	Empty space
CSplitter	Panes side by side, or stacked, with handles the user drags to share the space between them
CSplitterWidget	Panes along the axis fixed at creation, with handles between them that the user drags
CStackWidget	Children stacked along one axis, fixed at creation
CStateDecl	A state declaration
CStaticEnvironment	An environment that holds its values: for tests, and for evaluating outside a mounted screen
CStep	One step of a Steps indicator
CSteps	The steps of a process in order, each with its state
CStepsWidget	The steps of a process, each with its state
CSwitch	Shows the case whose key the selector yields; remounts only when that key changes
CSwitchCase	One case of a Switch
CTab	One page of Tabs
CTable	Keyed rows of cells under column headers. Each row's view is a Row whose children are the cells, one per column
CTableColumn	One column of a Table
CTableOptions	Everything about a table beyond its columns and rows
CTableRowView	What a table's row view builds for one row: its cells, one per column, and its tone
CTableWidget	Keyed rows under column headers, with selection and activation by key
CTabs	A tab bar over pages
CTabsWidget	A tab bar over page slots
CText	Static or bound text
CTextInput	An editable text field. The backend never reports its own setText back through onChange
CTextInputWidget	An editable text field
CTextWidget	Read-only text
CThemeIndex	The index of a theme: which token files make up each variant
CThemeShadow	A shadow of the set, resolved
CThemeShadowSpec	A shadow token's default, in the form a constexpr table can hold
CThemeTokenSpec	One token of the closed ui-theme/1 set: its path, kind and the MorphUi default
CThemeValues	The ui-theme/1 set's values for one resolved theme
CToastWidget	A passive, transient message outside the normal flow: non-modal, dims nothing, and never takes keyboard focus. Auto-dismisses after a backend-chosen interval
CToken	One token: its DTCG type and its value, which may hold aliases until the set is resolved
CType	A document type (spec 5 §3): a kind, whether null is allowed, and a list's element type
CUiClient	Opens an application's bundle through the UI service, verifying everything it fetches
CUiRegistry	Collects an application's screens and files and builds the bundle the UI service serves
CUiService	The UI service: answers ui-hello, ui-catalog and ui-fetch from one ServedBundle, and ui-evaluate through the server's ActionDispatcher, as an envelope service of a RemoteServer (ServerConfig::services)
CUnitInfo	One unit of the server's unit systems, as x-unitAlternatives declares it
CUploadRequest	What an upload command asks the host to send, and the mutation that will reference the file, which is what the server authorises the upload as (spec 6 §18)
CValue	The document's typed value (spec 5 §3): what every expression evaluates to
CVerifiedCache	A content-addressed cache that hands out only bytes that hash to the hash they are asked for
CVirtualization	When a keyed row list realizes a widget only for the rows in or near the visible range, instead of for every row regardless of scroll position. A row's own reactive state (its signal, rebuilt from the session on every change) is unaffected either way and is never released while its key exists; this setting only decides whether a row's mounted widget is also kept alive off-screen
CWatchDecl	A cascade: commands that run when a value changes (spec 5 §6)
CWidget	A retained widget. A new widget is visible, enabled, content-sized, not draggable and not a drop target
CWorkspace	Tabs over screens: a tab bar over a WorkspaceModel, one screen instance per tab, mounted into the tab's page through DocumentScreenHost::mountInto, with the screen's head row above it or, when the placement is External, mounted by the host instead
CWorkspaceModel	The workspace's tabs with no widgets: which screens are open, in which order, which is active, and how they open, close and are recorded (spec 6 §7, §15)
CWorkspaceModelOptions	A WorkspaceModel's options: the workspace's, and how a tab's page is made and unmade
CWorkspaceOptions	How a workspace treats screens
CWorkspaceScreen	What the shell needs to know of one screen id: the catalog's singleton and reuseEmpty
CWorkspaceStart	How a workspace starts (spec 6 §7, app-start)
CWorkspaceTab	One open tab, as an application's tab menu or a test reads it
CWorkspaceTabId	A tab's identity in a WorkspaceModel: issued when it opens, never reused
CWorkspaceTabState	One open tab, as an application's tab strip binds to it
Nunits
CUnitMeta	Static description of one unit, supplied by UnitTraits
CUnitRelation	One exact within-dimension conversion ratio between two peer units
CUnitAlternative	A derived per-unit view of one convertible display/entry unit
CQuantityBounds	Optional physical/wire bounds for one unit: the inclusive range a decoded value must fall within to be accepted. Returned by the optional UnitTraits<E>::bounds(E) customisation point (detected by HasUnitBounds) — e.g. a percentage unit bounding itself to [0, 100], or a mass unit rejecting a negative reading no scale can physically produce. Absent by default: a unit with no declared bounds accepts any value its precision allows, exactly as before this feature existed
CUnitTraits	Customisation point: the application specialises this for its unit enum, returning a UnitMeta per enumerator and (optionally) a relations array of UnitRelation entries and/or a bounds(E) static method
CQuantity	A unit-tagged, optionally-empty exact value with a declared precision in its type and (optionally) a recorded derivation
CNamedQuantity	A Quantity that names itself on construction and slices losslessly back to a plain Quantity. The name lives in the shared history
Nutil
Ndetail
CIsTagged	Trait: is T some Tagged<...>?
CTagged	An opaque, type-safe newtype wrapping a protocol scalar T, distinguished at compile time by the string tag Tag
Nviews
CBindEntry	Maps one target-action wire field to a row wire field, so a row's current value prefills the action's draft before it fires
CActionDescriptor	One action a view screen can fire — the row opener (v-rowAction) or an entry of v-actions
CColumnOverride	Declare-to-override entry for one derived column of a collection view
CCollectionView	Tag type: V::kind selects a plain list/table screen
CMasterDetailView	Tag type: V::kind selects a list + inline/side editor screen. Introduces no JSON keys beyond CollectionView — purely a rendering choice a conformant renderer may act on
CViewTraits	Traits specialisation that maps a view descriptor type to its string type-id. Specialise via BRIDGE_REGISTER_VIEW
CViewRegistry	Process-level registry mapping a view's string type-id to its viewSchemaJson<V>() provider, so a controller can enumerate every registered view by name — parallels ActionExecuteRegistry for actions (docs/spec/core/bridge.md), but a view registers no executor, only a schema provider
Nwire
Ndetail
CEscapingWriteOpts	Write options that escape ASCII control bytes as \\uXXXX sequences
CEnvelope	JSON wire envelope used between any client and RemoteServer
CProtocolRange	Inclusive protocol-version range a server advertises in reply to "hello"
CEventBody	The decoded body of an event envelope
CInstanceTopic	One instance topic: a model type, its directory key text and its instance id
CWatchBody	The body of a watch or unwatch request
CWatchReply	The body of the ok reply to a watch: the topics the server refused
CChangesBody	The payload of a changes event
CWireCodecOps	The serialisation primitive encode calls, as an injectable strategy