@elaraai/e3-ui 1.0.94 → 1.0.96

package/dist/test/flowchart/flowchart.examples.d.ts

@@ -2251,17 +2251,108 @@ export declare const handoverFlow: import("@elaraai/e3").DatasetDef<StructType<{
     }>>;
 }>, [variant<"field", "inputs">, variant<"field", "flowchart_handover">]>;
 export declare const StepTemplate: StructType<{
-    readonly code: StringType;
     readonly name: StringType;
     readonly kind: StringType;
     readonly slots: OptionType<IntegerType>;
 }>;
-export declare const stepTemplates: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
-    readonly code: StringType;
+export declare const stepTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly kind: StringType;
+    readonly slots: OptionType<IntegerType>;
+}>>, [variant<"field", "records">, variant<"field", "flowchart_step_templates">]>;
+export declare const stepsByKind: import("@elaraai/e3").RecordIndexDef<"flowchart_steps_by_kind", DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly kind: StringType;
+    readonly slots: OptionType<IntegerType>;
+}>>, StringType, NullType, readonly ["kind"]> & {
+    interval: undefined;
+};
+/** The step types' patch door: what another writer adds a step type through, the Steps tab's cards following. */
+export declare const stepTemplatesPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
     readonly name: StringType;
     readonly kind: StringType;
     readonly slots: OptionType<IntegerType>;
