@elaraai/e3-ui 1.0.97 → 1.0.99

package/dist/test/bind/data/data.examples.d.ts

@@ -48,29 +48,31 @@ export declare const OpsRow: StructType<{
         readonly rejected: NullType;
     }>;
 }>;
-/** One hall's presses (or the delivery vans), keyed by id. */
-export declare const OpsHall: DictType<StringType, StructType<{
-    readonly ticket: StringType;
-    /** ISO week the job starts (2026); the series turns it into an instant. */
-    readonly startWeek: IntegerType;
-    /** Duration in weeks. */
-    readonly weeks: IntegerType;
-    readonly sheets: FloatType;
-    /** % utilisation, which the load series expands into a weekly strip. */
-    readonly load: FloatType;
-    readonly state: import("@elaraai/east").VariantType<{
-        readonly estimated: NullType;
-        readonly proposed: import("@elaraai/east").VariantType<{
-            readonly added: NullType;
-            readonly recommended: NullType;
-            readonly removed: NullType;
+/** One hall — its presses (or the delivery vans), a Dict keyed by id, which its series step down into by field. */
+export declare const OpsHall: StructType<{
+    readonly presses: DictType<StringType, StructType<{
+        readonly ticket: StringType;
+        /** ISO week the job starts (2026); the series turns it into an instant. */
+        readonly startWeek: IntegerType;
+        /** Duration in weeks. */
+        readonly weeks: IntegerType;
+        readonly sheets: FloatType;
+        /** % utilisation, which the load series expands into a weekly strip. */
+        readonly load: FloatType;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
         }>;
-        readonly confirmed: NullType;
-        readonly "in-progress": NullType;
-        readonly actual: NullType;
-        readonly rejected: NullType;
-    }>;
-}>>;
+    }>>;
+}>;
 /**
  * The seeded ops schedule — an `e3.input`'s default IS the dataset's initial
  * value, so this is what a freshly-deployed workspace (and the offline
@@ -85,28 +87,30 @@ export declare const OpsHall: DictType<StringType, StructType<{
  * observed at the back, in-progress across it, confirmed then proposed then
  * estimated ahead of it.
  */
-export declare const opsInput: e3.DatasetDef<DictType<StringType, DictType<StringType, StructType<{
-    readonly ticket: StringType;
-    /** ISO week the job starts (2026); the series turns it into an instant. */
-    readonly startWeek: IntegerType;
-    /** Duration in weeks. */
-    readonly weeks: IntegerType;
-    readonly sheets: FloatType;
-    /** % utilisation, which the load series expands into a weekly strip. */
-    readonly load: FloatType;
-    readonly state: import("@elaraai/east").VariantType<{
-        readonly estimated: NullType;
-        readonly proposed: import("@elaraai/east").VariantType<{
-            readonly added: NullType;
-            readonly recommended: NullType;
-            readonly removed: NullType;
+export declare const opsInput: e3.DatasetDef<DictType<StringType, StructType<{
+    readonly presses: DictType<StringType, StructType<{
+        readonly ticket: StringType;
+        /** ISO week the job starts (2026); the series turns it into an instant. */
+        readonly startWeek: IntegerType;
+        /** Duration in weeks. */
+        readonly weeks: IntegerType;
+        readonly sheets: FloatType;
+        /** % utilisation, which the load series expands into a weekly strip. */
+        readonly load: FloatType;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: NullType;
+                readonly recommended: NullType;
+                readonly removed: NullType;
+            }>;
+            readonly confirmed: NullType;
+            readonly "in-progress": NullType;
+            readonly actual: NullType;
+            readonly rejected: NullType;
         }>;
-        readonly confirmed: NullType;
-        readonly "in-progress": NullType;
-        readonly actual: NullType;
-        readonly rejected: NullType;
-    }>;
-}>>>, [variant<"field", "inputs">, variant<"field", "ops">]>;
+    }>>;
+}>>, [variant<"field", "inputs">, variant<"field", "ops">]>;
 /**
  * A maintenance work order — the row of the `work_orders` record, keyed by
  * its order id. The id says nothing about urgency: the order a dispatcher
@@ -139,28 +143,12 @@ export declare const workOrders: e3.RecordDef<DictType<StringType, StructType<{
      *  the index sorts the queue with no rank to compute. */
     readonly status: StringType;
     readonly due: DateTimeType;
