@elaraai/e3-ui 1.0.98 → 1.0.100

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;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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"}
+{"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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAiCrB,CAAC;AAIH,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAoDxB,CAAC;AAEH;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,6CAsB7B,CAAC"}

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

@@ -53,51 +53,59 @@ import e3 from "@elaraai/e3";
 // ============================================================================
 // The depot's flows, by name: each a whole flowchart, written as literals and
 // checked when the package builds.
-export const depotFlows = e3.record("flowchart_depot_flows", Flowchart.Types.Flows, Flowchart.values({
-    "Inbound parcels": {
-        description: "From the trailer to the van",
-        lanes: [{ key: "intake", label: "Intake" }, { key: "sort", label: "Sort" }, { key: "load", label: "Load" }],
-        states: [
-            { key: "ARV", label: "Arrived", lane: "intake" },
-            { key: "SCN", label: "Scanned", lane: "intake" },
-            { key: "CH*", label: "Sort chutes", lane: "sort", members: 12n },
-            { key: "LDD", label: "Loaded", lane: "load" },
-        ],
-        links: [
-            { from: "ARV", to: "SCN" },
-            { from: "SCN", to: "CH*", trigger: "route" },
-            { from: "CH*", to: "LDD" },
-            { from: "SCN", to: "SCN", kind: "observed" },
-        ],
-        triggers: [{ key: "route", label: "route", owner: "sort-planner" }],
-    },
-    "Returns": {
-        description: "From the counter back to the sender",
-        lanes: [{ key: "counter", label: "Counter" }, { key: "check", label: "Check" }, { key: "out", label: "Out" }],
-        states: [
-            { key: "RCV", label: "Received", lane: "counter" },
-            { key: "INS", label: "Inspected", lane: "check" },
-            { key: "RSD", label: "Resent", lane: "out" },
-        ],
-        links: [{ from: "RCV", to: "INS" }, { from: "INS", to: "RSD" }, { from: "INS", to: "BIN", kind: "observed" }],
-    },
-}));
-export const depotFlowsPatch = e3.mutation.patch(depotFlows);
+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(),
+    }),
+});
 // A lone flow, edited on the canvas: a record of flows with one entry, bound
 // with its patch mutation.
-export const collectionFlows = e3.record("flowchart_collection_flows", Flowchart.Types.Flows, Flowchart.values({
-    "Collections": {
-        description: "From the booking to the depot's door",
-        lanes: [{ key: "book", label: "Book" }, { key: "van", label: "Van" }, { key: "depot", label: "Depot" }],
-        states: [
-            { key: "BKD", label: "Booked", lane: "book" },
-            { key: "CLD", label: "Collected", lane: "van" },
-            { key: "RCV", label: "Received", lane: "depot" },
-        ],
-        links: [{ key: "BKD→CLD", from: "BKD", to: "CLD" }, { key: "CLD→RCV", from: "CLD", to: "RCV" }],
-    },
-}));
-export const collectionFlowsPatch = e3.mutation.patch(collectionFlows);
+export const collectionFlows = e3.record("flowchart_collection_flows", Flowchart.Types.Flows, {
+    initial: Flowchart.values({
+        "Collections": {
+            description: "From the booking to the depot's door",
+            lanes: [{ key: "book", label: "Book" }, { key: "van", label: "Van" }, { key: "depot", label: "Depot" }],
+            states: [
+                { key: "BKD", label: "Booked", lane: "book" },
+                { key: "CLD", label: "Collected", lane: "van" },
+                { key: "RCV", label: "Received", lane: "depot" },
+            ],
+            links: [{ key: "BKD→CLD", from: "BKD", to: "CLD" }, { key: "CLD→RCV", from: "CLD", to: "RCV" }],
+        },
+    }),
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
+});
 // One flow, for an app that has only one: the host's, read only.
 export const handoverFlow = e3.input("flowchart_handover", Flowchart.Types.Flow, variant("value", Flowchart.value({
     description: "From the last scan to the driver's signature",
@@ -121,29 +129,43 @@ export const handoverFlow = e3.input("flowchart_handover", Flowchart.Types.Flow,
 // 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 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), 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 movesByKind = e3.recordIndex("flowchart_moves_by_kind", moveTemplates, { on: ["kind"] });
+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), 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"] });
+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"]),
+    }),
+});
 // 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 and its decisions.
 // `Flowchart.over` builds one flow from them; a task narrows the rows it
