@elaraai/e3-ui 1.0.103 → 1.0.104

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

@@ -3,827 +3,242 @@
  * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
  */
 /**
- * `Flowchart.library` — the flowchart's library pane (#1246, #1248,
- * `Flowchart Builder Spec.md` decisions 5–8, §4.2, §4.4, FB13, FB25–FB29):
- * `library` lists the pane's tabs, in order, each a `Flowchart.library.*`
- * call. Left out, or empty, the flowchart has no library pane.
- *
- * - `Flowchart.library.flows()` (#1246) — the Flows tab: every flow the
- *   flowchart holds by name, a click opening one on the canvas, and "+ New
- *   flow" naming another. Over one flow there is none to list, so one flow's
- *   library takes every tab but it.
- * - `Flowchart.library.states(rows, { … })` — state templates: one card per
- *   row, its `drop` the fields of the state a card dropped on a lane adds.
- * - `Flowchart.library.transitions(rows, { … })` — transition templates: one
- *   card per row, its `drop` the fields a card sets on the transition it lands
- *   on.
- * - `Flowchart.library.tab(rows, { … })` — the author's own cards; given a
- *   `drop`, its patch's type names what a card lands on: a state, a
- *   transition, a lane's header or a decision's diamond.
- *
- * Each data tab takes its own bound data (the user, 2026-10-08), apart from
- * the flows and from the other tabs, read as `Sheet.library.tab` reads its
- * rows: its accessors `(row, key) => …` reified once into a describe function
- * the rows' map then calls, a Dict's key the second argument and an Array's
- * index, printed, in its place. A card crosses the closed payload as the
- * fields its drop sets, typed by the row it lands on — a flow's rows are the
- * flowchart's own types. Dropped on the canvas (#1249), a state template adds
- * a state where it lands on a lane, a transition template retypes the
- * transition it lands on, and an author's card sets its fields on what its
- * drop's type names; ⏎ on a card drops it on the canvas's selection.
- *
- * Templates are records (#1340, ruling 9): the state and the transition
- * templates are each a record of their own, read whole
- * (`Data.bind(record).read()`, a `Dict<String, T>`), each card keyed by its
- * record's key, and each list names its `source` of the flowchart's one
- * `Slice.bindRecords`, which narrows its cards by those keys as it narrows
- * anything of that record's — a list written in the code names none, and is
- * refused, naming the change (#1346). An author's tab reads an `Array<T>` or
- * a `Dict<String, T>`, each card keyed by its `key`, a key that repeats
- * keeping its first card; naming a `source` it follows that source by its
- * cards' keys, and naming none it lists its rows whole.
+ * `Flowchart.library` (#1501, `Flowchart Records Spec.md` R14, D5, D8): the
+ * library pane's tabs, which `library` lists in order, and their wire, which
+ * the renderer draws. A kind's cards are on the kind, as the Schematic's are —
+ * `Flowchart.templates(rows, { name, group?, values, source })`, rows of a
+ * record of the app's — and its tab lists them, following their source of the
+ * slice:
+ *
+ * - `Flowchart.library.states()` — the Steps tab, the states' cards: one
+ *   dropped on a lane adds a state there from its values, keyed `state-<n>`,
+ *   its order between the cards it lands between.
+ * - `Flowchart.library.transitions()` — the Transitions tab, the transitions'
+ *   cards: one dropped on a transition gives it its values, its ends kept.
+ * - `Flowchart.library.lanes()` — the Lanes tab, the lanes' cards: one dropped
+ *   between two lanes, or at the band row's tail, adds a lane there from its
+ *   values, keyed `lane-<n>`, its order between theirs.
+ * - `Flowchart.library.tab(rows, { … })` — the app's own cards: its `drop` a
+ *   `Flowchart.patch(R, { … })` over one kind's row type, which names the kind
+ *   its cards land on — a state's, a transition's, a lane's or a decision's —
+ *   through the shared `buildScheduleTab`, as the Schematic's tabs are.
+ *
+ * There is no Flows tab: the Flowchart draws one flowchart. Left out, or
+ * empty, the Flowchart has no library pane.
  *
  * @packageDocumentation
  */
-import { ArrayType, DictType, NullType, OptionType, StringType, StructType, VariantType, type EastType, type ExprType, type SubtypeExprOrValue } from "@elaraai/east";
-import { type FlowchartPatchOf } from "./patch.js";
-import { FlowchartLinkType, FlowchartStateType } from "./types.js";
-/**
- * A card a library tab lists that drops nothing: an author's card read, never
- * dragged.
- *
- * @property key - Its identity in its tab
- * @property label - Its title
- * @property meta - A line under its title
- * @property group - The group its tab lists it under
- */
-export declare const FlowchartCardType: StructType<{
-    readonly key: StringType;
-    readonly label: StringType;
-    readonly meta: OptionType<StringType>;
-    readonly group: OptionType<StringType>;
-}>;
-/** Type representing {@link FlowchartCardType}. */
-export type FlowchartCardType = typeof FlowchartCardType;
+import { ArrayType, OptionType, StringType, StructType, VariantType, type DictType, type EastType, type ExprType, type SubtypeExprOrValue } from "@elaraai/east";
+import { type ScheduleLibraryTabConfig } from "../schedule/library.js";
+import type { FlowchartKindSort } from "./kinds.js";
+export { ScheduleLibraryCardType as FlowchartLibraryCardType } from "../schedule/library.js";
 /**
- * A state template's card: what it shows, and the fields of the state it
- * adds, over a state's defaults — the `Flowchart.patch(Flowchart.Types.State, …)`
- * its drop returns.
+ * A kind's tab on the wire: its name and icon, the author's when given; left
+ * out, the renderer names it in its words (`Steps`, `Transitions`, `Lanes`),
+ * so a host translates it. Its cards are its kind's. The tab an author lists
+ * is a {@link FlowchartKindTab}, which this is built from.
  */
