@elaraai/e3-ui 1.0.103 → 1.0.105

package/dist/src/flowchart/types.d.ts

@@ -2,7 +2,17 @@
  * Copyright (c) 2025 Elara AI Pty Ltd
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
-import { ArrayType, DateTimeType, DictType, FloatType, IntegerType, NullType, OptionType, StringType, StructType, VariantType } from "@elaraai/east";
+/**
+ * The Flowchart's East types (#1500, `Flowchart Records Spec.md` §3): the
+ * value types its accessors return and its canvas carries (`Flowchart.Types`)
+ * — an app's records hold their own types, which the kinds map — and the
+ * kinds' wire: each kind closed over the app's record behind East functions
+ * over beast2 bytes, as the Schematic's are, so the payload is one type
+ * whatever the rows hold.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, BlobType, BooleanType, DateTimeType, DictType, FloatType, FunctionType, IntegerType, NullType, OptionType, StringType, StructType, VariantType } from "@elaraai/east";
 /**
  * Link kind — the transition's provenance class.
  *
@@ -47,7 +57,8 @@ export declare const FlowchartOrientationType: VariantType<{
  */
 export type FlowchartOrientationType = typeof FlowchartOrientationType;
 /**
- * Imported evidence carried by a link — never hand-authored.
+ * Imported evidence carried by a transition — never hand-authored: what a
+ * transitions kind's `evidence` accessor builds from the app's own fields.
  *
  * @remarks
  * Evidence drives derived marks only: stroke weight scales with `volume`
@@ -75,70 +86,72 @@ export declare const FlowchartEvidenceType: StructType<{
  */
 export type FlowchartEvidenceType = typeof FlowchartEvidenceType;
 /**
- * One state — a node in the flowchart.
+ * Eyebrow freshness chip content.
  *
- * @remarks
- * The short mono `key` is the node identity everywhere (selection events,
- * link `from` / `to` refs, trigger queues). A state with `members` set is
- * a STATE CLASS — one node standing for N interchangeable members (the
- * `×N` badge). In-place transitions (`from == to` links) collapse to the
- * `↻ n` badge on the node and never route through handles.
+ * @property label - Chip label ("evidence-2026.06")
+ * @property date - Optional stamp printed after the label
+ */
+export declare const FlowchartFreshnessType: StructType<{
+    /** Chip label ("evidence-2026.06") */
+    readonly label: StringType;
+    /** Optional stamp printed after the label */
+    readonly date: OptionType<DateTimeType>;
+}>;
+/**
+ * Type representing the freshness chip.
+ */
+export type FlowchartFreshnessType = typeof FlowchartFreshnessType;
+/**
+ * A state's roles, as its kind reads them from the app's row (R2).
  *
- * @property key - Short mono code — the node identity ("IND")
- * @property label - Display label under the code
- * @property lane - The lane (ordered phase) this state belongs to
- * @property members - State-class member count → the ×N badge
- * @property notes - Free-text notes, shown and edited in the inspector
+ * @property label - Its card's name: its `label` field, empty for an Option field holding none
+ * @property lane - The lane it stands in, by the lane's key: its `lane` field; `none` for a kind with no `lane`
+ * @property order - Its place in its lane: its `order` field; `none` for a kind with no `order`, whose states stand by key
+ * @property members - A class of interchangeable states: the ×N badge, its `members` accessor's
  */
