@elaraai/e3-ui 1.0.86 → 1.0.88

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

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * `<Flowchart>` (#1244) — the tag: one form per source of flows — a record of
+ * flows by name, or the host's flows or flow, `data`'s type picking its form —
+ * each form's props typed (`Flowchart Builder Spec.md` §4.1, decision 3). A
+ * record always holds flows by name (ruled 2026-10-07). Over one flow the
+ * library lists every tab but the Flows tab (#1246, FB16) — its templates and
+ * the author's tabs, each over its own rows (#1248). No form takes a callback
+ * for an edit: the gestures are the editing session's, which Save commits
+ * (#1247, FB24). Its payload and every refusal are `payload.ts`'s, and its
+ * library's tabs and their refusals `library.ts`'s.
+ *
+ * @packageDocumentation
+ */
+import type { StringType, SubtypeExprOrValue } from "@elaraai/east";
+import type { RecordSliceChromeOptions } from "@elaraai/east-ui/internal";
+import type { UIElement } from "@elaraai/east-ui";
+import type { FlowchartSliceOptions } from "./canvas.js";
+import type { FlowchartLibraryTab, FlowchartOneFlowLibraryTab } from "./library.js";
+import { type FlowchartBindHandle, type FlowchartCommon, type FlowchartFlowApplyType, type FlowchartFlowsApplyType, type FlowchartRecordHandle } from "./payload.js";
+import type { FlowchartFlowType, FlowchartFlowsType } from "./types.js";
+/**
+ * `<Flowchart record={flows} flow="Inbound parcels" />` — a record of flows
+ * by name, bound with its patch mutation: the canvas shows `flow`, opened
+ * first, else the first flow by name. A lone flow is a record of one entry.
+ * Every gesture is a draft of the open flow's editing session, and Save
+ * commits the drafts as one patch through the record's patch mutation.
+ */
+export declare function FlowchartTag(props: {
+    record: FlowchartRecordHandle;
+    /** Page flows through Data.bindPaged(record), or Slice.rows of a record slice. */
+    window?: {
+        readonly page: unknown;
+        readonly total: unknown;
+    };
+    /** Shared index filters for the record's flows; never filters the open flow's children. */
+    slice?: RecordSliceChromeOptions;
+    /** Over many flows, the one opened first. */
+    flow?: SubtypeExprOrValue<StringType>;
+    /** The library pane's tabs, in order, each a `Flowchart.library.*` call; left out, or empty, no library pane. */
+    library?: readonly FlowchartLibraryTab[];
+} & FlowchartCommon): UIElement;
+/**
+ * `<Flowchart data={flows} />` — the host's flows by name: a value, an
+ * expression or a bind handle. Read only unless the host commits its edits
+ * through `onApply`: then every gesture is a draft, and Save hands the host
+ * the session's request id and one patch of the flows, the open flow's insert,
+ * update or delete by name — a Retry the same id again (#1275).
+ */
+export declare function FlowchartTag(props: {
+    data: SubtypeExprOrValue<FlowchartFlowsType> | FlowchartBindHandle<FlowchartFlowsType>;
+    /** Over many flows, the one opened first. */
+    flow?: SubtypeExprOrValue<StringType>;
+    /** The host's commit: the session's request id and one patch of the flows, answered as the editing session's Save is; a Retry hands the same id. */
+    onApply?: SubtypeExprOrValue<FlowchartFlowsApplyType>;
+    /** The library pane's tabs, in order, each a `Flowchart.library.*` call; left out, or empty, no library pane. */
+    library?: readonly FlowchartLibraryTab[];
+} & FlowchartSliceOptions & FlowchartCommon): UIElement;
+/**
+ * `<Flowchart data={Flowchart.over(states, { … })} />` — the host's one flow:
+ * a value, an expression or a bind handle, `Flowchart.over` building it from
+ * the host's tables. Read only unless the host commits its edits through
+ * `onApply`: then every gesture is a draft, and Save hands the host the
+ * session's request id and one patch of the flow — a Retry the same id again
+ * (#1275). Its library lists no Flows tab: one flow has none to list.
+ */
+export declare function FlowchartTag(props: {
+    data: SubtypeExprOrValue<FlowchartFlowType> | FlowchartBindHandle<FlowchartFlowType>;
+    /** The host's commit: the session's request id and one patch of the flow, answered as the editing session's Save is; a Retry hands the same id. */
+    onApply?: SubtypeExprOrValue<FlowchartFlowApplyType>;
+    /** The library pane's tabs, in order — every tab but the Flows tab; left out, or empty, no library pane. */
+    library?: readonly FlowchartOneFlowLibraryTab[];
+} & FlowchartSliceOptions & FlowchartCommon): UIElement;
+/** The type of `<Flowchart>` as a tag: every form its props take. */
+export type FlowchartTagType = typeof FlowchartTag;
+//# sourceMappingURL=flowchart.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"flowchart.d.ts","sourceRoot":"","sources":["../../../src/flowchart/flowchart.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AAEH,OAAO,KAAK,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAC;AACpE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,2BAA2B,CAAC;AAC1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAClD,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,aAAa,CAAC;AACzD,OAAO,KAAK,EAAE,mBAAmB,EAAE,0BAA0B,EAAE,MAAM,cAAc,CAAC;AACpF,OAAO,EAGH,KAAK,mBAAmB,EACxB,KAAK,eAAe,EACpB,KAAK,sBAAsB,EAC3B,KAAK,uBAAuB,EAC5B,KAAK,qBAAqB,EAC7B,MAAM,cAAc,CAAC;AACtB,OAAO,KAAK,EAAE,iBAAiB,EAAE,kBAAkB,EAAE,MAAM,YAAY,CAAC;AAExE;;;;;;GAMG;AACH,wBAAgB,YAAY,CACxB,KAAK,EAAE;IACH,MAAM,EAAE,qBAAqB,CAAC;IAC9B,kFAAkF;IAClF,MAAM,CAAC,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAC;QAAC,QAAQ,CAAC,KAAK,EAAE,OAAO,CAAA;KAAE,CAAC;IAC7D,2FAA2F;IAC3F,KAAK,CAAC,EAAE,wBAAwB,CAAC;IACjC,6CAA6C;IAC7C,IAAI,CAAC,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACtC,iHAAiH;IACjH,OAAO,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAC5C,GAAG,eAAe,GACpB,SAAS,CAAC;AACb;;;;;;GAMG;AACH,wBAAgB,YAAY,CACxB,KAAK,EAAE;IACH,IAAI,EAAE,kBAAkB,CAAC,kBAAkB,CAAC,GAAG,mBAAmB,CAAC,kBAAkB,CAAC,CAAC;IACvF,6CAA6C;IAC7C,IAAI,CAAC,EAAE,kBAAkB,CAAC,UAAU,CAAC,CAAC;IACtC,oJAAoJ;IACpJ,OAAO,CAAC,EAAE,kBAAkB,CAAC,uBAAuB,CAAC,CAAC;IACtD,iHAAiH;IACjH,OAAO,CAAC,EAAE,SAAS,mBAAmB,EAAE,CAAC;CAC5C,GAAG,qBAAqB,GAAG,eAAe,GAC5C,SAAS,CAAC;AACb;;;;;;;GAOG;AACH,wBAAgB,YAAY,CACxB,KAAK,EAAE;IACH,IAAI,EAAE,kBAAkB,CAAC,iBAAiB,CAAC,GAAG,mBAAmB,CAAC,iBAAiB,CAAC,CAAC;IACrF,mJAAmJ;IACnJ,OAAO,CAAC,EAAE,kBAAkB,CAAC,sBAAsB,CAAC,CAAC;IACrD,4GAA4G;IAC5G,OAAO,CAAC,EAAE,SAAS,0BAA0B,EAAE,CAAC;CACnD,GAAG,qBAAqB,GAAG,eAAe,GAC5C,SAAS,CAAC;AAKb,qEAAqE;AACrE,MAAM,MAAM,gBAAgB,GAAG,OAAO,YAAY,CAAC"}

package/dist/src/flowchart/flowchart.js

@@ -0,0 +1,9 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { FlowchartComponent, createFlowchartPayload, } from "./payload.js";
+export function FlowchartTag(props) {
+    return FlowchartComponent.Root(createFlowchartPayload(props));
+}
+//# sourceMappingURL=flowchart.js.map

package/dist/src/flowchart/flowchart.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"flowchart.js","sourceRoot":"","sources":["../../../src/flowchart/flowchart.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAqBH,OAAO,EACH,kBAAkB,EAClB,sBAAsB,GAMzB,MAAM,cAAc,CAAC;AA0DtB,MAAM,UAAU,YAAY,CAAC,KAAa;IACtC,OAAO,kBAAkB,CAAC,IAAI,CAAC,sBAAsB,CAAC,KAAK,CAAC,CAAC,CAAC;AAClE,CAAC"}

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

@@ -0,0 +1,305 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * 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.
+ *
+ * - `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 their wire.
+ * - `canvas.ts` — the canvas: what the flowchart draws its flow with.
+ * - `payload.ts` — the payload, its carrier, the shared keys, the props and
+ *   their refusals.
+ * - `flowchart.ts` — the tag.
+ *
+ * @packageDocumentation
+ */
+import { type FlowchartTagType } from "./flowchart.js";
+import { FlowchartCanvasType } from "./canvas.js";
+import { FlowchartCardType, FlowchartDecisionCardType, FlowchartLandsType, FlowchartLaneCardType, FlowchartLibraryTabType, FlowchartStateCardType, FlowchartTransitionCardType, type FlowchartLibrary } 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";
+export { FlowchartTag, type FlowchartTagType } from "./flowchart.js";
+export { FlowchartCanvasType, buildCanvas, type FlowchartCanvasOptions, type FlowchartSliceOptions, type FlowchartFreshnessInput, type FlowchartOrientationLiteral, } from "./canvas.js";
+export { flowchartOver, type RowElement, type FlowchartTables, type FlowchartStateFields, type FlowchartLinkFields, type FlowchartLaneFields, type FlowchartTriggerFields, type FlowchartEvidenceFields, type FlowchartLaneLiteral, } from "./over.js";
+export { FlowchartPatchTypeFor, flowchartPatch, type FlowchartRowType, type FlowchartPatchOf, type FlowchartPatchInput } from "./patch.js";
+export { FlowchartCardType, FlowchartDecisionCardType, FlowchartLandsType, FlowchartLaneCardType, FlowchartLibraryFactories, FlowchartLibraryTabType, FlowchartStateCardType, FlowchartTransitionCardType, libraryFlows, libraryStates, libraryTab, libraryTransitions, type FlowchartAuthorTab, type FlowchartCardAccessors, type FlowchartFlowsTab, type FlowchartLibrary, type FlowchartLibraryRows, type FlowchartLibraryTab, type FlowchartOneFlowLibraryTab, type FlowchartStatesConfig, type FlowchartStatesTab, type FlowchartTabConfig, type FlowchartTransitionsConfig, type FlowchartTransitionsTab, } from "./library.js";
+export { FlowchartComponent, FlowchartDataType, FlowchartFlowApplyType, FlowchartFlowsApplyType, FlowchartFlowsHandleType, FlowchartHistoryType, FlowchartInspectorType, FlowchartPayloadType, FlowchartSessionApplyType, FlowchartSourceType, createFlowchartPayload, flowchartKeys, type FlowchartBindHandle, type FlowchartCommon, type FlowchartInspectorOptions, type FlowchartRecordHandle, type FlowchartRowInspector, } from "./payload.js";
+export { flowchartValue, flowchartValues, type FlowchartFlowInput, type FlowchartLaneInput, type FlowchartStateInput, type FlowchartLinkInput, type FlowchartEvidenceInput, type FlowchartTriggerInput, type FlowchartLinkKindLiteral, } from "./values.js";
+/** The East types a flowchart is written with — `Flowchart.Types`. */
+export interface FlowchartTypes {
+    /** One flow: its lanes, states, transitions and decisions, and a sentence about it ({@link FlowchartFlowType}). */
+    Flow: typeof FlowchartFlowType;
+    /** A record of flows, by name ({@link FlowchartFlowsType}). */
+    Flows: typeof FlowchartFlowsType;
+    /** One state node ({@link FlowchartStateType}). */
+    State: typeof FlowchartStateType;
+    /** One transition ({@link FlowchartLinkType}). */
+    Link: typeof FlowchartLinkType;
+    /** One ordered phase band ({@link FlowchartLaneType}). */
+    Lane: typeof FlowchartLaneType;
+    /** One decision trigger ({@link FlowchartTriggerType}). */
+    Trigger: typeof FlowchartTriggerType;
+    /** Imported link evidence ({@link FlowchartEvidenceType}). */
+    Evidence: typeof FlowchartEvidenceType;
+    /** Link kind — planned | observed ({@link FlowchartLinkKindType}). */
+    Kind: typeof FlowchartLinkKindType;
+    /** Canvas orientation — LR | TD ({@link FlowchartOrientationType}). */
+    Orientation: typeof FlowchartOrientationType;
+    /** The toolbar's freshness chip ({@link FlowchartFreshnessType}). */
+    Freshness: typeof FlowchartFreshnessType;
+    /** `Patch(R)` — a patch over one of a flow's rows, every field an `Option` ({@link FlowchartPatchTypeFor}). */
+    Patch: typeof FlowchartPatchTypeFor;
+}
+/**
+ * The type of the {@link Flowchart} namespace: `<Flowchart>`, the values and
+ * patches a flowchart is written with, and its East types.
+ */
+export interface FlowchartNamespace extends FlowchartTagType {
+    /** One flow's value — written as a literal and checked when the package builds ({@link flowchartValue}). */
+    value: typeof flowchartValue;
+    /** A record of flows' value, by name — each flow written as a literal and checked when the package builds ({@link flowchartValues}). */
+    values: typeof flowchartValues;
+    /** One flow built from an app's own tables, through their row mappers ({@link flowchartOver}). */
+    over: typeof flowchartOver;
+    /** A patch over one of a flow's rows ({@link flowchartPatch}). */
+    patch: typeof flowchartPatch;
+    /** The library pane's tabs, each a factory `library` lists ({@link FlowchartLibrary}). */
+    library: FlowchartLibrary;
+    /** The East types a flowchart is written with ({@link FlowchartTypes}). */
+    Types: FlowchartTypes;
+}
+/**
+ * `<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.
+ *
+ * @remarks
+ * - **Its frame**: it renders in its builder frame wherever it is used — one
+ *   toolbar (find state, LR · TD, the freshness chip and, over `data`, the
+ *   slice's rail; over a record, 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 — an
+ *   input's or a record's, an Array or a `Dict<String, T>` — apart from the
+ *   flows and from the other tabs. 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.
+ * - **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, and `slice`
+ *   narrows what it builds.
+ * - **A dataset's value** is written as literals with `Flowchart.values`
+ *   (flows by name) or `Flowchart.value` (one flow), checked when the package
+ *   builds.
+ * - **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`,
+ *   `slice` or `affordances` over a record; `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>`; 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.*`.
+ *
+ * @example
+ * ```tsx
+ * // .tsx file with the `@jsxImportSource @elaraai/e3-ui` pragma
+ * import { East } from "@elaraai/east";
+ * import { Box, Reactive, UIComponentType } from "@elaraai/east-ui";
+ * import { Flowchart, Record } from "@elaraai/e3-ui";
+ * import e3 from "@elaraai/e3";
+ *
+ * export const depotFlows = e3.record("flowchart_depot_flows", Flowchart.Types.Flows, 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" }],
+ *     },
+ * }));
+ * export const depotFlowsPatch = e3.mutation.patch(depotFlows);
+ *
+ * const flowchart = East.function([], UIComponentType, (_$) => (
+ *     <Reactive>{$ => {
+ *         const flows = $.let(Record.bind(depotFlows, [depotFlowsPatch]));
+ *         return (
+ *             <Box height="500px">
+ *                 <Flowchart record={flows} flow="Inbound parcels" library={[Flowchart.library.flows()]} />
+ *             </Box>
+ *         );
+ *     }}</Reactive>
+ * ));
+ * ```
+ */
+export declare const Flowchart: FlowchartNamespace;
+/**
+ * The type of the internal Flowchart namespace — the public one, the payload
+ * the tag returns through its carrier, the carrier the renderer registers
+ * against, and the payload's own East types.
+ */
+export interface FlowchartInternalNamespace extends FlowchartNamespace {
+    /** Creates the flowchart's payload alone — what `<Flowchart>` returns through the `Flowchart` carrier ({@link createFlowchartPayload}). */
+    Payload: typeof createFlowchartPayload;
+    /** The `Flowchart` carrier ({@link FlowchartComponent}). */
+    Component: typeof FlowchartComponent;
+    /** The East types a flowchart is written with, and its payload's. */
+    Types: FlowchartTypes & {
+        /** The renderer's payload ({@link FlowchartPayloadType}). */
+        Payload: typeof FlowchartPayloadType;
+        /** What the canvas draws its flow with ({@link FlowchartCanvasType}). */
+        Canvas: typeof FlowchartCanvasType;
+        /** Where the flows come from ({@link FlowchartSourceType}). */
+        Source: typeof FlowchartSourceType;
+        /** The host's flows ({@link FlowchartDataType}). */
+        Data: typeof FlowchartDataType;
+        /** A record of flows, bound ({@link FlowchartFlowsHandleType}). */
+        FlowsHandle: typeof FlowchartFlowsHandleType;
+        /** The editing session's Save, over a record or the host's flows ({@link FlowchartSessionApplyType}). */
+        SessionApply: typeof FlowchartSessionApplyType;
+        /** The inspector pane: each kind's own Details ({@link FlowchartInspectorType}). */
+        Inspector: typeof FlowchartInspectorType;
+        /** One tab of the library ({@link FlowchartLibraryTabType}). */
+        LibraryTab: typeof FlowchartLibraryTabType;
+        /** An author's tab's cards, by what they land on ({@link FlowchartLandsType}). */
+        Lands: typeof FlowchartLandsType;
+        /** A card that drops nothing ({@link FlowchartCardType}). */
+        Card: typeof FlowchartCardType;
+        /** A state template's card ({@link FlowchartStateCardType}). */
+        StateCard: typeof FlowchartStateCardType;
+        /** A transition template's card ({@link FlowchartTransitionCardType}). */
+        TransitionCard: typeof FlowchartTransitionCardType;
+        /** An author's card that lands on a lane ({@link FlowchartLaneCardType}). */
+        LaneCard: typeof FlowchartLaneCardType;
+        /** An author's card that lands on a decision ({@link FlowchartDecisionCardType}). */
+        DecisionCard: typeof FlowchartDecisionCardType;
+    };
+}
+/**
+ * The internal Flowchart namespace — `@elaraai/e3-ui/internal`'s `Flowchart`:
+ * the public one, `Flowchart.Payload`, the `Flowchart` carrier and the
+ * payload's types, for the renderer and the tests.
+ *
+ * @internal
+ */
+export declare const FlowchartInternal: FlowchartInternalNamespace;
+//# sourceMappingURL=index.d.ts.map

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

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