@elaraai/e3-ui 1.0.103 → 1.0.104

package/dist/src/flowchart/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/flowchart/index.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/flowchart/index.ts"],"names":[],"mappings":"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"}

package/dist/src/flowchart/index.js

@@ -3,255 +3,257 @@
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 /**
- * The Flowchart (#1243–#1250): the state-transition flowchart, e3-ui's as the
- * Plan (#1177) and the Sheet (#1179) are. `<Flowchart>` takes its flows from
- * an e3 record of flows by name, or from the host — flows by name, or one
- * flow — and returns its payload through the `Flowchart` carrier, which
- * e3-ui-components' renderer draws in its builder frame and edits through its
- * editing session.
+ * The Flowchart (#1498): the state-transition flowchart over the app's own
+ * records, e3-ui's as the Plan, the Sheet and the Schematic are.
+ * `<Flowchart>` declares its kinds over the app's records — its states, and
+ * beside them its transitions, lanes and decisions, each record's fields
+ * mapped to the Flowchart's roles — and returns its payload through the
+ * `Flowchart` carrier, which e3-ui-components' renderer draws in its builder
+ * frame and edits through its editing session.
  *
- * - `types.ts` — the flow, the record of flows, and the row and closed-set
- *   types (`Flowchart.Types.*`).
- * - `values.ts` — `Flowchart.value` and `Flowchart.values`, a record's value
- *   written as literals and checked when the package builds.
- * - `over.ts` — `Flowchart.over`, one flow from an app's own tables.
- * - `patch.ts` — `Flowchart.patch`, a patch over one of a flow's rows.
- * - `library.ts` — `Flowchart.library`, the library pane's tabs — the Flows
- *   tab, the state and transition templates and the author's tabs, each
- *   reading its own rows and following the source of the slice it names —
- *   and their wire.
- * - `canvas.ts` — the canvas: what the flowchart draws its flow with.
- * - `window.ts` — the `flows` source of its slice: the Flows tab's pages, a
- *   flow read by its name, and the tab's own search (#1346).
+ * - `types.ts` — the value types its accessors return and its canvas
+ *   carries, and the kinds' wire (`Flowchart.Types.*`).
+ * - `kinds.ts` — `Flowchart.states`, `transitions`, `lanes` and
+ *   `decisions`: each role's check, the binding a kind's read takes, and the
+ *   closed functions over beast2 bytes.
+ * - `details.ts` — `Flowchart.details` and its four reads, `Flowchart.figure`,
+ *   `.histogram`, `.list` and `.tags`: a state's or a transition's details
+ *   over the app's rows, read as the kind is.
+ * - `templates.ts` — `Flowchart.templates`, a kind's cards read from a
+ *   record.
+ * - `library.ts` — `Flowchart.library`, the library pane's tabs, and their
+ *   wire.
+ * - `canvas.ts` — the canvas: what the Flowchart draws with besides its kinds.
  * - `payload.ts` — the payload, its carrier, the shared keys, the props and
  *   their refusals.
  * - `flowchart.ts` — the tag.
  *
  * @packageDocumentation
  */
-import { FlowchartTag } from "./flowchart.js";
+import { SchedulePatchTypeFor, schedulePatch } from "../schedule/patch.js";
 import { FlowchartCanvasType } from "./canvas.js";
-import { FlowchartCardType, FlowchartDecisionCardType, FlowchartLandsType, FlowchartLaneCardType, FlowchartLibraryFactories, FlowchartLibraryTabType, FlowchartStateCardType, FlowchartTransitionCardType, } from "./library.js";
-import { flowchartOver } from "./over.js";
-import { FlowchartPatchTypeFor, flowchartPatch } from "./patch.js";
-import { FlowchartComponent, FlowchartDataType, FlowchartFlowsHandleType, FlowchartInspectorType, FlowchartPayloadType, FlowchartSessionApplyType, FlowchartSourceType, createFlowchartPayload, } from "./payload.js";
-import { FlowchartEvidenceType, FlowchartFlowType, FlowchartFlowsType, FlowchartFreshnessType, FlowchartLaneType, FlowchartLinkKindType, FlowchartLinkType, FlowchartOrientationType, FlowchartStateType, FlowchartTriggerType, } from "./types.js";
-import { flowchartValue, flowchartValues } from "./values.js";
+import { flowchartDetails, flowchartFigure, flowchartHistogram, flowchartList, flowchartTags } from "./details.js";
+import { FlowchartTag } from "./flowchart.js";
+import { flowchartDecisions, flowchartLanes, flowchartStates, flowchartTransitions } from "./kinds.js";
+import { FlowchartKindTabWireType, FlowchartLibraryFactories, FlowchartLibraryTabType } from "./library.js";
+import { FlowchartComponent, FlowchartPayloadType, createFlowchartPayload } from "./payload.js";
+import { flowchartTemplates } from "./templates.js";
+import { FlowchartDecisionEntryType, FlowchartDecisionKindType, FlowchartDecisionRolesType, FlowchartDetailRowType, FlowchartDetailsType, FlowchartEvidenceType, FlowchartFreshnessType, FlowchartLaneEntryType, FlowchartLaneKindType, FlowchartLaneRolesType, FlowchartLaneWriteType, FlowchartLinkKindType, FlowchartNarrowedType, FlowchartOrientationType, FlowchartReadType, FlowchartShowType, FlowchartStateEntryType, FlowchartStateKindType, FlowchartStateRolesType, FlowchartStateWriteType, FlowchartTagColorType, FlowchartTemplateType, FlowchartTransitionEntryType, FlowchartTransitionKindType, FlowchartTransitionRolesType, FlowchartTransitionWriteType, FlowchartWeighedType, } from "./types.js";
 export { FlowchartTag } from "./flowchart.js";
 export { FlowchartCanvasType, buildCanvas, } from "./canvas.js";