-export declare const FlowchartStateCardType: StructType<{
-    readonly key: StringType;
-    readonly label: StringType;
-    readonly meta: OptionType<StringType>;
-    readonly group: OptionType<StringType>;
-    readonly sets: FlowchartPatchOf<StructType<{
-        readonly key: StringType;
-        readonly label: OptionType<StringType>;
-        readonly lane: StringType;
-        readonly members: OptionType<import("@elaraai/east").IntegerType>;
-        readonly notes: OptionType<StringType>;
-    }>>;
-}>;
-/** Type representing {@link FlowchartStateCardType}. */
-export type FlowchartStateCardType = typeof FlowchartStateCardType;
-/**
- * A transition template's card: what it shows, and the fields it sets on the
- * transition it lands on — the `Flowchart.patch(Flowchart.Types.Link, …)` its
- * drop returns.
- */
-export declare const FlowchartTransitionCardType: StructType<{
-    readonly key: StringType;
-    readonly label: StringType;
-    readonly meta: OptionType<StringType>;
-    readonly group: OptionType<StringType>;
-    readonly sets: FlowchartPatchOf<StructType<{
-        readonly key: OptionType<StringType>;
-        readonly from: StringType;
-        readonly to: StringType;
-        readonly kind: OptionType<VariantType<{
-            readonly planned: NullType;
-            readonly observed: NullType;
-        }>>;
-        readonly trigger: OptionType<StringType>;
-        readonly evidence: OptionType<StructType<{
-            readonly volume: OptionType<import("@elaraai/east").FloatType>;
-            readonly count: OptionType<import("@elaraai/east").IntegerType>;
-            readonly measuredAt: OptionType<import("@elaraai/east").DateTimeType>;
-            readonly unit: OptionType<StringType>;
-        }>>;
-    }>>;
-}>;
-/** Type representing {@link FlowchartTransitionCardType}. */
-export type FlowchartTransitionCardType = typeof FlowchartTransitionCardType;
-/** An author's card that lands on a lane's header, and the lane's fields it sets. */
-export declare const FlowchartLaneCardType: StructType<{
-    readonly key: StringType;
-    readonly label: StringType;
-    readonly meta: OptionType<StringType>;
-    readonly group: OptionType<StringType>;
-    readonly sets: FlowchartPatchOf<StructType<{
-        readonly key: StringType;
-        readonly label: OptionType<StringType>;
-    }>>;
-}>;
-/** Type representing {@link FlowchartLaneCardType}. */
-export type FlowchartLaneCardType = typeof FlowchartLaneCardType;
-/** An author's card that lands on a decision's diamond, and the decision's fields it sets. */
-export declare const FlowchartDecisionCardType: StructType<{
-    readonly key: StringType;
-    readonly label: StringType;
-    readonly meta: OptionType<StringType>;
-    readonly group: OptionType<StringType>;
-    readonly sets: FlowchartPatchOf<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly letter: OptionType<StringType>;
-        readonly owner: OptionType<StringType>;
-        readonly queue: OptionType<ArrayType<StringType>>;
-        readonly outcomes: OptionType<StringType>;
-    }>>;
-}>;
-/** Type representing {@link FlowchartDecisionCardType}. */
-export type FlowchartDecisionCardType = typeof FlowchartDecisionCardType;
-/**
- * An author's tab's cards, by what they land on — the type of the patch its
- * `drop` returns — each card with the fields it sets there.
- *
- * @property none - The tab declares no `drop`: its cards are read, never dragged
- * @property state - Its cards land on a state
- * @property transition - Its cards land on a transition
- * @property lane - Its cards land on a lane's header
- * @property decision - Its cards land on a decision's diamond
- */
-export declare const FlowchartLandsType: VariantType<{
-    readonly none: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly meta: OptionType<StringType>;
-        readonly group: OptionType<StringType>;
-    }>>;
-    readonly state: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly meta: OptionType<StringType>;
-        readonly group: OptionType<StringType>;
-        readonly sets: FlowchartPatchOf<StructType<{
-            readonly key: StringType;
-            readonly label: OptionType<StringType>;
-            readonly lane: StringType;
-            readonly members: OptionType<import("@elaraai/east").IntegerType>;
-            readonly notes: OptionType<StringType>;
-        }>>;
-    }>>;
-    readonly transition: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly meta: OptionType<StringType>;
-        readonly group: OptionType<StringType>;
-        readonly sets: FlowchartPatchOf<StructType<{
-            readonly key: OptionType<StringType>;
-            readonly from: StringType;
-            readonly to: StringType;
-            readonly kind: OptionType<VariantType<{
-                readonly planned: NullType;
-                readonly observed: NullType;
-            }>>;
-            readonly trigger: OptionType<StringType>;
-            readonly evidence: OptionType<StructType<{
-                readonly volume: OptionType<import("@elaraai/east").FloatType>;
-                readonly count: OptionType<import("@elaraai/east").IntegerType>;
-                readonly measuredAt: OptionType<import("@elaraai/east").DateTimeType>;
-                readonly unit: OptionType<StringType>;
-            }>>;
-        }>>;
-    }>>;
-    readonly lane: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly meta: OptionType<StringType>;
-        readonly group: OptionType<StringType>;
-        readonly sets: FlowchartPatchOf<StructType<{
-            readonly key: StringType;
-            readonly label: OptionType<StringType>;
-        }>>;
-    }>>;
-    readonly decision: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly label: StringType;
-        readonly meta: OptionType<StringType>;
-        readonly group: OptionType<StringType>;
-        readonly sets: FlowchartPatchOf<StructType<{
-            readonly key: StringType;
-            readonly label: StringType;
-            readonly letter: OptionType<StringType>;
-            readonly owner: OptionType<StringType>;
-            readonly queue: OptionType<ArrayType<StringType>>;
-            readonly outcomes: OptionType<StringType>;
-        }>>;
-    }>>;
+export declare const FlowchartKindTabWireType: StructType<{
+    readonly name: OptionType<StringType>;
+    readonly icon: OptionType<StringType>;
 }>;