-}>>, [variant<"field", "inputs">, variant<"field", "flowchart_step_templates">]>;
+}>>, [import("@elaraai/east").VariantType<{
+    unchanged: NullType;
+    replace: StructType<{
+        before: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly kind: StringType;
+            readonly slots: OptionType<IntegerType>;
+        }>>;
+        after: DictType<StringType, StructType<{
+            readonly name: StringType;
+            readonly kind: StringType;
+            readonly slots: OptionType<IntegerType>;
+        }>>;
+    }>;
+    patch: DictType<StringType, import("@elaraai/east").VariantType<{
+        delete: StructType<{
+            readonly name: StringType;
+            readonly kind: StringType;
+            readonly slots: OptionType<IntegerType>;
+        }>;
+        insert: StructType<{
+            readonly name: StringType;
+            readonly kind: StringType;
+            readonly slots: OptionType<IntegerType>;
+        }>;
+        update: import("@elaraai/east").VariantType<{
+            unchanged: NullType;
+            replace: StructType<{
+                before: StructType<{
+                    readonly name: StringType;
+                    readonly kind: StringType;
+                    readonly slots: OptionType<IntegerType>;
+                }>;
+                after: StructType<{
+                    readonly name: StringType;
+                    readonly kind: StringType;
+                    readonly slots: OptionType<IntegerType>;
+                }>;
+            }>;
+            patch: StructType<{
+                readonly name: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly kind: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: StringType;
+                        after: StringType;
+                    }>;
+                }>;
+                readonly slots: import("@elaraai/east").VariantType<{
+                    unchanged: NullType;
+                    replace: StructType<{
+                        before: OptionType<IntegerType>;
+                        after: OptionType<IntegerType>;
+                    }>;
+                    patch: import("@elaraai/east").VariantType<{
+                        none: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: NullType;
+                                after: NullType;
+                            }>;
+                        }>;
+                        some: import("@elaraai/east").VariantType<{
+                            unchanged: NullType;
+                            replace: StructType<{
+                                before: IntegerType;
+                                after: IntegerType;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>;
+    }>>;
+}>]>;
 export declare const MoveTemplate: StructType<{
     readonly kind: import("@elaraai/east").VariantType<{
         readonly planned: NullType;
@@ -2278,16 +2369,33 @@ export declare const moveTemplates: import("@elaraai/e3").RecordDef<DictType<Str
     readonly decision: OptionType<StringType>;
     readonly note: StringType;
 }>>, [variant<"field", "records">, variant<"field", "flowchart_move_templates">]>;
+export declare const movesByKind: import("@elaraai/e3").RecordIndexDef<"flowchart_moves_by_kind", DictType<StringType, StructType<{
+    readonly kind: import("@elaraai/east").VariantType<{
+        readonly planned: NullType;
+        readonly observed: NullType;
+    }>;
+    readonly decision: OptionType<StringType>;
+    readonly note: StringType;
+}>>, import("@elaraai/east").VariantType<{
+    readonly planned: NullType;
+    readonly observed: NullType;
+}>, NullType, readonly ["kind"]> & {
+    interval: undefined;
+};
 export declare const DecisionOwner: StructType<{
-    readonly role: StringType;
     readonly name: StringType;
     readonly desk: StringType;
 }>;
-export declare const decisionOwners: import("@elaraai/e3").DatasetDef<ArrayType<StructType<{
-    readonly role: StringType;
+export declare const decisionOwners: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly desk: StringType;
+}>>, [variant<"field", "records">, variant<"field", "flowchart_decision_owners">]>;
+export declare const ownersByDesk: import("@elaraai/e3").RecordIndexDef<"flowchart_owners_by_desk", DictType<StringType, StructType<{
     readonly name: StringType;
     readonly desk: StringType;
-}>>, [variant<"field", "inputs">, variant<"field", "flowchart_decision_owners">]>;
+}>>, StringType, NullType, readonly ["desk"]> & {
+    interval: undefined;
+};
 export declare const DepotState: StructType<{
     readonly code: StringType;
     readonly name: StringType;
@@ -2358,12 +2466,15 @@ export declare const flowchartFlows: import("@elaraai/east").ExampleDef<[], any>
  */
 export declare const flowchartVariants: import("@elaraai/east").ExampleDef<[], any>;
 /**
- * The library (#1248): the Flows tab, then the step types, the transition
- * types and the roles that own a decision — each tab its own bound data,
- * apart from the flows and from the other tabs: an input's rows, a record's
- * rows by name, another input's. Each template card is a drag source, as is
- * each of the author's cards, whose tab declares a `drop`; a click selects a
- * card, and a click on the selected card lets it go.
+ * The library (#1248, #1346): the Flows tab, then the step types, the
+ * transition types and the roles that own a decision — each tab its own
+ * bound data, apart from the flows and from the other tabs: a templates
+ * record by code, one by name, and a record of roles. One rail narrows them,
+ * a source each: each templates list and the Owners tab follow the source
+ * they name, counting what they show (`2 of 5`) and saying so, with Clear
+ * filters, when the rail leaves them none. Each template card is a drag
+ * source, as is each of the author's cards, whose tab declares a `drop`; a
+ * click selects a card, and a click on the selected card lets it go.
  */
 export declare const flowchartLibrary: import("@elaraai/east").ExampleDef<[], any>;
 /**
@@ -2371,11 +2482,9 @@ export declare const flowchartLibrary: import("@elaraai/east").ExampleDef<[], an
  * transitions mined from its scans and its decisions, each an e3 input of the
  * app's own rows, built into one flow by `Flowchart.over` through their row
  * mappers and shown read only: decision triggers, evidence-weighted links, a
- * ×14 state class, an ↻ in-place loop and an unresolved ghost. A bound slice
- * narrows the transitions the flow is built from, its rail at the toolbar's
- * end, and the freshness chip names the evidence. Its one pane is the
- * inspector, every field of what is selected printed, its Issues the
- * unresolved transition.
+ * ×14 state class, an ↻ in-place loop and an unresolved ghost. The freshness
+ * chip names the evidence. Its one pane is the inspector, every field of what
+ * is selected printed, its Issues the unresolved transition.
  */
 export declare const flowchartDepot: import("@elaraai/east").ExampleDef<[], any>;
 /**
@@ -3506,6 +3615,46 @@ export declare const indexedFlowsPatch: import("@elaraai/e3").MutationDef<"patch
         }>;
     }>>;
 }>]>;
+export declare const flowsByName: import("@elaraai/e3").RecordIndexDef<"name", DictType<StringType, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>, StringType, NullType, undefined> & {
+    interval: undefined;
+};
 export declare const flowsByDescription: import("@elaraai/e3").RecordIndexDef<"flowchart_by_description", DictType<StringType, StructType<{
     readonly description: OptionType<StringType>;
     readonly lanes: ArrayType<StructType<{
@@ -3546,6 +3695,49 @@ export declare const flowsByDescription: import("@elaraai/e3").RecordIndexDef<"f
 }>>, OptionType<StringType>, NullType, readonly ["description"]> & {
     interval: undefined;
 };
+export declare const flowsByDescriptionName: import("@elaraai/e3").RecordIndexDef<"flowchart_by_description_name", DictType<StringType, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly lanes: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+    }>>;
+    readonly states: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: OptionType<StringType>;
+        readonly lane: StringType;
+        readonly members: OptionType<IntegerType>;
+        readonly notes: OptionType<StringType>;
+    }>>;
+    readonly links: ArrayType<StructType<{
+        readonly key: OptionType<StringType>;
+        readonly from: StringType;
+        readonly to: StringType;
+        readonly kind: OptionType<import("@elaraai/east").VariantType<{
+            readonly planned: NullType;
+            readonly observed: NullType;
+        }>>;
+        readonly trigger: OptionType<StringType>;
+        readonly evidence: OptionType<StructType<{
+            readonly volume: OptionType<FloatType>;
+            readonly count: OptionType<IntegerType>;
+            readonly measuredAt: OptionType<DateTimeType>;
+            readonly unit: OptionType<StringType>;
+        }>>;
+    }>>;
+    readonly triggers: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly label: StringType;
+        readonly letter: OptionType<StringType>;
+        readonly owner: OptionType<StringType>;
+        readonly queue: OptionType<ArrayType<StringType>>;
+        readonly outcomes: OptionType<StringType>;
+    }>>;
+}>>, StructType<{
+    readonly description: OptionType<StringType>;
+    readonly name: StringType;
+}>, NullType, undefined> & {
+    interval: undefined;
+};
 export declare const flowsByStateCount: import("@elaraai/e3").RecordIndexDef<"stateCount", DictType<StringType, StructType<{
     readonly description: OptionType<StringType>;
     readonly lanes: ArrayType<StructType<{

package/dist/test/flowchart/flowchart.examples.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"flowchart.examples.d.ts","sourceRoot":"","sources":["../../../test/flowchart/flowchart.examples.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sCAAsC;AACtC,OAAO,EACH,SAAS,EAAe,YAAY,EAAE,QAAQ,EAAQ,SAAS,EAAgB,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAsB,UAAU,EAAE,UAAU,EACvI,OAAO,EAC/B,MAAM,eAAe,CAAC;AA+CvB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8EA4BpB,CAAC;AACJ,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAgC,CAAC;AAI7D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mFAWzB,CAAC;AACJ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"flowchart.examples.d.ts","sourceRoot":"","sources":["../../../test/flowchart/flowchart.examples.tsx"],"names":[],"mappings":"AAAA;;;GAGG;AACH,sCAAsC;AACtC,OAAO,EACH,SAAS,EAAe,YAAY,EAAE,QAAQ,EAAQ,SAAS,EAAgB,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAsB,UAAU,EAAE,UAAU,EACvI,OAAO,EAC/B,MAAM,eAAe,CAAC;AAmDvB,eAAO,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8EA4BpB,CAAC;AACJ,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAAgC,CAAC;AAI7D,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mFAWzB,CAAC;AACJ,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"}

package/dist/test/flowchart/flowchart.examples.js

@@ -20,11 +20,11 @@ import e3 from "@elaraai/e3";
 //   only as axes over the host's flows (`data`), which its `onApply` commits,
 //   the selection and a traced path heard in its aside;
 // - `flowchartLibrary`, the depot's flows (§3.3): the Flows tab, the step and
-//   transition templates and the decisions' owners, each card dropped on the
-//   canvas;
+//   transition templates and the decisions' owners, each a record of its own
+//   that one rail narrows, each card dropped on the canvas;
 // - `flowchartDepot`, a flow from the host's tables (§3.4): decisions,
 //   evidence, a state class, an in-place transition and an unresolved one,
-//   narrowed by a slice, read only;
+//   read only;
 // - `flowchartHandover`, the host's one flow, top down, with no pane;
 // - `flowchartDetail`, a record's one flow edited on the canvas, a
 //   connection veto, and a state's and a transition's own Details.
@@ -39,8 +39,12 @@ import e3 from "@elaraai/e3";
 // Every flowchart binds its flows from e3, so each runs on e3-web in the
 // showcase (§2a): a record of flows written with `Flowchart.values`, whose
 // patch mutation every Save commits through; an input of one flow written
-// with `Flowchart.value`; or the host's tables, each an input. `State` holds
-// only what the viewer owns: the configurator's axes and what it heard.
+// with `Flowchart.value`; or the host's tables, each an input. A flowchart's
+// narrowing is one `Slice.bindRecords` (#1346): a `flows` source over a record
+// of flows narrows the Flows tab, which pages it, and each other source the
+// templates list or the tab that names it; the host's tables are never
+// narrowed. `State` holds only what the viewer owns: the configurator's axes
+// and what it heard.
 //
 // A flowchart fills its parent, as a ui task's page fills the window: each
 // example gives it a box of its own height. One page shows them all, so every
@@ -111,32 +115,39 @@ export const handoverFlow = e3.input("flowchart_handover", Flowchart.Types.Flow,
     ],
     triggers: [{ key: "attempt", label: "attempt", owner: "driver" }],
 })));
-// The library's rows (#1248): each tab its own bound data, apart from the
-// flows and from the other tabs — the step types an input's rows, the
-// transition types a record's rows by name, and the roles that own a decision
-// another input's.
-export const StepTemplate = StructType({ code: StringType, name: StringType, kind: StringType, slots: OptionType(IntegerType) });
-export const stepTemplates = e3.input("flowchart_step_templates", ArrayType(StepTemplate), variant("value", [
-    { code: "ARV", name: "Arrived", kind: "Intake", slots: none },
-    { code: "SCN", name: "Scanned", kind: "Intake", slots: none },
-    { code: "CH*", name: "Sort chutes", kind: "Sort", slots: some(12n) },
-    { code: "HLD", name: "Held", kind: "Hold", slots: none },
-    { code: "LDD", name: "Loaded", kind: "Load", slots: none },
+// The library's records (#1248, #1346): each tab its own bound data, apart
+// from the flows and from the other tabs — the step types by code, the
+// transition types by name and the roles that own a decision, each a record
+// of its own, its cards its rows by key, and each indexed on the field the
+// rail narrows it by.
+export const StepTemplate = StructType({ name: StringType, kind: StringType, slots: OptionType(IntegerType) });
+export const stepTemplates = e3.record("flowchart_step_templates", DictType(StringType, StepTemplate), 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 }],
 ]));
+export const stepsByKind = e3.recordIndex("flowchart_steps_by_kind", stepTemplates, { on: ["kind"] });
+/** The step types' patch door: what another writer adds a step type through, the Steps tab's cards following. */
+export const stepTemplatesPatch = e3.mutation.patch(stepTemplates);
 export const MoveTemplate = StructType({ kind: Flowchart.Types.Kind, decision: OptionType(StringType), note: StringType });
 export const moveTemplates = e3.record("flowchart_move_templates", DictType(StringType, MoveTemplate), 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" }],
 ]));