-}>>, [variant<"field", "records">, variant<"field", "work_orders">]>;
-/**
- * The dispatch queue — every work order under `{status, due}`, carrying its
- * title so the queue renders from index pages alone and never reads an
- * order's row.
- */
-export declare const workQueue: e3.RecordIndexDef<"by_status", DictType<StringType, StructType<{
-    readonly site: StringType;
-    readonly title: StringType;
-    readonly crew: StringType;
-    /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
-     *  the index sorts the queue with no rank to compute. */
-    readonly status: StringType;
-    readonly due: DateTimeType;
-}>>, StructType<{
-    readonly status: StringType;
-    readonly due: DateTimeType;
-}>, StringType, undefined> & {
-    interval: undefined;
-};
-/** The work orders' patch door: another session's change to an order commits through it, and moves the queue with it. */
-export declare const workOrdersPatch: e3.MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "work_orders">], e3.IndexesOf<{
+    by_status: e3.IndexDraft<StructType<{
+        readonly status: StringType;
+        readonly due: DateTimeType;
+    }>, StringType, undefined, unknown>;
+}, DictType<StringType, StructType<{
     readonly site: StringType;
     readonly title: StringType;
     readonly crew: StringType;
@@ -168,109 +156,119 @@ export declare const workOrdersPatch: e3.MutationDef<"patch", DictType<StringTyp
      *  the index sorts the queue with no rank to compute. */
     readonly status: StringType;
     readonly due: DateTimeType;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly site: StringType;
-            readonly title: StringType;
-            readonly crew: StringType;
-            /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
-             *  the index sorts the queue with no rank to compute. */
-            readonly status: StringType;
-            readonly due: DateTimeType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly site: StringType;
-            readonly title: StringType;
-            readonly crew: StringType;
-            /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
-             *  the index sorts the queue with no rank to compute. */
-            readonly status: StringType;
-            readonly due: DateTimeType;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: StructType<{
-            readonly site: StringType;
-            readonly title: StringType;
-            readonly crew: StringType;
-            /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
-             *  the index sorts the queue with no rank to compute. */
-            readonly status: StringType;
-            readonly due: DateTimeType;
-        }>;
-        insert: StructType<{
-            readonly site: StringType;
-            readonly title: StringType;
-            readonly crew: StringType;
-            /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
-             *  the index sorts the queue with no rank to compute. */
-            readonly status: StringType;
-            readonly due: DateTimeType;
+}>>>, e3.MutationsOf<{
+    patch: e3.MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly site: StringType;
+                readonly title: StringType;
+                readonly crew: StringType;
+                /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+                 *  the index sorts the queue with no rank to compute. */
+                readonly status: StringType;
+                readonly due: DateTimeType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly site: StringType;
+                readonly title: StringType;
+                readonly crew: StringType;
+                /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+                 *  the index sorts the queue with no rank to compute. */
+                readonly status: StringType;
+                readonly due: DateTimeType;
+            }>>;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly site: StringType;
-                    readonly title: StringType;
-                    readonly crew: StringType;
-                    /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
-                     *  the index sorts the queue with no rank to compute. */
-                    readonly status: StringType;
-                    readonly due: DateTimeType;
-                }>;
-                after: StructType<{
-                    readonly site: StringType;
-                    readonly title: StringType;
-                    readonly crew: StringType;
-                    /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
-                     *  the index sorts the queue with no rank to compute. */
-                    readonly status: StringType;
-                    readonly due: DateTimeType;
-                }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly site: StringType;
+                readonly title: StringType;
+                readonly crew: StringType;
+                /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+                 *  the index sorts the queue with no rank to compute. */
+                readonly status: StringType;
+                readonly due: DateTimeType;
             }>;
-            patch: StructType<{
-                readonly site: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+            insert: StructType<{
+                readonly site: StringType;
+                readonly title: StringType;
+                readonly crew: StringType;
+                /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+                 *  the index sorts the queue with no rank to compute. */
+                readonly status: StringType;
+                readonly due: DateTimeType;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly site: StringType;
+                        readonly title: StringType;
+                        readonly crew: StringType;
+                        /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+                         *  the index sorts the queue with no rank to compute. */
+                        readonly status: StringType;
+                        readonly due: DateTimeType;
                     }>;
-                }>;
-                readonly title: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    after: StructType<{
+                        readonly site: StringType;
+                        readonly title: StringType;
+                        readonly crew: StringType;
+                        /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+                         *  the index sorts the queue with no rank to compute. */
+                        readonly status: StringType;
+                        readonly due: DateTimeType;
                     }>;
                 }>;
-                readonly crew: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                patch: StructType<{
+                    readonly site: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly status: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly title: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly due: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: DateTimeType;
-                        after: DateTimeType;
+                    readonly crew: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly status: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly due: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: DateTimeType;
+                            after: DateTimeType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly site: StringType;
+    readonly title: StringType;
+    readonly crew: StringType;
+    /** `late`, `open` or `planned` — alphabetical order IS urgency order, so
+     *  the index sorts the queue with no rank to compute. */
+    readonly status: StringType;
+    readonly due: DateTimeType;
+}>>>>;
 export declare const dataBindFloat: import("@elaraai/east").ExampleDef<[], any>;
 export declare const dataBindVariants: import("@elaraai/east").ExampleDef<[], any>;
 export declare const dataBindStagedFloat: import("@elaraai/east").ExampleDef<[], any>;