-export { flowchartOver, } from "./over.js";
-export { FlowchartPatchTypeFor, flowchartPatch } from "./patch.js";
-export { FlowchartCardType, FlowchartDecisionCardType, FlowchartLandsType, FlowchartLaneCardType, FlowchartLibraryFactories, FlowchartLibraryTabType, FlowchartStateCardType, FlowchartTransitionCardType, buildLibrary as buildFlowchartLibrary, libraryFlows, libraryStates, libraryTab, libraryTransitions, } from "./library.js";
-export { FlowchartComponent, FlowchartDataType, FlowchartFlowApplyType, FlowchartFlowsApplyType, FlowchartFlowsHandleType, FlowchartHistoryType, FlowchartInspectorType, FlowchartPayloadType, FlowchartSessionApplyType, FlowchartSourceType, createFlowchartPayload, flowchartKeys, } from "./payload.js";
-export { flowchartValue, flowchartValues, } from "./values.js";
-/** The East types a flowchart is written with. */
+export { FLOWCHART_DEF, flowchartDecisions, flowchartLanes, flowchartStates, flowchartTransitions, isFlowchartKind, } from "./kinds.js";
+export { FLOWCHART_DETAILS, FlowchartDetailsBrand, FlowchartReadBrand, flowchartDetails, flowchartFigure, flowchartHistogram, flowchartList, flowchartTags, isFlowchartDetails, } from "./details.js";
+export { FLOWCHART_TEMPLATES, checkedFlowchartTemplates, flowchartTemplates, isFlowchartTemplates, } from "./templates.js";
+export { FlowchartKindTabWireType, FlowchartLibraryCardType, FlowchartLibraryFactories, FlowchartLibraryTabType, buildFlowchartLibrary, flowchartTabSources, libraryLanes, libraryStates, libraryTab, libraryTransitions, } from "./library.js";
+export { FlowchartComponent, FlowchartPayloadType, createFlowchartPayload, flowchartKeys, } from "./payload.js";
+/** The East types a Flowchart is written with. */
 const TYPES = {
-    Flow: FlowchartFlowType,
-    Flows: FlowchartFlowsType,
-    State: FlowchartStateType,
-    Link: FlowchartLinkType,
-    Lane: FlowchartLaneType,
-    Trigger: FlowchartTriggerType,
     Evidence: FlowchartEvidenceType,
     Kind: FlowchartLinkKindType,
     Orientation: FlowchartOrientationType,
     Freshness: FlowchartFreshnessType,
-    Patch: FlowchartPatchTypeFor,
+    Patch: SchedulePatchTypeFor,
+    TagColor: FlowchartTagColorType,
 };
 /** The namespace's members — everything `Flowchart` carries beside the tag itself. */
 const MEMBERS = {
-    value: flowchartValue,
-    values: flowchartValues,
-    over: flowchartOver,
-    patch: flowchartPatch,
+    states: flowchartStates,
+    transitions: flowchartTransitions,
+    lanes: flowchartLanes,
+    decisions: flowchartDecisions,
+    details: flowchartDetails,
+    figure: flowchartFigure,
+    histogram: flowchartHistogram,
+    list: flowchartList,
+    tags: flowchartTags,
+    templates: flowchartTemplates,
+    patch: schedulePatch,
     library: FlowchartLibraryFactories,
     Types: TYPES,
 };
 /**
- * `<Flowchart>` — the state-transition flowchart: states as nodes in ordered
- * phase lanes (the layout derived, no coordinates), H/V-routed transitions,
- * decision triggers (lettered diamonds) and evidence-weighted strokes. The
- * selection — a state, a transition, a decision, a lane by its header, or
- * several states — and the pointer-highlight grammar are built in, and the
- * inspector shows what is selected.
+ * `<Flowchart>` — one state-transition flowchart over the app's own records:
+ * its states as cards in ordered lanes (the layout derived, no coordinates),
+ * H/V-routed transitions between them, the decisions that govern them as
+ * lettered diamonds, and evidence-weighted strokes. The selection — a state,
+ * a transition, a decision, a lane by its header, or several states — and the
+ * pointer-highlight grammar are built in, and the inspector shows what is
+ * selected.
  *
  * @remarks
- * - **Its frame**: it renders in its builder frame wherever it is used — one
- *   toolbar (find state, LR · TD, the freshness chip, the slice's rail and,
- *   where it edits, the history item), the canvas filling main and scrolling
- *   both ways inside it, and the footer's counts; a library pane when
- *   `library` lists tabs, and the inspector pane unless `inspector={false}`.
- *   It fills the box it is given and draws no border: give it a box of its
- *   own height.
- * - **Its inspector** (#1250, on by default, ruled by the user on
- *   2026-10-08): the end pane, Details and Issues — Issues with its count, and
- *   collapsed a rail with its icon and the issue count. Details shows what is
- *   selected through its form, every field by the shared input its type
- *   takes: a state (its key — a new one rekeying its transitions and the
- *   decisions' queues — label, lane, members and notes; its transitions in and
- *   out, each selecting it; Duplicate, Delete), a transition (its ends, its
- *   kind, its decision and its key; its evidence read only; Delete), a
- *   decision (its fields, its queue as tags over the flow's states; the
- *   transitions it governs; Delete), a lane — a click on its header selects
- *   it — (its key, which moves its states, and its label; its states' count;
- *   Delete while it holds none), several states (their count; moved to a
- *   lane, or deleted, together) or, with nothing selected, the open flow (its
- *   name and description — a new name renames it — Duplicate and Delete over
- *   many flows; its counts, its last save and who made it, and three hints).
- *   Each edit is one transaction, a field the drafts changed tinted against
- *   the record; read only, Details shows every field and edits none. Issues
- *   lists a transition naming a missing state, a state naming a missing lane,
- *   two of one key — which holds Save off — a decision's queue naming a
- *   missing state, and a Save's conflict or refusal, a click selecting what
- *   each names. `inspector={{ state, transition }}` gives a kind its own
- *   Details in place of its form: an East function over the row and its
- *   writer, `update` writing the edited row back as one transaction. The
- *   hover cards went: the inspector is where details live.
- * - **Its open flow**, over many flows: `flow`, else the first by name, until
- *   the viewer opens another — from the Flows tab
- *   (`Flowchart.library.flows()`), which lists every flow by name — kept in
- *   the UI store under its `name`, so a remount opens it again; a `flow` it
- *   doesn't hold is named in a banner above main. LR · TD is the viewer's
- *   too, kept under its `name`. Where it edits, "+ New flow" names a new
- *   flow, opened empty with one lane; each flow keeps its own drafts until
- *   the history item saves or discards them.
- * - **Its library** (#1248): the tabs `library` lists, in its order, each with
- *   its count and a search — the Flows tab; state templates
- *   (`Flowchart.library.states(rows, …)`) and transition templates
- *   (`Flowchart.library.transitions(rows, …)`), each card a drag source; and
- *   the author's own cards (`Flowchart.library.tab(rows, …)`), a drag source
- *   when the tab declares a `drop`. Each data tab reads its own rows apart
- *   from the flows and from the other tabs. Templates are records (#1340,
- *   ruling 9): each list's rows are its record's (`Data.bind(record).read()`,
- *   a `Dict<String, T>`), and it names its `source` of the slice. An author's
- *   tab reads an Array or a `Dict<String, T>`, and naming a `source` follows
- *   it. A click selects a card, and a click on the selected card lets it go;
- *   an empty tab says so in the shared empty state, and one the rail leaves
- *   none says so, with a Clear.
- * - **Its drops** (#1249): a card carried onto the canvas lands where its tab
- *   says — a state template on a lane, adding a state at the row under the
- *   pointer, its key the drop's, made unique or minted; a transition template
- *   on a transition, retyping it; an author's card on what its drop's type
- *   names — the ghost saying where, or, red, why not. ⏎ on a card drops it on
- *   the canvas's selection, and on a touch screen so does a tap on the
- *   selected card. Each drop is one transaction of the open flow's session.
- * - **Its edits** are its editing session's (#1247): over a record, and over
- *   `data` given `onApply`, every gesture — "+ LANE", a lane's header
- *   double-clicked into its rename (a click selects the lane, #1250) or its ×
- *   (off while the lane holds states), the "+ STATE" ghost, a state
- *   double-clicked into its editor (a new key rekeys its transitions and the
- *   decisions' queues) or dragged across lanes, a handle dragged to another
- *   state, Del on the selected state, states, transition, decision or empty
- *   lane, and every edit the inspector makes — is one transaction the history
- *   item undoes and redoes (⌘Z, ⇧⌘Z or ⌘Y anywhere in the frame but a field
- *   being typed into), and Save sends the open flow's drafts as one commit:
- *   through the record's patch mutation, or as one patch of `data`'s value to
- *   the host's `onApply`, handed the session's request id with it — the same
- *   id on a Retry, so a host that keys its write by it writes once (#1275).
- *   Two lanes, states, transitions or decisions of one
- *   key hold Save off. The footer counts the changes waiting on Save.
- * - **Its flows** are an e3 record's (`record`): `Flowchart.Types.Flows`,
- *   flows by name, bound with its patch mutation, the canvas showing `flow`,
- *   else the first by name. A record always holds flows by name (ruled
- *   2026-10-07: e3's patch mutation writes only keyed records), so a lone flow
- *   is a record of one entry. Or they are the host's (`data`): flows by name
- *   or one flow — a value, an expression or a bind handle — the value's type
- *   picking the arm, one prop taking either; `Flowchart.over` builds one flow
- *   from the host's own tables through their row mappers. The host's flows
- *   are never narrowed: a task narrows the rows it builds them from.
- * - **Its narrowing** (#1346) is one `Slice.bindRecords`, `slice={{ slice:
- *   Slice.bindRecords(key, { flows, … }) }}`, its rail on the toolbar. Over a
- *   record, its `flows` source — `Data.bindPaged(record, { indexes })` over
- *   the same record, its `fields` the indexes' — narrows the Flows tab, which
- *   pages it a window at a time with its count, the tab's own search finding
- *   within the narrowing by the source's `search` fields; the open flow is
- *   read by its name whatever the narrowing, and keeps its drafts. Each other
- *   source narrows the templates list or the author's tab that names it, by
- *   its cards' keys.
- * - **A dataset's value** is written as literals with `Flowchart.values`
- *   (flows by name) or `Flowchart.value` (one flow), checked when the package
- *   builds.
+ * - **Its kinds** are the app's records (R1): `states`, and beside them
+ *   `transitions`, `lanes` and `decisions` — `Flowchart.states(record, { … })`
+ *   and the rest — whose roles are the record's fields where a gesture
+ *   writes them or they name another row's key (a state's `label`, `lane`
+ *   and `order`; a transition's `from`, `to` and `decision`; a lane's `label`
+ *   and `order`; a decision's `queue`), and accessors over a row and its key
+ *   for the rest (R2). A role naming a field the row lacks, or one of another
+ *   type, is a type error naming the fields that fit. No record of the app's
+ *   holds a type of the Flowchart's.
+ * - **How a kind is bound follows how it is read** (R3): a state or a
+ *   transition `Record.bind(record)`, its record declaring `patch:
+ *   mutation.patch()`, to edit it — read whole, or through its source of the
+ *   slice with `entries: Data.bindPaged(record)` beside it — `Data.bind`,
+ *   read only and whole, or `Data.bindPaged` alone, read only, through its
+ *   source; a lane or a decision `Record.bind` or `Data.bind`, read whole.
+ * - **Its details** (R18–R21): a state or a transition takes `details`,
+ *   `Flowchart.details(binding, { details: [ … ] })` over the app's rows keyed
+ *   as the kind's are, read only and bound as the kind is read — four reads,
+ *   `Flowchart.figure`, `.histogram`, `.list` and `.tags`, in one array drawn
+ *   in its order on the cards and labels and shown in full in the inspector,
+ *   each where its `show` says.
+ * - **Its narrowing** (R4) is one `Slice.bindRecords`, `slice={{ slice:
+ *   Slice.bindRecords(key, { … }) }}`, its rail on the toolbar: its sources
+ *   named `states` and `transitions` — each `Data.bindPaged(record, { indexes
+ *   })` over that kind's own record — narrow that kind, and each other source
+ *   the cards list or the author's tab that names it. A preset may narrow
+ *   both at once: a record holding many flows shows one through a preset over
+ *   the field both share. `narrowed="dim"` draws what the narrowing leaves
+ *   out as context.
+ * - **Its edits** are its editing session's: every gesture — "+ LANE", a
+ *   lane's rename, the "+ STATE" ghost, a state's rename or move across lanes
+ *   or between two cards, a handle dragged to another state, Del, a card
+ *   dropped from the library, and every edit the inspector makes — writes
+ *   only its roles' fields, one transaction the history item undoes and
+ *   redoes, and Save writes each record through its own patch door.
+ * - **Its library** (R14): the Steps, Transitions and Lanes tabs
+ *   (`Flowchart.library.states()`, `.transitions()`, `.lanes()`) list each
+ *   kind's cards — `Flowchart.templates(rows, { name, values, source })` on
+ *   the kind — and `Flowchart.library.tab(rows, { … })` the app's own, its
+ *   `drop` a `Flowchart.patch(R, { … })` over one kind's row type.
+ * - **Its inspector** is on unless `inspector={false}`: Details shows what is
+ *   selected through its kind's form, or its kind's own `inspector`, and
+ *   Issues what holds Save off.
  * - **The host hears** the selection (`onSelectState`, `onSelectLink`,
  *   `onSelectTrigger`) and a traced path (`onTracePath`), and vetoes a
  *   connection with `canConnect`.
- * - **Refused when the surface is built**, each naming the prop and the
- *   remedy: flows from both `record` and `data`, or neither; `onApply` over a
- *   record; `window`, which the slice's `flows` source replaced; a `slice`
- *   that is not `{ slice }` — the bare handle a flow from the host's tables
- *   was narrowed by — or not `Slice.bindRecords` (`Slice.bind`,
- *   `Slice.bindRecord`), or holding a source nothing names; a `flows` source
- *   over `data`; `affordances` outside `slice`; a templates list written in
- *   the code, naming no source, or naming `flows`, and the two lists naming
- *   one source; `flow` over one flow; a record of one flow, or of another
- *   type, or not bound with its patch mutation; `"brush"` among the
- *   affordances; `height` or `maxHeight`, which the box it fills sets; `density`, which nothing drew by — the canvas draws at one
- *   rhythm, the spec's 116×40 cards in their lanes (#1251); a callback for an
- *   edit (`onAddState`, `onCreateLink`, …)
- *   or `linkMode`, which the session's gestures replace; a hover card's
- *   builder (`stateHover`, `linkHover`, `triggerHover`), which the inspector
- *   replaces; an `inspector` of another kind than a Boolean or `{ state,
- *   transition }`, a key other than those two, or a kind's own Details of
- *   another type than `(Row, (Row) => Null) => UIComponentType`; a library
- *   that lists a tab twice — the Flows tab or a template tab, or two of the
- *   author's tabs of one name — or the Flows tab over one flow; a data tab
- *   whose rows are neither an Array nor a `Dict<String, T>`, or a templates
- *   list's or a sourced tab's that are no `Dict<String, T>`; a tab's source
- *   the slice lacks; a `states` drop
- *   over another type than a state's patch, a `transitions` drop over another
- *   than a transition's, and a `tab` drop over none of a flow's row types.
- *
- * The closed-set fields in data (`kind`, `orientation`) are typed variant
- * values, `Flowchart.Types.*`.
+ * - It fills the box it is given and draws no border: give it a box of its
+ *   own height.
  *
  * @example
  * ```tsx
  * // .tsx file with the `@jsxImportSource @elaraai/e3-ui` pragma
- * import { East } from "@elaraai/east";
+ * import { DateTimeType, DictType, East, FloatType, IntegerType, NullType, OptionType, StringType, StructType, VariantType, none, some, variant } from "@elaraai/east";
  * import { Box, Reactive, UIComponentType } from "@elaraai/east-ui";
- * import { Flowchart, Record } from "@elaraai/e3-ui";
+ * import { Data, Flowchart } from "@elaraai/e3-ui";
  * import e3 from "@elaraai/e3";
  *
- * export const depotFlows = e3.record("flowchart_depot_flows", Flowchart.Types.Flows, {
- *     initial: Flowchart.values({
- *         "Inbound parcels": {
- *             description: "From the trailer to the van",
- *             lanes: [{ key: "intake", label: "Intake" }, { key: "sort", label: "Sort" }, { key: "load", label: "Load" }],
- *             states: [
- *                 { key: "ARV", label: "Arrived", lane: "intake" },
- *                 { key: "SCN", label: "Scanned", lane: "intake" },
- *                 { key: "CH*", label: "Sort chutes", lane: "sort", members: 12n },
- *                 { key: "LDD", label: "Loaded", lane: "load" },
- *             ],
- *             links: [
- *                 { from: "ARV", to: "SCN" },
- *                 { from: "SCN", to: "CH*", trigger: "route" },
- *                 { from: "CH*", to: "LDD" },
- *                 { from: "SCN", to: "SCN", kind: "observed" },
- *             ],
- *             triggers: [{ key: "route", label: "route", owner: "sort-planner" }],
- *         },
- *         "Returns": {
- *             description: "From the counter back to the sender",
- *             lanes: [{ key: "counter", label: "Counter" }, { key: "check", label: "Check" }, { key: "out", label: "Out" }],
- *             states: [
- *                 { key: "RCV", label: "Received", lane: "counter" },
- *                 { key: "INS", label: "Inspected", lane: "check" },
- *                 { key: "RSD", label: "Resent", lane: "out" },
- *             ],
- *             links: [{ from: "RCV", to: "INS" }, { from: "INS", to: "RSD" }, { from: "INS", to: "BIN", kind: "observed" }],
- *         },
+ * // The depot's states, transitions and lanes: three records of the app's, keyed by String, each row its own type.
+ * export const DepotState = StructType({
+ *     name: StringType,                         // what its card calls it
+ *     phase: StringType,                        // the lane it stands in, by the lane's key
+ *     seq: FloatType,                           // its place in its lane
+ *     slots: OptionType(IntegerType),           // a class of interchangeable states: the ×N badge
+ *     flow: StringType,                         // the flow it belongs to: one record holds the depot's flows
+ * });
+ * export const DepotTransition = StructType({
+ *     src: StringType,                          // the state it leaves, by its key
+ *     dst: StringType,                          // the state it enters
+ *     kind: VariantType({ planned: NullType, observed: NullType }),
+ *     trigger: OptionType(StringType),          // the decision that governs it, by its key
+ *     volume: OptionType(FloatType),            // the parcels measured on it
+ *     n: OptionType(IntegerType),               // the moves behind them
+ *     at: OptionType(DateTimeType),             // when they were measured
+ *     flow: StringType,
+ * });
+ * export const DepotLane = StructType({ label: StringType, seq: FloatType });
+ * export const depotStates = e3.record("flowchart_depot_states", DictType(StringType, DepotState), {
+ *     initial: new Map([
+ *         ["ARV", { name: "Arrived", phase: "intake", seq: 1, slots: none, flow: "Parcels" }],
+ *         ["SCN", { name: "Scanned", phase: "intake", seq: 2, slots: none, flow: "Parcels" }],
+ *         ["IND", { name: "Inducted", phase: "induct", seq: 1, slots: none, flow: "Parcels" }],
+ *         ["LBL", { name: "Relabelled", phase: "induct", seq: 2, slots: none, flow: "Parcels" }],
+ *         ["CH*", { name: "Sort chutes (class)", phase: "sort", seq: 1, slots: some(14n), flow: "Parcels" }],
+ *         ["SRD", { name: "Sorted", phase: "sort", seq: 2, slots: none, flow: "Parcels" }],
+ *         ["HLD", { name: "Held", phase: "hold", seq: 1, slots: none, flow: "Parcels" }],
+ *         ["CLR", { name: "Cleared", phase: "hold", seq: 2, slots: none, flow: "Parcels" }],
+ *         ["LDD", { name: "Loaded", phase: "dispatch", seq: 1, slots: none, flow: "Parcels" }],
+ *         ["DSP", { name: "Dispatched", phase: "dispatch", seq: 2, slots: none, flow: "Parcels" }],
+ *         // The returns flow's states, beside the parcels'.
+ *         ["RCV", { name: "Received", phase: "intake", seq: 3, slots: none, flow: "Returns" }],
+ *         ["INS", { name: "Inspected", phase: "hold", seq: 3, slots: none, flow: "Returns" }],
+ *         ["RSD", { name: "Resent", phase: "dispatch", seq: 3, slots: none, flow: "Returns" }],
+ *     ]),
+ *     mutations: (mutation) => ({ patch: mutation.patch() }),
+ *     indexes: (index) => ({
+ *         flowchart_states_by_flow: index.on(["flow"]),
+ *         flowchart_states_by_lane: index.on(["flow", "phase"]),
  *     }),
- *     mutations: (mutation) => ({
- *         patch: mutation.patch(),
+ * });
+ * export const depotTransitions = e3.record("flowchart_depot_transitions", DictType(StringType, DepotTransition), {
+ *     initial: new Map([
+ *         ["l1", { src: "ARV", dst: "SCN", kind: variant("planned", null), trigger: none, volume: some(18460), n: some(412n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Parcels" }],
+ *         ["l2", { src: "SCN", dst: "IND", kind: variant("planned", null), trigger: none, volume: some(18390), n: some(409n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Parcels" }],
+ *         // In place: parcels inducted again, counted but not weighed.
+ *         ["l3", { src: "IND", dst: "IND", kind: variant("observed", null), trigger: none, volume: none, n: some(2n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Parcels" }],
+ *         ["l4", { src: "IND", dst: "CH*", kind: variant("planned", null), trigger: some("route"), volume: some(17350), n: some(386n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Parcels" }],
+ *         ["l5", { src: "CH*", dst: "SRD", kind: variant("planned", null), trigger: none, volume: some(18210), n: some(405n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Parcels" }],
+ *         ["l6", { src: "SRD", dst: "HLD", kind: variant("planned", null), trigger: none, volume: some(8420), n: some(188n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Parcels" }],
+ *         ["l7", { src: "HLD", dst: "CLR", kind: variant("planned", null), trigger: some("customs"), volume: some(8350), n: some(186n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Parcels" }],
+ *         ["l8", { src: "CLR", dst: "LDD", kind: variant("planned", null), trigger: none, volume: some(8240), n: some(183n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Parcels" }],
+ *         ["l9", { src: "LDD", dst: "DSP", kind: variant("planned", null), trigger: none, volume: some(17030), n: some(378n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Parcels" }],
+ *         // Its far end names a state no row is keyed by: drawn as a ghost, and listed in Issues.
+ *         ["l10", { src: "DSP", dst: "DLV", kind: variant("planned", null), trigger: none, volume: none, n: none, at: none, flow: "Parcels" }],
+ *         // Observed, not planned: parcels relabelled before they are sorted.
+ *         ["l11", { src: "IND", dst: "LBL", kind: variant("observed", null), trigger: none, volume: some(980), n: some(22n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Parcels" }],
+ *         ["l12", { src: "LBL", dst: "CH*", kind: variant("observed", null), trigger: none, volume: some(975), n: some(22n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Parcels" }],
+ *         ["l13", { src: "SRD", dst: "LDD", kind: variant("planned", null), trigger: none, volume: some(8790), n: some(195n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Parcels" }],
+ *         ["r1", { src: "RCV", dst: "INS", kind: variant("planned", null), trigger: none, volume: some(640), n: some(15n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Returns" }],
+ *         ["r2", { src: "INS", dst: "RSD", kind: variant("planned", null), trigger: none, volume: some(610), n: some(14n), at: some(new Date("2026-06-30T00:00:00Z")), flow: "Returns" }],
+ *     ]),
+ *     mutations: (mutation) => ({ patch: mutation.patch() }),
+ *     indexes: (index) => ({
+ *         flowchart_transitions_by_flow: index.on(["flow"]),
  *     }),
  * });
+ * export const depotLanes = e3.record("flowchart_depot_lanes", DictType(StringType, DepotLane), {
+ *     initial: new Map([
+ *         ["intake", { label: "Intake", seq: 1 }], ["induct", { label: "Induct", seq: 2 }], ["sort", { label: "Sort", seq: 3 }],
+ *         ["hold", { label: "Hold", seq: 4 }], ["dispatch", { label: "Dispatch", seq: 5 }],
+ *     ]),
+ *     mutations: (mutation) => ({ patch: mutation.patch() }),
+ * });
+ *
+ * // The time each parcel spent in each state, keyed as the states are: its parcels counted into bins by how
+ * // long they stayed, each key a bin's lower edge, in hours.
+ * export const StateDwell = StructType({ hours: DictType(FloatType, IntegerType) });
+ * export const stateDwell = e3.input("flowchart_depot_dwell", DictType(StringType, StateDwell), variant("value", new Map([
+ *     ["ARV", { hours: new Map([[0, 7752n], [0.25, 6092n], [0.5, 2769n], [1, 1108n], [2, 554n], [4, 185n]]) }],
+ *     ["SCN", { hours: new Map([[0, 9195n], [0.25, 5517n], [0.5, 2391n], [1, 920n], [2, 367n]]) }],
+ *     ["IND", { hours: new Map([[0, 2207n], [0.25, 4781n], [0.5, 5517n], [1, 3310n], [2, 1655n], [4, 736n], [8, 184n]]) }],
+ *     ["LBL", { hours: new Map([[0.25, 59n], [0.5, 137n], [1, 255n], [2, 273n], [4, 157n], [8, 79n], [12, 20n]]) }],
+ *     ["CH*", { hours: new Map([[0, 1457n], [0.25, 4007n], [0.5, 6192n], [1, 4007n], [2, 1639n], [4, 728n], [8, 180n]]) }],
+ *     ["SRD", { hours: new Map([[0, 861n], [0.25, 2065n], [0.5, 4303n], [1, 4818n], [2, 3098n], [4, 1377n], [8, 516n], [12, 172n]]) }],
+ *     ["HLD", { hours: new Map([[0.25, 84n], [0.5, 167n], [1, 418n], [2, 752n], [4, 1169n], [8, 1417n],
+ *         [12, 1253n], [24, 1336n], [48, 1002n], [96, 501n], [168, 251n]]) }],
+ *     ["CLR", { hours: new Map([[0, 824n], [0.25, 1648n], [0.5, 2060n], [1, 1648n], [2, 989n], [4, 659n], [8, 330n], [12, 82n]]) }],
+ *     ["LDD", { hours: new Map([[0, 681n], [0.25, 1362n], [0.5, 2725n], [1, 4088n], [2, 3747n], [4, 2384n], [8, 1362n], [12, 511n], [24, 170n]]) }],
+ *     // Dispatched has no row: the app counts no time in it once a parcel has left, and its card says no data.
+ *     ["RCV", { hours: new Map([[0, 64n], [0.25, 115n], [0.5, 154n], [1, 141n], [2, 90n], [4, 51n], [8, 19n], [12, 6n]]) }],
+ *     ["INS", { hours: new Map([[0.25, 12n], [0.5, 37n], [1, 73n], [2, 122n], [4, 146n], [8, 110n], [12, 61n], [24, 37n], [48, 12n]]) }],
+ *     ["RSD", { hours: new Map([[0, 122n], [0.25, 183n], [0.5, 159n], [1, 85n], [2, 43n], [4, 18n]]) }],
+ * ])));
  *
- * const flowchart = East.function([], UIComponentType, (_$) => (
+ * const flowchartDwell = East.function([], UIComponentType, (_$) => (
  *     <Reactive>{$ => {
- *         const flows = $.let(Record.bind(depotFlows));
+ *         const states = $.let(Data.bind(depotStates));
+ *         const transitions = $.let(Data.bind(depotTransitions));
+ *         const lanes = $.let(Data.bind(depotLanes));
+ *         const dwell = $.let(Data.bind(stateDwell));
  *         return (
- *             <Box height="500px">
- *                 <Flowchart record={flows} flow="Inbound parcels" library={[Flowchart.library.flows()]} />
+ *             <Box height="600px">
+ *                 <Flowchart
+ *                     states={Flowchart.states(states, {
+ *                         label: "name", lane: "phase", order: "seq",
+ *                         // Keyed as the states are, and read as they are: whole.
+ *                         details: Flowchart.details(dwell, {
+ *                             details: [Flowchart.histogram("hours", { unit: "hours", label: "Time in state" })],
+ *                         }),
+ *                     })}
+ *                     transitions={Flowchart.transitions(transitions, { from: "src", to: "dst" })}
+ *                     lanes={Flowchart.lanes(lanes, { label: "label", order: "seq" })}
+ *                     name="dwell"
+ *                 />
  *             </Box>
  *         );
  *     }}</Reactive>
@@ -277,18 +279,30 @@ export const FlowchartInternal = Object.assign(FlowchartInternalTag, MEMBERS, {
         ...TYPES,
         Payload: FlowchartPayloadType,
         Canvas: FlowchartCanvasType,
-        Source: FlowchartSourceType,
-        Data: FlowchartDataType,
-        FlowsHandle: FlowchartFlowsHandleType,
-        SessionApply: FlowchartSessionApplyType,
-        Inspector: FlowchartInspectorType,
+        StateKind: FlowchartStateKindType,
+        TransitionKind: FlowchartTransitionKindType,
+        LaneKind: FlowchartLaneKindType,
+        DecisionKind: FlowchartDecisionKindType,
+        StateRoles: FlowchartStateRolesType,
+        TransitionRoles: FlowchartTransitionRolesType,
+        LaneRoles: FlowchartLaneRolesType,
+        DecisionRoles: FlowchartDecisionRolesType,
+        StateWrite: FlowchartStateWriteType,
+        TransitionWrite: FlowchartTransitionWriteType,
+        LaneWrite: FlowchartLaneWriteType,
+        StateEntry: FlowchartStateEntryType,
+        TransitionEntry: FlowchartTransitionEntryType,
+        LaneEntry: FlowchartLaneEntryType,
+        DecisionEntry: FlowchartDecisionEntryType,
+        Template: FlowchartTemplateType,
+        Narrowed: FlowchartNarrowedType,
         LibraryTab: FlowchartLibraryTabType,
-        Lands: FlowchartLandsType,
-        Card: FlowchartCardType,
-        StateCard: FlowchartStateCardType,
-        TransitionCard: FlowchartTransitionCardType,
-        LaneCard: FlowchartLaneCardType,
-        DecisionCard: FlowchartDecisionCardType,
+        KindTab: FlowchartKindTabWireType,
+        Details: FlowchartDetailsType,
+        Read: FlowchartReadType,
+        Show: FlowchartShowType,
+        DetailRow: FlowchartDetailRowType,
+        Weighed: FlowchartWeighedType,
     },
 });
 //# sourceMappingURL=index.js.map