-export const DecisionOwner = StructType({ role: StringType, name: StringType, desk: StringType });
-export const decisionOwners = e3.input("flowchart_decision_owners", ArrayType(DecisionOwner), variant("value", [
-    { role: "sort-planner", name: "Sort planner", desk: "Sort hall" },
-    { role: "customs-desk", name: "Customs desk", desk: "Hold bay" },
+export const movesByKind = e3.recordIndex("flowchart_moves_by_kind", moveTemplates, { on: ["kind"] });
+export const DecisionOwner = StructType({ name: StringType, desk: StringType });
+export const decisionOwners = e3.record("flowchart_decision_owners", DictType(StringType, DecisionOwner), new Map([
+    ["sort-planner", { name: "Sort planner", desk: "Sort hall" }],
+    ["customs-desk", { name: "Customs desk", desk: "Hold bay" }],
 ]));
+export const ownersByDesk = e3.recordIndex("flowchart_owners_by_desk", decisionOwners, { on: ["desk"] });
 // The depot's own tables (§3.4), each an input of the app's own rows: its
-// steps by phase, the transitions mined from its scans — what the slice
-// narrows — and its decisions. `Flowchart.over` builds one flow from them.
+// steps by phase, the transitions mined from its scans and its decisions.
+// `Flowchart.over` builds one flow from them; a task narrows the rows it
+// builds one from, for the flowchart narrows no table of the host's (#1346).
 export const DepotState = StructType({ code: StringType, name: StringType, phase: StringType, slots: OptionType(IntegerType) });
 export const depotStates = e3.input("flowchart_depot_states", ArrayType(DepotState), variant("value", [
     { code: "ARV", name: "Arrived", phase: "intake", slots: none },
@@ -250,40 +261,53 @@ export const flowchartVariants = example({
     inputs: [],
 });
 /**
- * The library (#1248): the Flows tab, then the step types, the transition
- * types and the roles that own a decision — each tab its own bound data,
- * apart from the flows and from the other tabs: an input's rows, a record's
- * rows by name, another input's. Each template card is a drag source, as is
- * each of the author's cards, whose tab declares a `drop`; a click selects a
- * card, and a click on the selected card lets it go.
+ * The library (#1248, #1346): the Flows tab, then the step types, the
+ * transition types and the roles that own a decision — each tab its own
+ * bound data, apart from the flows and from the other tabs: a templates
+ * record by code, one by name, and a record of roles. One rail narrows them,
+ * a source each: each templates list and the Owners tab follow the source
+ * they name, counting what they show (`2 of 5`) and saying so, with Clear
+ * filters, when the rail leaves them none. Each template card is a drag
+ * source, as is each of the author's cards, whose tab declares a `drop`; a
+ * click selects a card, and a click on the selected card lets it go.
  */
 export const flowchartLibrary = example({
-    keywords: ["Flowchart", "library", "Flowchart.library.states", "Flowchart.library.transitions", "Flowchart.library.tab", "templates", "state templates", "transition templates", "author's tab", "bound data", "Data.bind", "Record.bind", "drag", "cards", "Flowchart.patch"],
-    description: "A record of flows with its library — the Flows tab, step types from an input's rows, transition types from a record's rows by name, and the author's own cards — each tab its own bound data, each card a drag source a click selects",
+    keywords: ["Flowchart", "library", "Flowchart.library.states", "Flowchart.library.transitions", "Flowchart.library.tab", "templates", "state templates", "transition templates", "templates records", "author's tab", "bound data", "Data.bind", "Data.bindPaged", "recordIndex", "Slice.bindRecords", "source", "narrowing", "Record.bind", "drag", "cards", "Flowchart.patch"],
+    description: "A record of flows with its library — the Flows tab, step types and transition types from templates records, and the author's own cards from a record of roles — each tab its own bound data, one Slice.bindRecords rail narrowing each through the source it names, each card a drag source a click selects",
     fn: East.function([], UIComponentType, (_$) => (_jsx(Reactive, { children: $ => {
             const flows = $.let(Record.bind(depotFlows, [depotFlowsPatch]));
+            // 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(Record.bind(moveTemplates, []));
+            const moves = $.let(Data.bind(moveTemplates));
             const owners = $.let(Data.bind(decisionOwners));
-            return (_jsx(Box, { height: "560px", children: _jsx(Flowchart, { record: flows, flow: "Inbound parcels", name: "depot", library: [
+            // 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: [stepsByKind] }), label: "Steps", icon: { prefix: "fas", name: "box" },
+                    fields: { kind: { label: "Step kind", hints: ["Intake", "Sort", "Hold", "Load"] } } },
+                moves: { source: Data.bindPaged(moveTemplates, { indexes: [movesByKind] }), label: "Transitions", icon: { prefix: "fas", name: "arrow-right" },
+                    fields: { kind: { label: "Transition kind" } } },
+                owners: { source: Data.bindPaged(decisionOwners, { indexes: [ownersByDesk] }), label: "Owners", icon: { prefix: "fas", name: "user-tie" },
+                    fields: { desk: { label: "Desk", hints: ["Sort hall", "Hold bay"] } } },
+            }));
+            return (_jsx(Box, { height: "560px", children: _jsx(Flowchart, { record: flows, flow: "Inbound parcels", name: "depot", slice: { slice }, library: [
                         Flowchart.library.flows(),
-                        // Step types, an input's rows: a card dropped on a lane adds a state seeded with what its drop sets.
+                        // 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",
-                            key: s => s.code, label: s => s.name, meta: s => some(s.code), group: s => s.kind,
-                            drop: s => Flowchart.patch(Flowchart.Types.State, { key: s.code, label: some(s.name), members: s.slots }),
+                            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 record's rows by name: a card dropped on a transition retypes it.
+                        // Transition types, a templates record by name: a card dropped on a transition retypes it.
                         Flowchart.library.transitions(moves.read(), {
-                            icon: "arrow-right",
-                            key: (_m, name) => name, label: (_m, name) => name, meta: m => some(m.note),
+                            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 role dropped on a decision owns it.
+                        // 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",
-                            key: o => o.role, label: o => o.name, meta: o => some(o.desk),
-                            drop: o => Flowchart.patch(Flowchart.Types.Trigger, { owner: some(o.role) }),
+                            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) }),
                         }),
                     ] }) }));
         } }))),
@@ -294,30 +318,20 @@ export const flowchartLibrary = example({
  * transitions mined from its scans and its decisions, each an e3 input of the
  * app's own rows, built into one flow by `Flowchart.over` through their row
  * mappers and shown read only: decision triggers, evidence-weighted links, a
- * ×14 state class, an ↻ in-place loop and an unresolved ghost. A bound slice
- * narrows the transitions the flow is built from, its rail at the toolbar's
- * end, and the freshness chip names the evidence. Its one pane is the
- * inspector, every field of what is selected printed, its Issues the
- * unresolved transition.
+ * ×14 state class, an ↻ in-place loop and an unresolved ghost. The freshness
+ * chip names the evidence. Its one pane is the inspector, every field of what
+ * is selected printed, its Issues the unresolved transition.
  */
 export const flowchartDepot = example({
-    keywords: ["Flowchart", "Flowchart.over", "data", "states", "links", "lanes", "tables", "row mappers", "minimal", "planned", "observed", "triggers", "evidence", "slice", "Slice.rows", "Data.bind", "e3.input", "scans", "inspector", "Details", "Issues", "read only", "state class", "in-place", "unresolved", "freshness"],
-    description: "Parcel-depot flowchart over the host's tables, each an e3 input bound with Data.bind and built into one flow by Flowchart.over, read only — decision triggers, evidence-weighted links, a ×14 state class, an ↻ in-place loop, an unresolved ghost, a bound slice narrowing the transitions, the freshness chip, and the inspector showing the selected state, transition or decision read only, its Issues the unresolved transition",
+    keywords: ["Flowchart", "Flowchart.over", "data", "states", "links", "lanes", "tables", "row mappers", "minimal", "planned", "observed", "triggers", "evidence", "Data.bind", "e3.input", "scans", "inspector", "Details", "Issues", "read only", "state class", "in-place", "unresolved", "freshness"],
+    description: "Parcel-depot flowchart over the host's tables, each an e3 input bound with Data.bind and built into one flow by Flowchart.over, read only — decision triggers, evidence-weighted links, a ×14 state class, an ↻ in-place loop, an unresolved ghost, the freshness chip, and the inspector showing the selected state, transition or decision read only, its Issues the unresolved transition",
     fn: East.function([], UIComponentType, (_$) => (_jsx(Reactive, { children: $ => {
             const states = $.let(Data.bind(depotStates));
             const scans = $.let(Data.bind(scanTransitions));
             const decisions = $.let(Data.bind(depotDecisions));
-            const slice = $.let(Slice.bind("flowchart-depot", scans.read(), {
-                fields: {
-                    service: { label: "Service" },
-                    src: { label: "From" },
-                    dst: { label: "To" },
-                },
-                search: ["src", "dst"],
-            }));
             return (_jsx(Box, { height: "600px", children: _jsx(Flowchart, { data: Flowchart.over(states.read(), {
                         state: s => ({ key: s.code, label: s.name, lane: s.phase, members: s.slots }),
-                        links: Slice.rows(slice),
+                        links: scans.read(),
                         link: l => ({
                             key: l.id, from: l.src, to: l.dst, kind: l.kind, trigger: l.trigger,
                             evidence: { volume: l.parcels, count: l.n, measuredAt: some(l.at), unit: "parcels" },
@@ -329,7 +343,7 @@ export const flowchartDepot = example({
                         ],
                         triggers: decisions.read(),
                         trigger: t => ({ key: t.id, label: t.name, owner: t.who }),
-                    }), slice: slice, affordances: ["filter", "search"], freshness: { label: "evidence-2026.06", date: new Date("2026-06-30T00:00:00Z") }, name: "scans" }) }));
+                    }), freshness: { label: "evidence-2026.06", date: new Date("2026-06-30T00:00:00Z") }, name: "scans" }) }));
         } }))),
     inputs: [],
 });
@@ -422,7 +436,15 @@ export const indexedFlows = e3.record("flowchart_indexed_flows", Flowchart.Types
         }];
 }))));
 export const indexedFlowsPatch = e3.mutation.patch(indexedFlows);