@@ -421,78 +419,73 @@ export declare const IndexedPerson: StructType<{
 export declare const indexedPeople: e3.RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly skills: SetType<StringType>;
-}>>, [variant<"field", "records">, variant<"field", "indexed_people">]>;
-export declare const indexedPeoplePatch: e3.MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "indexed_people">], e3.IndexesOf<{
+    by_name: e3.IndexDraft<StringType, NullType, readonly ["name"], unknown>;
+    by_skill: e3.IndexDraft<StringType, NullType, readonly ["skills"], unknown>;
+}, DictType<StringType, StructType<{
     readonly name: StringType;
     readonly skills: SetType<StringType>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly skills: SetType<StringType>;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly skills: SetType<StringType>;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: StructType<{
-            readonly name: StringType;
-            readonly skills: SetType<StringType>;
-        }>;
-        insert: StructType<{
-            readonly name: StringType;
-            readonly skills: SetType<StringType>;
+}>>>, e3.MutationsOf<{
+    patch: e3.MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly skills: SetType<StringType>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly skills: SetType<StringType>;
+            }>>;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly name: StringType;
-                    readonly skills: SetType<StringType>;
-                }>;
-                after: StructType<{
-                    readonly name: StringType;
-                    readonly skills: SetType<StringType>;
-                }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly name: StringType;
+                readonly skills: SetType<StringType>;
+            }>;
+            insert: StructType<{
+                readonly name: StringType;
+                readonly skills: SetType<StringType>;
             }>;
-            patch: StructType<{
-                readonly name: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly name: StringType;
+                        readonly skills: SetType<StringType>;
+                    }>;
+                    after: StructType<{
+                        readonly name: StringType;
+                        readonly skills: SetType<StringType>;
                     }>;
                 }>;
-                readonly skills: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: SetType<StringType>;
-                        after: SetType<StringType>;
-                    }>;
-                    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-                        delete: NullType;
-                        insert: NullType;
-                    }>>;
+                patch: StructType<{
+                    readonly name: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly skills: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: SetType<StringType>;
+                            after: SetType<StringType>;
+                        }>;
+                        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+                            delete: NullType;
+                            insert: NullType;
+                        }>>;
+                    }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-export declare const peopleByName: e3.RecordIndexDef<"by_name", DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly skills: SetType<StringType>;
-}>>, StringType, NullType, readonly ["name"]> & {
-    interval: undefined;
-};
-export declare const peopleBySkill: e3.RecordIndexDef<"by_skill", DictType<StringType, StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
     readonly name: StringType;
     readonly skills: SetType<StringType>;
-}>>, StringType, NullType, readonly ["skills"]> & {
-    interval: undefined;
-};
+}>>>>;
 /** An event of a status over a span of time: no end is an instant, and no start the backlog. */
 export declare const IntervalEvent: StructType<{
     readonly status: StringType;
@@ -509,145 +502,866 @@ export declare const indexedIntervals: e3.RecordDef<DictType<StringType, StructT
     readonly status: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
-}>>, [variant<"field", "records">, variant<"field", "indexed_intervals">]>;
-export declare const indexedIntervalsPatch: e3.MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "indexed_intervals">], e3.IndexesOf<{
+    by_start: e3.IndexDraft<OptionType<DateTimeType>, NullType, readonly ["start"], unknown>;
+    by_status_time: e3.IndexDraft<StructType<{
+        on: StructType<{
+            status: StringType;
+        }>;
+        node: IntegerType;
+        at: OptionType<DateTimeType>;
+    }>, NullType, readonly ["status"], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
+    }>;
+    by_time: e3.IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        node: IntegerType;
+        at: OptionType<DateTimeType>;
+    }>, NullType, readonly [], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
+    }>;
+}, DictType<StringType, StructType<{
     readonly status: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly status: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly status: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
+}>>>, e3.MutationsOf<{
+    patch: e3.MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly status: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly status: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+            }>>;
+        }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly status: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+            }>;
+            insert: StructType<{
+                readonly status: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly status: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                    }>;
+                    after: StructType<{
+                        readonly status: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly status: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly start: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        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: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly end: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        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: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
         }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly status: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+}>>>>;
