commerce library

Purchases: paywall configuration and the paywall action, as commerceCatalog.

Over package:codelessly_api/core.dart, which it exports.

Classes

AccordionProps
An accordion: its first child is the header (with a toggle button over its end), its second the content shown while expanded.
ActionCommon
The fields every action has, read from its JSON: what an ActionSpec.decode passes on to the action's constructor.
ActionCommonFields
The fields every action has.
ActionDef
One action. Every action can be turned off (enabled), run without being awaited (nonBlocking: the chain goes on at once and its failure doesn't stop it) and run only while a predicate holds (when). JSON: {"type": type, ...its fields, "enabled": false, "nonBlocking": true, "when": {...}}.
ActionSpec
The declaration of one action type: what a WidgetSpec is to a node. Its fields generate an editor's panel and validate; decode makes the typed action. Without decode (a type declared as data, by a hosted or native plugin manifest) the action decodes as a DeclaredAction holding its fields as Props.
ActivityIndicatorProps
Flutter CupertinoActivityIndicator.
Alignment
Flutter's Alignment: -1 (start) to 1 (end) per axis. JSON: [x, y].
AnimateAction
Drives an animation (Flutter's AnimationController methods): node node's animation (NodeAnimation), or the number variable variable (an unbounded controller the screen keeps for it). JSON: {"type": "animate", "node": "card", "animation": "pop", "command": "forward", "from": "0"}, {"type": "animate", "variable": "shownTotal", "command": "animateTo", "target": "${total}", "duration": "800", "curve": "easeOutCubic"}. The chain waits for it to end (TickerFuture) unless it's nonBlocking; a repeat ends when its count does.
AnimateFields
AnimateAction: an AnimationController method on a node's animation or a number variable.
AnimationCurveCodec
An AnimationCurve, by the name of its Flutter Curves constant. Reads as leniently as the models do (AnimationCurve.parse).
AnimationPreset
A named short form of a NodeAnimation: its default timing, and the tracks it stands for as a function of its params.
AnimationPresets
The presets an animation's preset names. Loops (pulse, fade, scale, spin, bob, sway, flicker) repeat for a second and rest (on the design canvas) at their start; one-shot effects (shake, bounce, pop, wiggle, jelly, flash, keyframes) wait for a cue and last 520 ms; enter plays once from its from values to the node's own. Their tracks add to or multiply the node's own pose (TrackBlend), as a Flutter ScaleTransition or RotationTransition wrapped around it would.
AnimationRepeat
controller.repeat(reverse:, count:). count 0 repeats forever; a count ends at the end of its last run. JSON: {} (forever), {"reverse": true, "count": 3}; true and a bare count read too.
AnimationRepeatFields
AnimationRepeat: repeat(reverse:, count:).
AnimationTrack
One tween a NodeAnimation drives: a property at a binding path of a node, or a variable.
AnimationTrackFields
AnimationTrack: one tween.
AppBarProps
AppBar.
ArcOp
Canvas.drawArc(rect, startAngle, sweepAngle, useCenter, paint): angles in radians, clockwise from 3 o'clock, as Flutter's.
ArcOpFields
AxisPosition
Where a child of a freeform (stack) parent sits on one axis, as Flutter's Positioned or Align, in the parent's padded box:
AxisSize
Sizing along one axis. value is the design size: the size for SizeFit.fixed, and the fallback whenever a mode can't apply. JSON: a number (fixed) or {"fill"|"flexible"|"hug": value}.
BadgeProps
Badge: a small label (or a dot) over its child slot.
BarChartProps
A bar chart of values with optional labels, grid and a highlighted bar.
BarcodeProps
A barcode or QR code of data, filling the box.
BaseSegment
A piece of the base template: text, included when every condition in when holds (files, runtime, card, page, app, scripts, noScripts, docsTool, noDocsTool).
BehaviorFields
A node's Behaviors, one per key of Behaviors.keys: stored flat in the node's JSON ("motion": {...}, "tooltip": "..."), defaults as in Behaviors.none.
Behaviors
A node's behaviors. Stored flat in the node's JSON under keys.
BindPaths
Binding paths (keys of Node.bind) and how values are applied to them.
BindValue
Loose readers for bound values (what an expression gave). Each returns null for a value it can't read.
BoolCodec
BorderRadius
Flutter's BorderRadius: four corners, each circular or elliptical. JSON (sparse, see fromJson): 8, [16, 8] or [8, [16, 8], 0, 0].
BorderSide
Flutter's BorderSide. A null color is unset: the widget's theme default where it has one, else Flutter's black.
BorderSideFields
BoxConstraints
Flutter's BoxConstraints, where a missing bound means unconstrained.
BoxProps
A leaf box: Flutter Container with a decoration and no child.
Breakpoint
One screen size class of a project: from minWidth (inclusive) up to the next breakpoint's.
Breakpoints
A project's breakpoints, narrowest first (DESIGN.md §5.3).
BreakpointWidthsCodec
Breakpoint id → width (a variance's own switch points).
ButtonProps
ElevatedButton, FilledButton, TextButton, OutlinedButton: a label with an optional icon (their .icon constructors), styled by a ButtonStyle.
ButtonSegment
Flutter's ButtonSegment<String>: one segment of a segmented button.
ButtonSegmentFields
ButtonStyle
Flutter's ButtonStyle, as the buttons' styleFrom takes it. Null fields are the button's own defaults. The padding is the node's layout.padding; the size is the node's box (no minimum size).
ButtonStyleFields
CallFunctionAction
Calls a function the app registered by name with params (text values are expressions). Its result is the chain's ${result}: what the app's code answered (a permission granted, a share completed), which the next actions branch on. A function the app didn't register fails the chain, unless the action is optional.
CallFunctionFields
CallFunctionAction.
CanvasProps
A screen (Scaffold): its body slot is the page content.
Catalog
What a document may contain: declared node types, action types, data sources and formula functions. Immutable; composed with + or parts, never mutated.
ChartProps
A chart of data rows: bars, lines and areas over categories, a timeline of segments, or a donut.
ChartReferenceLine
A horizontal line across a chart's plot at value.
ChartSeries
One series of a chart: the values of field in each data row.
CheckboxProps
Flutter Checkbox, scaled to its box (40 px is Flutter's own size, 18 px when compact).
ChipProps
Chip, ActionChip, ChoiceChip, FilterChip and InputChip.
CircleOp
Canvas.drawCircle(c, radius, paint).
CircleOpFields
CircularProgressIndicatorProps
Flutter CircularProgressIndicator: a spinner, or a ring filled to value. startAngle and sweepAngle draw it as an arc (a dial).
CloseModalAction
Closes the modal it runs in, giving the chain that opened it result (its text values are expressions) as ${result}.
CloseModalFields
CloseModalAction.
Codecs
Common codecs. Nullable variants (optional*) read a missing or unreadable value as null.
CollectionCodecs
Codecs for the collections' value types.
CollectionScrollProps
The props every scrolling collection shares (ScrollView's parameters).
CollectionSlots
The slots a list or grid takes besides its item template.
Color
A 32-bit ARGB color, as Flutter's Color. JSON: "#AARRGGBB" ("#RRGGBB" and ints also read), or the name of one of the project's theme colors ("ember": ThemeTokens.colors, resolved before the document renders; see resolveThemeRefs).
ColorStop
One gradient stop.
ColorStopFields
Comparison
left op right (the right side only for ops that ConditionOp.takesRight).
ComponentDefinition
A component in a project's library: its nodes as a layout document with one root, its design size, and where it was made from.
ComponentEventAction
Inside a component definition: fires the component's event event with value as its payload. The call's reactions whose trigger is {"type": "event", "event": "<event>"} run, in the caller's scope, with the payload as ${result} (Flutter: calling widget.onChanged(value)). JSON: {"type": "componentEvent", "event": "onChoose", "value": "${props.plan.id}"}. Outside an instance it does nothing.
ComponentEventFields
CopyToClipboardAction. ComponentEventAction.
ComponentLibrary
Component definitions by type name: the project's (or a document's) library, and the catalog a page's calls decode with.
A node's link to a component (Node.component): the component's main node, or the top node of an instance of it.
ComponentPreview
A named parameter set a component renders with alone (Flutter's @Preview(name:, size:)): {"name": "Team, annual", "size": [432, 760], "props": {...}}.
ComponentSetting
One thing a component lets an instance customize, or a group of them.
Condition
An if / else-if / else rule. Its first branch whose test holds and that sets a property gives the property its value; when none does, the property keeps its binding's or its own value. JSON:
ConditionBranch
One branch: when when holds (always, for an else: null), the properties in sets take their values.
ConditionOperand
One side of a Comparison: an expression text whose ${...} are read (${count}, ${= a + b}, 3, done), or, when raw, a literal taken as written. Both are then parsed loosely (3 is a number, true a bool, [1, 2] a list). JSON: the text, or {"raw": text}.
ConfirmAction
Asks the user to confirm; runs actions when they do, cancelActions when they don't. With dialog (a screen id), that screen is the dialog and what its close modal action returns is ${result}.
ConfirmFields
ConfirmAction.
ControlDismissibleAction
Dismisses, brings back or resets node node (several ids: comma-separated).
ControlDismissibleFields
ControlDismissibleAction.
ControlTrackAction
Turns the Track of node node (several ids: comma-separated, the first on screen takes it).
ControlTrackFields
ControlTrackAction.
ControlTransformAction
Resets, zooms or poses the transform gesture of node node.
ControlTransformFields
ControlTransformAction.
CopyToClipboardAction
Copies text (an expression) to the clipboard.
CopyToClipboardFields
CoreAction
The core action types: navigation, modals, values and variables, flow, feedback, focus, scroll, animation, scripts, pagination. Exhaustive within itself.
CustomPaint
Flutter's CustomPaint on a node: painter drawn behind the node's content (its decoration and children) and foregroundPainter over it, both in the node's box (inside its transform and opacity, outside its clip). The node's layout is CustomPaint.size; its content is child.
CustomPaintFields
CustomPaint: the customPaint behavior.
DataSourceSpec
A kind of data a list, grid or pagination can load from, declared like a widget so its settings get a panel: data (the bound list) in the core, cloud and api in the data library.
DatePickerProps
A field showing a date (yyyy-MM-dd; empty shows its hint) that opens a calendar (Flutter's showDatePicker).
DateTimeInputProps
A field (Flutter's InputDecorator) showing a date, time or both, that opens the pickers.
DeclaredAction
An action of a type its catalog declares without a Dart class (a hosted plugin's, or one a native plugin declares by manifest): its spec and its fields as typed props, as a node holds props for its WidgetSpec. Keys the spec doesn't declare are kept (Props.unknown).
DecodedOps
A batch of ops read from a tool input: each op with the index of the input op it came from (a set with nodes gives several), and what could not be read.
Decoration
A box's paint: Flutter's BoxDecoration, with stacked paints as in a design tool (fills bottom to top, then strokes).
DecorationFields
A node's Decoration, field by field (JSON under decoration).
DelayAction
Waits ms milliseconds, or duration (a formula giving them) when that gives a number.
DelayFields
DelayAction.
DesignSystem
A design system in memory: its manifest, its two documents' text and its component library, whatever loaded them (load: a folder, a publish, an asset bundle; fromJson: one bundle).
DesignSystemComponent
One component of a design system as its list shows it.
DesignSystemManifest
A design system's manifest (design_system.json), loader-agnostic like SiteManifest: its id and name, references to its two documents and its component definitions (paths relative to the manifest, or publish ids), its tokens (a theme, the shape of site.json's theme), the fonts it ships and the base node types its components stand in for.
DismissibleBehavior
Swiped away past a threshold (node key dismissible): Flutter's Dismissible. The node follows the pointer toward its directions (held back by resistance the other ways); let go past its dismissThresholds share of its size, or faster than flingVelocity, it flies off over movementDuration and fires the swipe of that direction (swipeLeft...; Dismissible.onDismissed), then shows its next content back at rest. Otherwise it returns: on returnSpring, else over returnDuration along returnCurve. A swipe card.
DismissibleFields
DismissibleBehavior (node key dismissible): Flutter's Dismissible.
DividerProps
Divider and VerticalDivider: a line across the node's box.
DocPage
One page of the reference, as ui_docs serves it.
DocSection
One section of a reference page: its anchor id, title and Markdown text (links as in the page files).
DoubleCodec
DragSource
Lets the user pick the node up and drop it on a DropTarget that takes its group (Flutter's Draggable; LongPressDraggable with start longPress).
DragSourceFields
DragSource (node key draggable): Flutter's Draggable.
DrawOp
One draw operation: {"op": name, ...}. Every op may carry an id (editor selection, a binding path customPaint.painter.<id>.<field>) and when (false skips it). Keys an op doesn't know are kept in extra and written back.
DrawOpCommonFields
The fields every op has.
DrawOpsCodec
A list of draw ops.
DrawOpSpec
A draw op, as an editor shows it.
DrawOpSpecs
Every op an editor can add, by its JSON op.
DrawPaint
How a shape is drawn: Flutter's Paint, with its field names and defaults (black, fill, strokeWidth 0: a hairline, butt, miter, miter limit 4, srcOver, anti-aliased). shader is a gradient or image in the model's Paint form, laid out in the shape's bounds (Flutter's Gradient.createShader(rect)). dashPattern and scaleStroke have no Paint counterpart: dashes as a decoration's dashPattern, and a stroke that stays in the box's pixels under a scaling view box or group as the path node's scaleStroke: false.
DrawPaintFields
DrawPaint: Flutter's Paint.
DrawPaintsCodec
An op's paint: one DrawPaint or several (each may be an expression).
DrawRRect
A rounded clip: Flutter's RRect as {"rect": [l, t, w, h], "radius"}.
DrawRRectFields
Flutter DropdownButton<Object>. Its padding is the node's layout.padding.
DropTarget
Takes DragSources of the groups it accepts (Flutter's DragTarget).
DropTargetFields
EdgeInsets
Flutter's EdgeInsets (left, top, right, bottom). JSON: a number (all sides) or [left, top, right, bottom].
EditCheckInput
What an EditCheck is asked to check: the nodes an op touched, as JSON (as written: a set's node, a patched node's merged JSON), in the document after the op.
EditCode
One diagnostic code of the edit layer: its name, whether it rejects the op, and what it means.
EditCodes
The codes the edit layer itself reports. A check of the nodes an op touched adds the validator's codes (unknown_prop, wrong_type, invalid_enum...), listed with strict validation.
EditDiagnostic
One problem with one op of a batch.
EditOp
One edit operation on a layout document, addressed by node id.
EditOpField
One field of an op: its key, kind, whether the op needs it, and what it means.
EditOpSpec
The declaration of one op: its name, fields, meaning and an example.
EditResult
The outcome of applyOps.
EditRevisions
The revision of every field changed through ops, and by whom: what baseRev is compared with.
EditTextAction
Edits text field node's text at its cursor: wraps the selection in before / after, toggles a (numbered) list, inserts or sets text, replaces the word being typed, clears it or focuses it.
EditTextFields
EditTextAction.
Effect
A shadow or blur (Flutter's BoxShadow, ImageFilter.blur).
EffectFields
EnumCodec<T extends Enum>
ErrorTextCodec
Text, or a yes/no: true is kErrorWithoutMessage, false no error.
EventSpec
An event a component fires with componentEvent (Flutter: a VoidCallback or ValueChanged<T> constructor parameter, onChanged). JSON: {"key": "onChoose", "payload": {"kind": "string"}, "doc": "..."}.
ExpansionTileProps
Flutter ExpansionTile. The tile slot is a list tile whose leading, title, subtitle and trailing slots make the header; the children are shown while expanded.
Expr<T extends Object>
A value given as a literal value or computed by an expression source ("${size.width}", "${= index * 2}") when the list draws.
ExprCodec<T extends Object>
A value or an expression ("${...}") giving one: inner reads and writes the literal, and its type is the field's type.
ExternalProps
A widget the app builds (Codelessly's external component builders).
FieldValue
An immutable value made of declared fields, as a widget's props are: decoding is total, encoding sparse (a field at its default is omitted), equality by value. spec lists the fields (the editor's panels read it).
FlexProps
Row and Column: the same props, different main axis.
Flight
How a hero that flies in place (HeroFlies.inPlace) flies in from where the node with its tag was: on a spring by default (the node's motion transition's, when it has one with a spring), or, with a duration, along a curve that rises lift (or liftShare of the distance, the larger) above the higher end (as Flutter's MaterialRectArcTween bends a hero's path), swelling to swell at the middle and spinning turns times (toward the way it flies), trailing trail fading dots.
FlightFields
FlipCard
Makes the node a two-sided card (node key flip; a runtime 3D turn, not a mirror): its first child is the front, its second the back, turned 180° in advance; each hides while it faces away. The turn is the node's own Motion (rotateY, or rotateX for FlipAxis.x, 0 or 180), with its perspective, duration (600 ms without one), curve and keyframes. Inside the card ${flip.flipped} and ${flip.progress} (0 front, 1 back) can be read.
FlipCardFields
FlipCard (node key flip): a card that turns over.
FloatingActionButtonProps
FloatingActionButton (and its small, large and extended forms).
FocusAction
Focuses text field node (selecting its text with selectAll), or takes the focus away (unfocus; from every field when node is empty).
FocusFields
FocusAction.
FontAsset
One font file of a FontFamily (a pubspec fonts: entry's - asset:): its path relative to the site's folder, its weight (100–900) and style.
FontFamily
A font family a site declares (a pubspec fonts: entry): text styles name it by family ("fontFamily": "Fraunces", whatever the files call themselves inside), and each weight and style draws from its file.
FontWeightCodec
Flutter's FontWeight, as its weight: 100, 200 ... 900.
ForEachAction
Runs actions once per item of list items (a path or expression). Every action of a turn reads the item and its index as ${loop.item} and ${loop.index}; ${result.item} and ${result.index} hold them too, until an action of the turn gives a result of its own.
ForEachFields
ForEachAction.
FormBehavior
Flutter's Form: the text fields inside the node are one form. The validate action (FormState.validate()) checks them all with their validators, shows each one's error and focuses the first invalid field; autovalidateMode makes them check themselves too, as each field's own autovalidateMode does. The node and the nodes inside it read ${form.valid} (every field passes its validator now) and ${form.errors} (the errors the fields show, in order: {field, label, message}), for a summary. JSON true or {"autovalidateMode": ...}.
FormFields
FormBehavior: Flutter's Form.
FormulaSpec
A formula function: its name, parameters and what it does. A built-in one (the expression engine's) or a plugin's (a function variable).
GaugeMeterProps
A meter: value between min and max as a filled arc or bar (continuous or in segments), with ticks and a limit marker.
GaugeZone
A colored band of a radial gauge, from from to to in value units.
GesturePhysics
How a node moves on its own once the pointer lets go, the same for a DragMotion, a DragSource's return and a TransformGesture: a fling that slows by friction (Flutter's FrictionSimulation), a stretch of overscroll past the bounds, and a spring onto the snap target nearest to where the fling would stop.
GesturePhysicsFields
GesturePhysics: the release a drag, a drag source's return and a transform gesture share.
GestureSnap
The places a released node settles at (GesturePhysics.snap).
GestureSnapFields
GridViewProps
Flutter GridView with a fixed cross-axis count (SliverGridDelegateWithFixedCrossAxisCount) or, when maxCrossAxisExtent is set, a maximum cell extent (SliverGridDelegateWithMaxCrossAxisExtent).
GroupOp
canvas.save() (saveLayer with opacity or blendMode), then translate, scale, rotate (radians) and transform (a Matrix4's 16 numbers, column-major as Matrix4.storage), in that order, then clipRect, clipRRect, clipPath; its ops; canvas.restore().
GroupOpFields
HapticAction
Buzzes the device (HapticFeedback, on phones that support it; nothing elsewhere). Its common when buzzes only while a setting holds.
HapticFields
HapticAction.
HeroTag
Makes the node a shared element (Flutter's Hero): it flies from where the node with the same tag was to where it is, between two screens while a navigation plays (HeroFlies.betweenScreens, Flutter's) or when it appears in place (HeroFlies.inPlace). JSON: the tag alone ("hero": "avatar-1") or {"tag", "flies", "flightShuttle", "placeholder", "flight"}.
HeroTagFields
HeroTag (Flutter's Hero). Its JSON is {"tag", "flies", "flightShuttle", "placeholder", "flight"}, or just the tag when the rest is Flutter's default.
IconAction
An icon with its own size, color and tooltip: an app bar's leading icon or action (Flutter's IconButton in AppBar.actions). actions are its reactions, as a node's.
IconActionFields
IconButtonProps
IconButton: an icon, styled by a ButtonStyle.
IconProps
Flutter Icon (font icons) or an SVG/image icon.
IfAction
Runs then when condition holds, else orElse. JSON: {"type": "if", "condition": {...}, "then": [...], "else": [...]}.
IfFields
IfAction.
ImageOp
Canvas.drawImageRect(image, src, dst, paint): the image at url (may hold ${...}), its src rect (source pixels; null: the whole image) drawn into dst (null: the whole drawing). Without a paint, Flutter's default Paint().
ImageOpFields
ImagePaint
An image source and how it fills its box (Flutter's DecorationImage).
ImagePaintFields
IndicatorCodecs
Codecs shared by the indicators declarations.
InkWellStyle
The ink a tappable box shows, as Flutter's InkWell: ripples and the overlays of its states. Clipped to the box's radius.
InkWellStyleFields
InputBorder
Flutter's InputBorder: an OutlineInputBorder (the default here), an UnderlineInputBorder or InputBorder.none.
InputBorderFields
InputCodecs
Codecs for the inputs' value types.
InputDecoration
Flutter's InputDecoration: a text field's border, label, hint, helper, error, prefix and suffix. Every field has Flutter's default (unset: the theme's).
InputDecorationFields
InputIcon
An icon an input shows (Icon): a glyph as the icon node's icon prop ({"source", "name", "codepoint", ...} or an image), its size and color, and the actions a tap on it runs.
InputIconFields
IntCodec
Junction
All of parts (and) or any of them (or). Every part is evaluated. JSON: {"and": [...]} / {"or": [...]}.
KeyCombo
A key with the modifiers held with it, as Trigger.key names it: Enter, Meta+Enter, Shift+Tab, Meta+b, ArrowDown, Escape. Every part but the last is a modifier: Meta (also Cmd, Command, Ctrl, Control, Mod: Command on macOS, Control elsewhere), Shift, Alt (also Option). The key compares without case or spaces; Esc reads as Escape, Return as Enter.
Keyframe
One stop of a TweenSequence: the track's value at at (0–1 of the track's run), reached on curve from the stop before it.
KeyframeFields
Keyframe: a TweenSequence stop.
Layout
A node's layout.
LayoutDocument
A layout: a set of node trees (one per canvas/screen) in one flat map.
LayoutFields
A node's Layout, field by field (JSON under layout).
LayoutLogic
The variables and conditions of each screen of a layout, by canvas id. JSON (two keys of the layout document):
LineChartProps
A line chart of data rows (xField, yField; dates or numbers on x), with bands, ticks, markers and lines given as data (usually bound).
LineOp
Canvas.drawLine(p1, p2, paint).
LineOpFields
ListCodec<T>
ListReorder
Dragging a list's items to a new place, within the list and, with a group, into other lists of the group (a Kanban board). A drop runs the list's reorder reactions with ${result.from}, ${result.to}, ${result.item}, ${result.fromList} and ${result.toList}.
ListReorderFields
ListSections
Groups a data list's consecutive items with the same groupBy value into sections, each under the list's sectionHeader slot.
ListSectionsFields
ListTileProps
ListTile, its widgets in the leading, title, subtitle and trailing slots.
ListViewProps
Flutter ListView: its first child repeated per item.
Measure
Writes where the node is laid out, {x, y, width, height, centerX, centerY} in pixels, to a variable as layout changes: in the coordinates of the ancestor node relativeTo (empty: the screen), under key when the variable is a map. Other nodes then follow it: a marker travelling to the chip of the reader's layer on a timeline whose chips are laid out by data. The design canvas measures too.
MeasureFields
MediaRule
One media rule of a node: patch applies while the screen meets every condition given (minWidth, maxWidth, orientation).
MigrationEntry
One thing a migration step did.
MigrationReport
The entries of one or more migrations, in the order they happened. Pass one to migrate2to3 (and the other migrations) to collect them; document names the document the next entries belong to.
MigrationScope
What a step reports through, while it runs on one node or document.
MigrationStep
A named, separately tested step of a migration. It changes a node's JSON (node) or a document's (document) in place, and says what it did through the MigrationScope it is given. A node step may read the document it is in (MigrationScope.document) to see what other nodes do to its node (a state style or a setValue that targets it).
ModalProps
A dialog: its trigger slot is shown in place and opens the content slot in a Dialog.
Motion
A transform painted over the node's layout (Flutter's Transform): it moves nothing else. Its values are the node's rest pose; how it gets there is the node's animations and transitions.
MotionFields
Motion: a transform over the node's layout (Flutter's Transform).
MoveOp
Move node id under parent at index (or into slot); reordering is a move within the same parent.
Goes to another screen. JSON: {"type": "navigate", "mode": "push", "to": "canvas-b", "params": {"id": "${item.id}"}}. The destination reads params as ${route.<name>}.
NavigateAction.
What NavigationBar and BottomNavigationBar share: items, the selection, and the selected/unselected label and icon styles.
A navigation bar item: Flutter's NavigationDestination (and BottomNavigationBarItem). Icon colors are the item's own, over the bar's. actions are its reactions.
Node
One node: a widget declaration's values, placed in a tree by id.
NodeAnimation
One AnimationController on a node and the tweens it drives (behavior key animations, a list). A screen-wide one sits on the canvas node.
NodeAnimationFields
NodeAnimation: an AnimationController and its tracks.
NodeFields
A node's own top-level fields.
NodeValue
One property a SetValueAction sets: a binding path of the node (DESIGN.md §5.1) and its value (a string is an expression).
NoisePaint
A noise paint's procedural noise, parameterised as SVG's <feTurbulence> (baseFrequency, numOctaves, seed, type): the texture a web page's grain overlay draws (filter: url(#grain)), here a paint, drawn as a seamless tile repeated over the box.
NoisePaintFields
NoisePaint: SVG feTurbulence's attributes.
NullableDoublesCodec
A list of numbers with gaps (null items kept, e.g. a bar with no value).
NumberInText
The first number in a text ("1,204", "-3.5", "$12.50" → 12.50) and how it is written: what is around it, its decimals and whether its thousands are grouped. A text's number counts (AnimationTrack.lerpValue): each value between is written the same way (format).
Offset
An offset. JSON: [dx, dy].
OpenLinkAction
Opens a URL (a web page, mailto:, tel:, an app link).
OpenLinkFields
OpenLinkAction.
OpenModalAction
Shows a screen (canvas) as a modal: a dialog, a sheet, a popover. The CloseModalAction that closes it gives the chain that opened it its ${result}. JSON: {"type": "openModal", "to": "canvas-d", "presentation": "bottomSheet"}.
OpenModalFields
OpenModalAction.
OpenTypeFeature
An OpenType feature setting: a four-character tag and its value (1 on, 0 off, n an alternate). JSON is a string, "lnum" or "liga=0".
OpStreamDecoder
Decodes a streamed ui_apply input: add each text delta and it returns the ops that delta completed; close at the end.
OpStreamEnd
What is left when a stream ends: what could not be read, the tool input's baseRev and atomic, and the truncated tail if it ended inside an op.
OptionalBoolCodec
A bool that may be absent (null: the widget's own default).
OptionalDoubleCodec
A double that may be absent (itemExtent, mainAxisExtent).
OptionalEnumCodec<T extends Enum>
An enum value that may be absent (Flutter's nullable enum parameters).
OptionalIntCodec
An int that may be absent (maxLines).
OptionalStringCodec
A string that may be absent (a font family that falls back).
OvalOp
Canvas.drawOval(rect, paint).
OvalOpFields
PageViewProps
Flutter PageView: its first child repeated per page.
PaginateAction
Moves the pagination controller of a list or grid (its pagination, by controller, the pagination's name).
PaginateFields
PaginateAction.
Pagination
A pagination controller: loads a list's items page by page and exposes its state as a map variable named name (${name.items}, ${name.page}, ${name.pageCount}, ${name.hasMore}, ${name.isLoadingMore}, ${name.error}...). Paginate actions move it.
PaginationFields
PaginationProps
Page controls for a list's pagination (found by its name, controller): first, previous, page numbers with ellipses (1 … 4 5 6 … 16), next, last, a page size select and a summary. Choosing a page fires the node's changed reactions with the page as ${result}.
Paint
A fill or stroke paint: a solid color, a gradient or an image. Several paints stack, first at the bottom.
PaintFields
Pan
Follows the pointer (node key pan): GestureDetector(onPanUpdate:) moving a Transform.translate. On release it springs back to rest or stays (release), with physics a fling that slows by friction, a spring and snap points within bounds and the limits minX...maxY (a bottom sheet: {"axis": "vertical", "release": "stay", "minY": -560, "maxY": 0, "physics": {"snap": {"points": [[0, 0], [0, -560]]}}}). Its offset binds two-way to xVariable and yVariable; x and y (bindable) place its rest.
PanFields
Pan (node key pan): follows the pointer.
ParagraphOp
Canvas.drawParagraph (what TextPainter(text: TextSpan(text, style)) ..layout(maxWidth: maxWidth)..paint(canvas, offset) draws): text (may hold ${...}) in style, laid out up to maxWidth and maxLines, with the point anchor names (top left by default) at offset. A paint is the text's TextStyle.foreground.
ParagraphOpFields
ParticleEmitter
Confetti, stars or emoji the node bursts with on cue.
ParticleEmitterFields
PatchOp
An RFC 7396 merge patch on node id: objects merge, arrays and scalars replace, null deletes a key. It never changes children, slots or type (structural_key_in_patch).
PathCommand
One call of Flutter's Path builder: method (moveTo, lineTo, quadraticBezierTo, cubicTo, close) with its positional arguments args (each a literal or an expression), made only while when holds (if (cond) path.lineTo(x, y)). JSON: {"lineTo": [x, y]}, {"quadraticBezierTo": [x1, y1, x2, y2]}, {"close": true}, with an optional "when".
PathCommandsCodec
A path op's commands: Flutter Path builder calls (PathCommand).
PathFollow
A place along an SVG path: progress (0–1) of the way along path's length, turned with it as orient says. Shared by motion.path and a drag track's path.
PathFollowFields
PathFollow: a place along an SVG path.
PathOp
Canvas.drawPath: SVG path data d; or the Path builder's calls commands; or points joined by straight lines (closed back to the first). trimStart–trimEnd of its length (PathMetric.extractPath).
PathOpFields
PathProps
An SVG path, filled and stroked with the node's decoration (Flutter CustomPaint).
PaywallAction
A paywall interaction: buy the selected (or slot's) product, restore purchases, select a product, close the paywall, open a legal url, or open a server-resolved placement.
PaywallConfig
A project's paywall setup: its product slots, placements and legal links.
PaywallFields
PaywallAction.
PaywallPlacement
A named entry point (onboarding, settings) the app opens a paywall at: the layout it shows and the product slots in it.
PickerFieldProps
The look of a date or time picker: by default the design system's select field (a calendar or clock icon, the value, a chevron); with a PickerFieldProps.decoration the decoration's border, fill, hint and icons. The value shows in PickerFieldProps.format. Tapping opens the picker (a calendar, or hour and minute columns) under the field, or as a bottom sheet on a narrow screen, themed by PickerFieldProps.pickerTheme.
PlaceholderProps
An empty slot shown at design time (Flutter SizedBox).
PlotChartLabel
A label on a plot chart's x axis, centered on x.
PlotChartMarker
A labeled dot on a plot chart (on the curve when y is null).
PlotChartProps
A line/area chart of points spread evenly over an x domain, with an x value selected by tapping or dragging.
PlotChartRange
A shaded x range of a plot chart, painted behind the curve.
PlotChartSeries
One more curve on a plot chart, over the chart's x domain: points are evenly spaced from xMin to xMax like the chart's own, and a null point is a gap (the line breaks there: an undefined value or an asymptote).
PlotChartYLine
A horizontal line across a plot chart at y: a grid line, or a reference such as a target (dashed, with an inline label). axisLabel is written in the chart's y-axis gutter (PlotChartProps.yAxisWidth).
PointsCodec
Points ([[x, y], ...], a null breaking the line).
PointsOp
Canvas.drawPoints(pointMode, points, paint).
PointsOpFields
Pose
A Motion drawn with a fade and a blur: the pose a page of a page view (pageMotion) or a side of a route transition is drawn at. Flutter: a Transform in an Opacity in an ImageFiltered. JSON: motion's keys with opacity and blur beside them, flat ({"shiftX": -1, "opacity": 0.5}).
PoseFields
Pose: a Motion with a fade and a blur (flat).
Predicate
What a branch tests.
ProductSlot
A product slot: a stable id (monthly, annual) bindings use, mapped to each store's product id.
ProductTestData
A product slot's made-up store data for the SDK's test store: what a paywall shows and does on the web (preview and demo sites), where there is no store. Never charges and never grants a real entitlement: the test store's grants stay on the device and the paywall server rejects test receipts.
ProgressBand
A colored zone of an arc progress bar, from start to end as fractions of the max value.
ProgressBarProps
A progress bar filled to value of max: a bar (horizontal, or vertical filling upward) or an arc with ticks, bands and a needle.
PropCodec<T>
Reads and writes one prop's JSON. Decoding returns null for values it can't read (the prop then has its default).
PropDef<T>
One prop of a widget.
PropertySet
Sets property path (a binding path, DESIGN.md §5.1) of node node to value: a JSON value, where a string is an expression read like a binding's (${= qty * 2}, #FF0000, Hello ${name}).
PropRecord
A small immutable model whose fields are declared as PropDefs in schema (as a widget's props are): only non-default fields are held and encoded; unknown keys round-trip.
Props
A widget's prop values: only the ones that differ from Flutter's defaults are held. Keys a declaration doesn't know round-trip untouched, and read through a PropDef they decode: a node decoded with a catalog that doesn't declare its type (Catalog.core reading a video) still gives its values to code that knows the type.
PropType
What a prop holds (see PropKind). Pure data, read from a codec (PropCodec.type); a prop is nullable when its default is null (PropDef.nullable).
PropTypes
The Flutter value types' PropTypes.
RadialGaugeProps
A radial dial: zones, ticks, labels, a value arc (continuous or in segments), a target notch and a needle.
RadioGroupBehavior
Flutter's RadioGroup: the radio nodes inside the node that set no groupValue of their own share this one, and choosing one of them runs the node's changed reactions with its value as ${result} (RadioGroup.onChanged). Bind groupValue to the variable the choice is kept in: "bind": {"radioGroup.groupValue": "${budget}"}.
RadioGroupFields
RadioGroupBehavior: Flutter's RadioGroup.
RadioProps
Flutter Radio<String>, scaled to its box (32 px is its own size; its ring, 18 px, when compact).
Reaction
A trigger and the actions it runs, in order: one chain. A blocking action is awaited before the next; a failing one stops the chain. JSON:
RectOp
Canvas.drawRect(rect, paint); rect is [left, top, width, height].
RectOpFields
RemoveOp
Remove nodes ids and their subtrees, detaching them from their parents.
RepeatOp
Its ops once per item of each (an expression giving a list; a map gives its values), or count times: Flutter's for (final (index, item) in list.indexed) { ... }. Inside, the item is named as (item), its position indexAs (index), and count is how many there are.
RepeatOpFields
RetryFailedAction
Runs again the action chain whose failure the screen's actionError reaction is handling (a toast's Retry after an offline save or a failed load): the same node's reactions to the same trigger, with the same event and list item. Nothing happens outside an actionError reaction or when that failure can't be retried (${error.retryable} is false).
Reveal
Scrolls the node into view when it appears (or when its reveal.when binding turns true), to alignment of the viewport (0 top, 1 bottom). With follow it stays there while the content around it moves (lines added above an end marker, an image that loads late), until the user scrolls away: a chat or transcript pinned to its newest line.
RevealFields
RootsOp
Set the document's canvases (roots).
RouteDismiss
A drag anywhere on a screen that closes it interactively: the drag runs the transition backwards, and on release the pop completes or cancels with spring.
RouteDismissFields
RouteTransition
A composable route transition. enter is where the incoming screen starts, exit where the covered one ends; closing plays them in reverse unless popEnter (where the screen revealed by the pop starts) or popExit (where the closing screen goes) are given. A preset fills in what's left null. JSON: an object, or a bare preset name.
RouteTransitionFields
RRectOp
Canvas.drawRRect(RRect.fromRectAndCorners(rect, ...), paint); radius as a decoration's (8, [x, y], [tl, tr, br, bl]).
RRectOpFields
RunScriptAction
Runs script script (a layout's scripts, by id) with arguments (by parameter name; expressions: one ${...} passes its value as is, other text passes as JSON when it is JSON, else as text). Its result is the chain's ${result} (and goes in resultVariable when set). When it fails, onError runs with ${result} {error: {type, message, line, column}, logs}; without onError a failure stops the chain.
RunScriptFields
RunScriptAction.
ScriptDef
A script. Its params are variables in its source; what it returns at its top level (or what its main returns) is its result. It runs in a sandbox with no network, files or timers, reaching the app only through what its capabilities grant, and stops past timeoutMs of computing or memoryLimitMb. A page script (pageId set) wins over a project script of the same name. JSON (sparse):
ScriptFields
ScriptDef (a layout's scripts).
ScriptParam
A parameter of a ScriptDef: a JavaScript identifier, and the value a caller that passes none gets (defaultValue, JSON).
ScriptsOp
Define, change or remove the document's scripts by name (sandboxed JavaScript: ScriptDef). Allowed only where the trust profile allows scripts.
ScriptTest
A sample run of a ScriptDef and what it should give (the editor's test console): args by parameter, sample vars and input nodes values, and the result expected, or the error expectError (its type, its message, or Type: message).
ScrollProps
Scrolling, for any container that can scroll its content (SingleChildScrollView).
ScrollToAction
Scrolls node node into view: alignment 0 puts it at the start of the view, 1 at the end; offset moves it further. axis limits it to the scroll views along one axis (a map in a sideways window centers a point without scrolling the page under it); null scrolls every one around it.
ScrollToFields
ScrollToAction.
SegmentedButtonProps
Flutter SegmentedButton<String>.
SetOp
Create or replace node id with node (its JSON, as a document holds it under nodes), and optionally place it under parent at index (or in slot). Flutter: inserting a widget into the tree.
SetThemeModeAction
Sets the site's theme mode (Flutter's ThemeMode, as an app sets MaterialApp.themeMode): mode is an expression giving system, light or dark ("dark", "${= theme.isDark ? 'light' : 'dark'}" to toggle). Every screen of the site redraws its named colors, text styles and controls in that mode at once, and ${theme.mode} / ${theme.isDark} change with it. With persist the choice is kept in the site's local storage: a reload, and every page after it, starts in it. JSON: {"type": "setThemeMode", "mode": "dark"}.
SetThemeModeFields
SetThemeModeAction.
SettingTarget
Where a ComponentSetting writes: a node and a binding path into it (DESIGN.md §5.1), as a condition's set entries. A field path in the older properties.* form that has no binding path is kept as v1 (the stored key's name).
SetValueAction
Sets properties of node node at runtime (until the screen goes). A property bound to a variable sets the variable instead.
SetValueFields
SetValueAction.
SetVariableAction
Changes variable variable (of the screen, or the app): write. JSON: {"type": "setVariable", "variable": "count", "op": "add", "value": "1"}. A computed variable can't be set. To glide a number to a new value, AnimateAction it (animateTo).
SetVariableFields
SetVariableAction.
SetVariantAction
Shows variant variant of variance node node.
SetVariantFields
SetVariantAction.
ShapeBorder
One of Flutter's OutlinedBorders: its kind, corner radius and side. JSON: {"type": "stadium", "borderRadius": 8, "side": {...}}.
ShapeBorderFields
ShapeOp
An op that draws a shape: its paints, and hit, which makes it a hit region (Flutter's CustomPainter.hitTest).
ShapeOpFields
The fields every shape op has.
Shimmer
A band of light across what the node paints (a loading skeleton's shimmer: Flutter's ShaderMask with a moving LinearGradient), blended over the node's own pixels only. position places it; the shimmer animation preset sweeps it across, over and over. JSON (sparse): {"color": "#FFFFFFFF", "strength": 0.8, "width": 0.44, "angle": 0, "position": 0.5}.
ShimmerFields
Shimmer: a band of light across the node.
ShowToastAction
Shows a short message (a snackbar). Its button (actionLabel) runs actions on the chain that showed it. Cosmetics beyond the fields below (colors, radius, shadows, text styles, offsets per breakpoint) are in style, JSON.
ShowToastFields
ShowToastAction.
SignatureProps
A signature pad: strokes drawn with a finger or mouse, on a bordered card with a placeholder and a sign line.
SinglePlaceholderProps
A slot that shows its one child, or keeps its size when empty.
Site
A site in memory: its manifest, pages and component library, whatever loaded them (files, a publish, an editor's store).
SiteManifest
A site's manifest (site.json), loader-agnostic: which documents are its pages and components (as references the loader resolves: file paths relative to the manifest, publish ids...), its project variables (read by bare name in every document), breakpoints and any keys it doesn't model.
SliderProps
Flutter Slider with its SliderThemeData, at its box's design size.
SlotProps
Where a definition places what a call passes: the children slot (the call's children) or a named one (the call's slots[name]). With nothing passed it shows its own children (the default). Outside a definition it shows its children. Flutter: child / children / a Widget title parameter, placed in build.
SpacerProps
Flexible empty space in a row/column (Spacer), or a fixed gap. With no size along its parent's main axis it is Flutter's Spacer(): it takes the free space by its layout.flex; a fixed size there makes it a gap.
Spring
Flutter's SpringDescription: either the physical triple (SpringDescription(mass:, stiffness:, damping:), when stiffness and damping are both given) or SpringDescription.withDurationAndBounce (duration ms, bounce). The one spring value of the model: transitions, animations, gestures, a flip card's settle and a route's dismiss all take it. JSON: {"stiffness": 380, "damping": 36} or {"duration": 500, "bounce": 0.3} (sparse; {} is withDurationAndBounce()'s defaults).
SpringFields
Spring: Flutter's SpringDescription, physical or by duration and bounce.
StackProps
A freeform container: children placed by layout.x/layout.y (Flutter Stack with Positioned/Align children).
StateStyles
What a node and its descendants change to in each WidgetState: per state, node id → a patch of that node's JSON (a merge patch: maps merge, null removes, anything else replaces; see mergePatch). Later states in WidgetState's order win where active states overlap.
StateStylesFields
StateStyles: one field per WidgetState. Each holds that state's patches (node id → a merge patch of the node's JSON), which are free-form JSON (nodePatchesType): a patch can override any key of any node.
Sticky
Pins the node inside the scrolling row or column it scrolls in, as CSS position: sticky: once its leading edge reaches offset from the view's leading edge it stays there, drawn above the content scrolling under it, until the end of its parent (the section it heads) pushes it on. ${sticky.stuck} says whether it is pinned now (the node's own bindings and the nodes inside it read it). The design canvas, which doesn't scroll, draws it in place. JSON true or {"offset": 8}.
StickyFields
StreamedOp
One op out of a stream: the index of the op it came from in the tool input's ops, and whether it is part of a set op still arriving (a node of its nodes map).
StringCodec
SwipeAction
One action revealed behind a list item as it is swiped.
SwipeActionFields
SwipeActions
Swipe actions on a list's items (Dismissible): toward the start reveals endActions, toward the end startActions; past threshold the first of the side runs. Running one fires the list's swipeAction reactions with ${result.action}, ${result.item}, ${result.index}.
SwipeActionsFields
SwitchProps
Flutter Switch, scaled to its box (59 px wide is Flutter's own size).
TabBarProps
Flutter TabBar (labels only; no pages).
TableColumn
One column of a table view: the row field its cells show (key, read as ${item.value}), its header text (label, ${item.label}) and its width (null: the table's columnWidth).
TableColumnFields
TableViewProps
Flutter's TableView (two_dimensional_scrollables): a table that scrolls on both axes, with a header row and column that stay pinned. Rows are the bound data (or rowCount); columns are columns (or bound props.columns). Its slots are templates built per cell with ${item}: cell ({value, row, column, rowIndex, columnIndex}), columnHeader ({label, column, columnIndex}), rowHeader ({row, rowIndex}) and corner.
TabsProps
A TabBar over the selected child: one tab per child, titled by titles.
TextFieldProps
Flutter TextField (a TextFormField when it validates).
TextProps
Text.rich: a string with styled runs.
TextRun
A styled range of a text's characters, [start, end).
TextRunFields
TextStyle
Flutter's TextStyle. Every field is optional: a span's style is merged over its text's base style, as in Text.rich.
TextStyleFields
ThemeRefs
Resolves theme names in JSON written for declared types against a ThemeTokens (already for the screen's size and mode: ThemeTokens.atScreen, ThemeTokens.forBrightness).
ThemeTokens
A project's theme as published: what the runtime draws itself (dialogs, toasts, the loading and error screens), what layouts read at run time (${theme.primary}, ${theme.colors.brand}, ${theme.text.title.fontSize}, ${theme.isDark}) and what an app can read to match its own widgets to a layout. Every token is optional.
Tilt
Tilts the node in 3D toward the pointer while it hovers or drags over it. max holds the Motion values reached with the pointer at an edge: the edge under it tips away (rotateX at the top and bottom, rotateY at the sides, with its perspective); scale and translate are reached while the pointer is over the node at all. Inside it ${tilt.x}, ${tilt.y} (-1–1) can be read, for parallax.
TiltFields
TimePickerProps
A field showing a time (HH:mm; empty shows its hint) that opens hour and minute columns (Flutter's showTimePicker).
Track
A value the user sets by dragging (node key track): Flutter's Slider (value, min, max, divisions as step, onChanged as the changed reaction, onChangeEnd as changeEnd), generalised from a straight bar to a line, an arc or any path. The node carrying it is the thumb: it moves along the track as variable variable goes from min to max, and the design canvas draws it at the variable's value. Dragging it writes the variable; the wheel and arrow keys step it. Inside it ${track.value}, ${track.progress}, ${track.dragging} and ${track.focused} can be read; it fires changed (${result.value}, from, direction, crossed), dragEnd and changeEnd.
TrackFields
Track (node key track): a value set by dragging (Flutter's Slider).
TransformGesture
Makes the node pannable, zoomable and rotatable by touch, mouse and trackpad (Flutter's InteractiveViewer, and more): pinch and ctrl+wheel zoom about the focal point, one finger pans, two rotate, a double tap zooms to a point; a release flings and settles by physics within bounds and minScale–maxScale. The pose binds two-way to variables (xVariable...); inside it reads as ${transform.x}, ${transform.scale}... Each change runs the node's changed reactions, the end of a gesture its changeEnd ones.
TransformGestureFields
TransformHandles
On-canvas handles that make a node an editable object (a sticker, a collage): corners scale it, edges stretch it, a knob rotates it.
TransformHandlesFields
Transition
How a change of property animates (Flutter's implicit animations: AnimatedContainer(duration:, curve:), AnimatedOpacity, AnimatedScale, TweenAnimationBuilder): when the value there changes (a binding, a condition, a state style), the node tweens from what it shows to the new value over duration after delay on curve, or on spring. A change mid-flight carries on from where it is. A behavior key, a list: "transitions": [{"property": "motion", "duration": 240, "curve": "easeOutCubic"}, {"property": "opacity", "duration": 120}].
TransitionFields
Transition: how changes of one property path animate.
TransitionReveal
A clip that reveals a screen as a transition plays: a circle or rectangle growing from origin until it covers the screen.
TransitionRevealFields
TransitionSide
How one screen moves during a RouteTransition: an entering screen starts at motion and comes to rest; a leaving one starts at rest and ends at motion (a Pose: a transform, shiftX/shiftY in screen sizes, with an opacity and a blur); this side's curve, delayMs and durationMs time it inside the route's duration.
TransitionSideFields
Trigger
A trigger and its settings. JSON (sparse): {"type": "click"}, {"type": "changed", "debounceMs": 300}, {"type": "timer", "intervalMs": 500}, {"type": "keyDown", "key": "Meta+Enter"}.
TriggerFields
A reaction's trigger (Trigger, its JSON keys).
TrustProfile
What an edited document may use: node types, action types, scripts, link and image hosts, navigation, and size limits. TrustProfile.none allows everything; TrustProfile.agent is the default for agent-written UI.
Typewriter
Text that types itself out in a running app, like a typewriter or a terminal: charsPerSecond characters a second after delayMs, with a blinking block caret after the last one while it types. It types when the text first shows and again from the start when playKey changes; when the text grows by appending (a streamed reply) only the new characters type, and when it changes otherwise it types afresh. skip (bindable, e.g. to a tap that sets a variable) shows the rest at once; off enabled it shows all of it. The layout never changes as it types: the whole text is laid out and only what's typed is painted. The design canvas shows it all.
TypewriterFields
UnknownAction
An action of a type this version doesn't know: its JSON, kept. Running it does nothing.
UnknownDrawOp
An op this version doesn't know: kept whole and written back; it draws nothing.
ValidateAction
Flutter's FormState.validate(): checks every text field of the form with its validator and shows each one's error; the first invalid field takes the focus. node is the form (a node with a form behavior); empty: the form around the node whose reaction runs it, else every field of the screen. ${result} after it: whether all are valid (true / false), for an if that submits.
ValidateFields
ValidateAction.
ValueCodec<T>
A value type with its own fromJson / toJson.
ValueWrite
How a value is changed: op with value (an expression), at index in a list or mapKey in a map (expressions too). Stored flat in its action's JSON: "op": "insert", "value": "${item}", "index": "0".
ValueWriteFields
The ValueWrite keys, stored flat in SetVariableAction, SetStorageAction and CloudDocumentsAction JSON.
Variable
A variable: a name, a type and a default value, or a formula that computes it from other variables. JSON (sparse):
VariableOption
One option of a VariableType.choice variable.
VarianceProps
Shows one of several variants of its content (by id, or by breakpoint).
VarsOp
Set variable values, declare variables (a full variable object as the value) or remove them, in scope (a canvas id or page_variables).
VecCodec
A list of numbers of one of lengths ([x, y], [l, t, w, h]), each a literal or an expression.
ViewProgress
How far the node has scrolled through the viewport of the scrolling row or column (or list) it is in, as ${view.progress} (0–1) and ${view.visible} for its own bindings and the nodes inside it: a figure that draws itself as it scrolls up the screen (a path's trimEnd), a heading that fades in, a gauge reading how far through a section the reader is. Positions are fractions of the viewport's extent from its leading edge (0 top, 1 bottom), plus offset pixels. With variable, the progress is also written to that screen (or app) variable, under key when it's a map, for nodes elsewhere to read. The design canvas reads progress 0 above the fold and 1 for a node it shows whole.
ViewProgressFields
VisualDensity
Flutter's VisualDensity.
VisualDensityFields
Wave
A sine added to a track's value: amplitude * sin(2π(cycles·t + phase)), fading by 1 − decay·t (a shake dies out with decay 1), folded to its absolute value with rectify (a ball's hops). Flutter has no counterpart; a list of them is a Fourier series: a wobble, a sway, a flame's flicker.
WaveFields
Wave: a sine added to a track.
WidgetSpec
The declaration of one widget type.

Enums

AnimateCommand
An AnimationController method (AnimateAction.command).
AnimationCurve
An easing curve, by the name of its Flutter Curves constant. spring is a damped spring (see Motion.spring); step jumps half way.
ArcFit
How an arc progress bar sits in its box: the arc fitted to the box, or its whole circle (so arcs of any length line up into one ring).
AutovalidateMode
Flutter's AutovalidateMode: when a field (or every field of a form) checks itself with its validator and shows the error, besides when the form is validated (the validate action).
Axis
BarcodeErrorCorrection
How much of a QR code can be damaged and still be read.
BarcodeSymbology
The encoding of a barcode.
BaseForm
Which form of the base: for an agent writing files, or for a model streaming ops at run time.
BlendMode
BorderStyle
Flutter's BorderStyle.
BottomNavigationBarLandscapeLayout
BottomNavigationBarType
BoxFit
BoxHeightStyle
Flutter's BoxHeightStyle (selection boxes).
BoxWidthStyle
Flutter's BoxWidthStyle (selection boxes).
ChartGridLineMode
How a series chart places its grid lines (and solid reference lines). centered: centred on the value's rounded y (the bottom line one pixel row up, inside the plot); a 1 px line there straddles two pixel rows. crisp (the default): whole pixel rows from the value's rounded y down (the bottom line's up, inside the plot), so a line of whole width is sharp; other widths stay centred on the value. exact: the rows just above the value's unrounded y, like a Flutter box of that height whose bottom edge sits at the value (sharp when that is a whole pixel, soft otherwise).
ChartSeriesKind
How a chart series draws its values.
ChartStackGapEdge
Where a stacked bar's ChartProps.stackGap goes. between (the default): under each segment but the first, so the bar keeps its height. top: over every segment, the top one included, as a column of boxes each with a top margin (the bar's top sits the gap below its value).
ChartType
What a series chart draws.
ChartYLabelAlign
Where a series chart's y labels sit in the gutter left of the plot: end right-aligned 8 px left of the plot, start left-aligned at the chart's left edge.
ChildModel
How a widget takes children.
ChipVariant
How a chip is drawn.
Clip
ComponentRole
What a node is to its component.
ConditionOp
How a Comparison compares its operands. Loose: numbers as numbers, booleans as booleans, anything else as case-insensitive text.
CrossAxisAlignment
DateTimeInputMode
What a date/time input picks.
DateTimeInputPicker
What tapping a date/time input opens: the date and time pickers, or nothing (its own click reactions show a picker the design builds, and set its value).
DecorationShape
The shape a Decoration paints: Flutter's BoxShape.
DismissCommand
What a ControlDismissibleAction does to a DismissibleBehavior (or a Pan): dismiss flies it off toward the direction as if swiped (and fires that swipe: removing the item); returnFrom brings it back from off-screen on that side (re-inserting it; a card built in the next frame, an undo's, starts there); reset springs it back to rest. shake wiggles it once (deprecated: the shake animation preset).
DragAnchor
Which point of the copy that follows the pointer sits under it (Draggable.dragAnchorStrategy): where it was grabbed (childDragAnchorStrategy), or its center (a feedback node of another size).
DragAxis
DragDirection
A direction a node is dragged or dismissed in.
DragSourceStyle
What the node shows where it was picked up while dragged (Draggable.childWhenDragging): a faded copy, nothing, or itself.
DragStart
How a node starts a drag: on press, on long press, or long press on touch and press with a mouse.
DropSlot
Where a DropTarget inserts what's dropped on a list.
DropSlotSize
How big the slot a DropTarget opens in its list is: the dragged node's size, the slot node's own (room for an insertion line), or none: inGap draws the slot node in the gap between the items it would land between, moving nothing (a board's column insertion bar).
EditFieldKind
The kind of value an op field holds (its JSON Schema type).
EditTextOperation
What an EditTextAction does to its text field.
EffectType
FlipAxis
The axis a FlipCard turns around.
FloatingActionButtonLocation
Flutter's FloatingActionButtonLocations, by name.
FloatingActionButtonType
Which FloatingActionButton constructor: FloatingActionButton(), .small, .large or .extended.
FloatingLabelBehavior
Flutter's FloatingLabelBehavior.
FontStyle
GaugeLimitStyle
How a gauge meter's limit line is drawn.
GaugeShape
The shape of a gauge meter.
GestureBounds
What a gesture keeps a node inside of.
HapticKind
How strong a HapticAction buzz is (Flutter's HapticFeedback).
HeroFlies
When a hero flies.
HeroFlightShuttle
What a hero's navigation flight draws (Flutter's Hero.flightShuttleBuilder; standard is Flutter's default shuttle).
HeroPlaceholder
What a shared element's destination shows while its own drawing isn't ready (a network image still loading).
IconAlignment
Where a button's icon sits: Flutter's IconAlignment.
ImageRepeat
InputBorderType
Which of Flutter's InputBorders.
Join
KeyboardDismissBehavior
When a view's keyboard is dismissed (ScrollViewKeyboardDismissBehavior).
KeyframeInterpolation
How a track's AnimationTrack.keyframes are joined.
LineChartXLabelAnchor
Where a line chart's x labels sit about their tick. edgeClamped: centred, the first starting at the tick and the last ending there (so both stay over the plot). start: starting at the tick. center: centred on it. end: ending at it.
ListApply
What a reorder (or a swipe action that removes the item) changes on its own, before the list's reactions run.
ListLayout
How a list arranges its items.
ListSeparator
What a list draws between its items.
ListTileControlAffinity
Which side of a tile its control sits on (ListTileControlAffinity).
ListTileTitleAlignment
MainAxisAlignment
MainAxisSize
MasonryPlacement
Which lane a masonry grid puts each item in.
MediaOrientation
CSS orientation: portrait when the screen is at least as tall as wide.
MigrationEntryKind
What kind of thing a MigrationEntry records.
ModalAnchor
What a popover is anchored to: nothing, the node that opened it, the pointer, or a named node (OpenModalAction.anchorNode; in a list, the copy built for OpenModalAction.anchorItem), so a modal opened from a keyboard shortcut or a screen's load can sit by a node too.
ModalPresentation
How a modal shows.
Flutter's NavigationDestinationLabelBehavior (plus showing only the unselected labels, which BottomNavigationBar can).
Where navigation may go.
How a NavigateAction moves.
NodeValueMode
How a NodeValue sets its property.
NoiseType
SVG feTurbulence's type: Perlin noise summed (fractalNoise, a soft grain) or its absolute values summed (turbulence, ridged).
PagePaintOrder
Which pages of a page view draw on top where they overlap.
PageTransition
A page transition.
PaginateCommand
What a PaginateAction does to a pagination controller.
PaginationMode
How a list shows the pages.
PaginationSource
Where a pagination reads its items from.
PaginationStrategy
How a page is asked for.
PaintingStyle
Flutter's PaintingStyle: fill the shape, or stroke its outline.
PaintType
PanRelease
What a Pan does when let go: springs back to rest, or stays where it is (settling by its physics: a fling, snap points).
ParticleShape
A particle's shape; image draws the emitter's ParticleEmitter.image.
PathFillType
Flutter's PathFillType.
PathOrient
How a node on a PathFollow turns with the path.
PaywallOperation
Opens a placement, or acts inside a paywall screen.
PlotChartGridAnchor
Where a plot chart's grid lines start: at xMin (every step from the left edge, as a category axis), or at multiples of the step (0, ±step, …: a Cartesian graph whose grid stays put as the domain pans).
PlotChartMarkerPosition
Where a plot chart marker's label sits relative to its dot.
PlotChartMarkerShape
How a plot chart marker is drawn: a filled dot (the default), a hollow ring, a square or a diamond.
PlotChartSelectionGuides
How the selection is marked: a full-height line, dashed guides from the point to both axes, or only the dot.
PointMode
Flutter's PointMode (Canvas.drawPoints).
PopoverPlacement
Where a popover sits relative to its anchor.
ProgressBarShape
A straight progress bar, or an arc like a dial.
PropKind
The shape of a prop's value, for tools: PropType.name is the Flutter type (double, Color, EdgeInsets, MainAxisAlignment, List<Paint>, ButtonStyle), so a properties panel picks the control a Flutter developer expects, docs print it and codegen emits it.
ReorderPlaceholder
What shows where a dragged item would land.
ReorderStart
How a drag of a list item to a new place starts.
RevealOrigin
Where a TransitionReveal grows from.
RevealShape
The shape a TransitionReveal clips a screen to.
RouteSwipeBack
When a route can be swiped back from its left edge (iOS style).
RouteTransitionPreset
A ready-made RouteTransition; sides given next to it override its own.
ScaleMode
How a screen fits the device.
ScriptCapability
What a script may do besides computing; anything else it calls fails. JSON: the capability's id.
ScrollAxis
The scroll views a ScrollToAction moves.
ScrollPhysicsType
SegmentedVariant
How a segmented button is drawn.
ShapeBorderType
Which of Flutter's OutlinedBorders a ShapeBorder is.
ShowValueIndicator
Flutter's ShowValueIndicator.
SignaturePlaceholderPosition
Where a signature pad's placeholder sits.
SignLineStyle
How a signature pad's sign line is stroked.
SignMarkPlacement
Where a signature pad's mark sits: over the line's start, or before the line (centred on it, the line starting after it).
SizeFit
How a node sizes along one axis.
SliderThumbShape
The slider's thumb (SliderThemeData.thumbShape).
SliderTickMarkStyle
The tick marks of a discrete slider.
SliderTrackShape
The slider's track (SliderThemeData.trackShape).
SliderValueIndicatorShape
The value indicator (SliderThemeData.valueIndicatorShape).
SnapKind
Where a GestureSnap settles a released node.
StrokeAlign
Where a stroke sits relative to the box edge (Flutter's BorderSide.strokeAlign: inside -1, center 0, outside 1).
StrokeCap
StrokeJoin
StrokeSides
Which sides a box's stroke runs along: every side (rounded with the corners), one side, a pair of opposite sides (a ruled band), two sides meeting at a corner (topRight: the top and right sides, as a table's header corner), every side but one (noTop), or none, as Flutter's Border takes any of its sides.
TabAlignment
Flutter's TabAlignment.
TabBarIndicatorSize
Flutter's TabBarIndicatorSize.
TabContent
What a tab shows.
TabIndicatorStyle
How the selected tab is marked.
TestPurchaseOutcome
How a test purchase of a slot ends in the SDK's test store.
TextAlign
TextAlignVertical
Vertical placement of text inside its box (Flutter's TextAlignVertical).
TextCapitalization
Flutter's TextCapitalization.
TextDecoration
TextDecorationStyle
TextDirection
TextInputAction
Flutter's TextInputAction.
TextInputType
Flutter's TextInputType.
TextLeadingDistribution
How a line's extra height is shared above and below its glyphs.
TextOverflow
ThemeMode
Whether a site shows its light or dark colors (Flutter's ThemeMode, as MaterialApp.themeMode takes it).
TileMode
ToastPosition
Where a toast shows.
ToastStyle
A toast's look.
TrackBlend
How a track's value meets the property's own.
TrackCommand
What a ControlTrackAction does to a Track: step turns it by ControlTrackAction.steps of its step, as if dragged there (crossing each step, then settling: a dial's nudge buttons); animateTo moves it to ControlTrackAction.value (Slider.onChanged(value)), reporting changed, dragEnd and changeEnd.
TrackHitArea
Where a Track's node takes the pointer: on itself, or anywhere in its parent too (a knob turned from anywhere in its box).
TrackInput
How the pointer moves along a Track: following it (along the line or path, round the arc), or dragging up/down, left/right, or either (up or right raises it: dx − dy).
TrackInteraction
How the pointer may move a Track's value (Flutter's SliderInteraction, the two it has of four): only by dragging the thumb (slideThumb), or also by pressing the track, which moves the thumb there before the drag goes on (tapAndSlide; TrackInput.follow only).
TrackShape
The shape of a Track: a straight line, an arc about a pivot, or an SVG path (Track.path).
TrackUnits
What a Track's line and pivot are measured in: pixels, or fractions of the parent's size (x values of its width, y of its height).
TransformCommand
What a ControlTransformAction does to a TransformGesture (a map, a photo; transformationController.value = ...): reset springs it to its rest pose (on a node without one, its dismissible or pan); scaleBy scales it by ControlTransformAction.value (a factor: 1.5 in, 0.67 out) about the middle of what its viewport shows; animateTo springs it to the pose ControlTransformAction.value gives ({x, y, scale, rotation}, keys left out kept: "fit to route").
TransformPan
When one finger (or a mouse) pans a TransformGesture.
TransformTarget
What a TransformGesture moves.
TriggerType
What starts a reaction.
VariableType
What a variable holds.
VerticalDirection
ViewProgressMode
How a ViewProgress measures its node against the viewport.
WheelZoom
What the mouse wheel does over a TransformGesture.
WidgetState
The interaction states of Flutter's WidgetState a node can style.
WrapAlignment
How the items of a run are placed along it (Flutter's WrapAlignment).
WrapCrossAlignment
How the items of a run are placed across it (WrapCrossAlignment).
WriteOp
How a write changes a value.

Extensions

CatalogSelect on Catalog
A catalog's slice.
ComponentDocument on LayoutDocument
A layout document read as a component definition.
LayoutDocumentBreakpoints on LayoutDocument
A page document's copy of its project's breakpoints, until the editor keeps per-project data (as it keeps project scripts in the document).
LayoutDocumentLogic on LayoutDocument
LayoutDocumentScripts on LayoutDocument
The scripts of a layout document (its scripts key, in LayoutDocument.extra): project scripts and its page's.
Let on T
VarianceBreakpoints on Node
A variance node's responsive layout (DESIGN.md §5.3).

Constants

animationRepeatType → const PropType
animationTrackType → const PropType
axisPositionType → const PropType
AxisPosition: where a child of a freeform parent sits on one axis (Positioned / Align).
axisSizeType → const PropType
AxisSize: a design size and how it fits (SizedBox / Expanded / Flexible / intrinsic). JSON: a number or {"fill"|"flexible"|"hug": v}.
baseProps → const Map<String, List<String>>
The base node types and the props the base shows for each (in this order; a key the type does not declare is skipped).
callForbiddenKeys → const Set<String>
The node fields a call may not carry: the inside belongs to the definition (call_field_not_allowed).
callLayoutKeys → const Set<String>
The layout fields a call gives the instance's root: its size and placement. The root keeps its own padding (the inside is the definition's).
collectionsSpecs → const List<WidgetSpec>
commerceActionSpecs → const List<ActionSpec>
The commerce library's action type (PaywallAction).
commerceCatalog → const Catalog
The commerce library's declarations: Purchases and paywalls (PaywallAction).
componentDocumentKeys → const Set<String>
The keys a component document reads beyond a layout document's.
coreActionSpecs → const List<ActionSpec>
The core action types (the CoreAction family).
coreCatalog → const Catalog
Catalog.core: the core's node types and actions.
coreWidgetSpecs → const List<WidgetSpec>
The core's node types, in the order an editor lists them.
customPaintType → const PropType
dismissibleType → const PropType
docPages → const List<DocPage>
The reference's pages by section: what ui_docs serves (docs/reference/<id>.md).
docTasks → const List<DocTask>
The index's task table: a need and the section that answers it.
dragSourceType → const PropType
drawOpType → const PropType
One draw op: a union on op, its fields per DrawOpSpecs.
drawPaintType → const PropType
drawRRectType → const PropType
dropTargetType → const PropType
editNodeKeys → const Set<String>
The keys a node reads (beyond the behaviors).
everyItem → const String
The wildcard key: every item of a list.
flightType → const PropType
flipCardType → const PropType
formType → const PropType
gesturePhysicsType → const PropType
gestureSnapType → const PropType
heroTagType → const PropType
indicatorsSpecs → const List<WidgetSpec>
inkWellStyleType → const PropType
inputsSpecs → const List<WidgetSpec>
jsonEquality → const DeepCollectionEquality
Deep equality for JSON-like values (maps, lists, scalars).
kChildrenSlot → const String
The slot a call's children fill.
kDefaultHoldMs → const int
How long a TriggerType.hold is held by default, in milliseconds.
kDefaultVisibleFraction → const double
How much of a node must be visible, by default, for TriggerType.enterViewport.
kErrorWithoutMessage → const String
The InputDecorationFields.errorText of a field in error that shows no message (its error text bound to true): the error border only.
keyframeType → const PropType
kOldestSchemaVersion → const int
The oldest schema this package migrates. Anything older (and a document with no schema) is read as this one.
kPreviewsKey → const String
The document key of a component's previews.
kSchemaVersion → const int
The schema version this package reads and writes.
kWidgetKey → const String
The document key of a component's declaration.
listDataSource → const DataSourceSpec
The core's data source: the list bound to a list's data (or its item count). The data library adds cloud and api.
materialSpecs → const List<WidgetSpec>
measureType → const PropType
motionType → const PropType
nodeAnimationType → const PropType
nodePatchesType → const PropType
One interaction state's patches: node id → a merge patch of that node's JSON (see StateStyles). Free-form: a patch can touch any node key.
panType → const PropType
particleEmitterType → const PropType
pathAndSlotSpecs → const List<WidgetSpec>
The core's media-like types: vector paths and slots the app fills.
pathCommandType → const PropType
One Path builder call: {"<method>": [numbers...], "when": ...}.
pathFollowType → const PropType
poseType → const PropType
radioGroupType → const PropType
revealType → const PropType
routeDismissType → const PropType
routeTransitionCodec → const ValueCodec<RouteTransition?>
RouteTransition; a bare preset name reads as that preset.
routeTransitionType → const PropType
schemaMigrations → const Map<int, SchemaMigration>
Upgrades by the version they produce: 3 is migrate2to3.
scriptType → const PropType
shimmerType → const PropType
springType → const PropType
starterBuildExample → const Json
The base's build example: a ui_apply input that applies with no error or warning under TrustProfile.agent and strict validation, with a selectable list and a labelled button.
starterEditExample → const Json
The base's edit example, on starterBuildExample's document.
stateStylesType → const PropType
stickyType → const PropType
streamReferenceCodes → const Set<String>
Codes of a reference to something that may arrive later in a stream: a warning while it streams, an error if it is still unresolved at the end.
symbolIcons → const Map<int, String>
Icon names for symbols models write as text.
tableColumnCodec → const ValueCodec<TableColumn>
tiltType → const PropType
trackType → const PropType
transformGestureType → const PropType
transformHandlesType → const PropType
transitionRevealType → const PropType
transitionSideType → const PropType
transitionType → const PropType
typewriterType → const PropType
uiApplyCompactDescription → const String
The ui_apply tool's description in the compact tools, whose node contents the system prompt (the runtime starter) describes.
uiApplyDescription → const String
The ui_apply tool's description: what a model reads about the ops.
uiDocsDescription → const String
The ui_docs tool: the full reference, one topic at a time.
uiDocsInputSchema → const Json
The ui_docs tool input's JSON Schema.
uiReadCompactDescription → const String
The ui_read tool's description in the compact tools.
uiReadDescription → const String
The ui_read tool's description.
uiReadInputSchema → const Json
The ui_read tool input's JSON Schema.
viewProgressType → const PropType
waveType → const PropType

Properties

schema3Steps → List<MigrationStep>
The steps of migrate2to3, in order: schema 2's (migrationSteps2to3), then the one-way steps of 30.1.0 (spellingMigrationSteps).
no setter

Functions

actionsEqual(List<ActionDef> a, List<ActionDef> b) → bool
Whether a and b hold equal actions in the same order.
allowedChildFits(Node? parent, {required bool horizontal}) → List<SizeFit>
The fits allowed under parent along an axis.
animationRepeatFields() → List<PropDef<Object?>>
animationTrackFields() → List<PropDef<Object?>>
applyOps(LayoutDocument document, Object? ops, {Catalog? catalog, TrustProfile profile = TrustProfile.none, EditCheck? check = catalogCheck, bool atomic = false, EditRevisions revisions = const EditRevisions(), int? baseRev, String author = 'agent', bool incomplete = false, bool protectRoots = false}) → EditResult
Applies ops to document in order and returns the result. Never throws.
baseDocument({BaseForm form = BaseForm.runtime, Catalog catalog = Catalog.core, TrustProfile? profile, String kind = 'card', bool docsTool = true, DesignSystem? designSystem, List<BaseSegment>? segments, List<DocPage>? pages, List<DocTask>? tasks}) → String
The base: baseSegments assembled for form, with the node types and actions of catalog restricted by profile (the file form: every type; the runtime form: TrustProfile.agent unless given). kind (runtime) is card, page or app. docsTool: ui_docs is offered (runtime). segments and pages default to the generated ones; the generator passes the ones it just made.
borderSideFields() → List<PropDef<Object?>>
breakpointKey(String label) → String
label as a formula key: lower camel case of its letters and digits ("Large desktop" → largeDesktop, "XL" → xl). Empty for none.
canonicalJson(Object? value) → String
value (JSON) as text with every object's keys sorted, no whitespace, and a whole double written as an integer (1.0 → 1): one text for one value, whatever order a store kept its keys in. What a published component's digest is over, and how validation compares subtrees.
catalogCheck(EditCheckInput input) → List<EditDiagnostic>
An EditCheck over EditCheckInput.catalog's declarations: unknown node types, node keys, props, layout and decoration keys and action types; prop values a declaration cannot read; children or slots a type does not take. Codes as strict validation's.
cellChildFits(Node parent, SizeFit fit, bool horizontal) → String?
A grid or page view sizes its children: they fill their cell or page. Along a grid's rows, a grid whose rows shrink-wrap (shrinkWrapRows, CSS grid's auto rows) sizes each row by its tallest item and stretches the others to it (CSS align-items: stretch): a hugging or filling item counts its content there; a masonry grid's items keep their own length (they hug; fill has no end to reach).
changedVariables(LayoutDocument before, LayoutDocument after) → Map<String, Set<String>>
Scope → the names of the variables declared in after that are new or changed since before (what unresolvedReferences checks after a stream).
childFitOptions(Node? parent, {required bool horizontal}) → Map<SizeFit, String?>
Every fit, each with the reason it isn't allowed under parent (null: allowed). With no parent (a top-level node on the board), fixed, hug and fill.
colorStopFields() → List<PropDef<Object?>>
componentCycles(Map<String, Set<String>> calls) → List<List<String>>
Every cycle in the call graph calls (type → the types it calls), each as the path from its first type back to it ([A, B, A]), reported once (from the type that sorts first in it).
containerTypes(Catalog catalog) → List<String>
The node types of catalog that take a children list, most used first.
copyJson(Object? json) → Object?
json deep-copied (maps and lists; other values are shared).
customPaintFields() → List<PropDef<Object?>>
declaredProps(Catalog catalog, String type) → List<String>
The declared prop keys of type in catalog (for messages).
decodeOps(Object? input) → DecodedOps
Reads a batch of ops: the ui_apply tool input ({"ops": [...], "baseRev": 42, "atomic": false}), a bare list of ops, or one op. Total: what is not an op becomes a diagnostic with its index.
decodeOpStream(Stream<String> deltas, {bool partialSets = true}) → Stream<StreamedOp>
Decodes deltas as they arrive (OpStreamDecoder): every op as soon as it is complete. The stream's problems are not reported here: use the decoder for OpStreamEnd.
defaultChildFits(Node parent, SizeFit fit, bool horizontal) → String?
Most parents (stacks, screens' slots...): no Flexible; no Fill along an axis the parent scrolls.
describeTypes(Catalog catalog, Iterable<String> types) → Json
What ui_read {"types": [...]} answers: each node type's children and slots, whether it takes a decoration, and its props (type and doc).
designSystemSection(DesignSystem ds, {bool docsTool = true}) → String
The section of the base for ds: its principles in brief, its tokens by name, its components (each with its purpose, parameters, slots, events and a minimal call) and its patterns in brief.
designSystemTopic(DesignSystem ds, String topic) → String?
The ui_docs answer for topic from ds: design (DESIGN.md), patterns (PATTERNS.md), tokens, or a component's name (its whole declaration). Null when topic is none of them.
diffPatch(Json from, Json to) → Json?
The merge patch that turns from into to (null when they're equal).
dismissibleFields() → List<PropDef<Object?>>
docsIndex({Catalog catalog = Catalog.core, TrustProfile? profile, BaseForm form = BaseForm.runtime, List<DocPage>? pages, List<DocTask>? tasks}) → String
The index the base ends with: the task table (need → section) and the pages with what each documents. In the runtime form, every entry is a ui_docs topic.
docsTopic(String topic, {Catalog catalog = Catalog.core, TrustProfile? profile, List<DocPage>? pages, DesignSystem? designSystem}) → String
One topic, sized for a tool result (a few hundred tokens): a page (its "When to use", minimal example and pitfalls, and the list of its sections), a section of a page by its anchor, or a node type, action type, trigger or behavior by name (or by its anchor, node-slider). What profile does not allow says so: it is documented, not available.
docsTopicNames({Catalog catalog = Catalog.core, List<DocPage>? pages}) → List<String>
Every topic docsTopic answers.
dragSourceFields() → List<PropDef<Object?>>
drawPaintFields() → List<PropDef<Object?>>
drawRRectFields() → List<PropDef<Object?>>
dropNaturalLineHeightFlags(Object? json, {MigrationReport? report, String at = ''}) → Object?
json without schema 2's natural line height flags (_naturalFlag), for a carrier migrated by hand (a publish model).
dropTargetFields() → List<PropDef<Object?>>
editPointer(String path, Object key) → String
path extended by key, escaped as a JSON pointer token.
effectFields() → List<PropDef<Object?>>
endOfStream(LayoutDocument document) → List<EditDiagnostic>
What is wrong with document once a stream has ended: every child, slot or root id that still names no node (dangling_child, an error) and every node no root reaches (unreachable_node, a warning).
explainDiagnostic(EditDiagnostic d, {required Catalog catalog, Json? node}) → EditDiagnostic
d with a message that says how to fix it, when its code is one models hit; node is the node's JSON as the op wrote it.
findScript(Iterable<ScriptDef> scripts, String idOrName) → ScriptDef?
The script of scripts that idOrName names: by id, else by name, a page script over a project one.
firstSentences(String text, int n, {int max = 260}) → String
The first n sentences of text, at most max characters.
fixInstruction({required int rev, Set<String> pending = const {}}) → String
What a tool result tells a model to do about rejected ops and pending ids: fix the document as it is now, by patching it.
flexAxisOf(Node n) → Axis?
The main axis of a row, column or flex node (a flex by its FlexProps.direction); null for any other node.
flexChildFits(Node parent, SizeFit fit, bool horizontal) → String?
A row or column: Flexible along its main axis only; no Fill or Flexible along the main axis when it wraps or scrolls.
flickerAt(double t) → double
How far (0–1) the flicker preset (AnimationPresets) is between its from and to values at t (0–1) of a run: waves of 3, 7 and 17 per run, so it wavers, flares and dips like a flame and ends where it began.
flightFields() → List<PropDef<Object?>>
flipCardFields() → List<PropDef<Object?>>
fontCodepoints(List<int> bytes) → Set<int>
The codepoints a TrueType or OpenType font file maps (its cmap table, formats 4 and 12): what GlyphCoverage needs for a font a host loads. Empty when the file cannot be read.
formFields() → List<PropDef<Object?>>
gesturePhysicsFields() → List<PropDef<Object?>>
gestureSnapFields() → List<PropDef<Object?>>
heroTagFields() → List<PropDef<Object?>>
imagePaintFields() → List<PropDef<Object?>>
inkWellStyleFields() → List<PropDef<Object?>>
inverseOps(LayoutDocument before, LayoutDocument after) → List<EditOp>
The ops that turn after back into before (apply them with atomic: true): what EditResult.inverse holds for one batch, for any two documents (a whole stream of batches).
isComponentTypeName(String type) → bool
Whether type is written as a component's type name: UpperCamelCase, like a Dart class (PlanCard). Core types are lowerCamelCase (row), plugin types vendor.name.
isLayoutDocumentJson(Object? json) → bool
Whether json is a layout document: a nodes map holding a typed node.
isRelativeAssetPath(String path) → bool
Whether path names a file relative to a published site (images/hero.jpg, ./fonts/a.ttf), not a URL (https:, data:, asset:...), an absolute path or an expression.
isUnionType(PropType type) → bool
Whether type is a union: a value written in one of several forms.
jsonEncodeShort(Object? v) → String
keyframeFields() → List<PropDef<Object?>>
listChildFits(Node parent, SizeFit fit, bool horizontal) → String?
A list: its items fill across it; along it, they size themselves unless the list gives each the same extent (then they fill it).
listEquals<T>(List<T>? a, List<T>? b) → bool
Element-wise list equality.
materialIconNamed(String name) → Json?
The Material icon name names (check_circle, lock_open_rounded): a suffix (_outlined, _rounded, _sharp) sets its style. Null when name isn't an icon name.
measureFields() → List<PropDef<Object?>>
mediaPatchAt(List<MediaRule> rules, double width, double? height, Breakpoints breakpoints, {List<PropDef<Object?>>? props}) → Json?
The merged patch of the rules that hold on a screen width × height: in order, a later one winning where two set the same field (a union-typed value written in another form replaces the earlier one: mergeNodePatch, with the node type's props); keys outside MediaRule.patchKeys left out. Null when none holds.
mediaRuleSetting(List<MediaRule> rules, List<String> path, double width, double? height, Breakpoints breakpoints) → int?
The index of the last rule of rules holding on a screen width × height whose patch sets the field at path (["layout", "width"]), or null when none does (the node's own value applies).
mediaWidthRanges(Iterable<MediaRule> rules, Breakpoints breakpoints) → List<({double end, double width})>
Screen widths that between them meet every combination of rules' width conditions: the first width of each range their bounds cut the widths into (from 0), each with the range's end (exclusive; infinity for the last).
mergeNodePatch(Json base, Json patch, {List<PropDef<Object?>>? props, bool keepNulls = false}) → Json
base (a node's JSON, or a patch of it) with patch merged in, as the node's declarations read them: as mergePatch's JSON merge patch, except that where patch writes a union-typed field (isUnionType) in another form than base has, the patch's value replaces base's (its null keys left out), as CSS replaces a declaration. A size object always replaces (it has one key). props are the node type's prop declarations (null: its props merge as plain JSON). With keepNulls, a null is kept (two patches merged into one).
mergePatch(Json base, Json patch, {bool keepNulls = false}) → Json
base with patch merged in (RFC 7386): maps merge recursively, a null value removes the key (kept as null with keepNulls, to merge two patches), anything else replaces.
migrate2to3(Json document, {MigrationReport? report, List<MigrationStep>? steps}) → Json
Upgrades a schema-2 layout document's JSON to schema 3: every legacy key and deprecated field rewritten into the schema-3 form, or kept as legacy.<name> and reported when it has none. Then the steps of 30.1.0, which give each concept one spelling (the node's scale and layout.rotation are its motion, flightKey and flight its hero, strokePath, subpathColors and gradientPerSubpath customPaint path ops, a box's path a path node), run on the result. A document already at schema 3 (or later) is returned as given: it is read as current schema 3. Never throws: a step that fails on a node leaves that node as it was before the step and is reported. report collects what was done (MigrationReport.document names the document). steps, when given, are run instead, in one pass.
migrateDocument(Json document, {MigrationReport? report}) → Json
document (a layout document of any schema; none reads as kOldestSchemaVersion) at kSchemaVersion (migrate2to3). A document at kSchemaVersion or later is returned as given.
migrateJson(Object? json, {MigrationReport? report}) → Object?
Any JSON that carries documents at kSchemaVersion (migrateJson2to3).
migrateJson2to3(Object? json, {MigrationReport? report}) → Object?
Any JSON that carries documents (a document, a publish model or bundle, a component definition, a site manifest, a plugin package, or a file holding several) with every schema-2 document in it migrated (migrate2to3) and every other "schema": 2 (the carriers') set to 3. Text that holds a document (a stored payload) and a stored published component (a document with a digest) are left as they are: the digest covers what was stored, so they are migrated when they are read. Never throws.
migrateNode(Json node, {int from = kOldestSchemaVersion, MigrationReport? report, String id = ''}) → Json
A node's JSON alone, written in schema from, upgraded to kSchemaVersion (migrateNode2to3). Returns a new map; never throws.
migrateNode2to3(Json node, {MigrationReport? report, String id = ''}) → Json
A node's JSON alone (outside a document) upgraded as migrate2to3 upgrades the nodes of a document (its state and media patches on itself included). Returns a new map; never throws.
migrationReportMarkdown(MigrationReport report, {String title = 'Schema 2 → 3 migration report'}) → String
report as Markdown: the counts per step, every unconvertible value with the documents it was in, and every behaviour change, grouped by what was said.
motionFields() → List<PropDef<Object?>>
movedPathHint(String path) → String?
What to write now instead of a binding path path 30.1.0 moved (as 30.0.0 spelled it), or null when it is not one: in 30.1.0 the node's scale and layout.rotation are in motion, flightKey and flight in hero; strokePath and props.subpathColors are customPaint path ops, a box's props.path a path node's props.data. A path an action or a condition names in a schema-2 document is rewritten by the migration; one that comes from elsewhere at run time (another document, a script) is refused where it is used, with this.
nearestName(String word, Iterable<String> candidates) → String?
The candidate nearest to word (case-insensitive edit distance), or null when none is close.
nodeAnimationFields() → List<PropDef<Object?>>
nodeSchema(Catalog catalog) → Json
The JSON Schema of a node in catalog (its type one of the catalog's node types; the node keys and the behaviors as declared).
noisePaintFields() → List<PropDef<Object?>>
olderSchemaPathHint(String path) → String?
schema2PathHint, else movedPathHint: what to write in the current schema instead of an older schema's binding path path.
opSchema(EditOpSpec spec) → Json
The JSON Schema of one op, from its declaration.
opsFromDocument(LayoutDocument document) → List<EditOp>
The ops that build document from nothing, in the order a model writes them top-down: roots, then each canvas's nodes depth-first (its state variables right after it, a large data variable just before the first node that reads it) (a node before its children, the first section complete before the second). Nodes no root reaches come last.
outline(LayoutDocument document, {int rev = 0, int labelLength = 40}) → Json
The outline of document: {"rev": rev, "outline": [[id, type, label, depth, extras?], ...], "pending": [...]}. The label is the node's name, else the first labelLength characters of its text; extras list what is bound ("bind": ["props.text"]), its interaction states, its reactions' triggers and its media rules. Nodes under no root follow, at depth -1.
outlineRow(Node n, int depth, {int labelLength = 40}) → List<Object?>
One outline line: id, type, label, depth, and extras when there are any.
paintFields() → List<PropDef<Object?>>
panFields() → List<PropDef<Object?>>
particleEmitterFields() → List<PropDef<Object?>>
pathFollowFields() → List<PropDef<Object?>>
pendingIds(LayoutDocument document) → Set<String>
Ids document references (children, slots, roots) that it does not define.
poseFields() → List<PropDef<Object?>>
propKeys(WidgetSpec spec) → List<String>
The prop declarations of spec by key (for messages).
propTypeLabel(PropType t) → String
A prop type as a model writes it: start|end|center, number, "#AARRGGBB", TextStyle {fontSize, color...}.
put(Json json, String key, Object? value, [Object? defaultValue]) → void
Puts key in json unless value is null or equals defaultValue.
radioGroupFields() → List<PropDef<Object?>>
readBool(Object? v) → bool?
v as a bool, or null.
readDouble(Object? v) → double?
v as a finite double, or null.
readEnum<T extends Enum>(List<T> values, Object? v, T fallback) → T
The enum value named v, or fallback.
readExprPoints(Object? json) → Expr<List<Vec?>>?
readExprVec(Object? json, Set<int> lengths) → Expr<Vec>?
A vector field: a list of lengths numbers (each may be an expression), or one expression giving the list.
readFontFeatures(Object? json) → List<String>
A fontFeatures list read loosely: a list of settings (strings or {tag, value} maps) or one string of them separated by commas or spaces, as canonical strings; settings that aren't valid are dropped.
readInt(Object? v) → int?
v as an int, or null.
readList(Object? v) → List<Object?>?
v as a list, or null.
readMap(Object? v) → Json?
v as a JSON object, or null. Keys are stringified.
readPaints(Object? json) → List<Expr<DrawPaint>>
An op's paint: one paint, or several drawn in order (a fill then a stroke of the same shape, as two Flutter calls would). Each may be an expression.
readPathCommands(Object? json) → List<PathCommand>?
A list of PathCommands; unreadable entries are dropped.
readPoints(Object? json) → List<Vec?>?
A list of points: [[x, y], ...] (each coordinate may be an expression), {"x", "y"} maps, or flat numbers [x0, y0, x1, y1...]; a null entry breaks the line. Unreadable entries are dropped.
readString(Object? v) → String?
v as a string, or null.
readStrings(Object? v) → List<String>
v as a list of strings (non-strings dropped).
readUi(LayoutDocument document, Object? input, {int rev = 0, Catalog? catalog}) → Json
Answers a ui_read tool call (input: {"ids": [...], "outline": true}): the full nodes asked for (as the document holds them), missing ids, and the outline when asked or when no ids are given.
readVec(Object? json, Set<int> lengths) → Vec?
A literal Vec of one of lengths, or null.
resolveStyleColors(TextStyle style, Color? color(String)) → TextStyle
style with each color it names read by color (left as written when color has none).
resolveThemeRefs(LayoutDocument doc, ThemeTokens theme) → LayoutDocument
doc resolved against theme (ThemeRefs.document); doc itself when it names nothing of it.
revealFields() → List<PropDef<Object?>>
routeDismissFields() → List<PropDef<Object?>>
routeTransitionFields() → List<PropDef<Object?>>
runtimeStarter({Catalog catalog = Catalog.core, TrustProfile? profile, String kind = 'card', bool docsTool = true, DesignSystem? designSystem}) → String
The runtime form of the base: the system prompt of a model that streams ui_apply ops (baseDocument with BaseForm.runtime).
schema2PathHint(String path) → String?
What to write in schema 3 instead of schema-2 binding path path, or null when path is not one of schema 2's. Paths whose schema-3 form depends on the node (a loop's animation id, a drag's mode) name the pattern.
schemaOf(Object? json) → int
The schema of document (or publish model, bundle, manifest, package) JSON json: its schema, or kOldestSchemaVersion when it has none.
scriptFields() → List<PropDef<Object?>>
seamCall(Node root, Node call) → Node
The instance's root as shown at its call (root and call each as shown in their own scope): one box with the call's size and placement (its layout but for padding), visible the AND of both, opacity their product, the call's pointer reactions after the root's and the call's behaviors over the root's, key by key.
setJsonPath(Object? root, List<PathKey> keys, Object? value) → Json?
setJsonPathValue for a JSON object root.
setJsonPathValue(Object? root, List<PathKey> keys, Object? value) → Object?
Sets keys in JSON root (copied along the way) to value. Maps are created for missing keys; an index past a list's end (or a list missing) fails. Null when it can't be set.
settingSlug(String label) → String
label as a setting key: lower case, runs of other characters as _.
shimmerFields() → List<PropDef<Object?>>
springFields() → List<PropDef<Object?>>
stateStylesFields() → List<PropDef<Object?>>
stickyFields() → List<PropDef<Object?>>
textRunFields() → List<PropDef<Object?>>
textStyleFields() → List<PropDef<Object?>>
tiltFields() → List<PropDef<Object?>>
toolInputText(List<EditOp> ops, {int? baseRev}) → String
ops as a ui_apply tool input, the way a model streams it: compact JSON, one op per line.
text's links as ui_docs lookups: [x](forms.md#forms-validation) is x (ui_docs "forms-validation"), [x](forms.md) is x (ui_docs "forms"); a link within the base keeps its text only.
toRuntimeLinksIf(String s, bool runtime) → String
trackFields() → List<PropDef<Object?>>
transformGestureFields() → List<PropDef<Object?>>
transformHandlesFields() → List<PropDef<Object?>>
transitionFields() → List<PropDef<Object?>>
transitionRevealFields() → List<PropDef<Object?>>
transitionSideFields() → List<PropDef<Object?>>
typewriterFields() → List<PropDef<Object?>>
uiApplyCompactInputSchema() → Json
The compact ui_apply input schema: the op envelope, strictly (op names, field names and kinds from EditOp.specs); a node is any object, its contents described by the starter and checked by validation.
uiApplyInputSchema(Catalog catalog) → Json
The ui_apply tool input's JSON Schema, for catalog's node types.
uiLints(LayoutDocument document, {Iterable<String>? ids, GlyphCoverage? hasGlyph}) → List<EditDiagnostic>
Lints document (or only the nodes ids): empty_button, dead_control and low_contrast warnings, and with hasGlyph, missing_glyph.
uiTools(Catalog catalog, {bool compact = false, bool docs = false}) → List<Json>
The two tools, as {"name", "description", "input_schema"} (the shape most providers take; rename input_schema for one that differs). compact: the op envelope only (uiApplyCompactInputSchema), for a system prompt that describes the nodes (runtimeStarter); otherwise every node type and key of catalog is in the schema. docs: also ui_docs, the full reference one topic at a time (docsTopic).
unionForm(PropType type, Object? v) → String?
The form a union-typed value v of type is written in (what decides whether a patch merges into it or replaces it), or null when type has one form only, or v names none.
unresolvedReferences(LayoutDocument document, EditCheck check, {required Catalog catalog, required Iterable<String> nodes, Map<String, Set<String>> variables = const {}}) → List<EditDiagnostic>
What check still finds unresolved in document once a stream has ended: the references (streamReferenceCodes) of the nodes and variables (scope → names) the stream changed that were accepted as warnings while it ran ("it must exist when the stream ends") and never arrived, now errors (op -1; the ops stay applied). A formula that reads a name nothing declares, such as an item's field written without its item (filter(rows, status == 'Paid')), is reported here.
viewProgressFields() → List<PropDef<Object?>>
waveFields() → List<PropDef<Object?>>
writeDouble(double v) → num
Rounds a double for storage: integral values become ints, others keep up to 4 decimals (sub-pixel noise from editors goes away).
writeExprPoints(Expr<List<Vec?>> e) → Object?
writeExprVec(Expr<Vec> e) → Object?
readExprVec's JSON; a one-number vector is written as the number.
writePaints(List<Expr<DrawPaint>> paints) → Object?
readPaints' JSON: a single paint unwrapped.
writePoints(List<Vec?> points) → List<Object?>
writeRatio(double v) → num
A ratio for storage: integral values become ints, others keep 12 significant decimals. Rounding a ratio to 4 decimals (writeDouble) is off by up to 0.00005 per unit, which a size scales: 320/180 stored as 1.7778 made a 300 px drawing 168.748 tall instead of 168.75.
writeVec(Vec v) → List<Object?>
A Vec as JSON.

Typedefs

ActionDecoder = ActionDef Function(Json json, ActionCommon common)
Decodes one action type's JSON (json is the whole object).
ChildFitRule = String? Function(Node parent, SizeFit fit, bool horizontal)
Why fit isn't allowed on a child of parent along the horizontal axis, or null when it is.
DocTask = ({String anchor, String need})
A need and the section that answers it (the index's task table).
EditCheck = List<EditDiagnostic> Function(EditCheckInput input)
Checks the nodes an op touched; errors reject the op. catalogCheck is the core's; strictEditCheck (package:codelessly_api/validate.dart) runs the strict validator on them.
GlyphCoverage = bool Function(String? family, int codepoint)
Whether the font a text is drawn with (family: its fontFamily, null for the default) has a glyph for codepoint.
IconGlyph = Json
An icon glyph, as IconProps.icon holds it: {"source", "codepoint", "name", "style", "fontFamily"?, ...} or {"image": url}.
Json = Map<String, Object?>
A JSON object.
PathKey = Object
One step of a binding path: a key, an index ([2]), or every item (*).
SchemaMigration = Json Function(Json document, {MigrationReport? report})
One step that upgrades a document's JSON from schema n - 1 to n.
Vec = List<Expr<double>>
A list of numbers (a point [x, y], a rect [left, top, width, height], a scale, a matrix), each a literal or an expression.