+// A flow's name is its record's key: an index of its own, so the Flows tab's
+// search finds a flow by its name (#1346), alone and after a description.
+export const flowsByName = e3.recordIndex("name", indexedFlows, {
+    key: East.function([StringType, Flowchart.Types.Flow], StringType, (_$, name, _flow) => name),
+});
 export const flowsByDescription = e3.recordIndex("flowchart_by_description", indexedFlows, { on: ["description"] });
+export const flowsByDescriptionName = e3.recordIndex("flowchart_by_description_name", indexedFlows, {
+    key: East.function([StringType, Flowchart.Types.Flow], StructType({ description: OptionType(StringType), name: StringType }), (_$, name, flow) => ({ description: flow.description, name })),
+});
 // Slice derives controls from each computed index’s declared key type. Scalar
 // keys use the index name; a composite key supplies its field names.
 export const flowsByStateCount = e3.recordIndex("stateCount", indexedFlows, {
@@ -438,27 +460,32 @@ export const flowsByDecisionOwner = e3.recordIndex("decisionOwner", indexedFlows
     keys: East.function([StringType, Flowchart.Types.Flow], SetType(OptionType(StringType)), (_$, _id, flow) => flow.triggers.toSet((_$2, trigger) => trigger.owner)),
 });
 export const flowchartRecordIndexes = example({
-    keywords: ["Flowchart", "record", "indexes", "computed indexes", "state count", "lane", "decision owner", "recordIndex", "Slice.bindRecord", "Slice.rows", "Data.bindPaged", "paging", "Flows tab", "mobile", "Save"],
-    description: "2,048 route flowcharts in a paged record. Shared Slice filters use maintained indexes on description, computed state count, lane and decision owner. Choose an exact description plus a state-count range together; lane and owner use exact membership. The Flows tab pages results, and drafts keep their original record ID through filtering and Save.",
+    keywords: ["Flowchart", "record", "indexes", "computed indexes", "state count", "lane", "decision owner", "recordIndex", "Slice.bindRecords", "flows", "Data.bindPaged", "paging", "Flows tab", "count", "search", "mobile", "Save"],
+    description: "2,048 route flowcharts in a paged record, narrowed through the rail's flows source by maintained indexes on name, description, computed state count, lane and decision owner. Choose an exact description plus a state-count range together; lane and owner use exact membership. The Flows tab pages and counts what the rail narrows to, its search box finds a flow by name within it, and drafts keep their original record ID through filtering and Save.",
     fn: East.function([], UIComponentType, (_$) => (_jsx(Reactive, { children: $ => {
             const flows = $.let(Record.bind(indexedFlows, [indexedFlowsPatch]));
-            const indexed = $.let(Data.bindPaged(indexedFlows, { indexes: [flowsByDescription, flowsByStateCount, flowsByDescriptionStateCount, flowsByLane, flowsByDecisionOwner] }));
-            const slice = $.let(Slice.bindRecord("flowchart.recordIndexes", indexed, {
-                fields: {
-                    description: { label: "Flows" },
-                    stateCount: { label: "State count" },
-                    lane: { label: "Lane" },
-                    decisionOwner: { label: "Decision owner" },
+            // One rail over the flows (#1346): its `flows` source narrows the Flows tab, which pages and counts what it narrows to.
+            const slice = $.let(Slice.bindRecords("flowchart.recordIndexes", {
+                flows: {
+                    source: Data.bindPaged(indexedFlows, { indexes: [flowsByName, flowsByDescription, flowsByDescriptionName, flowsByStateCount, flowsByDescriptionStateCount, flowsByLane, flowsByDecisionOwner] }),
+                    fields: {
+                        description: { label: "Flows" },
+                        stateCount: { label: "State count" },
+                        lane: { label: "Lane" },
+                        decisionOwner: { label: "Decision owner" },
+                        name: { label: "Name" },
+                    },
+                    search: ["name", "description", "lane", "decisionOwner"],
                 },
-                search: ["description", "lane", "decisionOwner"],
+            }, {
                 presets: [
-                    { id: "inbound", name: "Inbound", where: { description: ["Inbound parcels"] } },
-                    { id: "inbound-review", name: "Inbound · 4–6 states", where: { description: ["Inbound parcels"], stateCount: { from: 4n, to: 7n } } },
-                    { id: "review", name: "Review lane", where: { lane: ["review"] } },
-                    { id: "customs", name: "Customs decisions", where: { decisionOwner: ["customs-desk"] } },
+                    { id: "inbound", name: "Inbound", where: { flows: { description: ["Inbound parcels"] } } },
+                    { id: "inbound-review", name: "Inbound · 4–6 states", where: { flows: { description: ["Inbound parcels"], stateCount: { from: 4n, to: 7n } } } },
+                    { id: "review", name: "Review lane", where: { flows: { lane: ["review"] } } },
+                    { id: "customs", name: "Customs decisions", where: { flows: { decisionOwner: ["customs-desk"] } } },
                 ],
             }));
-            return (_jsx(Box, { width: "100%", height: "640px", children: _jsx(Flowchart, { record: flows, window: Slice.rows(slice), slice: { slice, affordances: ["fields", "search", "presets", "summary"] }, library: [Flowchart.library.flows()], name: "recordIndexes" }) }));
+            return (_jsx(Box, { width: "100%", height: "640px", children: _jsx(Flowchart, { record: flows, slice: { slice, affordances: ["fields", "search", "presets", "summary"] }, library: [Flowchart.library.flows()], name: "recordIndexes" }) }));
         } }))),
     inputs: [],
 });