+/** A rack on a data centre floor, in metres: its hall, where it stands — by its centre — if anywhere yet, and its footprint. */
+export declare const IndexedRack: StructType<{
+    readonly hall: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>;
+/**
+ * Racks on a floor: three in hall A along a row, one in hall B across the
+ * aisle, one in hall B far down the floor, and one in hall A not yet placed —
+ * what a window over the row takes, what its margin takes, and what it leaves.
+ */
+export declare const indexedRacks: e3.RecordDef<DictType<StringType, StructType<{
+    readonly hall: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>>, [variant<"field", "records">, variant<"field", "indexed_racks">], e3.IndexesOf<{
+    racks_by_area: e3.IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        area: IntegerType;
+    }>, StructType<{
+        readonly hall: StringType;
+        readonly x: OptionType<FloatType>;
+        readonly y: OptionType<FloatType>;
+        readonly w: FloatType;
+        readonly h: FloatType;
+    }>, readonly [], {
+        readonly area: e3.AreaIndexOf<{
+            readonly x: "x";
+            readonly y: "y";
+            readonly width: "w";
+            readonly height: "h";
+            readonly at: "centre";
+            readonly cell: 0.01;
+        }>;
     }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: StructType<{
-            readonly status: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
+    racks_by_hall_area: e3.IndexDraft<StructType<{
+        on: StructType<{
+            hall: StringType;
         }>;
-        insert: StructType<{
-            readonly status: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
+        area: IntegerType;
+    }>, StructType<{
+        readonly hall: StringType;
+        readonly x: OptionType<FloatType>;
+        readonly y: OptionType<FloatType>;
+        readonly w: FloatType;
+        readonly h: FloatType;
+    }>, readonly ["hall"], {
+        readonly area: e3.AreaIndexOf<{
+            readonly on: readonly ["hall"];
+            readonly x: "x";
+            readonly y: "y";
+            readonly width: "w";
+            readonly height: "h";
+            readonly at: "centre";
+            readonly cell: 0.01;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly status: StringType;
-                    readonly start: OptionType<DateTimeType>;
-                    readonly end: OptionType<DateTimeType>;
-                }>;
-                after: StructType<{
-                    readonly status: StringType;
-                    readonly start: OptionType<DateTimeType>;
-                    readonly end: OptionType<DateTimeType>;
-                }>;
+    }>;
+    racks_by_hall: e3.IndexDraft<StringType, NullType, readonly ["hall"], unknown>;
+}, DictType<StringType, StructType<{
+    readonly hall: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>>>, e3.MutationsOf<{
+    patch: e3.MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly hall: StringType;
+                readonly x: OptionType<FloatType>;
+                readonly y: OptionType<FloatType>;
+                readonly w: FloatType;
+                readonly h: FloatType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly hall: StringType;
+                readonly x: OptionType<FloatType>;
+                readonly y: OptionType<FloatType>;
+                readonly w: FloatType;
+                readonly h: FloatType;
+            }>>;
+        }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly hall: StringType;
+                readonly x: OptionType<FloatType>;
+                readonly y: OptionType<FloatType>;
+                readonly w: FloatType;
+                readonly h: FloatType;
+            }>;
+            insert: StructType<{
+                readonly hall: StringType;
+                readonly x: OptionType<FloatType>;
+                readonly y: OptionType<FloatType>;
+                readonly w: FloatType;
+                readonly h: FloatType;
             }>;
-            patch: StructType<{
-                readonly status: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly hall: StringType;
+                        readonly x: OptionType<FloatType>;
+                        readonly y: OptionType<FloatType>;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
+                    }>;
+                    after: StructType<{
+                        readonly hall: StringType;
+                        readonly x: OptionType<FloatType>;
+                        readonly y: OptionType<FloatType>;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
                     }>;
                 }>;
-                readonly start: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                patch: StructType<{
+                    readonly hall: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly x: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<FloatType>;
+                            after: OptionType<FloatType>;
+                        }>;
+                        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: FloatType;
+                                    after: FloatType;
+                                }>;
                             }>;
                         }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
+                    }>;
+                    readonly y: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<FloatType>;
+                            after: OptionType<FloatType>;
+                        }>;
+                        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: FloatType;
+                                    after: FloatType;
+                                }>;
                             }>;
                         }>;
                     }>;
+                    readonly w: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly h: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
                 }>;