-export declare const FlowchartStateType: StructType<{
-    /** Short mono code — the node identity ("IND") */
-    readonly key: StringType;
-    /** Display label under the code */
-    readonly label: OptionType<StringType>;
-    /** The lane (ordered phase) this state belongs to */
-    readonly lane: StringType;
-    /** State-class member count → the ×N badge */
+export declare const FlowchartStateRolesType: StructType<{
+    readonly label: StringType;
+    readonly lane: OptionType<StringType>;
+    readonly order: OptionType<FloatType>;
     readonly members: OptionType<IntegerType>;
-    /** Free-text notes, shown and edited in the inspector */
-    readonly notes: OptionType<StringType>;
 }>;
+/** Type representing a state's roles. */
+export type FlowchartStateRolesType = typeof FlowchartStateRolesType;
 /**
- * Type representing flowchart states.
+ * What a gesture writes into a state's row (R8): each role's field, `none`
+ * leaving it as it was — or, for a new row, as a card's values give it, else
+ * its type's default.
+ *
+ * @property label - Its label: a rename; an empty label is `none` in an Option field
+ * @property lane - Its lane's key: a move across lanes
+ * @property order - Its place in its lane: a move between two cards
  */
-export type FlowchartStateType = typeof FlowchartStateType;
+export declare const FlowchartStateWriteType: StructType<{
+    readonly label: OptionType<StringType>;
+    readonly lane: OptionType<StringType>;
+    readonly order: OptionType<FloatType>;
+}>;
+/** Type representing a state's write. */
+export type FlowchartStateWriteType = typeof FlowchartStateWriteType;
 /**
- * One link — a state transition drawn as an H/V-routed arrow.
+ * A transition's roles, as its kind reads them from the app's row (R2).
  *
- * @remarks
- * `from` / `to` are state keys; a reference with no state row renders the
- * neg-dashed ghost "No state row" node (derived, counted in the footer).
- * At most one `trigger` per link — the lettered decision diamond anchored
- * to the midpoint of the longest straight run.
- *
- * @property key - Stable identity (selection / delete events); default derived from endpoints
- * @property from - Source state key
- * @property to - Target state key
- * @property kind - planned (default) | observed
- * @property trigger - 0..1 decision trigger key → diamond
- * @property evidence - Imported evidence (weight, badges, provenance)
+ * @property from - The state it leaves, by key
+ * @property to - The state it enters, by key
+ * @property decision - The decision that governs it, by key; `none` for none, an empty String field among them
+ * @property kind - Planned or observed: its `kind` accessor's, planned unless given
+ * @property evidence - The label's evidence line and the stroke's weight: its `evidence` accessor's
  */
-export declare const FlowchartLinkType: StructType<{
-    /** Stable identity (selection / delete events); default derived from endpoints */
-    readonly key: OptionType<StringType>;
-    /** Source state key */
+export declare const FlowchartTransitionRolesType: StructType<{
     readonly from: StringType;
-    /** Target state key */
     readonly to: StringType;
-    /** planned (default) | observed */
-    readonly kind: OptionType<VariantType<{
+    readonly decision: OptionType<StringType>;
+    readonly kind: VariantType<{
         /** A designed / expected transition (solid stroke) */
         readonly planned: NullType;
         /** A transition mined from evidence (dashed stroke) */
         readonly observed: NullType;
-    }>>;
-    /** 0..1 decision trigger key → diamond */
-    readonly trigger: OptionType<StringType>;
-    /** Imported evidence (weight, badges, provenance) */
+    }>;
     readonly evidence: OptionType<StructType<{
         /** Total measured volume behind the arrow */
         readonly volume: OptionType<FloatType>;
@@ -150,121 +163,105 @@ export declare const FlowchartLinkType: StructType<{
         readonly unit: OptionType<StringType>;
     }>>;
 }>;
+/** Type representing a transition's roles. */
+export type FlowchartTransitionRolesType = typeof FlowchartTransitionRolesType;
 /**
- * Type representing flowchart links.
+ * What a gesture writes into a transition's row (R8): its ends — Connect and
+ * a retarget — and its decision, each `none` leaving it as it was, or for a
+ * new row as a card's values give it, else its type's default.
+ *
+ * @property from - The state it leaves, by key
+ * @property to - The state it enters, by key
+ * @property decision - The decision that governs it: `some(none)` clears it — a decision's Del — and `some(some(key))` names one
  */
-export type FlowchartLinkType = typeof FlowchartLinkType;
+export declare const FlowchartTransitionWriteType: StructType<{
+    readonly from: OptionType<StringType>;
+    readonly to: OptionType<StringType>;
+    readonly decision: OptionType<OptionType<StringType>>;
+}>;
+/** Type representing a transition's write. */
+export type FlowchartTransitionWriteType = typeof FlowchartTransitionWriteType;
 /**
- * One lane — an ordered phase band.
+ * A lane's roles, as its kind reads them from the app's row (R2).
  *
- * @remarks
- * Lane order is array order; every state names its lane by `key`. The
- * dashed `+ LANE` affordance renders at the tail of the band row.
- *
- * @property key - Lane identity referenced by states
- * @property label - Band header label (defaults to the key, uppercased)
+ * @property label - Its header: its `label` field, empty for an Option field holding none
+ * @property order - Its place among the lanes: its `order` field, an Integer one read as a Float; `none` for a kind with no `order`, whose lanes stand by key
  */
-export declare const FlowchartLaneType: StructType<{
-    /** Lane identity referenced by states */
-    readonly key: StringType;
-    /** Band header label (defaults to the key, uppercased) */
-    readonly label: OptionType<StringType>;
+export declare const FlowchartLaneRolesType: StructType<{
+    readonly label: StringType;
+    readonly order: OptionType<FloatType>;
 }>;
+/** Type representing a lane's roles. */
+export type FlowchartLaneRolesType = typeof FlowchartLaneRolesType;
 /**
- * Type representing flowchart lanes.
+ * What a gesture writes into a lane's row (R8): + LANE, a rename and a card
+ * dropped between two lanes — each role's field, `none` leaving it as it was,
+ * or for a new row as a card's values give it, else its type's default. An
+ * `order` an Integer field can't hold — between two whole numbers — is refused
+ * (`none` from the write), and the renderer moves the lanes after it on.
+ *
+ * @property label - Its header
+ * @property order - Its place among the lanes
  */
-export type FlowchartLaneType = typeof FlowchartLaneType;
+export declare const FlowchartLaneWriteType: StructType<{
+    readonly label: OptionType<StringType>;
+    readonly order: OptionType<FloatType>;
+}>;
+/** Type representing a lane's write. */
+export type FlowchartLaneWriteType = typeof FlowchartLaneWriteType;
 /**
- * One decision trigger — a governed decision seam referenced by links.
+ * A decision's roles, as its kind reads them from the app's row (R2).
  *
- * @remarks
- * Triggers render as diamonds (max one per link) carrying a letter per
- * TYPE, not per instance. Clicking a diamond highlights every link it
- * governs (plus queue and outcome nodes).
- *
- * @property key - Trigger identity referenced by links
- * @property label - Decision name ("route")
- * @property letter - Diamond letter (default: first letter of the label)
- * @property owner - Owning role / system ("sort-planner")
- * @property queue - State keys queued at the decision
- * @property outcomes - Outcome summary line ("CH* (×14 chutes)")
+ * @property label - Its name: its `label` accessor's
+ * @property letter - The diamond's letter: its `letter` accessor's; `none`, the label's first
+ * @property owner - Who owns it: its `owner` accessor's
+ * @property outcomes - Its outcomes' summary line: its `outcomes` accessor's
+ * @property queue - The states queued at it, by key: its `queue` field, a Set's in its order; empty for a kind with no `queue`
  */
-export declare const FlowchartTriggerType: StructType<{
-    /** Trigger identity referenced by links */
-    readonly key: StringType;
-    /** Decision name ("route") */
+export declare const FlowchartDecisionRolesType: StructType<{
     readonly label: StringType;
-    /** Diamond letter (default: first letter of the label) */
     readonly letter: OptionType<StringType>;
-    /** Owning role / system ("sort-planner") */
     readonly owner: OptionType<StringType>;
-    /** State keys queued at the decision */
-    readonly queue: OptionType<ArrayType<StringType>>;
-    /** Outcome summary line ("CH* (×14 chutes)") */
     readonly outcomes: OptionType<StringType>;
+    readonly queue: ArrayType<StringType>;
 }>;
+/** Type representing a decision's roles. */
+export type FlowchartDecisionRolesType = typeof FlowchartDecisionRolesType;
 /**
- * Type representing flowchart triggers.
- */
-export type FlowchartTriggerType = typeof FlowchartTriggerType;
-/**
- * One flow — a whole flowchart: its lanes, its states, the transitions
- * between them and the decisions that govern them (#1244, `Flowchart Builder
- * Spec.md` §5.1).
- *
- * @remarks
- * A record of flows holds one per name ({@link FlowchartFlowsType}), and a
- * lone flow is a record of one entry, or the host's `data`. `Flowchart.value`
- * writes one from a literal, and `Flowchart.over` builds one from an app's
- * own tables. A record's entries are flows, so it is a stored form.
+ * One stored row as a kind's `rows` gives it: its roles, read in the pass
+ * that reads the row, and the row as bytes at the record's row type — what a
+ * write and the editing session take.
  *
- * @property description - One sentence about the flow: the line its card in the Flows tab shows
- * @property lanes - Its lanes, in band order
- * @property states - Its states, each in one of its lanes
- * @property links - Its transitions; one naming a state the flow does not have draws as the unresolved ghost
- * @property triggers - Its decisions, each named by the transitions it governs
+ * @typeParam R - The roles' type
+ * @param roles - The roles' type
+ * @returns The entry's type
  */
-export declare const FlowchartFlowType: StructType<{
-    /** One sentence about the flow: the line its card in the Flows tab shows */
-    readonly description: OptionType<StringType>;
-    /** Its lanes, in band order */
-    readonly lanes: ArrayType<StructType<{
-        /** Lane identity referenced by states */
-        readonly key: StringType;
-        /** Band header label (defaults to the key, uppercased) */
-        readonly label: OptionType<StringType>;
-    }>>;
-    /** Its states, each in one of its lanes */
-    readonly states: ArrayType<StructType<{
-        /** Short mono code — the node identity ("IND") */
-        readonly key: StringType;
-        /** Display label under the code */
-        readonly label: OptionType<StringType>;
-        /** The lane (ordered phase) this state belongs to */
-        readonly lane: StringType;
-        /** State-class member count → the ×N badge */
+export declare function FlowchartEntryType<R extends StructType>(roles: R): StructType<{
+    readonly roles: R;
+    readonly row: BlobType;
+}>;
+/** One stored state: its roles and its row's bytes. */
+export declare const FlowchartStateEntryType: StructType<{
+    readonly roles: StructType<{
+        readonly label: StringType;
+        readonly lane: OptionType<StringType>;
+        readonly order: OptionType<FloatType>;
         readonly members: OptionType<IntegerType>;
-        /** Free-text notes, shown and edited in the inspector */
-        readonly notes: OptionType<StringType>;
-    }>>;
-    /** Its transitions; one naming a state the flow does not have draws as the unresolved ghost */
-    readonly links: ArrayType<StructType<{
-        /** Stable identity (selection / delete events); default derived from endpoints */
-        readonly key: OptionType<StringType>;
-        /** Source state key */
+    }>;
+    readonly row: BlobType;
+}>;
+/** One stored transition: its roles and its row's bytes. */
+export declare const FlowchartTransitionEntryType: StructType<{
+    readonly roles: StructType<{
         readonly from: StringType;
-        /** Target state key */
         readonly to: StringType;
-        /** planned (default) | observed */
-        readonly kind: OptionType<VariantType<{
+        readonly decision: OptionType<StringType>;
+        readonly kind: VariantType<{
             /** A designed / expected transition (solid stroke) */
             readonly planned: NullType;
             /** A transition mined from evidence (dashed stroke) */
             readonly observed: NullType;
-        }>>;
-        /** 0..1 decision trigger key → diamond */
-        readonly trigger: OptionType<StringType>;
-        /** Imported evidence (weight, badges, provenance) */
+        }>;
         readonly evidence: OptionType<StructType<{
             /** Total measured volume behind the arrow */
             readonly volume: OptionType<FloatType>;
@@ -275,74 +272,1269 @@ export declare const FlowchartFlowType: StructType<{
             /** Volume unit suffix for badges ("parcels") */
             readonly unit: OptionType<StringType>;
         }>>;
-    }>>;
-    /** Its decisions, each named by the transitions it governs */
-    readonly triggers: ArrayType<StructType<{
-        /** Trigger identity referenced by links */
-        readonly key: StringType;
-        /** Decision name ("route") */
+    }>;
+    readonly row: BlobType;
+}>;
+/** One stored lane: its roles and its row's bytes. */
+export declare const FlowchartLaneEntryType: StructType<{
+    readonly roles: StructType<{
+        readonly label: StringType;
+        readonly order: OptionType<FloatType>;
+    }>;
+    readonly row: BlobType;
+}>;
+/** One stored decision: its roles and its row's bytes. */
+export declare const FlowchartDecisionEntryType: StructType<{
+    readonly roles: StructType<{
         readonly label: StringType;
-        /** Diamond letter (default: first letter of the label) */
         readonly letter: OptionType<StringType>;
-        /** Owning role / system ("sort-planner") */
         readonly owner: OptionType<StringType>;
-        /** State keys queued at the decision */
-        readonly queue: OptionType<ArrayType<StringType>>;
-        /** Outcome summary line ("CH* (×14 chutes)") */
         readonly outcomes: OptionType<StringType>;
+        readonly queue: ArrayType<StringType>;
+    }>;
+    readonly row: BlobType;
+}>;
+/**
+ * One card a kind's library tab lists, read from a record the app keeps
+ * (R14): dropped, it makes a row of its kind from its values.
+ *
+ * @property key - Its key: its record's key
+ * @property name - Its card's name
+ * @property group - The tab's group it sits under
+ * @property values - Every field of the row but those a drop writes — a state's lane and order, a transition's ends, a lane's order — as bytes
+ */
+export declare const FlowchartTemplateType: StructType<{
+    readonly key: StringType;
+    readonly name: StringType;
+    readonly group: OptionType<StringType>;
+    readonly values: BlobType;
+}>;
+/** Type representing a card. */
+export type FlowchartTemplateType = typeof FlowchartTemplateType;
+/**
+ * A tag's look, as a Tag takes it (R30): east-ui's `ColorSchemeType` and
+ * `StyleVariantType`. `Flowchart.Types.TagColor`, for an app that keeps its
+ * looks as data — an Array of them, the first ranked first.
+ *
+ * @property tag - The tag
+ * @property colorPalette - Its palette
+ * @property variant - Its variant: `subtle`, a 6% wash of its palette on a 1px rule of it, unless the app gives another
+ */
+export declare const FlowchartTagColorType: StructType<{
+    readonly tag: StringType;
+    readonly colorPalette: VariantType<{
+        readonly brand: NullType;
+        readonly gray: NullType;
+        readonly red: NullType;
+        readonly orange: NullType;
+        readonly yellow: NullType;
+        readonly green: NullType;
+        readonly teal: NullType;
+        readonly blue: NullType;
+        readonly cyan: NullType;
+        readonly purple: NullType;
+        readonly pink: NullType;
+        readonly success: NullType;
+        readonly warning: NullType;
+        readonly danger: NullType;
+        readonly info: NullType;
+        readonly neutral: NullType;
+    }>;
+    readonly variant: VariantType<{
+        readonly subtle: NullType;
+        readonly solid: NullType;
+        readonly outline: NullType;
+        readonly brand: NullType;
+        readonly ok: NullType;
+        readonly warn: NullType;
+        readonly danger: NullType;
+        readonly dashed: NullType;
+        readonly plain: NullType;
+        readonly count: NullType;
+        readonly callout: NullType;
+    }>;
+}>;
+/** Type representing a tag's look. */
+export type FlowchartTagColorType = typeof FlowchartTagColorType;
+/**
+ * Where a read shows (R21): `all`, the default — on the canvas, a state's
+ * card or a transition's label, and in the inspector; `canvas` — there alone;
+ * `inspector` — in the inspector alone. A variant, as the Schematic carries
+ * its narrowed `show`.
+ *
+ * @property all - On the canvas and in the inspector
+ * @property canvas - On the canvas alone
+ * @property inspector - In the inspector alone
+ */
+export declare const FlowchartShowType: VariantType<{
+    readonly all: NullType;
+    readonly canvas: NullType;
+    readonly inspector: NullType;
+}>;
+/** Type representing where a read shows. */
+export type FlowchartShowType = typeof FlowchartShowType;
+/**
+ * A read, described (R20): what it draws a row's value as, and in which
+ * words.
+ *
+ * @property figure - A number: its label, and its unit
+ * @property histogram - Counts by duration: its label, its durations' unit, what is counted, the app's bins — none, every
+ *   row's edges merged — how the bars space them, and the edges the axis names — none, round durations
+ * @property list - Items by name: its label, its unit, and how many lines it draws on the canvas — 2 on a card and 1 on a
+ *   label unless given, at most 3
+ * @property tags - The row's tags: its label, each tag's look, first defined first shown, and whether the canvas's legend lists them
+ */
+export declare const FlowchartReadType: VariantType<{
+    readonly figure: StructType<{
+        readonly label: StringType;
+        readonly unit: OptionType<StringType>;
+    }>;
+    readonly histogram: StructType<{
+        readonly label: StringType;
+        readonly unit: VariantType<{
+            readonly minutes: NullType;
+            readonly hours: NullType;
+            readonly days: NullType;
+        }>;
+        readonly counts: OptionType<StringType>;
+        readonly bins: OptionType<ArrayType<FloatType>>;
+        readonly scale: VariantType<{
+            readonly band: NullType;
+            readonly linear: NullType;
+        }>;
+        readonly ticks: OptionType<ArrayType<StructType<{
+            readonly at: FloatType;
+            readonly label: OptionType<StringType>;
+        }>>>;
+    }>;
+    readonly list: StructType<{
+        readonly label: StringType;
+        readonly unit: OptionType<StringType>;
+        readonly top: IntegerType;
+    }>;
+    readonly tags: StructType<{
+        readonly label: StringType;
+        readonly colors: ArrayType<StructType<{
+            readonly tag: StringType;
+            readonly colorPalette: VariantType<{
+                readonly brand: NullType;
+                readonly gray: NullType;
+                readonly red: NullType;
+                readonly orange: NullType;
+                readonly yellow: NullType;
+                readonly green: NullType;
+                readonly teal: NullType;
+                readonly blue: NullType;
+                readonly cyan: NullType;
+                readonly purple: NullType;
+                readonly pink: NullType;
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly variant: VariantType<{
+                readonly subtle: NullType;
+                readonly solid: NullType;
+                readonly outline: NullType;
+                readonly brand: NullType;
+                readonly ok: NullType;
+                readonly warn: NullType;
+                readonly danger: NullType;
+                readonly dashed: NullType;
+                readonly plain: NullType;
+                readonly count: NullType;
+                readonly callout: NullType;
+            }>;
+        }>>;
+        readonly legend: BooleanType;
+    }>;
+}>;
+/** Type representing a read, described. */
+export type FlowchartReadType = typeof FlowchartReadType;
+/**
+ * What a details row holds (R18): one value a read, in the reads' order.
+ *
+ * @property figure - The number; `none` where the row holds none
+ * @property histogram - Its counts, each at the lower edge of the bin it counts: a Dict's durations as they are, keyed; an
+ *   Array's counts at their bins' edges, in order — or, for an Array whose length is not its bins', every count at `NaN`,
+ *   which no bin holds, so the renderer lists the row in Issues and draws its bars absent (R27, R38)
+ * @property list - Its items as the row holds them, by name: each its value, and the note its draw gives
+ * @property tags - Its tags, in the row's order
+ */
+export declare const FlowchartDetailRowType: ArrayType<VariantType<{
+    readonly figure: OptionType<FloatType>;
+    readonly histogram: ArrayType<StructType<{
+        readonly from: FloatType;
+        readonly count: FloatType;
+    }>>;
+    readonly list: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly value: FloatType;
+        readonly note: OptionType<StringType>;
     }>>;
+    readonly tags: ArrayType<StringType>;
+}>>;
+/** Type representing what a details row holds. */
+export type FlowchartDetailRowType = typeof FlowchartDetailRowType;
+/**
+ * How the rail's picks weigh a kind's details (#1522, R43–R46): the source
+ * whose picks of a Dict field weigh them, and the entries index the field is
+ * filed through. A drawn row's picked entries — the picked keys' ranges of the
+ * index, by the row's key — are what each read the picks weigh draws, added up
+ * by kind; with no pick, every read draws the row's own (`values`).
+ *
+ * @property source - The rail's source whose picks weigh them: a source of the Flowchart's slice over the details' record
+ * @property field - Its Dict field, the one the entries index files entry by entry
+ * @property index - The entries index: its lean rows, under `<index>_rows`, are what the drawn rows are read by key through
+ * @property reads - Whether the picks weigh each read, in the reads' order: one the entries hold, unless it says
+ *   `weigh: false`. A row holding none of the picks says *no data* in these, and draws the row's own in the others
+ * @property fold - A row's values, from its bytes and its picked entries' bytes, each an entry's value, in the entries'
+ *   key order: one a read, in the reads' order
+ */
+export declare const FlowchartWeighedType: StructType<{
+    readonly source: StringType;
+    readonly field: StringType;
+    readonly index: StringType;
+    readonly reads: ArrayType<BooleanType>;
+    readonly fold: FunctionType<[BlobType, ArrayType<BlobType>], ArrayType<VariantType<{
+        readonly figure: OptionType<FloatType>;
+        readonly histogram: ArrayType<StructType<{
+            readonly from: FloatType;
+            readonly count: FloatType;
+        }>>;
+        readonly list: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly value: FloatType;
+            readonly note: OptionType<StringType>;
+        }>>;
+        readonly tags: ArrayType<StringType>;
+    }>>>;
 }>;
+/** Type representing how the rail's picks weigh a kind's details. */
+export type FlowchartWeighedType = typeof FlowchartWeighedType;
 /**
- * Type representing one flow.
+ * A kind's details, closed (R18, R19): each read described once, and the
+ * rows' values, read as the kind is — whole, or by the drawn rows' keys
+ * through the paged read named. The details' row type never reaches the
+ * payload: `values` turns a row into one value a read.
+ *
+ * @property reads - Every read, in the details' order, each where it shows
+ * @property rows - The details read whole, beside a kind read whole: `()` → each row's bytes, by key, `none` while the read
+ *   is in flight; `none` beside a kind read through its source
+ * @property paged - The paged read the details are read by key through, beside a kind read through its source: the drawn
+ *   rows' keys, every key in one request; `none` beside a kind read whole
+ * @property values - A row's values, from its bytes: one a read, in the reads' order
+ * @property weighed - How the rail's picks weigh them (#1522, R43–R46), for details that name a source; `none` for any
+ *   other. They are read by key whatever their kind's read, `paged` naming the binding.
  */
-export type FlowchartFlowType = typeof FlowchartFlowType;
+export declare const FlowchartDetailsType: StructType<{
+    readonly reads: ArrayType<StructType<{
+        readonly show: VariantType<{
+            readonly all: NullType;
+            readonly canvas: NullType;
+            readonly inspector: NullType;
+        }>;
+        readonly read: VariantType<{
+            readonly figure: StructType<{
+                readonly label: StringType;
+                readonly unit: OptionType<StringType>;
+            }>;
+            readonly histogram: StructType<{
+                readonly label: StringType;
+                readonly unit: VariantType<{
+                    readonly minutes: NullType;
+                    readonly hours: NullType;
+                    readonly days: NullType;
+                }>;
+                readonly counts: OptionType<StringType>;
+                readonly bins: OptionType<ArrayType<FloatType>>;
+                readonly scale: VariantType<{
+                    readonly band: NullType;
+                    readonly linear: NullType;
+                }>;
+                readonly ticks: OptionType<ArrayType<StructType<{
+                    readonly at: FloatType;
+                    readonly label: OptionType<StringType>;
+                }>>>;
+            }>;
+            readonly list: StructType<{
+                readonly label: StringType;
+                readonly unit: OptionType<StringType>;
+                readonly top: IntegerType;
+            }>;
+            readonly tags: StructType<{
+                readonly label: StringType;
+                readonly colors: ArrayType<StructType<{
+                    readonly tag: StringType;
+                    readonly colorPalette: VariantType<{
+                        readonly brand: NullType;
+                        readonly gray: NullType;
+                        readonly red: NullType;
+                        readonly orange: NullType;
+                        readonly yellow: NullType;
+                        readonly green: NullType;
+                        readonly teal: NullType;
+                        readonly blue: NullType;
+                        readonly cyan: NullType;
+                        readonly purple: NullType;
+                        readonly pink: NullType;
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly variant: VariantType<{
+                        readonly subtle: NullType;
+                        readonly solid: NullType;
+                        readonly outline: NullType;
+                        readonly brand: NullType;
+                        readonly ok: NullType;
+                        readonly warn: NullType;
+                        readonly danger: NullType;
+                        readonly dashed: NullType;
+                        readonly plain: NullType;
+                        readonly count: NullType;
+                        readonly callout: NullType;
+                    }>;
+                }>>;
+                readonly legend: BooleanType;
+            }>;
+        }>;
+    }>>;
+    readonly rows: OptionType<FunctionType<[], OptionType<DictType<StringType, BlobType>>>>;
+    readonly paged: OptionType<StringType>;
+    readonly values: FunctionType<[BlobType], ArrayType<VariantType<{
+        readonly figure: OptionType<FloatType>;
+        readonly histogram: ArrayType<StructType<{
+            readonly from: FloatType;
+            readonly count: FloatType;
+        }>>;
+        readonly list: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly value: FloatType;
+            readonly note: OptionType<StringType>;
+        }>>;
+        readonly tags: ArrayType<StringType>;
+    }>>>;
+    readonly weighed: OptionType<StructType<{
+        readonly source: StringType;
+        readonly field: StringType;
+        readonly index: StringType;
+        readonly reads: ArrayType<BooleanType>;
+        readonly fold: FunctionType<[BlobType, ArrayType<BlobType>], ArrayType<VariantType<{
+            readonly figure: OptionType<FloatType>;
+            readonly histogram: ArrayType<StructType<{
+                readonly from: FloatType;
+                readonly count: FloatType;
+            }>>;
+            readonly list: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly value: FloatType;
+                readonly note: OptionType<StringType>;
+            }>>;
+            readonly tags: ArrayType<StringType>;
+        }>>>;
+    }>>;
+}>;
+/** Type representing a kind's details, closed. */
+export type FlowchartDetailsType = typeof FlowchartDetailsType;
 /**
- * A record of flows, by name — the record a flowchart is bound to (#1244,
- * `Flowchart Builder Spec.md` §5.1): a record always holds flows by name, e3's
- * patch mutation writing only keyed records. A name is the flow's key in the
- * record. `Flowchart.values` writes one from literals.
+ * The states, closed (§3): a record of the app's, read whole or complete
+ * through their source of the slice.
+ *
+ * @property rows - Its stored states a read holds, by key, each its roles and its row: its record read whole, or its narrowing read complete through its source
+ * @property rowsOf - Rows a reader read by key through the states' source of the slice, as beast2 bytes of an `Array` of `{ key, row }`, made its stored states: a hidden end's, and Find's
+ * @property read - A drafted row's roles, from its bytes and its key
+ * @property write - The row with a gesture's roles written and every other field as it was
+ * @property create - A new row from a gesture's roles, every other field a card's values, or its type's default
+ * @property laneField - The field naming a state's lane by the lane's key, `none` without lanes: a conflict on it named by the lane's label
+ * @property templates - Its cards, the Steps tab's
+ * @property templatesSource - The slice's source its cards follow
+ * @property details - Its details over the app's rows keyed as the states are, read only, drawn on each card and in the
+ *   inspector (#1507); `none` for states with none, which keep today's cards
  */
-export declare const FlowchartFlowsType: DictType<StringType, StructType<{
-    /** One sentence about the flow: the line its card in the Flows tab shows */
-    readonly description: OptionType<StringType>;
-    /** Its lanes, in band order */
-    readonly lanes: ArrayType<StructType<{
-        /** Lane identity referenced by states */
-        readonly key: StringType;
-        /** Band header label (defaults to the key, uppercased) */
-        readonly label: OptionType<StringType>;
+export declare const FlowchartStateKindType: StructType<{
+    readonly editable: BooleanType;
+    readonly editing: OptionType<StructType<{
+        sourceId: StringType;
+        entryType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        idField: OptionType<StringType>;
+        draftType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        children: OptionType<StringType>;
+        keyType: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>>;
+        snapshot: OptionType<BlobType>;
+        readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+        onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+        onApply: OptionType<VariantType<{
+            readonly sync: FunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+            readonly async: import("@elaraai/east").AsyncFunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+        }>>;
+        mode: VariantType<{
+            readonly batch: NullType;
+            readonly auto: NullType;
+        }>;
     }>>;
-    /** Its states, each in one of its lanes */
-    readonly states: ArrayType<StructType<{
-        /** Short mono code — the node identity ("IND") */
-        readonly key: StringType;
-        /** Display label under the code */
-        readonly label: OptionType<StringType>;
-        /** The lane (ordered phase) this state belongs to */
-        readonly lane: StringType;
-        /** State-class member count → the ×N badge */
+    readonly entries: OptionType<StructType<{
+        readonly revision: FunctionType<[], OptionType<StringType>>;
+        readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+        readonly entry: FunctionType<[StringType], OptionType<OptionType<BlobType>>>;
+        readonly last: FunctionType<[], OptionType<OptionType<StringType>>>;
+    }>>;
+    readonly history: OptionType<FunctionType<[], OptionType<ArrayType<StructType<{
+        readonly hash: StringType;
+        readonly parent: OptionType<StringType>;
+        readonly state: StringType;
+        readonly mutation: StringType;
+        readonly actor: StringType;
+        readonly at: DateTimeType;
+        readonly delta: OptionType<StringType>;
+    }>>>>>;
+    readonly fields: ArrayType<StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly label: StringType;
+        readonly help: OptionType<StringType>;
+        readonly group: OptionType<StringType>;
+        readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly optional: BooleanType;
+        readonly editor: VariantType<{
+            readonly text: StructType<{
+                readonly placeholder: OptionType<StringType>;
+            }>;
+            readonly number: StructType<{
+                readonly unit: OptionType<StringType>;
+                readonly step: OptionType<FloatType>;
+                readonly min: OptionType<FloatType>;
+                readonly max: OptionType<FloatType>;
+            }>;
+            readonly checkbox: NullType;
+            readonly datetime: StructType<{
+                readonly precision: OptionType<VariantType<{
+                    readonly date: NullType;
+                    readonly time: NullType;
+                    readonly datetime: NullType;
+                }>>;
+            }>;
+            readonly select: ArrayType<StructType<{
+                readonly case: StringType;
+                readonly label: StringType;
+            }>>;
+            readonly tags: StructType<{
+                readonly options: ArrayType<StringType>;
+            }>;
+            readonly checklist: StructType<{
+                readonly text: StringType;
+                readonly done: StringType;
+            }>;
+            readonly reference: StructType<{
+                readonly of: StringType;
+            }>;
+            readonly readonly: NullType;
+        }>;
+    }>>;
+    readonly inspector: OptionType<FunctionType<[BlobType, FunctionType<[BlobType], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    readonly ready: OptionType<FunctionType<[ArrayType<StructType<{
+        readonly id: StringType;
+        readonly entry: BlobType;
+    }>>], ArrayType<VariantType<{
+        readonly ready: NullType;
+        readonly incomplete: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+        readonly invalid: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+    }>>>>;
+    readonly set: FunctionType<[BlobType, ArrayType<StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly value: BlobType;
+    }>>], OptionType<BlobType>>;
+    readonly rowType: import("@elaraai/east").RecursiveType<VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: NullType;
+        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Dict: StructType<{
+            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Recursive: VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    readonly name: StringType;
+    readonly icon: StringType;
+    readonly rows: FunctionType<[], OptionType<DictType<StringType, StructType<{
+        readonly roles: StructType<{
+            readonly label: StringType;
+            readonly lane: OptionType<StringType>;
+            readonly order: OptionType<FloatType>;
+            readonly members: OptionType<IntegerType>;
+        }>;
+        readonly row: BlobType;
+    }>>>>;
+    readonly rowsOf: FunctionType<[BlobType], DictType<StringType, StructType<{
+        readonly roles: StructType<{
+            readonly label: StringType;
+            readonly lane: OptionType<StringType>;
+            readonly order: OptionType<FloatType>;
+            readonly members: OptionType<IntegerType>;
+        }>;
+        readonly row: BlobType;
+    }>>>;
+    readonly read: FunctionType<[BlobType, StringType], StructType<{
+        readonly label: StringType;
+        readonly lane: OptionType<StringType>;
+        readonly order: OptionType<FloatType>;
         readonly members: OptionType<IntegerType>;
-        /** Free-text notes, shown and edited in the inspector */
-        readonly notes: OptionType<StringType>;
     }>>;
-    /** Its transitions; one naming a state the flow does not have draws as the unresolved ghost */
-    readonly links: ArrayType<StructType<{
-        /** Stable identity (selection / delete events); default derived from endpoints */
-        readonly key: OptionType<StringType>;
-        /** Source state key */
+    readonly write: FunctionType<[BlobType, StructType<{
+        readonly label: OptionType<StringType>;
+        readonly lane: OptionType<StringType>;
+        readonly order: OptionType<FloatType>;
+    }>], OptionType<BlobType>>;
+    readonly create: FunctionType<[StructType<{
+        readonly label: OptionType<StringType>;
+        readonly lane: OptionType<StringType>;
+        readonly order: OptionType<FloatType>;
+    }>, OptionType<BlobType>], OptionType<BlobType>>;
+    readonly laneField: OptionType<StringType>;
+    readonly templates: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+        readonly group: OptionType<StringType>;
+        readonly values: BlobType;
+    }>>;
+    readonly templatesSource: OptionType<StringType>;
+    readonly details: OptionType<StructType<{
+        readonly reads: ArrayType<StructType<{
+            readonly show: VariantType<{
+                readonly all: NullType;
+                readonly canvas: NullType;
+                readonly inspector: NullType;
+            }>;
+            readonly read: VariantType<{
+                readonly figure: StructType<{
+                    readonly label: StringType;
+                    readonly unit: OptionType<StringType>;
+                }>;
+                readonly histogram: StructType<{
+                    readonly label: StringType;
+                    readonly unit: VariantType<{
+                        readonly minutes: NullType;
+                        readonly hours: NullType;
+                        readonly days: NullType;
+                    }>;
+                    readonly counts: OptionType<StringType>;
+                    readonly bins: OptionType<ArrayType<FloatType>>;
+                    readonly scale: VariantType<{
+                        readonly band: NullType;
+                        readonly linear: NullType;
+                    }>;
+                    readonly ticks: OptionType<ArrayType<StructType<{
+                        readonly at: FloatType;
+                        readonly label: OptionType<StringType>;
+                    }>>>;
+                }>;
+                readonly list: StructType<{
+                    readonly label: StringType;
+                    readonly unit: OptionType<StringType>;
+                    readonly top: IntegerType;
+                }>;
+                readonly tags: StructType<{
+                    readonly label: StringType;
+                    readonly colors: ArrayType<StructType<{
+                        readonly tag: StringType;
+                        readonly colorPalette: VariantType<{
+                            readonly brand: NullType;
+                            readonly gray: NullType;
+                            readonly red: NullType;
+                            readonly orange: NullType;
+                            readonly yellow: NullType;
+                            readonly green: NullType;
+                            readonly teal: NullType;
+                            readonly blue: NullType;
+                            readonly cyan: NullType;
+                            readonly purple: NullType;
+                            readonly pink: NullType;
+                            readonly success: NullType;
+                            readonly warning: NullType;
+                            readonly danger: NullType;
+                            readonly info: NullType;
+                            readonly neutral: NullType;
+                        }>;
+                        readonly variant: VariantType<{
+                            readonly subtle: NullType;
+                            readonly solid: NullType;
+                            readonly outline: NullType;
+                            readonly brand: NullType;
+                            readonly ok: NullType;
+                            readonly warn: NullType;
+                            readonly danger: NullType;
+                            readonly dashed: NullType;
+                            readonly plain: NullType;
+                            readonly count: NullType;
+                            readonly callout: NullType;
+                        }>;
+                    }>>;
+                    readonly legend: BooleanType;
+                }>;
+            }>;
+        }>>;
+        readonly rows: OptionType<FunctionType<[], OptionType<DictType<StringType, BlobType>>>>;
+        readonly paged: OptionType<StringType>;
+        readonly values: FunctionType<[BlobType], ArrayType<VariantType<{
+            readonly figure: OptionType<FloatType>;
+            readonly histogram: ArrayType<StructType<{
+                readonly from: FloatType;
+                readonly count: FloatType;
+            }>>;
+            readonly list: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly value: FloatType;
+                readonly note: OptionType<StringType>;
+            }>>;
+            readonly tags: ArrayType<StringType>;
+        }>>>;
+        readonly weighed: OptionType<StructType<{
+            readonly source: StringType;
+            readonly field: StringType;
+            readonly index: StringType;
+            readonly reads: ArrayType<BooleanType>;
+            readonly fold: FunctionType<[BlobType, ArrayType<BlobType>], ArrayType<VariantType<{
+                readonly figure: OptionType<FloatType>;
+                readonly histogram: ArrayType<StructType<{
+                    readonly from: FloatType;
+                    readonly count: FloatType;
+                }>>;
+                readonly list: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly value: FloatType;
+                    readonly note: OptionType<StringType>;
+                }>>;
+                readonly tags: ArrayType<StringType>;
+            }>>>;
+        }>>;
+    }>>;
+}>;
+/** Type representing the states, closed. */
+export type FlowchartStateKindType = typeof FlowchartStateKindType;
+/**
+ * The transitions, closed (§3): a record of the app's, read whole or
+ * complete through their source of the slice.
+ *
+ * @property rows - Its stored transitions a read holds, by key, each its roles and its row
+ * @property read - A drafted row's roles, from its bytes and its key
+ * @property write - The row with its ends and its decision written, each where given, and every other field as it was
+ * @property create - A new transition between two states — Connect — every other field a card's values, or its type's default
+ * @property fromField - The field naming its start by its state's key: a conflict on it named by the state's label
+ * @property toField - The field naming its end by its state's key: a conflict on it named by the state's label
+ * @property decisionField - The field naming its decision by the decision's key, `none` without one: a conflict on it named by the decision's label
+ * @property templates - Its cards, the Transitions tab's: dropped on a transition, one gives it its values, its ends kept
+ * @property templatesSource - The slice's source its cards follow
+ * @property details - Its details over the app's rows keyed as the transitions are, read only, drawn as lines under each
+ *   label's evidence and in the inspector (#1507); `none` for transitions with none
+ */
+export declare const FlowchartTransitionKindType: StructType<{
+    readonly editable: BooleanType;
+    readonly editing: OptionType<StructType<{
+        sourceId: StringType;
+        entryType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        idField: OptionType<StringType>;
+        draftType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        children: OptionType<StringType>;
+        keyType: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>>;
+        snapshot: OptionType<BlobType>;
+        readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+        onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+        onApply: OptionType<VariantType<{
+            readonly sync: FunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+            readonly async: import("@elaraai/east").AsyncFunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+        }>>;
+        mode: VariantType<{
+            readonly batch: NullType;
+            readonly auto: NullType;
+        }>;
+    }>>;
+    readonly entries: OptionType<StructType<{
+        readonly revision: FunctionType<[], OptionType<StringType>>;
+        readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+        readonly entry: FunctionType<[StringType], OptionType<OptionType<BlobType>>>;
+        readonly last: FunctionType<[], OptionType<OptionType<StringType>>>;
+    }>>;
+    readonly history: OptionType<FunctionType<[], OptionType<ArrayType<StructType<{
+        readonly hash: StringType;
+        readonly parent: OptionType<StringType>;
+        readonly state: StringType;
+        readonly mutation: StringType;
+        readonly actor: StringType;
+        readonly at: DateTimeType;
+        readonly delta: OptionType<StringType>;
+    }>>>>>;
+    readonly fields: ArrayType<StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly label: StringType;
+        readonly help: OptionType<StringType>;
+        readonly group: OptionType<StringType>;
+        readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly optional: BooleanType;
+        readonly editor: VariantType<{
+            readonly text: StructType<{
+                readonly placeholder: OptionType<StringType>;
+            }>;
+            readonly number: StructType<{
+                readonly unit: OptionType<StringType>;
+                readonly step: OptionType<FloatType>;
+                readonly min: OptionType<FloatType>;
+                readonly max: OptionType<FloatType>;
+            }>;
+            readonly checkbox: NullType;
+            readonly datetime: StructType<{
+                readonly precision: OptionType<VariantType<{
+                    readonly date: NullType;
+                    readonly time: NullType;
+                    readonly datetime: NullType;
+                }>>;
+            }>;
+            readonly select: ArrayType<StructType<{
+                readonly case: StringType;
+                readonly label: StringType;
+            }>>;
+            readonly tags: StructType<{
+                readonly options: ArrayType<StringType>;
+            }>;
+            readonly checklist: StructType<{
+                readonly text: StringType;
+                readonly done: StringType;
+            }>;
+            readonly reference: StructType<{
+                readonly of: StringType;
+            }>;
+            readonly readonly: NullType;
+        }>;
+    }>>;
+    readonly inspector: OptionType<FunctionType<[BlobType, FunctionType<[BlobType], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    readonly ready: OptionType<FunctionType<[ArrayType<StructType<{
+        readonly id: StringType;
+        readonly entry: BlobType;
+    }>>], ArrayType<VariantType<{
+        readonly ready: NullType;
+        readonly incomplete: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+        readonly invalid: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+    }>>>>;
+    readonly set: FunctionType<[BlobType, ArrayType<StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly value: BlobType;
+    }>>], OptionType<BlobType>>;
+    readonly rowType: import("@elaraai/east").RecursiveType<VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: NullType;
+        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Dict: StructType<{
+            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Recursive: VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    readonly name: StringType;
+    readonly icon: StringType;
+    readonly rows: FunctionType<[], OptionType<DictType<StringType, StructType<{
+        readonly roles: StructType<{
+            readonly from: StringType;
+            readonly to: StringType;
+            readonly decision: OptionType<StringType>;
+            readonly kind: VariantType<{
+                /** A designed / expected transition (solid stroke) */
+                readonly planned: NullType;
+                /** A transition mined from evidence (dashed stroke) */
+                readonly observed: NullType;
+            }>;
+            readonly evidence: OptionType<StructType<{
+                /** Total measured volume behind the arrow */
+                readonly volume: OptionType<FloatType>;
+                /** Event count behind the arrow (e.g. cage moves) */
+                readonly count: OptionType<IntegerType>;
+                /** When the evidence was measured */
+                readonly measuredAt: OptionType<DateTimeType>;
+                /** Volume unit suffix for badges ("parcels") */
+                readonly unit: OptionType<StringType>;
+            }>>;
+        }>;
+        readonly row: BlobType;
+    }>>>>;
+    readonly read: FunctionType<[BlobType, StringType], StructType<{
         readonly from: StringType;
-        /** Target state key */
         readonly to: StringType;
-        /** planned (default) | observed */
-        readonly kind: OptionType<VariantType<{
+        readonly decision: OptionType<StringType>;
+        readonly kind: VariantType<{
             /** A designed / expected transition (solid stroke) */
             readonly planned: NullType;
             /** A transition mined from evidence (dashed stroke) */
             readonly observed: NullType;
-        }>>;
-        /** 0..1 decision trigger key → diamond */
-        readonly trigger: OptionType<StringType>;
-        /** Imported evidence (weight, badges, provenance) */
+        }>;
         readonly evidence: OptionType<StructType<{
             /** Total measured volume behind the arrow */
             readonly volume: OptionType<FloatType>;
@@ -354,40 +1546,892 @@ export declare const FlowchartFlowsType: DictType<StringType, StructType<{
             readonly unit: OptionType<StringType>;
         }>>;
     }>>;
-    /** Its decisions, each named by the transitions it governs */
-    readonly triggers: ArrayType<StructType<{
-        /** Trigger identity referenced by links */
+    readonly write: FunctionType<[BlobType, StructType<{
+        readonly from: OptionType<StringType>;
+        readonly to: OptionType<StringType>;
+        readonly decision: OptionType<OptionType<StringType>>;
+    }>], OptionType<BlobType>>;
+    readonly create: FunctionType<[StructType<{
+        readonly from: OptionType<StringType>;
+        readonly to: OptionType<StringType>;
+        readonly decision: OptionType<OptionType<StringType>>;
+    }>, OptionType<BlobType>], OptionType<BlobType>>;
+    readonly fromField: StringType;
+    readonly toField: StringType;
+    readonly decisionField: OptionType<StringType>;
+    readonly templates: ArrayType<StructType<{
         readonly key: StringType;
-        /** Decision name ("route") */
-        readonly label: StringType;
-        /** Diamond letter (default: first letter of the label) */
-        readonly letter: OptionType<StringType>;
-        /** Owning role / system ("sort-planner") */
-        readonly owner: OptionType<StringType>;
-        /** State keys queued at the decision */
-        readonly queue: OptionType<ArrayType<StringType>>;
-        /** Outcome summary line ("CH* (×14 chutes)") */
-        readonly outcomes: OptionType<StringType>;
+        readonly name: StringType;
+        readonly group: OptionType<StringType>;
+        readonly values: BlobType;
     }>>;
-}>>;
+    readonly templatesSource: OptionType<StringType>;
+    readonly details: OptionType<StructType<{
+        readonly reads: ArrayType<StructType<{
+            readonly show: VariantType<{
+                readonly all: NullType;
+                readonly canvas: NullType;
+                readonly inspector: NullType;
+            }>;
+            readonly read: VariantType<{
+                readonly figure: StructType<{
+                    readonly label: StringType;
+                    readonly unit: OptionType<StringType>;
+                }>;
+                readonly histogram: StructType<{
+                    readonly label: StringType;
+                    readonly unit: VariantType<{
+                        readonly minutes: NullType;
+                        readonly hours: NullType;
+                        readonly days: NullType;
+                    }>;
+                    readonly counts: OptionType<StringType>;
+                    readonly bins: OptionType<ArrayType<FloatType>>;
+                    readonly scale: VariantType<{
+                        readonly band: NullType;
+                        readonly linear: NullType;
+                    }>;
+                    readonly ticks: OptionType<ArrayType<StructType<{
+                        readonly at: FloatType;
+                        readonly label: OptionType<StringType>;
+                    }>>>;
+                }>;
+                readonly list: StructType<{
+                    readonly label: StringType;
+                    readonly unit: OptionType<StringType>;
+                    readonly top: IntegerType;
+                }>;
+                readonly tags: StructType<{
+                    readonly label: StringType;
+                    readonly colors: ArrayType<StructType<{
+                        readonly tag: StringType;
+                        readonly colorPalette: VariantType<{
+                            readonly brand: NullType;
+                            readonly gray: NullType;
+                            readonly red: NullType;
+                            readonly orange: NullType;
+                            readonly yellow: NullType;
+                            readonly green: NullType;
+                            readonly teal: NullType;
+                            readonly blue: NullType;
+                            readonly cyan: NullType;
+                            readonly purple: NullType;
+                            readonly pink: NullType;
+                            readonly success: NullType;
+                            readonly warning: NullType;
+                            readonly danger: NullType;
+                            readonly info: NullType;
+                            readonly neutral: NullType;
+                        }>;
+                        readonly variant: VariantType<{
+                            readonly subtle: NullType;
+                            readonly solid: NullType;
+                            readonly outline: NullType;
+                            readonly brand: NullType;
+                            readonly ok: NullType;
+                            readonly warn: NullType;
+                            readonly danger: NullType;
+                            readonly dashed: NullType;
+                            readonly plain: NullType;
+                            readonly count: NullType;
+                            readonly callout: NullType;
+                        }>;
+                    }>>;
+                    readonly legend: BooleanType;
+                }>;
+            }>;
+        }>>;
+        readonly rows: OptionType<FunctionType<[], OptionType<DictType<StringType, BlobType>>>>;
+        readonly paged: OptionType<StringType>;
+        readonly values: FunctionType<[BlobType], ArrayType<VariantType<{
+            readonly figure: OptionType<FloatType>;
+            readonly histogram: ArrayType<StructType<{
+                readonly from: FloatType;
+                readonly count: FloatType;
+            }>>;
+            readonly list: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly value: FloatType;
+                readonly note: OptionType<StringType>;
+            }>>;
+            readonly tags: ArrayType<StringType>;
+        }>>>;
+        readonly weighed: OptionType<StructType<{
+            readonly source: StringType;
+            readonly field: StringType;
+            readonly index: StringType;
+            readonly reads: ArrayType<BooleanType>;
+            readonly fold: FunctionType<[BlobType, ArrayType<BlobType>], ArrayType<VariantType<{
+                readonly figure: OptionType<FloatType>;
+                readonly histogram: ArrayType<StructType<{
+                    readonly from: FloatType;
+                    readonly count: FloatType;
+                }>>;
+                readonly list: ArrayType<StructType<{
+                    readonly name: StringType;
+                    readonly value: FloatType;
+                    readonly note: OptionType<StringType>;
+                }>>;
+                readonly tags: ArrayType<StringType>;
+            }>>>;
+        }>>;
+    }>>;
+}>;
+/** Type representing the transitions, closed. */
+export type FlowchartTransitionKindType = typeof FlowchartTransitionKindType;
 /**
- * Type representing a record of flows.
+ * The lanes, closed (§3): a small record of the app's, read whole.
+ *
+ * @property rows - Its lanes, by key, each its roles and its row; `none` while the read is in flight
+ * @property read - A drafted row's roles, from its bytes and its key
+ * @property write - The row with its label and its order written, each where given, and every other field as it was; `none` for an order an Integer field can't hold
+ * @property create - A new lane from its label and its order, every other field a card's values, or its type's default; `none` as `write` refuses
+ * @property templates - Its cards, the Lanes tab's
+ * @property templatesSource - The slice's source its cards follow
  */
-export type FlowchartFlowsType = typeof FlowchartFlowsType;
+export declare const FlowchartLaneKindType: StructType<{
+    readonly editable: BooleanType;
+    readonly editing: OptionType<StructType<{
+        sourceId: StringType;
+        entryType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        idField: OptionType<StringType>;
+        draftType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        children: OptionType<StringType>;
+        keyType: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>>;
+        snapshot: OptionType<BlobType>;
+        readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+        onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+        onApply: OptionType<VariantType<{
+            readonly sync: FunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+            readonly async: import("@elaraai/east").AsyncFunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+        }>>;
+        mode: VariantType<{
+            readonly batch: NullType;
+            readonly auto: NullType;
+        }>;
+    }>>;
+    readonly entries: OptionType<StructType<{
+        readonly revision: FunctionType<[], OptionType<StringType>>;
+        readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+        readonly entry: FunctionType<[StringType], OptionType<OptionType<BlobType>>>;
+        readonly last: FunctionType<[], OptionType<OptionType<StringType>>>;
+    }>>;
+    readonly history: OptionType<FunctionType<[], OptionType<ArrayType<StructType<{
+        readonly hash: StringType;
+        readonly parent: OptionType<StringType>;
+        readonly state: StringType;
+        readonly mutation: StringType;
+        readonly actor: StringType;
+        readonly at: DateTimeType;
+        readonly delta: OptionType<StringType>;
+    }>>>>>;
+    readonly fields: ArrayType<StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly label: StringType;
+        readonly help: OptionType<StringType>;
+        readonly group: OptionType<StringType>;
+        readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly optional: BooleanType;
+        readonly editor: VariantType<{
+            readonly text: StructType<{
+                readonly placeholder: OptionType<StringType>;
+            }>;
+            readonly number: StructType<{
+                readonly unit: OptionType<StringType>;
+                readonly step: OptionType<FloatType>;
+                readonly min: OptionType<FloatType>;
+                readonly max: OptionType<FloatType>;
+            }>;
+            readonly checkbox: NullType;
+            readonly datetime: StructType<{
+                readonly precision: OptionType<VariantType<{
+                    readonly date: NullType;
+                    readonly time: NullType;
+                    readonly datetime: NullType;
+                }>>;
+            }>;
+            readonly select: ArrayType<StructType<{
+                readonly case: StringType;
+                readonly label: StringType;
+            }>>;
+            readonly tags: StructType<{
+                readonly options: ArrayType<StringType>;
+            }>;
+            readonly checklist: StructType<{
+                readonly text: StringType;
+                readonly done: StringType;
+            }>;
+            readonly reference: StructType<{
+                readonly of: StringType;
+            }>;
+            readonly readonly: NullType;
+        }>;
+    }>>;
+    readonly inspector: OptionType<FunctionType<[BlobType, FunctionType<[BlobType], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    readonly ready: OptionType<FunctionType<[ArrayType<StructType<{
+        readonly id: StringType;
+        readonly entry: BlobType;
+    }>>], ArrayType<VariantType<{
+        readonly ready: NullType;
+        readonly incomplete: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+        readonly invalid: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+    }>>>>;
+    readonly set: FunctionType<[BlobType, ArrayType<StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly value: BlobType;
+    }>>], OptionType<BlobType>>;
+    readonly rowType: import("@elaraai/east").RecursiveType<VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: NullType;
+        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Dict: StructType<{
+            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Recursive: VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    readonly name: StringType;
+    readonly icon: StringType;
+    readonly rows: FunctionType<[], OptionType<DictType<StringType, StructType<{
+        readonly roles: StructType<{
+            readonly label: StringType;
+            readonly order: OptionType<FloatType>;
+        }>;
+        readonly row: BlobType;
+    }>>>>;
+    readonly read: FunctionType<[BlobType, StringType], StructType<{
+        readonly label: StringType;
+        readonly order: OptionType<FloatType>;
+    }>>;
+    readonly write: FunctionType<[BlobType, StructType<{
+        readonly label: OptionType<StringType>;
+        readonly order: OptionType<FloatType>;
+    }>], OptionType<BlobType>>;
+    readonly create: FunctionType<[StructType<{
+        readonly label: OptionType<StringType>;
+        readonly order: OptionType<FloatType>;
+    }>, OptionType<BlobType>], OptionType<BlobType>>;
+    readonly templates: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+        readonly group: OptionType<StringType>;
+        readonly values: BlobType;
+    }>>;
+    readonly templatesSource: OptionType<StringType>;
+}>;
+/** Type representing the lanes, closed. */
+export type FlowchartLaneKindType = typeof FlowchartLaneKindType;
 /**
- * Eyebrow freshness chip content.
+ * The decisions, closed (§3): a small record of the app's, read whole.
  *
- * @property label - Chip label ("evidence-2026.06")
- * @property date - Optional stamp printed after the label
+ * @property rows - Its decisions, by key, each its roles and its row; `none` while the read is in flight
+ * @property read - A drafted row's roles, from its bytes and its key
+ * @property unqueue - The row with a state's key taken out of its queue — a state's Del; `none` for a kind with no `queue`
  */
-export declare const FlowchartFreshnessType: StructType<{
-    /** Chip label ("evidence-2026.06") */
-    readonly label: StringType;
-    /** Optional stamp printed after the label */
-    readonly date: OptionType<DateTimeType>;
+export declare const FlowchartDecisionKindType: StructType<{
+    readonly editable: BooleanType;
+    readonly editing: OptionType<StructType<{
+        sourceId: StringType;
+        entryType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        idField: OptionType<StringType>;
+        draftType: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        children: OptionType<StringType>;
+        keyType: OptionType<import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>>;
+        snapshot: OptionType<BlobType>;
+        readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+        onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+        onApply: OptionType<VariantType<{
+            readonly sync: FunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+            readonly async: import("@elaraai/east").AsyncFunctionType<[BlobType], VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+        }>>;
+        mode: VariantType<{
+            readonly batch: NullType;
+            readonly auto: NullType;
+        }>;
+    }>>;
+    readonly entries: OptionType<StructType<{
+        readonly revision: FunctionType<[], OptionType<StringType>>;
+        readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+        readonly entry: FunctionType<[StringType], OptionType<OptionType<BlobType>>>;
+        readonly last: FunctionType<[], OptionType<OptionType<StringType>>>;
+    }>>;
+    readonly history: OptionType<FunctionType<[], OptionType<ArrayType<StructType<{
+        readonly hash: StringType;
+        readonly parent: OptionType<StringType>;
+        readonly state: StringType;
+        readonly mutation: StringType;
+        readonly actor: StringType;
+        readonly at: DateTimeType;
+        readonly delta: OptionType<StringType>;
+    }>>>>>;
+    readonly fields: ArrayType<StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly label: StringType;
+        readonly help: OptionType<StringType>;
+        readonly group: OptionType<StringType>;
+        readonly type: import("@elaraai/east").RecursiveType<VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Dict: StructType<{
+                readonly key: import("@elaraai/east").RecursiveTypeMarker;
+                readonly value: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Struct: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Variant: ArrayType<StructType<{
+                readonly name: StringType;
+                readonly type: import("@elaraai/east").RecursiveTypeMarker;
+            }>>;
+            readonly Recursive: VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: IntegerType;
+                    readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+                }>;
+            }>;
+            readonly Function: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly AsyncFunction: StructType<{
+                readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+                readonly output: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+            readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+            readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly optional: BooleanType;
+        readonly editor: VariantType<{
+            readonly text: StructType<{
+                readonly placeholder: OptionType<StringType>;
+            }>;
+            readonly number: StructType<{
+                readonly unit: OptionType<StringType>;
+                readonly step: OptionType<FloatType>;
+                readonly min: OptionType<FloatType>;
+                readonly max: OptionType<FloatType>;
+            }>;
+            readonly checkbox: NullType;
+            readonly datetime: StructType<{
+                readonly precision: OptionType<VariantType<{
+                    readonly date: NullType;
+                    readonly time: NullType;
+                    readonly datetime: NullType;
+                }>>;
+            }>;
+            readonly select: ArrayType<StructType<{
+                readonly case: StringType;
+                readonly label: StringType;
+            }>>;
+            readonly tags: StructType<{
+                readonly options: ArrayType<StringType>;
+            }>;
+            readonly checklist: StructType<{
+                readonly text: StringType;
+                readonly done: StringType;
+            }>;
+            readonly reference: StructType<{
+                readonly of: StringType;
+            }>;
+            readonly readonly: NullType;
+        }>;
+    }>>;
+    readonly inspector: OptionType<FunctionType<[BlobType, FunctionType<[BlobType], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    readonly ready: OptionType<FunctionType<[ArrayType<StructType<{
+        readonly id: StringType;
+        readonly entry: BlobType;
+    }>>], ArrayType<VariantType<{
+        readonly ready: NullType;
+        readonly incomplete: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+        readonly invalid: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+    }>>>>;
+    readonly set: FunctionType<[BlobType, ArrayType<StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly value: BlobType;
+    }>>], OptionType<BlobType>>;
+    readonly rowType: import("@elaraai/east").RecursiveType<VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: NullType;
+        readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Array: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Set: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Dict: StructType<{
+            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Recursive: VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    readonly name: StringType;
+    readonly icon: StringType;
+    readonly rows: FunctionType<[], OptionType<DictType<StringType, StructType<{
+        readonly roles: StructType<{
+            readonly label: StringType;
+            readonly letter: OptionType<StringType>;
+            readonly owner: OptionType<StringType>;
+            readonly outcomes: OptionType<StringType>;
+            readonly queue: ArrayType<StringType>;
+        }>;
+        readonly row: BlobType;
+    }>>>>;
+    readonly read: FunctionType<[BlobType, StringType], StructType<{
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly outcomes: OptionType<StringType>;
+        readonly queue: ArrayType<StringType>;
+    }>>;
+    readonly unqueue: OptionType<FunctionType<[BlobType, StringType], OptionType<BlobType>>>;
 }>;
+/** Type representing the decisions, closed. */
+export type FlowchartDecisionKindType = typeof FlowchartDecisionKindType;
 /**
- * Type representing the freshness chip.
+ * What a narrowing does (R6): `hide`, the default — a row it leaves out is
+ * never read — or `dim` — every row is read, and those it leaves out are
+ * drawn as context, selected by no path.
+ *
+ * @property hide - A row the narrowing leaves out is never read
+ * @property dim - Every row is read, those left out drawn faded
  */
-export type FlowchartFreshnessType = typeof FlowchartFreshnessType;
+export declare const FlowchartNarrowedType: VariantType<{
+    readonly hide: NullType;
+    readonly dim: NullType;
+}>;
+/** Type representing what a narrowing does. */
+export type FlowchartNarrowedType = typeof FlowchartNarrowedType;
 //# sourceMappingURL=types.d.ts.map