@@ -187,7 +209,7 @@ export const flowchartFlows = example({
     keywords: ["Flowchart", "record", "Flows", "Flowchart.values", "Record.bind", "flow", "many flows", "e3.record", "Flowchart.library.flows", "Flows tab", "New flow"],
     description: "A record of flows by name — the depot's inbound parcels and its returns — bound with its patch mutation, the inbound flow opened first and the Flows tab listing every flow",
     fn: East.function([], UIComponentType, (_$) => (_jsx(Reactive, { children: $ => {
-            const flows = $.let(Record.bind(depotFlows, [depotFlowsPatch]));
+            const flows = $.let(Record.bind(depotFlows));
             return (_jsx(Box, { height: "500px", children: _jsx(Flowchart, { record: flows, flow: "Inbound parcels", library: [Flowchart.library.flows()] }) }));
         } }))),
     inputs: [],
@@ -211,7 +233,7 @@ export const flowchartVariants = example({
     keywords: ["Flowchart", "configurator", "Configurator", "legend", "minimap", "readOnly", "read only", "onSelectState", "onSelectLink", "onSelectTrigger", "onTracePath", "selection", "trace", "callbacks", "data", "onApply", "commit", "requestId", "request id", "Retry", "Record.bind", "commit.patch", "Editing.Types.ApplyResult", "Flows tab", "Flowchart.library.flows", "many flows", "inspector={false}", "library", "Switch", "State", "Reactive"],
     description: "Flowchart configurator — the legend, the minimap and read only, each expression-fed into one live flowchart in its frame over the host's flows by name (data, from the depot's e3 record), its Flows tab over them, Save committed by the host's onApply through the record's patch mutation under the session's request id, a Retry safe to repeat; onSelectState, onSelectLink, onSelectTrigger and onTracePath heard in the aside, with no inspector",
     fn: East.function([], UIComponentType, (_$) => (_jsx(Reactive, { children: $ => {
-            const flows = $.let(Record.bind(depotFlows, [depotFlowsPatch]));
+            const flows = $.let(Record.bind(depotFlows));
             // The host's commit: the open flow's patch through the record's patch mutation under the session's request id, e3's outcome as Save's answer.
             const onApply = $.const(East.asyncFunction([StringType, PatchType(Flowchart.Types.Flows)], Editing.Types.ApplyResult, ($2, requestId, patch) => {
                 const outcome = $2.let(flows.commit.patch(requestId, patch));
@@ -272,21 +294,21 @@ export const flowchartVariants = example({
  * 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", "templates records", "author's tab", "bound data", "Data.bind", "Data.bindPaged", "recordIndex", "Slice.bindRecords", "source", "narrowing", "Record.bind", "drag", "cards", "Flowchart.patch"],
+    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", "indexes", "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]));
+            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: [stepsByKind] }), label: "Steps", icon: { prefix: "fas", name: "box" },
+                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: [movesByKind] }), label: "Transitions", icon: { prefix: "fas", name: "arrow-right" },
+                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: [ownersByDesk] }), label: "Owners", icon: { prefix: "fas", name: "user-tie" },
+                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 (_jsx(Box, { height: "560px", children: _jsx(Flowchart, { record: flows, flow: "Inbound parcels", name: "depot", slice: { slice }, library: [
@@ -382,7 +404,7 @@ export const flowchartDetail = example({
     keywords: ["Flowchart", "record", "Record.bind", "one flow", "one entry", "lone flow", "editing", "builder", "Save", "undo", "redo", "history", "+ LANE", "+ STATE", "connect", "canConnect", "Del", "rename", "move", "authoring", "interactive", "edit", "inspector", "Details", "own Details", "update", "one transaction", "state", "transition", "Button", "Issues"],
     description: "A record's one flow — the collections, from the booking to the depot's door — edited on the canvas: + LANE, lane rename and ×, the + STATE ghost, double-click edit, cross-lane drag, handle-drag connecting and Del, each a draft the history item undoes and Save commits through the record's patch mutation, a canConnect veto keeping transitions out of the booking; and the inspector's own Details by kind — a state's, whose button gives it one more member, and a transition's, whose button marks it observed — each in place of its form, each button's update one transaction",
     fn: East.function([], UIComponentType, (_$) => (_jsx(Reactive, { children: $ => {
-            const flows = $.let(Record.bind(collectionFlows, [collectionFlowsPatch]));
+            const flows = $.let(Record.bind(collectionFlows));
             // The connection veto: nothing comes back to the booking, though a
             // drop on BKD from BKD is its in-place transition.
             const canConnect = $.const(East.function([StringType, StringType], BooleanType, (_$2, from, to) => East.equal(to, "BKD").not().or(() => East.equal(from, to))));
@@ -412,62 +434,56 @@ export const flowchartDetail = example({
 });
 // A network's route flowcharts: enough independent record entries to exercise
 // multiple pages and eviction. Each entry remains one complete graph.
-export const indexedFlows = e3.record("flowchart_indexed_flows", Flowchart.Types.Flows, Flowchart.values(Object.fromEntries(Array.from({ length: 2048 }, (_, i) => {
-    const checks = [
-        { key: "CHK", label: "Checked", lane: "review" },
-        { key: "HLD", label: "Held", lane: "review" },
-        { key: "REL", label: "Released", lane: "review" },
-    ].slice(0, i % 4);
-    const states = [
-        { key: "ARV", label: "Arrived", lane: "intake" },
-        { key: "SCN", label: "Scanned", lane: "intake" },
-        ...checks,
-        { key: "LDD", label: "Loaded", lane: "dispatch" },
-    ];
-    return [`FLOW-${10000 + i}`, {
-            description: ["Inbound parcels", "Returns", "Collections"][i % 3],
-            lanes: [{ key: "intake", label: "Intake" },
-                ...(checks.length ? [{ key: "review", label: "Review" }] : []),
-                { key: "dispatch", label: "Dispatch" }],
-            states,
-            links: states.slice(1).map((state, j) => ({ from: states[j].key, to: state.key,
-                ...(j === 0 && i % 5 !== 0 ? { trigger: "route" } : {}) })),
-            triggers: i % 5 === 0 ? [] : [{ key: "route", label: "Route", owner: ["sort-planner", "customs-desk", "shift-lead"][Math.floor(i / 4) % 3] }],
-        }];
-}))));
-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, {
-    key: East.function([StringType, Flowchart.Types.Flow], IntegerType, (_$, _id, flow) => flow.states.size()),
-});
-export const flowsByDescriptionStateCount = e3.recordIndex("flowchart_by_description_state_count", indexedFlows, {
-    key: East.function([StringType, Flowchart.Types.Flow], StructType({ description: OptionType(StringType), stateCount: IntegerType }), (_$, _id, flow) => ({ description: flow.description, stateCount: flow.states.size() })),
-});
-export const flowsByLane = e3.recordIndex("lane", indexedFlows, {
-    keys: East.function([StringType, Flowchart.Types.Flow], SetType(StringType), (_$, _id, flow) => flow.lanes.toSet((_$2, lane) => lane.key)),
-});
-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 indexedFlows = e3.record("flowchart_indexed_flows", Flowchart.Types.Flows, {
+    initial: Flowchart.values(Object.fromEntries(Array.from({ length: 2048 }, (_, i) => {
+        const checks = [
+            { key: "CHK", label: "Checked", lane: "review" },
+            { key: "HLD", label: "Held", lane: "review" },
+            { key: "REL", label: "Released", lane: "review" },
+        ].slice(0, i % 4);
+        const states = [
+            { key: "ARV", label: "Arrived", lane: "intake" },
+            { key: "SCN", label: "Scanned", lane: "intake" },
+            ...checks,
+            { key: "LDD", label: "Loaded", lane: "dispatch" },
+        ];
+        return [`FLOW-${10000 + i}`, {
+                description: ["Inbound parcels", "Returns", "Collections"][i % 3],
+                lanes: [{ key: "intake", label: "Intake" },
+                    ...(checks.length ? [{ key: "review", label: "Review" }] : []),
+                    { key: "dispatch", label: "Dispatch" }],
+                states,
+                links: states.slice(1).map((state, j) => ({ from: states[j].key, to: state.key,
+                    ...(j === 0 && i % 5 !== 0 ? { trigger: "route" } : {}) })),
+                triggers: i % 5 === 0 ? [] : [{ key: "route", label: "Route", owner: ["sort-planner", "customs-desk", "shift-lead"][Math.floor(i / 4) % 3] }],
+            }];
+    }))),
+    indexes: (index) => ({
+        // 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.
+        name: index.key(East.function([StringType, Flowchart.Types.Flow], StringType, (_$, name, _flow) => name)),
+        flowchart_by_description: index.on(["description"]),
+        flowchart_by_description_name: index.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.
+        stateCount: index.key(East.function([StringType, Flowchart.Types.Flow], IntegerType, (_$, _id, flow) => flow.states.size())),
+        flowchart_by_description_state_count: index.key(East.function([StringType, Flowchart.Types.Flow], StructType({ description: OptionType(StringType), stateCount: IntegerType }), (_$, _id, flow) => ({ description: flow.description, stateCount: flow.states.size() }))),
+        lane: index.keys(East.function([StringType, Flowchart.Types.Flow], SetType(StringType), (_$, _id, flow) => flow.lanes.toSet((_$2, lane) => lane.key))),
+        decisionOwner: index.keys(East.function([StringType, Flowchart.Types.Flow], SetType(OptionType(StringType)), (_$, _id, flow) => flow.triggers.toSet((_$2, trigger) => trigger.owner))),
+    }),
+    mutations: (mutation) => ({
+        patch: mutation.patch(),
+    }),
 });
 export const flowchartRecordIndexes = example({
-    keywords: ["Flowchart", "record", "indexes", "computed indexes", "state count", "lane", "decision owner", "recordIndex", "Slice.bindRecords", "flows", "Data.bindPaged", "paging", "Flows tab", "count", "search", "mobile", "Save"],
+    keywords: ["Flowchart", "record", "indexes", "computed indexes", "state count", "lane", "decision owner", "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 flows = $.let(Record.bind(indexedFlows));
             // 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] }),
+                    source: Data.bindPaged(indexedFlows, { indexes: ["name", "flowchart_by_description", "flowchart_by_description_name", "stateCount", "flowchart_by_description_state_count", "lane", "decisionOwner"] }),
                     fields: {
                         description: { label: "Flows" },
                         stateCount: { label: "State count" },
@@ -489,4 +505,78 @@ export const flowchartRecordIndexes = example({
         } }))),
     inputs: [],
 });
+// ============================================================================
+// flowchartConflicts — your edits meeting someone else's save
+// ============================================================================
+/** The flows the conflicts example edits, in a record of their own, so no other example's edits meet them. */
+export const conflictFlows = e3.record("flowchart_conflict_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" },
+            ],
+            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" }],
+        },
+    }),
+    mutations: (mutation) => ({
+        // The flows' patch door — every Save commits through it.
+        patch: mutation.patch(),
+        // Someone else's save: every step of every flow renamed, " (theirs)" put on its name, or taken off again; its lane
+        // and its other fields as they were.
+        elsewhere: mutation.reduce(East.function([Flowchart.Types.Flows], Flowchart.Types.Flows, (_$, flows) => flows.map((_$2, flow) => ({
+            description: flow.description,
+            lanes: flow.lanes,
+            states: flow.states.map(($3, state) => {
+                const named = $3.let(state.label.match({ some: (_$4, label) => label, none: (_$4) => state.key }));
+                return {
+                    key: state.key,
+                    label: East.value(some(named.endsWith(" (theirs)").ifElse(() => named.replace(" (theirs)", ""), () => named.concat(" (theirs)"))), OptionType(StringType)),
+                    lane: state.lane,
+                    members: state.members,
+                    notes: state.notes,
+                };
+            }),
+            links: flow.links,
+            triggers: flow.triggers,
+        })))),
+    }),
+});
+/**
+ * Your edits meeting someone else's save, in one window: edit, then press
+ * Someone else saves, which saves another person's change to the same flows —
+ * every step renamed. A step you renamed too is a conflict, waiting for you to
+ * choose; a step you moved to another lane combines with theirs. Each press
+ * saves their change again.
+ */
+export const flowchartConflicts = example({
+    keywords: ["Flowchart", "conflict", "conflicts", "combine", "someone else", "Choose", "rename", "step", "Record.bind", "mutate", "Button", "Save"],
+    description: "Your edits meeting someone else's save, in one window — rename a step, then press Someone else saves, which saves another person's change to the same flows (every step renamed, \"(theirs)\" put on its name or taken off), so yours conflict and wait to be chosen; a step moved to another lane combines with theirs",
+    fn: East.function([], UIComponentType, (_$) => (_jsx(Reactive, { children: $ => {
+            const flows = $.let(Record.bind(conflictFlows, ["patch"]));
+            const others = $.let(Record.bind(conflictFlows, ["elsewhere"]));
+            const theirs = $.const(East.function([], NullType, ($) => { $(others.mutate.elsewhere()); }));
+            return (_jsxs(VStack, { gap: "3", align: "stretch", children: [_jsxs(HStack, { gap: "3", children: [_jsx(Button, { variant: "outline", onClick: theirs, loading: others.mutate.pending(), children: "Someone else saves" }), _jsx(Text, { color: "fg.muted", children: "Their change: every step renamed" })] }), _jsx(Box, { height: "500px", children: _jsx(Flowchart, { name: "conflicts", record: flows, flow: "Inbound parcels", library: [Flowchart.library.flows()] }) })] }));
+        } }))),
+    inputs: [],
+});
 //# sourceMappingURL=flowchart.examples.js.map