-                readonly end: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly hall: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+    readonly w: FloatType;
+    readonly h: FloatType;
+}>>>>;
+/**
+ * A rack whose fields are named as e3's own parts of a generated key once were
+ * (#1432): `area`, `__area`, `tile` and `__tile`. No name is reserved — e3's
+ * parts are its index's kind's — so each is a field of the rail like any
+ * other, and an area index may be led by them.
+ */
+export declare const NamedRack: StructType<{
+    readonly area: StringType;
+    readonly __area: StringType;
+    readonly tile: StringType;
+    readonly __tile: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+}>;
+/**
+ * Five racks: two in area A1 by B — one inside the window over the floor's
+ * corner, one far down it — one by C and one in A2 inside it, and one in A1 by
+ * B not yet placed.
+ */
+export declare const namedRacks: e3.RecordDef<DictType<StringType, StructType<{
+    readonly area: StringType;
+    readonly __area: StringType;
+    readonly tile: StringType;
+    readonly __tile: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+}>>, [variant<"field", "records">, variant<"field", "named_racks">], e3.IndexesOf<{
+    named_by_area: e3.IndexDraft<StringType, NullType, readonly ["area"], unknown>;
+    named_by_under_area: e3.IndexDraft<StringType, NullType, readonly ["__area"], unknown>;
+    named_by_tile: e3.IndexDraft<StringType, NullType, readonly ["tile"], unknown>;
+    named_by_under_tile: e3.IndexDraft<StringType, NullType, readonly ["__tile"], unknown>;
+    named_by_place: e3.IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        area: IntegerType;
+    }>, StructType<{
+        readonly area: StringType;
+        readonly __area: StringType;
+        readonly tile: StringType;
+        readonly __tile: StringType;
+        readonly x: OptionType<FloatType>;
+        readonly y: OptionType<FloatType>;
+    }>, readonly [], {
+        readonly area: e3.AreaIndexOf<{
+            readonly x: "x";
+            readonly y: "y";
+            readonly cell: 1;
+        }>;
+    }>;
+    named_by_area_place: e3.IndexDraft<StructType<{
+        on: StructType<{
+            area: StringType;
+            __area: StringType;
+        }>;
+        area: IntegerType;
+    }>, StructType<{
+        readonly area: StringType;
+        readonly __area: StringType;
+        readonly tile: StringType;
+        readonly __tile: StringType;
+        readonly x: OptionType<FloatType>;
+        readonly y: OptionType<FloatType>;
+    }>, readonly ["area", "__area"], {
+        readonly area: e3.AreaIndexOf<{
+            readonly on: readonly ["area", "__area"];
+            readonly x: "x";
+            readonly y: "y";
+            readonly cell: 1;
+        }>;
+    }>;
+}, DictType<StringType, StructType<{
+    readonly area: StringType;
+    readonly __area: StringType;
+    readonly tile: StringType;
+    readonly __tile: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+}>>>, e3.MutationsOf<{
+    patch: e3.MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly area: StringType;
+                readonly __area: StringType;
+                readonly tile: StringType;
+                readonly __tile: StringType;
+                readonly x: OptionType<FloatType>;
+                readonly y: OptionType<FloatType>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly area: StringType;
+                readonly __area: StringType;
+                readonly tile: StringType;
+                readonly __tile: StringType;
+                readonly x: OptionType<FloatType>;
+                readonly y: OptionType<FloatType>;
+            }>>;
+        }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly area: StringType;
+                readonly __area: StringType;
+                readonly tile: StringType;
+                readonly __tile: StringType;
+                readonly x: OptionType<FloatType>;
+                readonly y: OptionType<FloatType>;
+            }>;
+            insert: StructType<{
+                readonly area: StringType;
+                readonly __area: StringType;
+                readonly tile: StringType;
+                readonly __tile: StringType;
+                readonly x: OptionType<FloatType>;
+                readonly y: OptionType<FloatType>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly area: StringType;
+                        readonly __area: StringType;
+                        readonly tile: StringType;
+                        readonly __tile: StringType;
+                        readonly x: OptionType<FloatType>;
+                        readonly y: OptionType<FloatType>;
+                    }>;
+                    after: StructType<{
+                        readonly area: StringType;
+                        readonly __area: StringType;
+                        readonly tile: StringType;
+                        readonly __tile: StringType;
+                        readonly x: OptionType<FloatType>;
+                        readonly y: OptionType<FloatType>;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly area: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly __area: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly tile: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly __tile: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly x: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<FloatType>;
+                            after: OptionType<FloatType>;
+                        }>;
+                        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: FloatType;
+                                    after: FloatType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly y: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<FloatType>;
+                            after: OptionType<FloatType>;
                         }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
+                        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: FloatType;
+                                    after: FloatType;
+                                }>;
                             }>;
                         }>;
                     }>;
                 }>;
             }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly area: StringType;
+    readonly __area: StringType;
+    readonly tile: StringType;
+    readonly __tile: StringType;
+    readonly x: OptionType<FloatType>;
+    readonly y: OptionType<FloatType>;
+}>>>>;
+/** A rack's load: what its card's figure and its dot draw. */
+export declare const IndexedRackLoad: StructType<{
+    readonly kw: FloatType;
+    readonly alarm: StringType;
+}>;
+/**
+ * The racks' loads, keyed as the racks are: two of the row's three, the rack
+ * across the aisle's and the far one's — none for `r3`, nor for the rack not
+ * yet placed, and one for a rack the floor does not hold — what a window's
+ * racks read their details by, through the runs the area index files them in
+ * (#1393).
+ */
+export declare const indexedRackLoads: e3.RecordDef<DictType<StringType, StructType<{
+    readonly kw: FloatType;
+    readonly alarm: StringType;
+}>>, [variant<"field", "records">, variant<"field", "indexed_rack_loads">], e3.IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly kw: FloatType;
+    readonly alarm: StringType;
+}>>>, e3.MutationsOf<{
+    patch: e3.MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly kw: FloatType;
+                readonly alarm: StringType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly kw: FloatType;
+                readonly alarm: StringType;
+            }>>;
         }>;