-/** Type representing {@link FlowchartLandsType}. */
-export type FlowchartLandsType = typeof FlowchartLandsType;
+/** Type representing {@link FlowchartKindTabWireType}. */
+export type FlowchartKindTabWireType = typeof FlowchartKindTabWireType;
 /**
- * One tab of the library pane, as `library` lists it (`Flowchart Builder
- * Spec.md` §4.2).
+ * One tab of the library pane on the wire, in the order `library` lists them.
  *
- * @remarks
- * A card crosses the closed payload as the fields its drop sets, typed by the
- * row it lands on — a flow's rows are the flowchart's own types. A template
- * tab's name is the author's when given; left out, the renderer names it in
- * its words (`States`, `Transitions`), so a host translates it.
- *
- * @property flows - Every flow in the record — over a slice, those its `flows` source narrows them to; a click opens one
- * @property states - State templates from the tab's own record: its name, its icon, its cards, and the source of the slice they follow, by their keys (#1346)
- * @property transitions - Transition templates from the tab's own record: its name, its icon, its cards, and the source of the slice they follow, by their keys (#1346)
- * @property tab - The author's own cards: its name, its icon, its cards by what they land on, and the source of the slice they follow, by their keys — none, its cards whole (#1346)
+ * @property states - The Steps tab: the states' cards, which the states kind carries
+ * @property transitions - The Transitions tab: the transitions' cards
+ * @property lanes - The Lanes tab: the lanes' cards
+ * @property tab - The author's own: its name, its icon, the kind its cards land on, its cards and the source they follow
  */
 export declare const FlowchartLibraryTabType: VariantType<{
-    readonly flows: NullType;
     readonly states: StructType<{
         readonly name: OptionType<StringType>;
         readonly icon: OptionType<StringType>;
-        readonly cards: ArrayType<StructType<{
-            readonly key: StringType;
-            readonly label: StringType;
-            readonly meta: OptionType<StringType>;
-            readonly group: OptionType<StringType>;
-            readonly sets: FlowchartPatchOf<StructType<{
-                readonly key: StringType;
-                readonly label: OptionType<StringType>;
-                readonly lane: StringType;
-                readonly members: OptionType<import("@elaraai/east").IntegerType>;
-                readonly notes: OptionType<StringType>;
-            }>>;
-        }>>;
-        readonly source: StringType;
     }>;
     readonly transitions: StructType<{
         readonly name: OptionType<StringType>;
         readonly icon: OptionType<StringType>;
+    }>;
+    readonly lanes: StructType<{
+        readonly name: OptionType<StringType>;
+        readonly icon: OptionType<StringType>;
+    }>;
+    readonly tab: StructType<{
+        readonly name: StringType;
+        readonly icon: OptionType<StringType>;
+        readonly drop: OptionType<StringType>;
         readonly cards: ArrayType<StructType<{
             readonly key: StringType;
             readonly label: StringType;
             readonly meta: OptionType<StringType>;
             readonly group: OptionType<StringType>;
-            readonly sets: FlowchartPatchOf<StructType<{
-                readonly key: OptionType<StringType>;
-                readonly from: StringType;
-                readonly to: StringType;
-                readonly kind: OptionType<VariantType<{
-                    readonly planned: NullType;
-                    readonly observed: NullType;
-                }>>;
-                readonly trigger: OptionType<StringType>;
-                readonly evidence: OptionType<StructType<{
-                    readonly volume: OptionType<import("@elaraai/east").FloatType>;
-                    readonly count: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly measuredAt: OptionType<import("@elaraai/east").DateTimeType>;
-                    readonly unit: OptionType<StringType>;
-                }>>;
+            readonly sets: ArrayType<StructType<{
+                readonly path: ArrayType<StringType>;
+                readonly value: import("@elaraai/east").BlobType;
             }>>;
         }>>;
-        readonly source: StringType;
-    }>;
-    readonly tab: StructType<{
-        readonly name: StringType;
-        readonly icon: OptionType<StringType>;
-        readonly lands: VariantType<{
-            readonly none: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly label: StringType;
-                readonly meta: OptionType<StringType>;
-                readonly group: OptionType<StringType>;
-            }>>;
-            readonly state: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly label: StringType;
-                readonly meta: OptionType<StringType>;
-                readonly group: OptionType<StringType>;
-                readonly sets: FlowchartPatchOf<StructType<{
-                    readonly key: StringType;
-                    readonly label: OptionType<StringType>;
-                    readonly lane: StringType;
-                    readonly members: OptionType<import("@elaraai/east").IntegerType>;
-                    readonly notes: OptionType<StringType>;
-                }>>;
-            }>>;
-            readonly transition: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly label: StringType;
-                readonly meta: OptionType<StringType>;
-                readonly group: OptionType<StringType>;
-                readonly sets: FlowchartPatchOf<StructType<{
-                    readonly key: OptionType<StringType>;
-                    readonly from: StringType;
-                    readonly to: StringType;
-                    readonly kind: OptionType<VariantType<{
-                        readonly planned: NullType;
-                        readonly observed: NullType;
-                    }>>;
-                    readonly trigger: OptionType<StringType>;
-                    readonly evidence: OptionType<StructType<{
-                        readonly volume: OptionType<import("@elaraai/east").FloatType>;
-                        readonly count: OptionType<import("@elaraai/east").IntegerType>;
-                        readonly measuredAt: OptionType<import("@elaraai/east").DateTimeType>;
-                        readonly unit: OptionType<StringType>;
-                    }>>;
-                }>>;
-            }>>;
-            readonly lane: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly label: StringType;
-                readonly meta: OptionType<StringType>;
-                readonly group: OptionType<StringType>;
-                readonly sets: FlowchartPatchOf<StructType<{
-                    readonly key: StringType;
-                    readonly label: OptionType<StringType>;
-                }>>;
-            }>>;
-            readonly decision: ArrayType<StructType<{
-                readonly key: StringType;
-                readonly label: StringType;
-                readonly meta: OptionType<StringType>;
-                readonly group: OptionType<StringType>;
-                readonly sets: FlowchartPatchOf<StructType<{
-                    readonly key: StringType;
-                    readonly label: StringType;
-                    readonly letter: OptionType<StringType>;
-                    readonly owner: OptionType<StringType>;
-                    readonly queue: OptionType<ArrayType<StringType>>;
-                    readonly outcomes: OptionType<StringType>;
-                }>>;
-            }>>;
-        }>;
         readonly source: OptionType<StringType>;
     }>;
 }>;
 /** Type representing {@link FlowchartLibraryTabType}. */
 export type FlowchartLibraryTabType = typeof FlowchartLibraryTabType;
