@elaraai/e3-ui 1.0.102 → 1.0.104

package/dist/src/flowchart/library.js

@@ -3,420 +3,158 @@
  * 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` (#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.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.
+ * - `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.
  *
- * 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.
+ * There is no Flows tab: the Flowchart draws one flowchart. Left out, or
+ * empty, the Flowchart has no library pane.
  *
  * @packageDocumentation
  */
-import { ArrayType, DictType, East, Expr, NullType, OptionType, SetType, StringType, StructType, VariantType, isTypeEqual, none, printType, some, variant, } from "@elaraai/east";
-import { tabSource, templatesSource } from "../utils/record-sources.js";
-import { FlowchartPatchTypeFor } from "./patch.js";
-import { FlowchartLaneType, FlowchartLinkType, FlowchartStateType, FlowchartTriggerType } from "./types.js";
+import { ArrayType, East, Expr, OptionType, StringType, StructType, VariantType, isTypeEqual, none, printType, some, variant, } from "@elaraai/east";
+import { ScheduleAuthorTabType, buildScheduleTab } from "../schedule/library.js";
+export { ScheduleLibraryCardType as FlowchartLibraryCardType } from "../schedule/library.js";
 // ============================================================================
 // The wire
 // ============================================================================
 /**
- * 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 const FlowchartCardType = StructType({
-    key: StringType,
-    label: StringType,
-    meta: OptionType(StringType),
-    group: OptionType(StringType),
-});
-/**
- * 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.
- */
-export const FlowchartStateCardType = StructType({
-    ...FlowchartCardType.fields,
-    sets: FlowchartPatchTypeFor(FlowchartStateType),
-});
-/**
- * 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.
+ * 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 const FlowchartTransitionCardType = StructType({
-    ...FlowchartCardType.fields,
-    sets: FlowchartPatchTypeFor(FlowchartLinkType),
-});
-/** An author's card that lands on a lane's header, and the lane's fields it sets. */
-export const FlowchartLaneCardType = StructType({
-    ...FlowchartCardType.fields,
-    sets: FlowchartPatchTypeFor(FlowchartLaneType),
-});
-/** An author's card that lands on a decision's diamond, and the decision's fields it sets. */
-export const FlowchartDecisionCardType = StructType({
-    ...FlowchartCardType.fields,
-    sets: FlowchartPatchTypeFor(FlowchartTriggerType),
+export const FlowchartKindTabWireType = StructType({
+    name: OptionType(StringType),
+    icon: OptionType(StringType),
 });
 /**
- * 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.
+ * One tab of the library pane on the wire, in the order `library` lists them.
  *
- * @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
+ * @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 const FlowchartLandsType = VariantType({
-    none: ArrayType(FlowchartCardType),
-    state: ArrayType(FlowchartStateCardType),
-    transition: ArrayType(FlowchartTransitionCardType),
-    lane: ArrayType(FlowchartLaneCardType),
-    decision: ArrayType(FlowchartDecisionCardType),
+export const FlowchartLibraryTabType = VariantType({
+    states: FlowchartKindTabWireType,
+    transitions: FlowchartKindTabWireType,
+    lanes: FlowchartKindTabWireType,
+    tab: ScheduleAuthorTabType,
 });
+/** The cards a kind's `templates` takes, as a refusal writes them. */
+const CARDS = "templates: Flowchart.templates(cards.read(), { name, values, source })";
+/** How each kind's tab is named in a refusal, what its kind is called, and the kind with its cards, as a refusal writes it. */
+const KIND_TABS = {
+    states: { call: "Flowchart.library.states()", noun: "states", declare: `Flowchart.states(record, { label, …, ${CARDS} })` },
+    transitions: { call: "Flowchart.library.transitions()", noun: "transitions", declare: `Flowchart.transitions(record, { from, to, …, ${CARDS} })` },
+    lanes: { call: "Flowchart.library.lanes()", noun: "lanes", declare: `Flowchart.lanes(record, { label, …, ${CARDS} })` },
+};
 /**
- * One tab of the library pane, as `library` lists it (`Flowchart Builder
- * Spec.md` §4.2).
+ * A kind's tab, its options checked.
  *
- * @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)
+ * @param kind - The kind whose cards it lists
+ * @param options - The call's first argument
+ * @param rest - Any argument after it
+ * @returns The tab
+ * @throws {Error} When given anything but `{ name?, icon? }` — rows and a config, as the earlier form took, among them — naming the cards on the kind
  */
-export const FlowchartLibraryTabType = VariantType({
-    flows: NullType,
-    states: StructType({ name: OptionType(StringType), icon: OptionType(StringType), cards: ArrayType(FlowchartStateCardType), source: StringType }),
-    transitions: StructType({ name: OptionType(StringType), icon: OptionType(StringType), cards: ArrayType(FlowchartTransitionCardType), source: StringType }),
-    tab: StructType({ name: StringType, icon: OptionType(StringType), lands: FlowchartLandsType, source: OptionType(StringType) }),
-});
+function kindTab(kind, options, rest) {
+    const { call, noun, declare } = KIND_TABS[kind];
+    const words = `${call} lists the ${noun}' cards, which are on the kind — ${declare} — and takes at most { name, icon }`;
+    if (rest.length > 0 || options instanceof Expr || (options !== undefined && (typeof options !== "object" || options === null || Array.isArray(options)))) {
+        throw new Error(words);
+    }
+    const o = (options ?? {});
+    for (const key of Object.keys(o)) {
+        if (key !== "name" && key !== "icon")
+            throw new Error(`${words} — \`${key}\` is neither`);
+    }
+    if (o["name"] !== undefined && (typeof o["name"] !== "string" || o["name"] === ""))
+        throw new Error(`${call}: \`name\` is the tab's name, a string`);
+    if (o["icon"] !== undefined && (typeof o["icon"] !== "string" || o["icon"] === ""))
+        throw new Error(`${call}: \`icon\` is a Font Awesome solid icon's name`);
+    return { kind, name: o["name"], icon: o["icon"] };
+}
 /**
- * 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 function libraryFlows() {
-    return { kind: "flows" };
+export function libraryStates(options, ...rest) {
+    return kindTab("states", options, rest);
 }
 /**
- * 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).
- *
- * @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.
+ * 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.
  *
- * @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 function libraryStates(rows, config) {
-    return { kind: "states", rows, config: config };
+export function libraryTransitions(options, ...rest) {
+    return kindTab("transitions", options, rest);
 }
 /**
- * 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 function libraryTransitions(rows, config) {
-    return { kind: "transitions", rows, config: config };
+export function libraryLanes(options, ...rest) {
+    return kindTab("lanes", options, rest);
 }
 /**
  * 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
  */
@@ -425,320 +163,76 @@ export function libraryTab(rows, config) {
 }
 /** The library pane's tabs, each a factory (`Flowchart.library`). */
 export const FlowchartLibraryFactories = {
-    flows: libraryFlows,
     states: libraryStates,
     transitions: libraryTransitions,
+    lanes: libraryLanes,
     tab: libraryTab,
 };
-/** The cards a key repeats on, folded: the first kept, in the rows' order — as a register's members fold. */
-function keepFirst(cardType) {
-    return East.function([ArrayType(cardType)], ArrayType(cardType), ($, cards) => {
-        const out = $.let([], ArrayType(cardType));
-        const seen = $.let(new Set(), SetType(StringType));
-        $.for(cards, ($2, card) => {
-            const key = $2.let(card.key, StringType);
-            $2.if(seen.has(key).not(), ($3) => {
-                $3(seen.insert(key));
-                $3(out.pushLast(card));
-            });
-        });
-        return out;
-    });
-}
-/** Each card type's fold, once. */
-const KEEP_FIRST = new Map([
-    FlowchartCardType, FlowchartStateCardType, FlowchartTransitionCardType, FlowchartLaneCardType, FlowchartDecisionCardType,
-].map((cardType) => [cardType, keepFirst(cardType)]));
-/** What an author's card lands on, by its drop's row type: the arm its cards ride, and their type. */
-const LANDINGS = [
-    ["state", FlowchartStateType, FlowchartStateCardType],
-    ["transition", FlowchartLinkType, FlowchartTransitionCardType],
-    ["lane", FlowchartLaneType, FlowchartLaneCardType],
-    ["decision", FlowchartTriggerType, FlowchartDecisionCardType],
-];
 /** How a tab names itself in a refusal. */
 function tabName(tab) {
-    return tab.kind === "tab" ? `the "${tab.config.name}" tab` : `Flowchart.library.${tab.kind}()`;
+    return tab.kind === "tab" ? `the "${tab.config.name}" tab` : KIND_TABS[tab.kind].call;
 }
-/**
- * A data tab's rows: a Dict by String keys — for a templates list, its
- * templates record's, each card that record's row by its key (#1346) — or,
- * for an author's tab, an Array too.
- *
- * @param tab - The tab
- * @returns The rows, as East reads them
- * @throws {Error} Naming the tab: rows that are neither an Array nor a `Dict<String, T>`, or a templates list's that are no `Dict<String, T>`
- */
-function rowsOf(tab) {
-    const expr = East.value(tab.rows);
-    const type = Expr.type(expr);
-    if (type.type === "Dict" && type.key.type === "String")
-        return { expr, dict: true, row: type.value };
-    // A templates list's rows are its templates record's.
-    const templates = tab.kind !== "tab";
-    if (type.type === "Array" && !templates)
-        return { expr, dict: false, row: type.value };
-    if (type.type === "Array") {
-        throw new Error(`Flowchart: ${tabName(tab)} lists templates, which are records — its rows are its templates record's, each card a row by its key: a Dict<String, T>, its binding's read() — and these are an Array`);
+/** Whether a value is one of the library's tabs. */
+function isTab(value) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const kind = value.kind;
+    if (kind === "tab") {
+        const config = value.config;
+        return typeof config === "object" && config !== null;
     }
-    throw new Error(templates
-        ? `Flowchart: ${tabName(tab)} reads its rows as a Dict<String, T> — its templates record's, its binding's read(), its own apart from the flows and the other tabs — and these are ${printType(type)}`
-        : `Flowchart: ${tabName(tab)} reads its rows as an Array<T> or a Dict<String, T> — a value, or an expression such as a binding's read(), its own apart from the flows and the other tabs — and these are ${printType(type)}`);
+    return kind === "states" || kind === "transitions" || kind === "lanes";
 }
 /**
- * A templates list's cards are its record's rows, each keyed by its record's
- * key (#1346): a `key` given beside them — the accessor every list took
- * before its rows were a record's — is refused, naming the change.
- *
- * @param tab - The templates list
- * @throws {Error} Naming the list, when its config gives a `key`
- */
-function keyedByRecord(tab) {
-    if ("key" in tab.config) {
-        throw new Error(`Flowchart: ${tabName(tab)}'s cards are its templates record's rows, each keyed by the record's key, which its source follows — leave \`key\` out`);
-    }
-}
-/**
- * A data tab's drop, reified once over its rows' type: the function a card's
- * fields are set by, and the type of the patch it returns.
- */
-function dropOf(rows, drop) {
-    const fn = East.function([rows.row, StringType], undefined, (_$, row, key) => drop(row, key));
-    return { fn, patch: Expr.type(fn).output };
-}
-/**
- * A data tab's cards: one per row, read through its accessors, each with what
- * its drop sets, when the tab's cards set anything, and a key that repeats
- * keeping its first card.
- *
- * @param rows - The tab's rows
- * @param config - What each card shows, and — an author's tab's — its key; with none, each card's key is its row's
- * @param cardType - The cards' type
- * @param sets - What a card sets, from its row and its key, checked as it is read; `undefined` for cards that set nothing
- * @returns The cards, in the rows' order
- */
-function cardsOf(rows, config, cardType, sets) {
-    const keyOf = config.key;
-    const describe = East.function([rows.row, StringType], cardType, ($, row, key) => {
-        const card = $.let(keyOf === undefined ? key : keyOf(row, key), StringType);
-        return {
-            key: card,
-            label: config.label(row, key),
-            meta: config.meta !== undefined ? config.meta(row, key) : East.value(none, OptionType(StringType)),
-            group: config.group !== undefined ? some(config.group(row, key)) : East.value(none, OptionType(StringType)),
-            ...(sets === undefined ? {} : { sets: sets($, row, key, card) }),
-        };
-    });
-    const list = rows.dict
-        ? rows.expr.toArray(($, row, key) => {
-            const read = $.const(describe);
-            return read(row, key);
-        })
-        : rows.expr.map(($, row, index) => {
-            const read = $.const(describe);
-            return read(row, East.print(index));
-        });
-    const fold = KEEP_FIRST.get(cardType);
-    return fold(list);
-}
-/**
- * The state templates on the wire: the tab's name and icon, its cards, each
- * with the state its drop seeds, and the source they follow.
+ * An author's tab's rows, as the shared tab reads them: a Dict by String keys
+ * as it is; an Array as a Dict keyed by each row's index, printed.
  *
  * @param tab - The tab
- * @param sources - The slice's sources
- * @returns The tab's wire value
- * @throws {Error} Naming the tab: a list naming no source of the slice, a `key`, rows that are no `Dict<String, T>`, or a `drop` over another type than a state's patch
+ * @returns Its declaration over Dict rows
+ * @throws {Error} Naming the tab: rows that are neither an Array nor a `Dict<String, T>`; an Array following a source,
+ *   whose cards' keys are its indexes, never that record's keys; and a `key`, which the rows' keys are
  */
-function statesTab(tab, sources) {
-    const source = templatesSource("Flowchart", TEMPLATES_CALL.states, tab.config.source, sources);
-    keyedByRecord(tab);
-    const rows = rowsOf(tab);
-    const drop = dropOf(rows, tab.config.drop);
-    if (!isTypeEqual(drop.patch, FlowchartPatchTypeFor(FlowchartStateType))) {
-        throw new Error(`Flowchart: ${tabName(tab)}'s \`drop\` returns the fields of the state a card adds — Flowchart.patch(Flowchart.Types.State, { … }) — and this one returns ${printType(drop.patch)}`);
-    }
-    const cards = cardsOf(rows, tab.config, FlowchartStateCardType, ($, row, key) => {
-        const seed = $.const(drop.fn);
-        return seed(row, key);
-    });
-    // The cards' expression is typed loosely here; East checks it against the tab's type.
-    return East.value(variant("states", {
-        name: tab.config.name === undefined ? none : some(tab.config.name),
-        icon: tab.config.icon === undefined ? none : some(tab.config.icon),
-        cards,
-        source,
-    }), FlowchartLibraryTabType);
-}
-/**
- * The transition templates on the wire: the tab's name and icon, its cards,
- * each with what it sets on the transition it lands on — refused, as the card
- * is read, when that is the transition's `key`, `from` or `to` — and the source
- * they follow.
- *
- * @param tab - The tab
- * @param sources - The slice's sources
- * @returns The tab's wire value
- * @throws {Error} Naming the tab: a list naming no source of the slice, a `key`, rows that are no `Dict<String, T>`, or a `drop` over another type than a transition's patch
- */
-function transitionsTab(tab, sources) {
-    const source = templatesSource("Flowchart", TEMPLATES_CALL.transitions, tab.config.source, sources);
-    keyedByRecord(tab);
-    const rows = rowsOf(tab);
-    const drop = dropOf(rows, tab.config.drop);
-    if (!isTypeEqual(drop.patch, FlowchartPatchTypeFor(FlowchartLinkType))) {
-        throw new Error(`Flowchart: ${tabName(tab)}'s \`drop\` returns the fields a card sets on the transition it lands on — Flowchart.patch(Flowchart.Types.Link, { … }) — and this one returns ${printType(drop.patch)}`);
-    }
-    const name = tabName(tab);
-    const cards = cardsOf(rows, tab.config, FlowchartTransitionCardType, ($, row, key, card) => {
-        const retype = $.const(drop.fn);
-        const patched = $.let(retype(row, key));
-        const sets = patched;
-        // A transition card retypes the transition it lands on: never its key, nor its ends.
-        const refusal = (field) => East.str `Flowchart: ${name}'s card "${card}" sets a transition's \`${field}\` — a transition card retypes the transition it lands on, its kind, its decision and its other fields, never its key or its ends: leave \`key\`, \`from\` and \`to\` out of its Flowchart.patch`;
-        $.if(sets.key.hasTag("some"), ($2) => { $2.error(refusal("key")); });
-        $.if(sets.from.hasTag("some"), ($2) => { $2.error(refusal("from")); });
-        $.if(sets.to.hasTag("some"), ($2) => { $2.error(refusal("to")); });
-        return patched;
-    });
-    return East.value(variant("transitions", {
-        name: tab.config.name === undefined ? none : some(tab.config.name),
-        icon: tab.config.icon === undefined ? none : some(tab.config.icon),
-        cards,
-        source,
-    }), FlowchartLibraryTabType);
-}
-/**
- * An author's tab on the wire: its name and icon, its cards by what they land
- * on — the row type of the patch its `drop` returns — or read, never dragged,
- * without one, and the source it follows, if it names one.
- *
- * @param tab - The tab
- * @param sources - The slice's sources
- * @returns The tab's wire value
- * @throws {Error} Naming the tab: a source the slice lacks, rows that are neither an Array nor a `Dict<String, T>`, or a `drop` over none of a flow's row types
- */
-function authorTab(tab, sources) {
-    const source = tabSource("Flowchart", `"${tab.config.name}"`, tab.config.source, sources);
-    const rows = rowsOf(tab);
-    const config = tab.config;
-    // Without a drop, its cards are read, never dragged: they land nowhere.
-    let arm = "none";
-    let cardType = FlowchartCardType;
-    let sets = undefined;
-    if (config.drop !== undefined) {
-        const drop = dropOf(rows, config.drop);
-        const landing = LANDINGS.find(([, rowType]) => isTypeEqual(drop.patch, FlowchartPatchTypeFor(rowType)));
-        if (landing === undefined) {
-            throw new Error(`Flowchart: ${tabName(tab)}'s \`drop\` returns a patch over one of a flow's rows, its type naming what a card lands on — Flowchart.patch(Flowchart.Types.State, Link, Lane or Trigger, { … }) — and this one returns ${printType(drop.patch)}`);
-        }
-        [arm, , cardType] = landing;
-        sets = ($, row, key) => {
-            const setsOf = $.const(drop.fn);
-            return setsOf(row, key);
-        };
-    }
-    const lands = East.value(variant(arm, cardsOf(rows, config, cardType, sets)), FlowchartLandsType);
-    return East.value(variant("tab", {
-        name: config.name,
-        icon: config.icon === undefined ? none : some(config.icon),
-        lands,
-        source,
-    }), FlowchartLibraryTabType);
-}
-/** The kinds of tab `library` lists. */
-const KINDS = new Set(["flows", "states", "transitions", "tab"]);
-/** How a templates refusal writes the declaration to make, by the list's kind. */
-const TEMPLATES_CALL = {
-    states: "Flowchart.library.states(rows, { …, source: \"stateTemplates\" })",
-    transitions: "Flowchart.library.transitions(rows, { …, source: \"transitionTemplates\" })",
-};
-/** A tab `library` lists, as a `Flowchart.library.*` call makes one; `undefined` for anything else. */
-function declaredTab(given) {
-    const tab = given;
-    if (tab === null || tab === undefined || typeof tab !== "object" || !KINDS.has(tab.kind)
-        || (tab.kind !== "flows" && (typeof tab.config !== "object" || tab.config === null))) {
-        return undefined;
+function keyedRows(tab) {
+    if ("key" in tab.config) {
+        throw new Error(`Flowchart: ${tabName(tab)}'s cards are keyed by its rows' keys — a Dict's key, or an Array's index — leave \`key\` out`);
     }
-    return tab;
-}
-/** Each tab `library` lists, as declared, those of no `Flowchart.library.*` call left out. */
-function declaredTabs(library) {
-    return (Array.isArray(library) ? library : []).flatMap((given) => {
-        const tab = declaredTab(given);
-        return tab === undefined ? [] : [tab];
-    });
-}
-/**
- * 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`.
- *
- * @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 function checkTemplatesSources(library, names) {
-    const lists = declaredTabs(library).flatMap((tab) => (tab.kind === "states" || tab.kind === "transitions" ? [tab] : []));
-    for (const list of lists)
-        templatesSource("Flowchart", TEMPLATES_CALL[list.kind], list.config.source, names);
-    const flows = lists.find((list) => list.config.source === "flows");
-    if (flows !== undefined) {
-        throw new Error(`Flowchart: ${tabName(flows)} names the source 'flows', which narrows the flows — each templates list is a record of its own, and its own source of the slice`);
+    const rows = East.value(tab.rows);
+    const type = Expr.type(rows);
+    if (type.type === "Dict" && isTypeEqual(type.key, StringType))
+        return { ...tab, rows };
+    if (type.type !== "Array") {
+        throw new Error(`Flowchart: ${tabName(tab)} reads its rows as an Array<T> or a Dict<String, T> — a value, or an expression such as a record's read() — ` +
+            `and these are ${printType(type)}`);
     }
-    // The two lists naming one source; a list listed twice is the library's refusal (`buildLibrary`).
-    const states = lists.find((list) => list.kind === "states");
-    const transitions = lists.find((list) => list.kind === "transitions");
-    if (states !== undefined && transitions !== undefined && states.config.source === transitions.config.source) {
-        throw new Error(`Flowchart: the state templates and the transition templates both name the source '${states.config.source}' — each templates list is a record of its own, and its own source of the slice`);
+    if (tab.config.source !== undefined) {
+        throw new Error(`Flowchart: ${tabName(tab)} follows the source '${tab.config.source}' by its cards' keys, each a row's key in that record — ` +
+            "read its rows as that record's, a Dict<String, T>, its binding's read(), never an Array keyed by index");
     }
+    const array = rows;
+    return { ...tab, rows: array.toDict(($, _row, index) => East.print(index), ($, row, _index) => row) };
 }
 /**
- * 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
- * @internal
- */
-export function librarySources(library) {
-    const named = declaredTabs(library).flatMap((tab) => (tab.kind === "flows" || tab.config.source === undefined ? [] : [tab.config.source]));
-    return named.filter((source, i) => named.indexOf(source) === i);
-}
-/**
- * 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.
- *
- * @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
+ * @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 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
+ * @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 function buildLibrary(library, many, sources = []) {
-    if (library === undefined)
+export function buildFlowchartLibrary(tabs, ctx) {
+    if (tabs === undefined)
         return East.value([], ArrayType(FlowchartLibraryTabType));
-    const LIST = "Flowchart: `library` lists the library pane's tabs, each a Flowchart.library.* call — library={[Flowchart.library.flows()]}";
-    if (!Array.isArray(library))
-        throw new Error(LIST);
+    if (!Array.isArray(tabs) || !tabs.every(isTab)) {
+        throw new Error("Flowchart: `library` lists the library pane's tabs, in order, each a Flowchart.library.* call — " +
+            "states(), transitions(), lanes() or tab(rows, { … })");
+    }
     const seen = new Set();
-    const wires = library.map((given) => {
-        const tab = declaredTab(given);
-        if (tab === undefined)
-            throw new Error(LIST);
-        // A tab once: the Flows tab and the templates by kind, an author's tab by its name.
+    for (const tab of tabs) {
         const id = tab.kind === "tab" ? `tab:${tab.config.name}` : tab.kind;
         if (seen.has(id)) {
             throw new Error(tab.kind === "tab"
@@ -746,17 +240,41 @@ export function buildLibrary(library, many, sources = []) {
                 : `Flowchart: the library lists ${tabName(tab)} twice — each tab once`);
         }
         seen.add(id);
-        switch (tab.kind) {
-            case "flows":
-                if (!many) {
-                    throw new Error(`Flowchart: ${tabName(tab)} lists flows by name, and this \`data\` is one flow, Flowchart.Types.Flow — leave the Flows tab out of \`library\`, or pass the flows by name`);
-                }
-                return East.value(variant("flows", null), FlowchartLibraryTabType);
-            case "states": return statesTab(tab, sources);
-            case "transitions": return transitionsTab(tab, sources);
-            case "tab": return authorTab(tab, sources);
+        if (tab.kind !== "tab") {
+            const { noun, declare } = KIND_TABS[tab.kind];
+            const kind = ctx.kinds.find((one) => one.sort === tab.kind);
+            if (kind === undefined) {
+                throw new Error(`Flowchart: the library lists ${tabName(tab)}, and this Flowchart has no ${noun} — give ${tab.kind}={${declare}}`);
+            }
+            if (!kind.templates) {
+                throw new Error(`Flowchart: the library lists ${tabName(tab)}, and the ${noun} have no cards — give them their cards: ${declare}`);
+            }
+        }
+    }
+    const landsOn = ctx.kinds.map((kind) => [kind.sort, { rowType: kind.rowType }]);
+    const wires = tabs.map((tab) => {
+        if (tab.kind === "tab") {
+            const keyed = keyedRows(tab);
+            return East.value(variant("tab", buildScheduleTab(keyed, landsOn, "Flowchart", ctx.sources, { kind: "kind", patch: "Flowchart.patch" })), FlowchartLibraryTabType);
         }
+        return East.value(variant(tab.kind, {
+            name: tab.name === undefined ? none : some(tab.name),
+            icon: tab.icon === undefined ? none : some(tab.icon),
+        }), FlowchartLibraryTabType);
     });
     return East.value(wires, ArrayType(FlowchartLibraryTabType));
 }
+/**
+ * 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 tabs - The Flowchart's `library`
+ * @returns The sources its tabs name, in order
+ * @internal
+ */
+export function flowchartTabSources(tabs) {
+    if (!Array.isArray(tabs))
+        return [];
+    return tabs.filter(isTab).flatMap((tab) => tab.kind === "tab" && tab.config.source !== undefined ? [tab.config.source] : []);
+}
 //# sourceMappingURL=library.js.map