-    }>>;
-}>]>;
-export declare const intervalsByStart: e3.RecordIndexDef<"by_start", DictType<StringType, StructType<{
-    readonly status: StringType;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly kw: FloatType;
+                readonly alarm: StringType;
+            }>;
+            insert: StructType<{
+                readonly kw: FloatType;
+                readonly alarm: StringType;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly kw: FloatType;
+                        readonly alarm: StringType;
+                    }>;
+                    after: StructType<{
+                        readonly kw: FloatType;
+                        readonly alarm: StringType;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly kw: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly alarm: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly kw: FloatType;
+    readonly alarm: StringType;
+}>>>>;
+/** A print job: the press it runs on, if any yet, its state, and when it runs, if it is scheduled. */
+export declare const IndexedJob: StructType<{
+    readonly press: OptionType<StringType>;
+    readonly state: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
-}>>, OptionType<DateTimeType>, NullType, readonly ["start"]> & {
-    interval: undefined;
-};
-export declare const intervalsByStatusTime: e3.RecordIndexDef<"by_status_time", DictType<StringType, StructType<{
-    readonly status: StringType;
+}>;
+/**
+ * Jobs on three presses about the week of Monday 5 October 2026: one carried in
+ * from the week before, one across the week's end into the next, one the whole
+ * month, two inside the week, an instant at its start, one on no press yet and
+ * one in the backlog — what a cell of some presses in a week holds, and what a
+ * month's totals count (#1039).
+ */
+export declare const indexedJobs: e3.RecordDef<DictType<StringType, StructType<{
+    readonly press: OptionType<StringType>;
+    readonly state: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
-}>>, StructType<{
-    status: StringType;
-} & {
-    __interval: IntegerType;
-} & {
-    start: OptionType<DateTimeType>;
-}>, NullType, readonly ["status", "start"]> & {
-    interval: {
-        readonly from: "start";
-        readonly to: "end";
-    };
-};
-export declare const intervalsByTime: e3.RecordIndexDef<"by_time", DictType<StringType, StructType<{
-    readonly status: StringType;
+}>>, [variant<"field", "records">, variant<"field", "indexed_jobs">], e3.IndexesOf<{
+    jobs_by_time: e3.IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        node: IntegerType;
+        at: OptionType<DateTimeType>;
+    }>, NullType, readonly [], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
+    }>;
+    jobs_by_state_time: e3.IndexDraft<StructType<{
+        on: StructType<{
+            state: StringType;
+        }>;
+        node: IntegerType;
+        at: OptionType<DateTimeType>;
+    }>, NullType, readonly ["state"], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
+    }>;
+    jobs_by_press_week: e3.IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        key: OptionType<StringType>;
+        level: import("@elaraai/e3-types").RecordLevelType;
+        tile: DateTimeType;
+    }>, StructType<{
+        readonly press: OptionType<StringType>;
+        readonly state: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+    }>, readonly [], {
+        readonly series: e3.TimeTileOf<{
+            readonly key: "press";
+            readonly from: "start";
+            readonly to: "end";
+            readonly tile: "week";
+        }>;
+    }>;
+    jobs_by_state_press_week: e3.IndexDraft<StructType<{
+        on: StructType<{
+            state: StringType;
+        }>;
+        key: OptionType<StringType>;
+        level: import("@elaraai/e3-types").RecordLevelType;
+        tile: DateTimeType;
+    }>, StructType<{
+        readonly press: OptionType<StringType>;
+        readonly state: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+    }>, readonly ["state"], {
+        readonly series: e3.TimeTileOf<{
+            readonly on: readonly ["state"];
+            readonly key: "press";
+            readonly from: "start";
+            readonly to: "end";
+            readonly tile: "week";
+        }>;
+    }>;
+    jobs_by_press_month: e3.IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        key: OptionType<StringType>;
+        tile: DateTimeType;
+    }>, StructType<{
+        readonly count: IntegerType;
+        readonly ms: IntegerType;
+    }>, readonly [], {
+        readonly summary: e3.TimeTileOf<{
+            readonly key: "press";
+            readonly from: "start";
+            readonly to: "end";
+            readonly tile: "month";
+        }>;
+    }>;
+}, DictType<StringType, StructType<{
+    readonly press: OptionType<StringType>;
+    readonly state: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+}>>>, e3.MutationsOf<{
+    patch: e3.MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly press: OptionType<StringType>;
+                readonly state: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly press: OptionType<StringType>;
+                readonly state: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+            }>>;
+        }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly press: OptionType<StringType>;
+                readonly state: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+            }>;
+            insert: StructType<{
+                readonly press: OptionType<StringType>;
+                readonly state: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly press: OptionType<StringType>;
+                        readonly state: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                    }>;
+                    after: StructType<{
+                        readonly press: OptionType<StringType>;
+                        readonly state: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly press: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<StringType>;
+                            after: OptionType<StringType>;
+                        }>;
+                        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: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly state: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly start: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        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: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly end: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        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: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly press: OptionType<StringType>;
+    readonly state: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
-}>>, StructType<Record<never, never> & {
-    __interval: IntegerType;
-} & {
-    start: OptionType<DateTimeType>;
-}>, NullType, readonly ["start"]> & {
-    interval: {
-        readonly from: "start";
-        readonly to: "end";
-    };
-};
+}>>>>;
 /** A step of a flow: its lane, and who owns it, if anyone. */
 export declare const ComputedStep: StructType<{
     readonly lane: StringType;
@@ -668,227 +1382,171 @@ export declare const computedFlows: e3.RecordDef<DictType<StringType, StructType
         readonly lane: StringType;
         readonly owner: OptionType<StringType>;
     }>>;