-/**
- * What a data tab's card shows, read off one of its rows — its value and its
- * key: a Dict's key, or an Array's index, printed — as `Sheet.library.tab`'s
- * accessors read them.
- *
- * @typeParam T - The rows' element type
- */
-export interface FlowchartCardAccessors<T extends EastType> {
-    /** The card's name. */
-    label: (row: ExprType<T>, key: ExprType<StringType>) => SubtypeExprOrValue<StringType>;
-    /** The line under it — return the field's `Option`. */
-    meta?: (row: ExprType<T>, key: ExprType<StringType>) => SubtypeExprOrValue<OptionType<StringType>>;
-    /** The tab's group the card sits under. */
-    group?: (row: ExprType<T>, key: ExprType<StringType>) => SubtypeExprOrValue<StringType>;
-}
-/**
- * A state template tab — `Flowchart.library.states(rows, { … })`: its name
- * and icon, what each card shows, and the fields of the state it adds. Each
- * card is keyed by its templates record's key (#1346): it takes no `key`.
- *
- * @typeParam T - The rows' element type
- */
-export interface FlowchartStatesConfig<T extends EastType> extends FlowchartCardAccessors<T> {
-    /** The tab's name; left out, `States`, in the flowchart's words. */
+/** The kinds that take cards, each with a tab of its own: the states, the transitions and the lanes. */
+export type FlowchartCardKind = "states" | "transitions" | "lanes";
+/** A kind's tab's options: its name and its icon. */
+export interface FlowchartKindTabOptions {
+    /** The tab's name; left out, the Flowchart's words: `Steps`, `Transitions` or `Lanes`. */
     name?: string;
-    /** A Font Awesome solid icon name for the tab's cards. */
-    icon?: string;
-    /** The fields of the state a card dropped on a lane adds, over a state's defaults: `Flowchart.patch(Flowchart.Types.State, { … })`. */
-    drop: (row: ExprType<T>, key: ExprType<StringType>) => ExprType<FlowchartPatchOf<FlowchartStateType>>;
-    /**
-     * The source of the flowchart's `Slice.bindRecords` over this templates
-     * record (#1340, ruling 9): its shown keys narrow the tab's cards, each
-     * card's key its record's key. A templates list must name one.
-     */
-    source?: string;
-}
-/**
- * A transition template tab — `Flowchart.library.transitions(rows, { … })`:
- * its name and icon, what each card shows, and the fields it sets on the
- * transition it lands on. Each card is keyed by its templates record's key
- * (#1346): it takes no `key`.
- *
- * @typeParam T - The rows' element type
- */
-export interface FlowchartTransitionsConfig<T extends EastType> extends FlowchartCardAccessors<T> {
-    /** The tab's name; left out, `Transitions`, in the flowchart's words. */
-    name?: string;
-    /** A Font Awesome solid icon name for the tab's cards. */
-    icon?: string;
-    /**
-     * The fields a card sets on the transition it lands on —
-     * `Flowchart.patch(Flowchart.Types.Link, { … })`: its kind, its decision
-     * and its other fields, never its `key`, `from` or `to`.
-     */
-    drop: (row: ExprType<T>, key: ExprType<StringType>) => ExprType<FlowchartPatchOf<FlowchartLinkType>>;
-    /**
-     * The source of the flowchart's `Slice.bindRecords` over this templates
-     * record (#1340, ruling 9): its shown keys narrow the tab's cards, each
-     * card's key its record's key. A templates list must name one.
-     */
-    source?: string;
-}
-/**
- * An author's tab — `Flowchart.library.tab(rows, { … })`: its name and icon,
- * what each card shows, and, given a `drop`, the fields a card sets where it
- * lands.
- *
- * @typeParam T - The rows' element type
- * @typeParam P - The patch `drop` returns: `Flowchart.Types.Patch` of a flow's row type
- */
-export interface FlowchartTabConfig<T extends EastType, P extends EastType = EastType> extends FlowchartCardAccessors<T> {
-    /** The tab's name: its label in the tab row, and its identity in `library`. */
-    name: string;
-    /**
-     * The card's key — unique within the tab; a key that repeats keeps its
-     * first card. Following a `source`, it is the key of that record's row:
-     * the tab follows the source by it.
-     */
-    key: (row: ExprType<T>, key: ExprType<StringType>) => SubtypeExprOrValue<StringType>;
-    /** A Font Awesome solid icon name for the tab's cards. */
+    /** A Font Awesome solid icon name for the tab. */
     icon?: string;
-    /**
-     * What a dropped card sets: `Flowchart.patch(R, { … })` over a flow's row
-     * type, whose type names what it lands on — `State` a state, `Link` a
-     * transition, `Lane` a lane's header, `Trigger` a decision's diamond.
-     * Without one, the cards are read, never dragged.
-     */
-    drop?: (row: ExprType<T>, key: ExprType<StringType>) => ExprType<P>;
-    /**
-     * The source of the flowchart's `Slice.bindRecords` whose shown keys
-     * filter this tab's cards (#1346), each card's key its row's key in that
-     * record; omitted, the tab lists its rows whole. It counts what it shows,
-     * and says so when the rail leaves it none.
-     */
-    source?: string;
 }
-/** The Flows tab, as `Flowchart.library.flows()` returns it. */
-export interface FlowchartFlowsTab {
-    readonly kind: "flows";
-}
-/** The state templates' tab, as `Flowchart.library.states(…)` returns it: its rows and how it reads them. */
-export interface FlowchartStatesTab {
-    readonly kind: "states";
-    readonly rows: unknown;
-    readonly config: FlowchartStatesConfig<EastType>;
-}
-/** The transition templates' tab, as `Flowchart.library.transitions(…)` returns it: its rows and how it reads them. */
-export interface FlowchartTransitionsTab {
-    readonly kind: "transitions";
-    readonly rows: unknown;
-    readonly config: FlowchartTransitionsConfig<EastType>;
+/** A kind's tab, as `Flowchart.library.states()`, `.transitions()` or `.lanes()` returns it. */
+export interface FlowchartKindTab {
+    /** The kind whose cards it lists. */
+    readonly kind: FlowchartCardKind;
+    /** Its name, when given. */
+    readonly name: string | undefined;
+    /** Its icon, when given. */
+    readonly icon: string | undefined;
 }
 /** An author's tab, as `Flowchart.library.tab(…)` returns it: its rows and how it reads them. */
 export interface FlowchartAuthorTab {
+    /** Identifies an author's tab. */
     readonly kind: "tab";
+    /** Its rows: an Array, or a Dict by String keys. */
     readonly rows: unknown;
-    readonly config: FlowchartTabConfig<EastType>;
+    /** How it reads them. */
+    readonly config: ScheduleLibraryTabConfig<EastType, EastType>;
 }
-/** One tab of the library pane — what each `Flowchart.library.*` call returns, and `library` lists. */
-export type FlowchartLibraryTab = FlowchartFlowsTab | FlowchartStatesTab | FlowchartTransitionsTab | FlowchartAuthorTab;
+/** One tab of the library pane: what each `Flowchart.library.*` call returns, and `library` lists. */
+export type FlowchartLibraryTab = FlowchartKindTab | FlowchartAuthorTab;
 /**
- * The tabs a flowchart over one flow may list: every tab but the Flows tab,
- * which lists flows by name — one flow has none to list (FB16).
+ * An author's tab's options — `Flowchart.library.tab(rows, { … })`: its name
+ * and icon, what each card shows, the source of the slice it follows, and the
+ * patch a card dropped on a row sets.
+ *
+ * @typeParam T - The rows' element type
+ * @typeParam P - The patch `drop` returns
  */
-export type FlowchartOneFlowLibraryTab = FlowchartStatesTab | FlowchartTransitionsTab | FlowchartAuthorTab;
-/** The rows an author's tab reads: an Array, or a Dict by String keys — a record's, when it follows a source. */
+export type FlowchartTabConfig<T extends EastType, P extends EastType = EastType> = ScheduleLibraryTabConfig<StringType, T, P>;
+/** The rows an author's tab reads: an Array, each card keyed by its index, printed; or a Dict by String keys — a record's, when it follows a source. */
 export type FlowchartLibraryRows<T extends EastType> = SubtypeExprOrValue<ArrayType<T>> | SubtypeExprOrValue<DictType<StringType, T>>;
-/** The rows a templates list reads (#1340, ruling 9): its templates record's, by String keys — its binding's `read()`. */
-export type FlowchartTemplateRows<T extends EastType> = SubtypeExprOrValue<DictType<StringType, T>>;
 /**
- * The Flows tab — `Flowchart.library.flows()` (FB13, FB14): every flow the
- * flowchart holds, by name, each card its name and its description — or, with
- * none, its counts — the open flow placed, and a flow whose drafts are not
- * yet saved marked Pending. A click opens a flow on the canvas, and the
- * tab's search reads names and descriptions. Where the flowchart edits — a
- * record, or the host's flows given `onApply`, and not read only — "+ New
- * flow" names another, refusing a name the flowchart holds, and opens it
- * empty, one lane, as a draft the history item saves or discards.
- *
- * @remarks
- * Over a record of flows, or the host's flows by name. Over one flow (`data`
- * of `Flowchart.Types.Flow`) it is refused, when the surface is built and by
- * the tag's types.
+ * The Steps tab — `Flowchart.library.states()` (R14, D8): the states' cards,
+ * `Flowchart.templates` on `Flowchart.states`, grouped by their `group` and
+ * searched by their name, each a drag source. One dropped on a lane adds a
+ * state there from its values, keyed `state-<n>`, its order between the
+ * cards it lands between. It follows its cards' source of the slice, counting
+ * what it shows.
  *
+ * @param options - The tab's name — `Steps` unless given — and its icon
+ * @param rest - Nothing: rows and a config, as the earlier form took, are refused
  * @returns The tab
- *
- * @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, {
- *     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" }],
- *         },
- *     }),
- *     mutations: (mutation) => ({
- *         patch: mutation.patch(),
- *     }),
- * });
- *
- * const flowchart = East.function([], UIComponentType, (_$) => (
- *     <Reactive>{$ => {
- *         const flows = $.let(Record.bind(depotFlows));
- *         return (
- *             <Box height="500px">
- *                 <Flowchart record={flows} flow="Inbound parcels" library={[Flowchart.library.flows()]} />
- *             </Box>
- *         );
- *     }}</Reactive>
- * ));
- * ```
+ * @throws {Error} When given anything but `{ name?, icon? }`, naming the cards on the kind
  */
-export declare function libraryFlows(): FlowchartFlowsTab;
+export declare function libraryStates(options?: FlowchartKindTabOptions, ...rest: readonly never[]): FlowchartKindTab;
 /**
- * The state templates — `Flowchart.library.states(rows, { … })` (FB26,
- * decisions 6 and 7): one card per row of the tab's own templates record —
- * its label, the line under it, the tab's icon — grouped by its `group` and
- * searched by its key, label and line. Each card is a drag source, and a click
- * selects it, a click on the selected card letting it go. A card dropped on a
- * lane adds a state there, seeded with the fields its `drop` sets over a
- * state's defaults (#1249).
+ * The Transitions tab — `Flowchart.library.transitions()` (R14, D8): the
+ * transitions' cards, `Flowchart.templates` on `Flowchart.transitions`. One
+ * dropped on a transition gives it its values, its ends kept.
  *
- * @remarks
- * Templates are records (#1340, ruling 9): the rows are a templates record's,
- * read whole — `Data.bind(record).read()`, a `Dict<String, T>` — apart from
- * the flows and from the other tabs, each accessor taking a row and its key.
- * A card's key is its record's key, and the tab follows `source`, the
- * flowchart's slice's source over that record, by it (#1346). Left out, the
- * tab's name is `States`, in the flowchart's words. Refused when the surface
- * is built: a list naming no source — one written in the code — or one the
- * slice lacks, or `flows`; rows that are no `Dict<String, T>`; a `key`, which
- * the record's keys are; a `drop` over another type than
- * `Flowchart.Types.State`; and the tab listed twice.
- *
- * @typeParam T - The rows' element type
- * @param rows - The templates record's rows — a `Dict<String, T>` expression, its binding's `read()`
- * @param config - The tab's name and icon, what each card shows, its `drop` and its `source` ({@link FlowchartStatesConfig})
+ * @param options - The tab's name — `Transitions` unless given — and its icon
+ * @param rest - Nothing: rows and a config, as the earlier form took, are refused
  * @returns The tab
- *
- * @example
- * ```tsx
- * // .tsx file with the `@jsxImportSource @elaraai/e3-ui` pragma
- * import { DictType, East, IntegerType, OptionType, StringType, StructType, none, some, variant } from "@elaraai/east";
- * import { Box, Reactive, Slice, UIComponentType } from "@elaraai/east-ui";
- * import { Data, Flowchart, Record } 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" }],
- *         },
- *     }),
- *     mutations: (mutation) => ({
- *         patch: mutation.patch(),
- *     }),
- * });
- * export const StepTemplate = StructType({ name: StringType, kind: StringType, slots: OptionType(IntegerType) });
- * export const stepTemplates = e3.record("flowchart_step_templates", DictType(StringType, StepTemplate), {
- *     initial: new Map([
- *         ["ARV", { name: "Arrived", kind: "Intake", slots: none }],
- *         ["SCN", { name: "Scanned", kind: "Intake", slots: none }],
- *         ["CH*", { name: "Sort chutes", kind: "Sort", slots: some(12n) }],
- *         ["HLD", { name: "Held", kind: "Hold", slots: none }],
- *         ["LDD", { name: "Loaded", kind: "Load", slots: none }],
- *     ]),
- *     indexes: (index) => ({
- *         flowchart_steps_by_kind: index.on(["kind"]),
- *     }),
- *     mutations: (mutation) => ({
- *         // The step types' patch door: what another writer adds a step type through, the Steps tab's cards following.
- *         patch: mutation.patch(),
- *     }),
- * });
- * export const MoveTemplate = StructType({ kind: Flowchart.Types.Kind, decision: OptionType(StringType), note: StringType });
- * export const moveTemplates = e3.record("flowchart_move_templates", DictType(StringType, MoveTemplate), {
- *     initial: new Map([
- *         ["Observed", { kind: variant("observed", null), decision: none, note: "Mined from the scans" }],
- *         ["Planned", { kind: variant("planned", null), decision: none, note: "The designed path" }],
- *         ["Routed", { kind: variant("planned", null), decision: some("route"), note: "Governed by the route decision" }],
- *     ]),
- *     indexes: (index) => ({
- *         flowchart_moves_by_kind: index.on(["kind"]),
- *     }),
- * });
- * export const DecisionOwner = StructType({ name: StringType, desk: StringType });
- * export const decisionOwners = e3.record("flowchart_decision_owners", DictType(StringType, DecisionOwner), {
- *     initial: new Map([
- *         ["sort-planner", { name: "Sort planner", desk: "Sort hall" }],
- *         ["customs-desk", { name: "Customs desk", desk: "Hold bay" }],
- *     ]),
- *     indexes: (index) => ({
- *         flowchart_owners_by_desk: index.on(["desk"]),
- *     }),
- * });
- *
- * const flowchart = East.function([], UIComponentType, (_$) => (
- *     <Reactive>{$ => {
- *         const flows = $.let(Record.bind(depotFlows));
- *         // What a tab reads whole binds with Data.bind, which keeps it loaded beside its pages.
- *         const steps = $.let(Data.bind(stepTemplates));
- *         const moves = $.let(Data.bind(moveTemplates));
- *         const owners = $.let(Data.bind(decisionOwners));
- *         // One rail over the library's records, a source each (#1346): each tab follows the source it names.
- *         const slice = $.let(Slice.bindRecords("flowchart.depot", {
- *             steps: { source: Data.bindPaged(stepTemplates, { indexes: ["flowchart_steps_by_kind"] }), label: "Steps", icon: { prefix: "fas", name: "box" },
- *                 fields: { kind: { label: "Step kind", hints: ["Intake", "Sort", "Hold", "Load"] } } },
- *             moves: { source: Data.bindPaged(moveTemplates, { indexes: ["flowchart_moves_by_kind"] }), label: "Transitions", icon: { prefix: "fas", name: "arrow-right" },
- *                 fields: { kind: { label: "Transition kind" } } },
- *             owners: { source: Data.bindPaged(decisionOwners, { indexes: ["flowchart_owners_by_desk"] }), label: "Owners", icon: { prefix: "fas", name: "user-tie" },
- *                 fields: { desk: { label: "Desk", hints: ["Sort hall", "Hold bay"] } } },
- *         }));
- *         return (
- *             <Box height="560px">
- *                 <Flowchart
- *                     record={flows}
- *                     flow="Inbound parcels"
- *                     name="depot"
- *                     slice={{ slice }}
- *                     library={[
- *                         Flowchart.library.flows(),
- *                         // Step types, a templates record by code: a card dropped on a lane adds a state seeded with what its drop sets.
- *                         Flowchart.library.states(steps.read(), {
- *                             name: "Steps", icon: "box", source: "steps",
- *                             label: s => s.name, meta: (_s, code) => some(code), group: s => s.kind,
- *                             drop: (s, code) => Flowchart.patch(Flowchart.Types.State, { key: code, label: some(s.name), members: s.slots }),
- *                         }),
- *                         // Transition types, a templates record by name: a card dropped on a transition retypes it.
- *                         Flowchart.library.transitions(moves.read(), {
- *                             icon: "arrow-right", source: "moves",
- *                             label: (_m, name) => name, meta: m => some(m.note),
- *                             drop: m => Flowchart.patch(Flowchart.Types.Link, { kind: some(m.kind), trigger: m.decision }),
- *                         }),
- *                         // The author's own cards, a record of roles: a role dropped on a decision owns it.
- *                         Flowchart.library.tab(owners.read(), {
- *                             name: "Owners", icon: "user-tie", source: "owners",
- *                             key: (_o, role) => role, label: o => o.name, meta: o => some(o.desk),
- *                             drop: (_o, role) => Flowchart.patch(Flowchart.Types.Trigger, { owner: some(role) }),
- *                         }),
- *                     ]}
- *                 />
- *             </Box>
- *         );
- *     }}</Reactive>
- * ));
- * ```
+ * @throws {Error} When given anything but `{ name?, icon? }`, naming the cards on the kind
  */
-export declare function libraryStates<T extends EastType>(rows: FlowchartTemplateRows<T>, config: FlowchartStatesConfig<T>): FlowchartStatesTab;
+export declare function libraryTransitions(options?: FlowchartKindTabOptions, ...rest: readonly never[]): FlowchartKindTab;
 /**
- * The transition templates — `Flowchart.library.transitions(rows, { … })`
- * (FB26, decision 8): one card per row of the tab's own rows, as
- * {@link libraryStates}' are, each a drag source that a click selects and a
- * second click lets go. A card dropped on a transition sets the fields its
- * `drop` sets on it — its kind, its decision and its other fields (#1249): a
- * connection makes a transition of the default type, and a card retypes it.
- *
- * @remarks
- * The rows are a templates record's, read as {@link libraryStates}' are, each
- * card keyed by its record's key, and the tab follows its `source` as theirs
- * does. Left out, the tab's name is `Transitions`, in the flowchart's words.
- * Refused when the surface is built: a list naming no source, or one the slice
- * lacks, or `flows`; rows that are no `Dict<String, T>`; a `key`; a `drop`
- * over another type than `Flowchart.Types.Link`; and the tab listed twice;
- * and, when the tab's cards are read, a card whose `drop` sets the
- * transition's `key`, `from` or `to` — the fields a patch sets are values its
- * rows give, which the build cannot see.
+ * The Lanes tab — `Flowchart.library.lanes()` (R14, D5): the lanes' cards,
+ * `Flowchart.templates` on `Flowchart.lanes`. One dropped between two lanes,
+ * or at the band row's tail, adds a lane there from its values, keyed
+ * `lane-<n>`, its order between theirs. + LANE stays on the canvas.
  *
- * @typeParam T - The rows' element type
- * @param rows - The templates record's rows — a `Dict<String, T>` expression, its binding's `read()`
- * @param config - The tab's name and icon, what each card shows, its `drop` and its `source` ({@link FlowchartTransitionsConfig})
+ * @param options - The tab's name — `Lanes` unless given — and its icon
+ * @param rest - Nothing: anything after the options is refused
  * @returns The tab
+ * @throws {Error} When given anything but `{ name?, icon? }`
  */
-export declare function libraryTransitions<T extends EastType>(rows: FlowchartTemplateRows<T>, config: FlowchartTransitionsConfig<T>): FlowchartTransitionsTab;
+export declare function libraryLanes(options?: FlowchartKindTabOptions, ...rest: readonly never[]): FlowchartKindTab;
 /**
  * A tab of the author's own cards — `Flowchart.library.tab(rows, { … })`
- * (FB27): one card per row of the tab's own rows, as {@link libraryStates}'
- * are, a click selecting a card and a second click letting it go. Given a
- * `drop`, each card is a drag source, which lands where its patch's type says
- * — a state, a transition, a lane's header or a decision's diamond — and sets
- * its fields there (#1249); without one, the cards are read, never dragged.
+ * (R14): one card per row, its label and the line under it, grouped by its
+ * `group` and searched by its key, label and line. Given a `drop` —
+ * `Flowchart.patch(R, { … })` over one kind's row type, which names that kind
+ * — a card dropped on a row of that kind sets the fields the patch sets:
+ * an owner dropped on a decision's diamond, say. Without one, the cards are
+ * read, never dragged.
  *
  * @remarks
- * The rows are an `Array<T>` or a `Dict<String, T>` the app binds, each
- * accessor taking a row and its key, a Dict's key or an Array's index,
- * printed; a key that repeats keeps its first card. Naming a `source` of the
- * flowchart's slice (#1346), the tab follows it by its cards' keys, each a
- * row's key in that record; naming none, it lists its rows whole. A tab's
- * name is its identity in `library`. Refused when the surface is built: rows
- * that are neither an Array nor a `Dict<String, T>`; a `source` the slice
- * lacks; a `drop` over none of a flow's row types; and two tabs of one name.
+ * The rows are an `Array<T>`, each card keyed by its index, printed, or a
+ * `Dict<String, T>`, each by its key. Naming a `source` of the Flowchart's
+ * slice, the tab follows it by its cards' keys, each a row's key in that
+ * record — so its rows are that record's, a Dict; naming none, it lists its
+ * rows whole. A tab's name is its identity in `library`. `Flowchart.templates`'
+ * example, the depot, shows the tabs together, its Owners tab among them.
  *
  * @typeParam T - The rows' element type
  * @typeParam P - The patch `drop` returns
- * @param rows - The rows — an `Array<T>` or a `Dict<String, T>` value or expression, such as a binding's `read()`
+ * @param rows - The rows: an `Array<T>` or a `Dict<String, T>`, usually a record's `read()`
  * @param config - The tab's name and icon, what each card shows, its `drop` and its `source` ({@link FlowchartTabConfig})
  * @returns The tab
  */
 export declare function libraryTab<T extends EastType, P extends EastType = EastType>(rows: FlowchartLibraryRows<T>, config: FlowchartTabConfig<T, P>): FlowchartAuthorTab;
 /** The library pane's tabs — `Flowchart.library`. */
 export interface FlowchartLibrary {
-    /** The Flows tab: every flow by name, a click opening one, and "+ New flow" ({@link libraryFlows}). */
-    flows: typeof libraryFlows;
-    /** State templates from the tab's own rows, each card adding a state where it is dropped ({@link libraryStates}). */
+    /** The Steps tab: the states' cards ({@link libraryStates}). */
     states: typeof libraryStates;
-    /** Transition templates from the tab's own rows, each card retyping the transition it is dropped on ({@link libraryTransitions}). */
+    /** The Transitions tab: the transitions' cards ({@link libraryTransitions}). */
     transitions: typeof libraryTransitions;
-    /** The author's own cards from the tab's own rows ({@link libraryTab}). */
+    /** The Lanes tab: the lanes' cards ({@link libraryLanes}). */
+    lanes: typeof libraryLanes;
+    /** The author's own cards ({@link libraryTab}). */
     tab: typeof libraryTab;
 }
 /** The library pane's tabs, each a factory (`Flowchart.library`). */
 export declare const FlowchartLibraryFactories: FlowchartLibrary;
+/** One of the Flowchart's kinds, as its library is built against it. */
+export interface FlowchartLibraryKind {
+    /** Its sort: the prop it fills. */
+    readonly sort: FlowchartKindSort;
+    /** Its record's row type. */
+    readonly rowType: StructType;
+    /** Whether it has cards. */
+    readonly templates: boolean;
+}
 /**
- * Checks the library's templates lists against the flowchart's slice, before
- * the slice itself is checked, so a list written in the code is refused with
- * the change to make before a source no list names is (#1340, ruling 9): each
- * templates list is a record of its own, naming its source of the flowchart's
- * one `Slice.bindRecords`.
+ * What a Flowchart's library is built against.
  *
- * @param library - The flowchart's `library`, as given
- * @param names - The sources the slice names, read before it is checked (`sliceSourceNames`)
- * @throws {Error} Naming the list and the change to make: a list naming no source — one written in the code — or one the slice lacks, a list naming `flows`, and the state and the transition templates naming one source
  * @internal
  */
-export declare function checkTemplatesSources(library: unknown, names: readonly string[]): void;
+export interface FlowchartLibraryContext {
+    /** Its kinds, in order: its states, and its transitions, lanes and decisions where given. */
+    readonly kinds: readonly FlowchartLibraryKind[];
+    /** The slice's sources: an author's tab's `source` names one of them. */
+    readonly sources: readonly string[];
+}
 /**
- * The sources the library names (#1346), each once, in its order: each
- * templates list's and each author's tab's — what the flowchart's slice may
- * hold beside `flows`.
+ * Builds the library pane on the wire (R14): its tabs in the order `library`
+ * lists them; none when it is left out.
  *
- * @param library - The flowchart's `library`, as given
- * @returns The sources' names
+ * @param tabs - The tabs, each a `Flowchart.library.*` call
+ * @param ctx - What the library is built against
+ * @returns The tabs on the wire
+ * @throws {Error} Naming the tab: a `library` that is no list of `Flowchart.library.*` calls; a tab listed twice (an
+ *   author's tab by its name); a kind's tab when the Flowchart has no such kind, or the kind has no cards; and each of
+ *   an author's tab's refusals — rows that are neither an Array nor a `Dict<String, T>`, an Array following a source,
+ *   a `key`, a source the slice lacks, and a `drop` over no kind's row type, or over one several kinds share
  * @internal
  */
-export declare function librarySources(library: unknown): string[];
+export declare function buildFlowchartLibrary(tabs: unknown, ctx: FlowchartLibraryContext): ExprType<ArrayType<FlowchartLibraryTabType>>;
 /**
- * The library pane on the wire (`Flowchart Builder Spec.md` §4.2, §4.4, FB16,
- * FB25–FB29): its tabs in the order `library` lists them; none when it is
- * left out, or empty.
+ * The sources of the slice the author's tabs name: each one the slice may
+ * hold, and its tab refused when the slice lacks it.
  *
- * @param library - The tabs, each a `Flowchart.library.*` call
- * @param many - Whether the flowchart holds flows by name, rather than one flow
- * @param sources - The flowchart's slice's sources, which each templates list's and each author's tab's `source` must be one of
- * @returns The tabs on the wire
- * @throws {Error} Naming the tab and the remedy: a `library` that is no list
- *   of `Flowchart.library.*` calls; a tab listed twice — the Flows tab, the
- *   state templates or the transition templates, or two of the author's tabs
- *   of one name; the Flows tab over one flow; and each of a data tab's
- *   refusals — a source the slice lacks, rows that are neither an Array nor a
- *   `Dict<String, T>` (a templates record's, for a templates list), a
- *   templates list's `key`, and a `drop` of another type than its tab's
+ * @param tabs - The Flowchart's `library`
+ * @returns The sources its tabs name, in order
  * @internal
  */
-export declare function buildLibrary(library: unknown, many: boolean, sources?: readonly string[]): ExprType<ArrayType<FlowchartLibraryTabType>>;
+export declare function flowchartTabSources(tabs: unknown): string[];
 //# sourceMappingURL=library.d.ts.map