-}>>, [variant<"field", "records">, variant<"field", "computed_flows">]>;
-export declare const computedFlowsPatch: e3.MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "computed_flows">], e3.IndexesOf<{
+    description: e3.IndexDraft<StringType, NullType, readonly ["description"], unknown>;
+    state_count: e3.IndexDraft<StructType<{
+        readonly stateCount: IntegerType;
+    }>, NullType, undefined, unknown>;
+    description_count: e3.IndexDraft<StructType<{
+        readonly description: StringType;
+        readonly stateCount: IntegerType;
+    }>, NullType, undefined, unknown>;
+    lane: e3.IndexDraft<StructType<{
+        readonly lane: StringType;
+    }>, NullType, undefined, unknown>;
+    owner: e3.IndexDraft<StructType<{
+        readonly owner: OptionType<StringType>;
+    }>, NullType, undefined, unknown>;
+    label: e3.IndexDraft<StringType, NullType, undefined, unknown>;
+    size: e3.IndexDraft<IntegerType, NullType, undefined, unknown>;
+    decisionOwner: e3.IndexDraft<OptionType<StringType>, NullType, undefined, unknown>;
+}, DictType<StringType, StructType<{
     readonly description: StringType;
     readonly states: ArrayType<StructType<{
         readonly lane: StringType;
         readonly owner: OptionType<StringType>;
     }>>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly description: StringType;
-            readonly states: ArrayType<StructType<{
-                readonly lane: StringType;
-                readonly owner: OptionType<StringType>;
-            }>>;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly description: StringType;
-            readonly states: ArrayType<StructType<{
-                readonly lane: StringType;
-                readonly owner: OptionType<StringType>;
-            }>>;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: StructType<{
-            readonly description: StringType;
-            readonly states: ArrayType<StructType<{
-                readonly lane: StringType;
-                readonly owner: OptionType<StringType>;
+}>>>, e3.MutationsOf<{
+    patch: e3.MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly description: StringType;
+                readonly states: ArrayType<StructType<{
+                    readonly lane: StringType;
+                    readonly owner: OptionType<StringType>;
+                }>>;
             }>>;
-        }>;
-        insert: StructType<{
-            readonly description: StringType;
-            readonly states: ArrayType<StructType<{
-                readonly lane: StringType;
-                readonly owner: OptionType<StringType>;
+            after: DictType<StringType, StructType<{
+                readonly description: StringType;
+                readonly states: ArrayType<StructType<{
+                    readonly lane: StringType;
+                    readonly owner: OptionType<StringType>;
+                }>>;
             }>>;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly description: StringType;
-                    readonly states: ArrayType<StructType<{
-                        readonly lane: StringType;
-                        readonly owner: OptionType<StringType>;
-                    }>>;
-                }>;
-                after: StructType<{
-                    readonly description: StringType;
-                    readonly states: ArrayType<StructType<{
-                        readonly lane: StringType;
-                        readonly owner: OptionType<StringType>;
-                    }>>;
-                }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: StructType<{
+                readonly description: StringType;
+                readonly states: ArrayType<StructType<{
+                    readonly lane: StringType;
+                    readonly owner: OptionType<StringType>;
+                }>>;
             }>;
-            patch: StructType<{
-                readonly description: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-                readonly states: import("@elaraai/east").VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: ArrayType<StructType<{
+            insert: StructType<{
+                readonly description: StringType;
+                readonly states: ArrayType<StructType<{
+                    readonly lane: StringType;
+                    readonly owner: OptionType<StringType>;
+                }>>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly description: StringType;
+                        readonly states: ArrayType<StructType<{
                             readonly lane: StringType;
                             readonly owner: OptionType<StringType>;
                         }>>;
-                        after: ArrayType<StructType<{
+                    }>;
+                    after: StructType<{
+                        readonly description: StringType;
+                        readonly states: ArrayType<StructType<{
                             readonly lane: StringType;
                             readonly owner: OptionType<StringType>;
                         }>>;
                     }>;
-                    patch: ArrayType<StructType<{
-                        key: IntegerType;
-                        offset: IntegerType;
-                        operation: import("@elaraai/east").VariantType<{
-                            delete: StructType<{
+                }>;
+                patch: StructType<{
+                    readonly description: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly states: import("@elaraai/east").VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: ArrayType<StructType<{
                                 readonly lane: StringType;
                                 readonly owner: OptionType<StringType>;
-                            }>;
-                            insert: StructType<{
+                            }>>;
+                            after: ArrayType<StructType<{
                                 readonly lane: StringType;
                                 readonly owner: OptionType<StringType>;
-                            }>;
-                            update: import("@elaraai/east").VariantType<{
-                                unchanged: NullType;
-                                replace: StructType<{
-                                    before: StructType<{
-                                        readonly lane: StringType;
-                                        readonly owner: OptionType<StringType>;
-                                    }>;
-                                    after: StructType<{
-                                        readonly lane: StringType;
-                                        readonly owner: OptionType<StringType>;
-                                    }>;
+                            }>>;
+                        }>;
+                        patch: ArrayType<StructType<{
+                            key: IntegerType;
+                            offset: IntegerType;
+                            operation: import("@elaraai/east").VariantType<{
+                                delete: StructType<{
+                                    readonly lane: StringType;
+                                    readonly owner: OptionType<StringType>;
+                                }>;
+                                insert: StructType<{
+                                    readonly lane: StringType;
+                                    readonly owner: OptionType<StringType>;
                                 }>;
-                                patch: StructType<{
-                                    readonly lane: import("@elaraai/east").VariantType<{
-                                        unchanged: NullType;
-                                        replace: StructType<{
-                                            before: StringType;
-                                            after: StringType;
+                                update: import("@elaraai/east").VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: StructType<{
+                                            readonly lane: StringType;
+                                            readonly owner: OptionType<StringType>;
+                                        }>;
+                                        after: StructType<{
+                                            readonly lane: StringType;
+                                            readonly owner: OptionType<StringType>;
                                         }>;
                                     }>;
-                                    readonly owner: import("@elaraai/east").VariantType<{
-                                        unchanged: NullType;
-                                        replace: StructType<{
-                                            before: OptionType<StringType>;
-                                            after: OptionType<StringType>;
+                                    patch: StructType<{
+                                        readonly lane: import("@elaraai/east").VariantType<{
+                                            unchanged: NullType;
+                                            replace: StructType<{
+                                                before: StringType;
+                                                after: StringType;
+                                            }>;
                                         }>;
-                                        patch: import("@elaraai/east").VariantType<{
-                                            none: import("@elaraai/east").VariantType<{
-                                                unchanged: NullType;
-                                                replace: StructType<{
-                                                    before: NullType;
-                                                    after: NullType;
-                                                }>;
+                                        readonly owner: import("@elaraai/east").VariantType<{
+                                            unchanged: NullType;
+                                            replace: StructType<{
+                                                before: OptionType<StringType>;
+                                                after: OptionType<StringType>;
                                             }>;
-                                            some: import("@elaraai/east").VariantType<{
-                                                unchanged: NullType;
-                                                replace: StructType<{
-                                                    before: StringType;
-                                                    after: StringType;
+                                            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: StringType;
+                                                        after: StringType;
+                                                    }>;
                                                 }>;
                                             }>;
                                         }>;
                                     }>;
                                 }>;
                             }>;
-                        }>;
-                    }>>;
+                        }>>;
+                    }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-export declare const computedByDescription: e3.RecordIndexDef<"description", DictType<StringType, StructType<{
-    readonly description: StringType;
-    readonly states: ArrayType<StructType<{
-        readonly lane: StringType;
-        readonly owner: OptionType<StringType>;
-    }>>;
-}>>, StringType, NullType, readonly ["description"]> & {
-    interval: undefined;
-};
-export declare const computedByStateCount: e3.RecordIndexDef<"state_count", DictType<StringType, StructType<{
-    readonly description: StringType;
-    readonly states: ArrayType<StructType<{
-        readonly lane: StringType;
-        readonly owner: OptionType<StringType>;
-    }>>;
-}>>, StructType<{
-    readonly stateCount: IntegerType;
-}>, NullType, undefined> & {
-    interval: undefined;
-};
-export declare const computedByDescriptionCount: e3.RecordIndexDef<"description_count", DictType<StringType, StructType<{
-    readonly description: StringType;
-    readonly states: ArrayType<StructType<{
-        readonly lane: StringType;
-        readonly owner: OptionType<StringType>;
-    }>>;
-}>>, StructType<{
-    readonly description: StringType;
-    readonly stateCount: IntegerType;
-}>, NullType, undefined> & {
-    interval: undefined;
-};
-export declare const computedByLane: e3.RecordIndexDef<"lane", DictType<StringType, StructType<{
-    readonly description: StringType;
-    readonly states: ArrayType<StructType<{
-        readonly lane: StringType;
-        readonly owner: OptionType<StringType>;
-    }>>;
-}>>, StructType<{
-    readonly lane: StringType;
-}>, NullType, undefined> & {
-    interval: undefined;
-};
-export declare const computedByOwner: e3.RecordIndexDef<"owner", DictType<StringType, StructType<{
-    readonly description: StringType;
-    readonly states: ArrayType<StructType<{
-        readonly lane: StringType;
-        readonly owner: OptionType<StringType>;
-    }>>;
-}>>, StructType<{
-    readonly owner: OptionType<StringType>;
-}>, NullType, undefined> & {
-    interval: undefined;
-};
-export declare const computedByLabel: e3.RecordIndexDef<"label", DictType<StringType, StructType<{
-    readonly description: StringType;
-    readonly states: ArrayType<StructType<{
-        readonly lane: StringType;
-        readonly owner: OptionType<StringType>;
-    }>>;
-}>>, StringType, NullType, undefined> & {
-    interval: undefined;
-};
-export declare const computedBySize: e3.RecordIndexDef<"size", DictType<StringType, StructType<{
-    readonly description: StringType;
-    readonly states: ArrayType<StructType<{
-        readonly lane: StringType;
-        readonly owner: OptionType<StringType>;
-    }>>;
-}>>, IntegerType, NullType, undefined> & {
-    interval: undefined;
-};
-export declare const computedByDecisionOwner: e3.RecordIndexDef<"decisionOwner", DictType<StringType, StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
     readonly description: StringType;
     readonly states: ArrayType<StructType<{
         readonly lane: StringType;
         readonly owner: OptionType<StringType>;
     }>>;
-}>>, OptionType<StringType>, NullType, undefined> & {
-    interval: undefined;
-};
+}>>>>;
 //# sourceMappingURL=data.examples.d.ts.map