@elaraai/e3-ui 1.0.98 → 1.0.99

package/dist/test/plan/plan-windows.examples.d.ts

@@ -30,22 +30,18 @@ export declare const planSeriesPresses: import("@elaraai/e3").RecordDef<DictType
     readonly name: StringType;
     readonly hall: StringType;
     readonly sheets_per_hour: import("@elaraai/east").FloatType;
-}>>, [variant<"field", "records">, variant<"field", "plan_series_presses">]>;
-/**
- * The presses by hall (#1344): each hall's presses, in their key order — what
- * the rail's `presses` source narrows them through, and the order a Plan pages
- * the presses of the halls chosen in.
- */
-export declare const planSeriesPressesByHall: import("@elaraai/e3").RecordIndexDef<"plan_series_presses_by_hall", DictType<StringType, import("@elaraai/east").StructType<{
+}>>, [variant<"field", "records">, variant<"field", "plan_series_presses">], import("@elaraai/e3").IndexesOf<{
+    plan_series_presses_by_hall: import("@elaraai/e3").IndexDraft<StringType, import("@elaraai/east").NullType, readonly ["hall"], unknown>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly name: StringType;
     readonly hall: StringType;
     readonly sheets_per_hour: import("@elaraai/east").FloatType;
-}>>, StringType, import("@elaraai/east").NullType, readonly ["hall"]>;
-/**
- * The print jobs on the presses, from Monday 5 October 2026: a night run into
- * the next day, a run over three days, jobs on presses in each window of 200,
- * jobs in the weeks after the first two, and four waiting in the backlog.
- */
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, import("@elaraai/east").StructType<{
+    readonly name: StringType;
+    readonly hall: StringType;
+    readonly sheets_per_hour: import("@elaraai/east").FloatType;
+}>>>>;
+/** The print jobs on the presses ({@link windowJobs}), read through their indexes. */
 export declare const planWindowJobs: import("@elaraai/e3").RecordDef<DictType<StringType, import("@elaraai/east").StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
@@ -71,9 +67,88 @@ export declare const planWindowJobs: import("@elaraai/e3").RecordDef<DictType<St
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, [variant<"field", "records">, variant<"field", "plan_window_jobs">]>;
-/** The jobs' patch door: every Save commits through it. */
-export declare const planWindowJobsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, import("@elaraai/east").StructType<{
+}>>, [variant<"field", "records">, variant<"field", "plan_window_jobs">], import("@elaraai/e3").IndexesOf<{
+    plan_window_jobs_by_time: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        on: import("@elaraai/east").StructType<Record<never, never>>;
+        node: IntegerType;
+        at: OptionType<DateTimeType>;
+    }>, import("@elaraai/east").NullType, readonly [], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
+    }>;
+    plan_window_jobs_by_press_week: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        on: import("@elaraai/east").StructType<Record<never, never>>;
+        key: OptionType<StringType>;
+        level: import("@elaraai/e3-types").RecordLevelType;
+        tile: DateTimeType;
+    }>, import("@elaraai/east").StructType<{
+        readonly title: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly press: OptionType<StringType>;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: import("@elaraai/east").NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: import("@elaraai/east").NullType;
+                readonly recommended: import("@elaraai/east").NullType;
+                readonly removed: import("@elaraai/east").NullType;
+            }>;
+            readonly confirmed: import("@elaraai/east").NullType;
+            readonly "in-progress": import("@elaraai/east").NullType;
+            readonly actual: import("@elaraai/east").NullType;
+            readonly rejected: import("@elaraai/east").NullType;
+        }>;
+        readonly sheets: import("@elaraai/east").FloatType;
+        readonly customer: StringType;
+        readonly stock: import("@elaraai/east").VariantType<{
+            readonly coated: import("@elaraai/east").NullType;
+            readonly uncoated: import("@elaraai/east").NullType;
+            readonly board: import("@elaraai/east").NullType;
+        }>;
+        readonly due: OptionType<DateTimeType>;
+    }>, readonly [], {
+        readonly series: import("@elaraai/e3").TimeTileOf<{
+            readonly key: "press";
+            readonly from: "start";
+            readonly to: "end";
+            readonly tile: "week";
+        }>;
+    }>;
+    plan_window_jobs_by_press_month: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        on: import("@elaraai/east").StructType<Record<never, never>>;
+        key: OptionType<StringType>;
+        tile: DateTimeType;
+    }>, import("@elaraai/east").StructType<{
+        readonly count: IntegerType;
+        readonly ms: IntegerType;
+    }>, readonly [], {
+        readonly summary: import("@elaraai/e3").TimeTileOf<{
+            readonly key: "press";
+            readonly from: "start";
+            readonly to: "end";
+            readonly tile: "month";
+        }>;
+    }>;
+    plan_window_jobs_by_press_month_again: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        on: import("@elaraai/east").StructType<Record<never, never>>;
+        key: OptionType<StringType>;
+        tile: DateTimeType;
+    }>, import("@elaraai/east").StructType<{
+        readonly count: IntegerType;
+        readonly ms: IntegerType;
+    }>, readonly [], {
+        readonly summary: import("@elaraai/e3").TimeTileOf<{
+            readonly key: "press";
+            readonly from: "start";
+            readonly to: "end";
+            readonly tile: "month";
+        }>;
+    }>;
+    plan_window_jobs_by_day: import("@elaraai/e3").IndexDraft<DateTimeType, import("@elaraai/east").NullType, undefined, unknown>;
+    plan_window_jobs_unscheduled: import("@elaraai/e3").IndexDraft<OptionType<DateTimeType>, import("@elaraai/east").NullType, undefined, unknown>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
@@ -98,252 +173,125 @@ export declare const planWindowJobsPatch: import("@elaraai/e3").MutationDef<"pat
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: import("@elaraai/east").NullType;
-    replace: import("@elaraai/east").StructType<{
-        before: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly press: OptionType<StringType>;
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly estimated: import("@elaraai/east").NullType;
-                readonly proposed: import("@elaraai/east").VariantType<{
-                    readonly added: import("@elaraai/east").NullType;
-                    readonly recommended: import("@elaraai/east").NullType;
-                    readonly removed: import("@elaraai/east").NullType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: import("@elaraai/east").NullType;
+        replace: import("@elaraai/east").StructType<{
+            before: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
+                    }>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
                 }>;
-                readonly confirmed: import("@elaraai/east").NullType;
-                readonly "in-progress": import("@elaraai/east").NullType;
-                readonly actual: import("@elaraai/east").NullType;
-                readonly rejected: import("@elaraai/east").NullType;
-            }>;
-            readonly sheets: import("@elaraai/east").FloatType;
-            readonly customer: StringType;
-            readonly stock: import("@elaraai/east").VariantType<{
-                readonly coated: import("@elaraai/east").NullType;
-                readonly uncoated: import("@elaraai/east").NullType;
-                readonly board: import("@elaraai/east").NullType;
-            }>;
-            readonly due: OptionType<DateTimeType>;
-        }>>;
-        after: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly press: OptionType<StringType>;
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly estimated: import("@elaraai/east").NullType;
-                readonly proposed: import("@elaraai/east").VariantType<{
-                    readonly added: import("@elaraai/east").NullType;
-                    readonly recommended: import("@elaraai/east").NullType;
-                    readonly removed: import("@elaraai/east").NullType;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
                 }>;
-                readonly confirmed: import("@elaraai/east").NullType;
-                readonly "in-progress": import("@elaraai/east").NullType;
-                readonly actual: import("@elaraai/east").NullType;
-                readonly rejected: import("@elaraai/east").NullType;
-            }>;
-            readonly sheets: import("@elaraai/east").FloatType;
-            readonly customer: StringType;
-            readonly stock: import("@elaraai/east").VariantType<{
-                readonly coated: import("@elaraai/east").NullType;
-                readonly uncoated: import("@elaraai/east").NullType;
-                readonly board: import("@elaraai/east").NullType;
-            }>;
-            readonly due: OptionType<DateTimeType>;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: import("@elaraai/east").StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly press: OptionType<StringType>;
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly estimated: import("@elaraai/east").NullType;
-                readonly proposed: import("@elaraai/east").VariantType<{
-                    readonly added: import("@elaraai/east").NullType;
-                    readonly recommended: import("@elaraai/east").NullType;
-                    readonly removed: import("@elaraai/east").NullType;
+                readonly due: OptionType<DateTimeType>;
+            }>>;
+            after: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
+                    }>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
                 }>;
-                readonly confirmed: import("@elaraai/east").NullType;
-                readonly "in-progress": import("@elaraai/east").NullType;
-                readonly actual: import("@elaraai/east").NullType;
-                readonly rejected: import("@elaraai/east").NullType;
-            }>;
-            readonly sheets: import("@elaraai/east").FloatType;
-            readonly customer: StringType;
-            readonly stock: import("@elaraai/east").VariantType<{
-                readonly coated: import("@elaraai/east").NullType;
-                readonly uncoated: import("@elaraai/east").NullType;
-                readonly board: import("@elaraai/east").NullType;
-            }>;
-            readonly due: OptionType<DateTimeType>;
-        }>;
-        insert: import("@elaraai/east").StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly press: OptionType<StringType>;
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly estimated: import("@elaraai/east").NullType;
-                readonly proposed: import("@elaraai/east").VariantType<{
-                    readonly added: import("@elaraai/east").NullType;
-                    readonly recommended: import("@elaraai/east").NullType;
-                    readonly removed: import("@elaraai/east").NullType;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
                 }>;
-                readonly confirmed: import("@elaraai/east").NullType;
-                readonly "in-progress": import("@elaraai/east").NullType;
-                readonly actual: import("@elaraai/east").NullType;
-                readonly rejected: import("@elaraai/east").NullType;
-            }>;
-            readonly sheets: import("@elaraai/east").FloatType;
-            readonly customer: StringType;
-            readonly stock: import("@elaraai/east").VariantType<{
-                readonly coated: import("@elaraai/east").NullType;
-                readonly uncoated: import("@elaraai/east").NullType;
-                readonly board: import("@elaraai/east").NullType;
-            }>;
-            readonly due: OptionType<DateTimeType>;
+                readonly due: OptionType<DateTimeType>;
+            }>>;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: import("@elaraai/east").NullType;
-            replace: import("@elaraai/east").StructType<{
-                before: import("@elaraai/east").StructType<{
-                    readonly title: StringType;
-                    readonly start: OptionType<DateTimeType>;
-                    readonly end: OptionType<DateTimeType>;
-                    readonly press: OptionType<StringType>;
-                    readonly state: import("@elaraai/east").VariantType<{
-                        readonly estimated: import("@elaraai/east").NullType;
-                        readonly proposed: import("@elaraai/east").VariantType<{
-                            readonly added: import("@elaraai/east").NullType;
-                            readonly recommended: import("@elaraai/east").NullType;
-                            readonly removed: import("@elaraai/east").NullType;
-                        }>;
-                        readonly confirmed: import("@elaraai/east").NullType;
-                        readonly "in-progress": import("@elaraai/east").NullType;
-                        readonly actual: import("@elaraai/east").NullType;
-                        readonly rejected: import("@elaraai/east").NullType;
-                    }>;
-                    readonly sheets: import("@elaraai/east").FloatType;
-                    readonly customer: StringType;
-                    readonly stock: import("@elaraai/east").VariantType<{
-                        readonly coated: import("@elaraai/east").NullType;
-                        readonly uncoated: import("@elaraai/east").NullType;
-                        readonly board: import("@elaraai/east").NullType;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
                     }>;
-                    readonly due: OptionType<DateTimeType>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
                 }>;
-                after: import("@elaraai/east").StructType<{
-                    readonly title: StringType;
-                    readonly start: OptionType<DateTimeType>;
-                    readonly end: OptionType<DateTimeType>;
-                    readonly press: OptionType<StringType>;
-                    readonly state: import("@elaraai/east").VariantType<{
-                        readonly estimated: import("@elaraai/east").NullType;
-                        readonly proposed: import("@elaraai/east").VariantType<{
-                            readonly added: import("@elaraai/east").NullType;
-                            readonly recommended: import("@elaraai/east").NullType;
-                            readonly removed: import("@elaraai/east").NullType;
-                        }>;
-                        readonly confirmed: import("@elaraai/east").NullType;
-                        readonly "in-progress": import("@elaraai/east").NullType;
-                        readonly actual: import("@elaraai/east").NullType;
-                        readonly rejected: import("@elaraai/east").NullType;
-                    }>;
-                    readonly sheets: import("@elaraai/east").FloatType;
-                    readonly customer: StringType;
-                    readonly stock: import("@elaraai/east").VariantType<{
-                        readonly coated: import("@elaraai/east").NullType;
-                        readonly uncoated: import("@elaraai/east").NullType;
-                        readonly board: import("@elaraai/east").NullType;
-                    }>;
-                    readonly due: OptionType<DateTimeType>;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
                 }>;
+                readonly due: OptionType<DateTimeType>;
             }>;
-            patch: import("@elaraai/east").StructType<{
-                readonly title: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-                readonly start: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                }>;
-                readonly end: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
-                            }>;
-                        }>;
+            insert: import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
                     }>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
                 }>;
-                readonly press: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<StringType>;
-                        after: OptionType<StringType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
-                        }>;
-                    }>;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
                 }>;
-                readonly state: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").VariantType<{
+                readonly due: OptionType<DateTimeType>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: import("@elaraai/east").NullType;
+                replace: import("@elaraai/east").StructType<{
+                    before: import("@elaraai/east").StructType<{
+                        readonly title: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                        readonly press: OptionType<StringType>;
+                        readonly state: import("@elaraai/east").VariantType<{
                             readonly estimated: import("@elaraai/east").NullType;
                             readonly proposed: import("@elaraai/east").VariantType<{
                                 readonly added: import("@elaraai/east").NullType;
@@ -355,7 +303,21 @@ export declare const planWindowJobsPatch: import("@elaraai/e3").MutationDef<"pat
                             readonly actual: import("@elaraai/east").NullType;
                             readonly rejected: import("@elaraai/east").NullType;
                         }>;
-                        after: import("@elaraai/east").VariantType<{
+                        readonly sheets: import("@elaraai/east").FloatType;
+                        readonly customer: StringType;
+                        readonly stock: import("@elaraai/east").VariantType<{
+                            readonly coated: import("@elaraai/east").NullType;
+                            readonly uncoated: import("@elaraai/east").NullType;
+                            readonly board: import("@elaraai/east").NullType;
+                        }>;
+                        readonly due: OptionType<DateTimeType>;
+                    }>;
+                    after: import("@elaraai/east").StructType<{
+                        readonly title: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                        readonly press: OptionType<StringType>;
+                        readonly state: import("@elaraai/east").VariantType<{
                             readonly estimated: import("@elaraai/east").NullType;
                             readonly proposed: import("@elaraai/east").VariantType<{
                                 readonly added: import("@elaraai/east").NullType;
@@ -367,169 +329,277 @@ export declare const planWindowJobsPatch: import("@elaraai/e3").MutationDef<"pat
                             readonly actual: import("@elaraai/east").NullType;
                             readonly rejected: import("@elaraai/east").NullType;
                         }>;
+                        readonly sheets: import("@elaraai/east").FloatType;
+                        readonly customer: StringType;
+                        readonly stock: import("@elaraai/east").VariantType<{
+                            readonly coated: import("@elaraai/east").NullType;
+                            readonly uncoated: import("@elaraai/east").NullType;
+                            readonly board: import("@elaraai/east").NullType;
+                        }>;
+                        readonly due: OptionType<DateTimeType>;
+                    }>;
+                }>;
+                patch: import("@elaraai/east").StructType<{
+                    readonly title: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly start: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly end: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        readonly estimated: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        readonly proposed: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").VariantType<{
+                    readonly press: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<StringType>;
+                            after: OptionType<StringType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly state: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly estimated: import("@elaraai/east").NullType;
+                                readonly proposed: import("@elaraai/east").VariantType<{
                                     readonly added: import("@elaraai/east").NullType;
                                     readonly recommended: import("@elaraai/east").NullType;
                                     readonly removed: import("@elaraai/east").NullType;
                                 }>;
-                                after: import("@elaraai/east").VariantType<{
+                                readonly confirmed: import("@elaraai/east").NullType;
+                                readonly "in-progress": import("@elaraai/east").NullType;
+                                readonly actual: import("@elaraai/east").NullType;
+                                readonly rejected: import("@elaraai/east").NullType;
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly estimated: import("@elaraai/east").NullType;
+                                readonly proposed: import("@elaraai/east").VariantType<{
                                     readonly added: import("@elaraai/east").NullType;
                                     readonly recommended: import("@elaraai/east").NullType;
                                     readonly removed: import("@elaraai/east").NullType;
                                 }>;
+                                readonly confirmed: import("@elaraai/east").NullType;
+                                readonly "in-progress": import("@elaraai/east").NullType;
+                                readonly actual: import("@elaraai/east").NullType;
+                                readonly rejected: import("@elaraai/east").NullType;
                             }>;
-                            patch: import("@elaraai/east").VariantType<{
-                                readonly added: import("@elaraai/east").VariantType<{
-                                    unchanged: import("@elaraai/east").NullType;
-                                    replace: import("@elaraai/east").StructType<{
-                                        before: import("@elaraai/east").NullType;
-                                        after: import("@elaraai/east").NullType;
-                                    }>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly estimated: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
                                 }>;
-                                readonly recommended: import("@elaraai/east").VariantType<{
-                                    unchanged: import("@elaraai/east").NullType;
-                                    replace: import("@elaraai/east").StructType<{
-                                        before: import("@elaraai/east").NullType;
-                                        after: import("@elaraai/east").NullType;
+                            }>;
+                            readonly proposed: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").VariantType<{
+                                        readonly added: import("@elaraai/east").NullType;
+                                        readonly recommended: import("@elaraai/east").NullType;
+                                        readonly removed: import("@elaraai/east").NullType;
+                                    }>;
+                                    after: import("@elaraai/east").VariantType<{
+                                        readonly added: import("@elaraai/east").NullType;
+                                        readonly recommended: import("@elaraai/east").NullType;
+                                        readonly removed: import("@elaraai/east").NullType;
                                     }>;
                                 }>;
-                                readonly removed: import("@elaraai/east").VariantType<{
-                                    unchanged: import("@elaraai/east").NullType;
-                                    replace: import("@elaraai/east").StructType<{
-                                        before: import("@elaraai/east").NullType;
-                                        after: import("@elaraai/east").NullType;
+                                patch: import("@elaraai/east").VariantType<{
+                                    readonly added: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
+                                    }>;
+                                    readonly recommended: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
+                                    }>;
+                                    readonly removed: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
                                     }>;
                                 }>;
                             }>;
-                        }>;
-                        readonly confirmed: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                            readonly confirmed: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
-                        }>;
-                        readonly "in-progress": import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                            readonly "in-progress": import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
-                        }>;
-                        readonly actual: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                            readonly actual: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
-                        }>;
-                        readonly rejected: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                            readonly rejected: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly sheets: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").FloatType;
-                        after: import("@elaraai/east").FloatType;
-                    }>;
-                }>;
-                readonly customer: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-                readonly stock: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").VariantType<{
-                            readonly coated: import("@elaraai/east").NullType;
-                            readonly uncoated: import("@elaraai/east").NullType;
-                            readonly board: import("@elaraai/east").NullType;
+                    readonly sheets: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").FloatType;
+                            after: import("@elaraai/east").FloatType;
                         }>;
-                        after: import("@elaraai/east").VariantType<{
-                            readonly coated: import("@elaraai/east").NullType;
-                            readonly uncoated: import("@elaraai/east").NullType;
-                            readonly board: import("@elaraai/east").NullType;
+                    }>;
+                    readonly customer: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
                         }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        readonly coated: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                    readonly stock: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly coated: import("@elaraai/east").NullType;
+                                readonly uncoated: import("@elaraai/east").NullType;
+                                readonly board: import("@elaraai/east").NullType;
                             }>;
-                        }>;
-                        readonly uncoated: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly coated: import("@elaraai/east").NullType;
+                                readonly uncoated: import("@elaraai/east").NullType;
+                                readonly board: import("@elaraai/east").NullType;
                             }>;
                         }>;
-                        readonly board: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly coated: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            readonly uncoated: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            readonly board: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly due: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                    readonly due: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
                             }>;
                         }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-/**
- * The jobs over their interval index (#1344): a job is filed by the interval
- * it runs over, so a window reads each job overlapping it once, however many
- * days it runs, and a job in the backlog under its Unset start — what the
- * rail's `job` source narrows them through.
- */
-export declare const planWindowJobsByTime: import("@elaraai/e3").RecordIndexDef<"plan_window_jobs_by_time", DictType<StringType, import("@elaraai/east").StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
@@ -554,23 +624,18 @@ export declare const planWindowJobsByTime: import("@elaraai/e3").RecordIndexDef<
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, import("@elaraai/east").StructType<Record<never, never> & {
-    __interval: IntegerType;
-} & {
-    start: OptionType<DateTimeType>;
-}>, import("@elaraai/east").NullType, readonly ["start"]> & {
-    interval: {
-        readonly from: "start";
-        readonly to: "end";
-    };
-};
+}>>>>;
 /**
- * The jobs by the press each is on and the weeks each touches (#1039): a job
- * is filed under every week it runs into, carrying its row, so the jobs of
- * fifty presses over a week are one contiguous range of the index — a cell —
- * and `planWindows` reads only the cells around the rows in view.
+ * The same jobs ({@link windowJobs}) by their stock, then the press each is on
+ * and the weeks each touches, and their monthly totals by their stock (#1432):
+ * a series and a summary index led by a field, which a narrowing choosing the
+ * stock reads exactly — its cells hold that stock's jobs alone, so the stock is
+ * asked of none of them, and its totals shade zoomed out. The interval index
+ * led by the stock is what the rail narrows them through, the window beside
+ * the stock. A record of their own: every write maintains every index its
+ * record declares, and the jobs' others need none of these.
  */
-export declare const planWindowJobsByPressWeek: import("@elaraai/e3").RecordIndexDef<"plan_window_jobs_by_press_week", DictType<StringType, import("@elaraai/east").StructType<{
+export declare const planStockJobs: import("@elaraai/e3").RecordDef<DictType<StringType, import("@elaraai/east").StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
@@ -595,141 +660,91 @@ export declare const planWindowJobsByPressWeek: import("@elaraai/e3").RecordInde
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, import("@elaraai/east").StructType<Record<never, never> & {
-    __tile: DateTimeType;
-} & {
-    press: OptionType<StringType>;
-}>, import("@elaraai/east").StructType<{
-    readonly title: StringType;
-    readonly start: OptionType<DateTimeType>;
-    readonly end: OptionType<DateTimeType>;
-    readonly press: OptionType<StringType>;
-    readonly state: import("@elaraai/east").VariantType<{
-        readonly estimated: import("@elaraai/east").NullType;
-        readonly proposed: import("@elaraai/east").VariantType<{
-            readonly added: import("@elaraai/east").NullType;
-            readonly recommended: import("@elaraai/east").NullType;
-            readonly removed: import("@elaraai/east").NullType;
+}>>, [variant<"field", "records">, variant<"field", "plan_stock_jobs">], import("@elaraai/e3").IndexesOf<{
+    plan_stock_jobs_by_stock_time: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        on: import("@elaraai/east").StructType<{
+            stock: import("@elaraai/east").VariantType<{
+                readonly coated: import("@elaraai/east").NullType;
+                readonly uncoated: import("@elaraai/east").NullType;
+                readonly board: import("@elaraai/east").NullType;
+            }>;
         }>;
-        readonly confirmed: import("@elaraai/east").NullType;
-        readonly "in-progress": import("@elaraai/east").NullType;
-        readonly actual: import("@elaraai/east").NullType;
-        readonly rejected: import("@elaraai/east").NullType;
-    }>;
-    readonly sheets: import("@elaraai/east").FloatType;
-    readonly customer: StringType;
-    readonly stock: import("@elaraai/east").VariantType<{
-        readonly coated: import("@elaraai/east").NullType;
-        readonly uncoated: import("@elaraai/east").NullType;
-        readonly board: import("@elaraai/east").NullType;
-    }>;
-    readonly due: OptionType<DateTimeType>;
-}>, readonly ["__tile", "press"]> & {
-    series: import("@elaraai/e3").TimeTileOf<{
-        readonly key: "press";
-        readonly from: "start";
-        readonly to: "end";
-        readonly tile: "week";
+        node: IntegerType;
+        at: OptionType<DateTimeType>;
+    }>, import("@elaraai/east").NullType, readonly ["stock"], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
     }>;
-};
-/**
- * How busy each press is, a month at a time (#1039): under each press and
- * month, how many jobs touch it and the milliseconds of it they cover — what
- * `planWindows` shades where the jobs in view are too many to draw.
- */
-export declare const planWindowJobsByPressMonth: import("@elaraai/e3").RecordIndexDef<"plan_window_jobs_by_press_month", DictType<StringType, import("@elaraai/east").StructType<{
-    readonly title: StringType;
-    readonly start: OptionType<DateTimeType>;
-    readonly end: OptionType<DateTimeType>;
-    readonly press: OptionType<StringType>;
-    readonly state: import("@elaraai/east").VariantType<{
-        readonly estimated: import("@elaraai/east").NullType;
-        readonly proposed: import("@elaraai/east").VariantType<{
-            readonly added: import("@elaraai/east").NullType;
-            readonly recommended: import("@elaraai/east").NullType;
-            readonly removed: import("@elaraai/east").NullType;
+    plan_stock_jobs_by_stock_press_week: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        on: import("@elaraai/east").StructType<{
+            stock: import("@elaraai/east").VariantType<{
+                readonly coated: import("@elaraai/east").NullType;
+                readonly uncoated: import("@elaraai/east").NullType;
+                readonly board: import("@elaraai/east").NullType;
+            }>;
         }>;
-        readonly confirmed: import("@elaraai/east").NullType;
-        readonly "in-progress": import("@elaraai/east").NullType;
-        readonly actual: import("@elaraai/east").NullType;
-        readonly rejected: import("@elaraai/east").NullType;
-    }>;
-    readonly sheets: import("@elaraai/east").FloatType;
-    readonly customer: StringType;
-    readonly stock: import("@elaraai/east").VariantType<{
-        readonly coated: import("@elaraai/east").NullType;
-        readonly uncoated: import("@elaraai/east").NullType;
-        readonly board: import("@elaraai/east").NullType;
-    }>;
-    readonly due: OptionType<DateTimeType>;
-}>>, import("@elaraai/east").StructType<Record<never, never> & {
-    __tile: DateTimeType;
-} & {
-    press: OptionType<StringType>;
-}>, import("@elaraai/east").StructType<{
-    readonly count: IntegerType;
-    readonly ms: IntegerType;
-}>, readonly ["__tile", "press"]> & {
-    summary: import("@elaraai/e3").TimeTileOf<{
-        readonly key: "press";
-        readonly from: "start";
-        readonly to: "end";
-        readonly tile: "month";
-    }>;
-};
-/**
- * The jobs' monthly summary declared again (#1039): no example lists it — a
- * Plan refuses two summaries of one tile over the same fields, naming both,
- * and the series spec lists it beside `planWindowJobsByPressMonth` to see it
- * refused.
- */
-export declare const planWindowJobsByPressMonthAgain: import("@elaraai/e3").RecordIndexDef<"plan_window_jobs_by_press_month_again", DictType<StringType, import("@elaraai/east").StructType<{
-    readonly title: StringType;
-    readonly start: OptionType<DateTimeType>;
-    readonly end: OptionType<DateTimeType>;
-    readonly press: OptionType<StringType>;
-    readonly state: import("@elaraai/east").VariantType<{
-        readonly estimated: import("@elaraai/east").NullType;
-        readonly proposed: import("@elaraai/east").VariantType<{
-            readonly added: import("@elaraai/east").NullType;
-            readonly recommended: import("@elaraai/east").NullType;
-            readonly removed: import("@elaraai/east").NullType;
+        key: OptionType<StringType>;
+        level: import("@elaraai/e3-types").RecordLevelType;
+        tile: DateTimeType;
+    }>, import("@elaraai/east").StructType<{
+        readonly title: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly press: OptionType<StringType>;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: import("@elaraai/east").NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: import("@elaraai/east").NullType;
+                readonly recommended: import("@elaraai/east").NullType;
+                readonly removed: import("@elaraai/east").NullType;
+            }>;
+            readonly confirmed: import("@elaraai/east").NullType;
+            readonly "in-progress": import("@elaraai/east").NullType;
+            readonly actual: import("@elaraai/east").NullType;
+            readonly rejected: import("@elaraai/east").NullType;
+        }>;
+        readonly sheets: import("@elaraai/east").FloatType;
+        readonly customer: StringType;
+        readonly stock: import("@elaraai/east").VariantType<{
+            readonly coated: import("@elaraai/east").NullType;
+            readonly uncoated: import("@elaraai/east").NullType;
+            readonly board: import("@elaraai/east").NullType;
+        }>;
+        readonly due: OptionType<DateTimeType>;
+    }>, readonly ["stock"], {
+        readonly series: import("@elaraai/e3").TimeTileOf<{
+            readonly on: readonly ["stock"];
+            readonly key: "press";
+            readonly from: "start";
+            readonly to: "end";
+            readonly tile: "week";
         }>;
-        readonly confirmed: import("@elaraai/east").NullType;
-        readonly "in-progress": import("@elaraai/east").NullType;
-        readonly actual: import("@elaraai/east").NullType;
-        readonly rejected: import("@elaraai/east").NullType;
-    }>;
-    readonly sheets: import("@elaraai/east").FloatType;
-    readonly customer: StringType;
-    readonly stock: import("@elaraai/east").VariantType<{
-        readonly coated: import("@elaraai/east").NullType;
-        readonly uncoated: import("@elaraai/east").NullType;
-        readonly board: import("@elaraai/east").NullType;
     }>;
-    readonly due: OptionType<DateTimeType>;
-}>>, import("@elaraai/east").StructType<Record<never, never> & {
-    __tile: DateTimeType;
-} & {
-    press: OptionType<StringType>;
-}>, import("@elaraai/east").StructType<{
-    readonly count: IntegerType;
-    readonly ms: IntegerType;
-}>, readonly ["__tile", "press"]> & {
-    summary: import("@elaraai/e3").TimeTileOf<{
-        readonly key: "press";
-        readonly from: "start";
-        readonly to: "end";
-        readonly tile: "month";
+    plan_stock_jobs_by_stock_press_month: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        on: import("@elaraai/east").StructType<{
+            stock: import("@elaraai/east").VariantType<{
+                readonly coated: import("@elaraai/east").NullType;
+                readonly uncoated: import("@elaraai/east").NullType;
+                readonly board: import("@elaraai/east").NullType;
+            }>;
+        }>;
+        key: OptionType<StringType>;
+        tile: DateTimeType;
+    }>, import("@elaraai/east").StructType<{
+        readonly count: IntegerType;
+        readonly ms: IntegerType;
+    }>, readonly ["stock"], {
+        readonly summary: import("@elaraai/e3").TimeTileOf<{
+            readonly on: readonly ["stock"];
+            readonly key: "press";
+            readonly from: "start";
+            readonly to: "end";
+            readonly tile: "month";
+        }>;
     }>;
-};
-/**
- * The jobs by the days each touches (`Schedule.days`): a scheduled job is
- * filed under every day it runs into, and a job in the backlog under none —
- * the index a kind with no rail reads the days in view through (`window`), on
- * resources read whole: on paged presses, a Plan refuses it.
- */
-export declare const planWindowJobsByDay: import("@elaraai/e3").RecordIndexDef<"plan_window_jobs_by_day", DictType<StringType, import("@elaraai/east").StructType<{
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
@@ -754,19 +769,439 @@ export declare const planWindowJobsByDay: import("@elaraai/e3").RecordIndexDef<"
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, DateTimeType, import("@elaraai/east").NullType, undefined>;
-/**
- * The jobs with no start, by when they are due (`Schedule.unscheduled`): the
- * index a kind with no rail reads its backlog through (`backlogWindow`), and
- * nothing scheduled in it.
- */
-export declare const planWindowJobsUnscheduled: import("@elaraai/e3").RecordIndexDef<"plan_window_jobs_unscheduled", DictType<StringType, import("@elaraai/east").StructType<{
-    readonly title: StringType;
-    readonly start: OptionType<DateTimeType>;
-    readonly end: OptionType<DateTimeType>;
-    readonly press: OptionType<StringType>;
-    readonly state: import("@elaraai/east").VariantType<{
-        readonly estimated: import("@elaraai/east").NullType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: import("@elaraai/east").NullType;
+        replace: import("@elaraai/east").StructType<{
+            before: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
+                    }>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
+                }>;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
+                }>;
+                readonly due: OptionType<DateTimeType>;
+            }>>;
+            after: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
+                    }>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
+                }>;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
+                }>;
+                readonly due: OptionType<DateTimeType>;
+            }>>;
+        }>;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
+                    }>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
+                }>;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
+                }>;
+                readonly due: OptionType<DateTimeType>;
+            }>;
+            insert: import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
+                    }>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
+                }>;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
+                }>;
+                readonly due: OptionType<DateTimeType>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: import("@elaraai/east").NullType;
+                replace: import("@elaraai/east").StructType<{
+                    before: import("@elaraai/east").StructType<{
+                        readonly title: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                        readonly press: OptionType<StringType>;
+                        readonly state: import("@elaraai/east").VariantType<{
+                            readonly estimated: import("@elaraai/east").NullType;
+                            readonly proposed: import("@elaraai/east").VariantType<{
+                                readonly added: import("@elaraai/east").NullType;
+                                readonly recommended: import("@elaraai/east").NullType;
+                                readonly removed: import("@elaraai/east").NullType;
+                            }>;
+                            readonly confirmed: import("@elaraai/east").NullType;
+                            readonly "in-progress": import("@elaraai/east").NullType;
+                            readonly actual: import("@elaraai/east").NullType;
+                            readonly rejected: import("@elaraai/east").NullType;
+                        }>;
+                        readonly sheets: import("@elaraai/east").FloatType;
+                        readonly customer: StringType;
+                        readonly stock: import("@elaraai/east").VariantType<{
+                            readonly coated: import("@elaraai/east").NullType;
+                            readonly uncoated: import("@elaraai/east").NullType;
+                            readonly board: import("@elaraai/east").NullType;
+                        }>;
+                        readonly due: OptionType<DateTimeType>;
+                    }>;
+                    after: import("@elaraai/east").StructType<{
+                        readonly title: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                        readonly press: OptionType<StringType>;
+                        readonly state: import("@elaraai/east").VariantType<{
+                            readonly estimated: import("@elaraai/east").NullType;
+                            readonly proposed: import("@elaraai/east").VariantType<{
+                                readonly added: import("@elaraai/east").NullType;
+                                readonly recommended: import("@elaraai/east").NullType;
+                                readonly removed: import("@elaraai/east").NullType;
+                            }>;
+                            readonly confirmed: import("@elaraai/east").NullType;
+                            readonly "in-progress": import("@elaraai/east").NullType;
+                            readonly actual: import("@elaraai/east").NullType;
+                            readonly rejected: import("@elaraai/east").NullType;
+                        }>;
+                        readonly sheets: import("@elaraai/east").FloatType;
+                        readonly customer: StringType;
+                        readonly stock: import("@elaraai/east").VariantType<{
+                            readonly coated: import("@elaraai/east").NullType;
+                            readonly uncoated: import("@elaraai/east").NullType;
+                            readonly board: import("@elaraai/east").NullType;
+                        }>;
+                        readonly due: OptionType<DateTimeType>;
+                    }>;
+                }>;
+                patch: import("@elaraai/east").StructType<{
+                    readonly title: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly start: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly end: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly press: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<StringType>;
+                            after: OptionType<StringType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly state: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly estimated: import("@elaraai/east").NullType;
+                                readonly proposed: import("@elaraai/east").VariantType<{
+                                    readonly added: import("@elaraai/east").NullType;
+                                    readonly recommended: import("@elaraai/east").NullType;
+                                    readonly removed: import("@elaraai/east").NullType;
+                                }>;
+                                readonly confirmed: import("@elaraai/east").NullType;
+                                readonly "in-progress": import("@elaraai/east").NullType;
+                                readonly actual: import("@elaraai/east").NullType;
+                                readonly rejected: import("@elaraai/east").NullType;
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly estimated: import("@elaraai/east").NullType;
+                                readonly proposed: import("@elaraai/east").VariantType<{
+                                    readonly added: import("@elaraai/east").NullType;
+                                    readonly recommended: import("@elaraai/east").NullType;
+                                    readonly removed: import("@elaraai/east").NullType;
+                                }>;
+                                readonly confirmed: import("@elaraai/east").NullType;
+                                readonly "in-progress": import("@elaraai/east").NullType;
+                                readonly actual: import("@elaraai/east").NullType;
+                                readonly rejected: import("@elaraai/east").NullType;
+                            }>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly estimated: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            readonly proposed: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").VariantType<{
+                                        readonly added: import("@elaraai/east").NullType;
+                                        readonly recommended: import("@elaraai/east").NullType;
+                                        readonly removed: import("@elaraai/east").NullType;
+                                    }>;
+                                    after: import("@elaraai/east").VariantType<{
+                                        readonly added: import("@elaraai/east").NullType;
+                                        readonly recommended: import("@elaraai/east").NullType;
+                                        readonly removed: import("@elaraai/east").NullType;
+                                    }>;
+                                }>;
+                                patch: import("@elaraai/east").VariantType<{
+                                    readonly added: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
+                                    }>;
+                                    readonly recommended: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
+                                    }>;
+                                    readonly removed: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
+                                    }>;
+                                }>;
+                            }>;
+                            readonly confirmed: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            readonly "in-progress": import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            readonly actual: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            readonly rejected: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly sheets: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").FloatType;
+                            after: import("@elaraai/east").FloatType;
+                        }>;
+                    }>;
+                    readonly customer: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly stock: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly coated: import("@elaraai/east").NullType;
+                                readonly uncoated: import("@elaraai/east").NullType;
+                                readonly board: import("@elaraai/east").NullType;
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly coated: import("@elaraai/east").NullType;
+                                readonly uncoated: import("@elaraai/east").NullType;
+                                readonly board: import("@elaraai/east").NullType;
+                            }>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly coated: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            readonly uncoated: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            readonly board: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly due: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
+    readonly title: StringType;
+    readonly start: OptionType<DateTimeType>;
+    readonly end: OptionType<DateTimeType>;
+    readonly press: OptionType<StringType>;
+    readonly state: import("@elaraai/east").VariantType<{
+        readonly estimated: import("@elaraai/east").NullType;
         readonly proposed: import("@elaraai/east").VariantType<{
             readonly added: import("@elaraai/east").NullType;
             readonly recommended: import("@elaraai/east").NullType;
@@ -785,7 +1220,7 @@ export declare const planWindowJobsUnscheduled: import("@elaraai/e3").RecordInde
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, OptionType<DateTimeType>, import("@elaraai/east").NullType, undefined>;
+}>>>>;
 /**
  * The jobs of the series benchmark (#1039), filed as the jobs are: empty here,
  * so neither the showcase nor a test deploys them — e3-ui-components' series
@@ -818,9 +1253,71 @@ export declare const planBenchJobs: import("@elaraai/e3").RecordDef<DictType<Str
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, [variant<"field", "records">, variant<"field", "plan_bench_jobs">]>;
-/** The benchmark jobs' patch door: what the benchmark fills them through. */
-export declare const planBenchJobsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, import("@elaraai/east").StructType<{
+}>>, [variant<"field", "records">, variant<"field", "plan_bench_jobs">], import("@elaraai/e3").IndexesOf<{
+    plan_bench_jobs_by_time: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        on: import("@elaraai/east").StructType<Record<never, never>>;
+        node: IntegerType;
+        at: OptionType<DateTimeType>;
+    }>, import("@elaraai/east").NullType, readonly [], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
+    }>;
+    plan_bench_jobs_by_press_week: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        on: import("@elaraai/east").StructType<Record<never, never>>;
+        key: OptionType<StringType>;
+        level: import("@elaraai/e3-types").RecordLevelType;
+        tile: DateTimeType;
+    }>, import("@elaraai/east").StructType<{
+        readonly title: StringType;
+        readonly start: OptionType<DateTimeType>;
+        readonly end: OptionType<DateTimeType>;
+        readonly press: OptionType<StringType>;
+        readonly state: import("@elaraai/east").VariantType<{
+            readonly estimated: import("@elaraai/east").NullType;
+            readonly proposed: import("@elaraai/east").VariantType<{
+                readonly added: import("@elaraai/east").NullType;
+                readonly recommended: import("@elaraai/east").NullType;
+                readonly removed: import("@elaraai/east").NullType;
+            }>;
+            readonly confirmed: import("@elaraai/east").NullType;
+            readonly "in-progress": import("@elaraai/east").NullType;
+            readonly actual: import("@elaraai/east").NullType;
+            readonly rejected: import("@elaraai/east").NullType;
+        }>;
+        readonly sheets: import("@elaraai/east").FloatType;
+        readonly customer: StringType;
+        readonly stock: import("@elaraai/east").VariantType<{
+            readonly coated: import("@elaraai/east").NullType;
+            readonly uncoated: import("@elaraai/east").NullType;
+            readonly board: import("@elaraai/east").NullType;
+        }>;
+        readonly due: OptionType<DateTimeType>;
+    }>, readonly [], {
+        readonly series: import("@elaraai/e3").TimeTileOf<{
+            readonly key: "press";
+            readonly from: "start";
+            readonly to: "end";
+            readonly tile: "week";
+        }>;
+    }>;
+    plan_bench_jobs_by_press_month: import("@elaraai/e3").IndexDraft<import("@elaraai/east").StructType<{
+        on: import("@elaraai/east").StructType<Record<never, never>>;
+        key: OptionType<StringType>;
+        tile: DateTimeType;
+    }>, import("@elaraai/east").StructType<{
+        readonly count: IntegerType;
+        readonly ms: IntegerType;
+    }>, readonly [], {
+        readonly summary: import("@elaraai/e3").TimeTileOf<{
+            readonly key: "press";
+            readonly from: "start";
+            readonly to: "end";
+            readonly tile: "month";
+        }>;
+    }>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
@@ -845,252 +1342,125 @@ export declare const planBenchJobsPatch: import("@elaraai/e3").MutationDef<"patc
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: import("@elaraai/east").NullType;
-    replace: import("@elaraai/east").StructType<{
-        before: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly press: OptionType<StringType>;
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly estimated: import("@elaraai/east").NullType;
-                readonly proposed: import("@elaraai/east").VariantType<{
-                    readonly added: import("@elaraai/east").NullType;
-                    readonly recommended: import("@elaraai/east").NullType;
-                    readonly removed: import("@elaraai/east").NullType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: import("@elaraai/east").NullType;
+        replace: import("@elaraai/east").StructType<{
+            before: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
+                    }>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
                 }>;
-                readonly confirmed: import("@elaraai/east").NullType;
-                readonly "in-progress": import("@elaraai/east").NullType;
-                readonly actual: import("@elaraai/east").NullType;
-                readonly rejected: import("@elaraai/east").NullType;
-            }>;
-            readonly sheets: import("@elaraai/east").FloatType;
-            readonly customer: StringType;
-            readonly stock: import("@elaraai/east").VariantType<{
-                readonly coated: import("@elaraai/east").NullType;
-                readonly uncoated: import("@elaraai/east").NullType;
-                readonly board: import("@elaraai/east").NullType;
-            }>;
-            readonly due: OptionType<DateTimeType>;
-        }>>;
-        after: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly press: OptionType<StringType>;
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly estimated: import("@elaraai/east").NullType;
-                readonly proposed: import("@elaraai/east").VariantType<{
-                    readonly added: import("@elaraai/east").NullType;
-                    readonly recommended: import("@elaraai/east").NullType;
-                    readonly removed: import("@elaraai/east").NullType;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
                 }>;
-                readonly confirmed: import("@elaraai/east").NullType;
-                readonly "in-progress": import("@elaraai/east").NullType;
-                readonly actual: import("@elaraai/east").NullType;
-                readonly rejected: import("@elaraai/east").NullType;
-            }>;
-            readonly sheets: import("@elaraai/east").FloatType;
-            readonly customer: StringType;
-            readonly stock: import("@elaraai/east").VariantType<{
-                readonly coated: import("@elaraai/east").NullType;
-                readonly uncoated: import("@elaraai/east").NullType;
-                readonly board: import("@elaraai/east").NullType;
-            }>;
-            readonly due: OptionType<DateTimeType>;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: import("@elaraai/east").StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly press: OptionType<StringType>;
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly estimated: import("@elaraai/east").NullType;
-                readonly proposed: import("@elaraai/east").VariantType<{
-                    readonly added: import("@elaraai/east").NullType;
-                    readonly recommended: import("@elaraai/east").NullType;
-                    readonly removed: import("@elaraai/east").NullType;
+                readonly due: OptionType<DateTimeType>;
+            }>>;
+            after: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
+                    }>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
                 }>;
-                readonly confirmed: import("@elaraai/east").NullType;
-                readonly "in-progress": import("@elaraai/east").NullType;
-                readonly actual: import("@elaraai/east").NullType;
-                readonly rejected: import("@elaraai/east").NullType;
-            }>;
-            readonly sheets: import("@elaraai/east").FloatType;
-            readonly customer: StringType;
-            readonly stock: import("@elaraai/east").VariantType<{
-                readonly coated: import("@elaraai/east").NullType;
-                readonly uncoated: import("@elaraai/east").NullType;
-                readonly board: import("@elaraai/east").NullType;
-            }>;
-            readonly due: OptionType<DateTimeType>;
-        }>;
-        insert: import("@elaraai/east").StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly press: OptionType<StringType>;
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly estimated: import("@elaraai/east").NullType;
-                readonly proposed: import("@elaraai/east").VariantType<{
-                    readonly added: import("@elaraai/east").NullType;
-                    readonly recommended: import("@elaraai/east").NullType;
-                    readonly removed: import("@elaraai/east").NullType;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
                 }>;
-                readonly confirmed: import("@elaraai/east").NullType;
-                readonly "in-progress": import("@elaraai/east").NullType;
-                readonly actual: import("@elaraai/east").NullType;
-                readonly rejected: import("@elaraai/east").NullType;
-            }>;
-            readonly sheets: import("@elaraai/east").FloatType;
-            readonly customer: StringType;
-            readonly stock: import("@elaraai/east").VariantType<{
-                readonly coated: import("@elaraai/east").NullType;
-                readonly uncoated: import("@elaraai/east").NullType;
-                readonly board: import("@elaraai/east").NullType;
-            }>;
-            readonly due: OptionType<DateTimeType>;
+                readonly due: OptionType<DateTimeType>;
+            }>>;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: import("@elaraai/east").NullType;
-            replace: import("@elaraai/east").StructType<{
-                before: import("@elaraai/east").StructType<{
-                    readonly title: StringType;
-                    readonly start: OptionType<DateTimeType>;
-                    readonly end: OptionType<DateTimeType>;
-                    readonly press: OptionType<StringType>;
-                    readonly state: import("@elaraai/east").VariantType<{
-                        readonly estimated: import("@elaraai/east").NullType;
-                        readonly proposed: import("@elaraai/east").VariantType<{
-                            readonly added: import("@elaraai/east").NullType;
-                            readonly recommended: import("@elaraai/east").NullType;
-                            readonly removed: import("@elaraai/east").NullType;
-                        }>;
-                        readonly confirmed: import("@elaraai/east").NullType;
-                        readonly "in-progress": import("@elaraai/east").NullType;
-                        readonly actual: import("@elaraai/east").NullType;
-                        readonly rejected: import("@elaraai/east").NullType;
-                    }>;
-                    readonly sheets: import("@elaraai/east").FloatType;
-                    readonly customer: StringType;
-                    readonly stock: import("@elaraai/east").VariantType<{
-                        readonly coated: import("@elaraai/east").NullType;
-                        readonly uncoated: import("@elaraai/east").NullType;
-                        readonly board: import("@elaraai/east").NullType;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
                     }>;
-                    readonly due: OptionType<DateTimeType>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
                 }>;
-                after: import("@elaraai/east").StructType<{
-                    readonly title: StringType;
-                    readonly start: OptionType<DateTimeType>;
-                    readonly end: OptionType<DateTimeType>;
-                    readonly press: OptionType<StringType>;
-                    readonly state: import("@elaraai/east").VariantType<{
-                        readonly estimated: import("@elaraai/east").NullType;
-                        readonly proposed: import("@elaraai/east").VariantType<{
-                            readonly added: import("@elaraai/east").NullType;
-                            readonly recommended: import("@elaraai/east").NullType;
-                            readonly removed: import("@elaraai/east").NullType;
-                        }>;
-                        readonly confirmed: import("@elaraai/east").NullType;
-                        readonly "in-progress": import("@elaraai/east").NullType;
-                        readonly actual: import("@elaraai/east").NullType;
-                        readonly rejected: import("@elaraai/east").NullType;
-                    }>;
-                    readonly sheets: import("@elaraai/east").FloatType;
-                    readonly customer: StringType;
-                    readonly stock: import("@elaraai/east").VariantType<{
-                        readonly coated: import("@elaraai/east").NullType;
-                        readonly uncoated: import("@elaraai/east").NullType;
-                        readonly board: import("@elaraai/east").NullType;
-                    }>;
-                    readonly due: OptionType<DateTimeType>;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
                 }>;
+                readonly due: OptionType<DateTimeType>;
             }>;
-            patch: import("@elaraai/east").StructType<{
-                readonly title: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-                readonly start: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                }>;
-                readonly end: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
-                            }>;
-                        }>;
+            insert: import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
                     }>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
                 }>;
-                readonly press: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<StringType>;
-                        after: OptionType<StringType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
-                        }>;
-                    }>;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
                 }>;
-                readonly state: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").VariantType<{
+                readonly due: OptionType<DateTimeType>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: import("@elaraai/east").NullType;
+                replace: import("@elaraai/east").StructType<{
+                    before: import("@elaraai/east").StructType<{
+                        readonly title: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                        readonly press: OptionType<StringType>;
+                        readonly state: import("@elaraai/east").VariantType<{
                             readonly estimated: import("@elaraai/east").NullType;
                             readonly proposed: import("@elaraai/east").VariantType<{
                                 readonly added: import("@elaraai/east").NullType;
@@ -1102,7 +1472,21 @@ export declare const planBenchJobsPatch: import("@elaraai/e3").MutationDef<"patc
                             readonly actual: import("@elaraai/east").NullType;
                             readonly rejected: import("@elaraai/east").NullType;
                         }>;
-                        after: import("@elaraai/east").VariantType<{
+                        readonly sheets: import("@elaraai/east").FloatType;
+                        readonly customer: StringType;
+                        readonly stock: import("@elaraai/east").VariantType<{
+                            readonly coated: import("@elaraai/east").NullType;
+                            readonly uncoated: import("@elaraai/east").NullType;
+                            readonly board: import("@elaraai/east").NullType;
+                        }>;
+                        readonly due: OptionType<DateTimeType>;
+                    }>;
+                    after: import("@elaraai/east").StructType<{
+                        readonly title: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                        readonly press: OptionType<StringType>;
+                        readonly state: import("@elaraai/east").VariantType<{
                             readonly estimated: import("@elaraai/east").NullType;
                             readonly proposed: import("@elaraai/east").VariantType<{
                                 readonly added: import("@elaraai/east").NullType;
@@ -1114,263 +1498,277 @@ export declare const planBenchJobsPatch: import("@elaraai/e3").MutationDef<"patc
                             readonly actual: import("@elaraai/east").NullType;
                             readonly rejected: import("@elaraai/east").NullType;
                         }>;
+                        readonly sheets: import("@elaraai/east").FloatType;
+                        readonly customer: StringType;
+                        readonly stock: import("@elaraai/east").VariantType<{
+                            readonly coated: import("@elaraai/east").NullType;
+                            readonly uncoated: import("@elaraai/east").NullType;
+                            readonly board: import("@elaraai/east").NullType;
+                        }>;
+                        readonly due: OptionType<DateTimeType>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        readonly estimated: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        readonly proposed: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").VariantType<{
+                }>;
+                patch: import("@elaraai/east").StructType<{
+                    readonly title: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly start: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly end: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly press: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<StringType>;
+                            after: OptionType<StringType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly state: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly estimated: import("@elaraai/east").NullType;
+                                readonly proposed: import("@elaraai/east").VariantType<{
                                     readonly added: import("@elaraai/east").NullType;
                                     readonly recommended: import("@elaraai/east").NullType;
                                     readonly removed: import("@elaraai/east").NullType;
                                 }>;
-                                after: import("@elaraai/east").VariantType<{
+                                readonly confirmed: import("@elaraai/east").NullType;
+                                readonly "in-progress": import("@elaraai/east").NullType;
+                                readonly actual: import("@elaraai/east").NullType;
+                                readonly rejected: import("@elaraai/east").NullType;
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly estimated: import("@elaraai/east").NullType;
+                                readonly proposed: import("@elaraai/east").VariantType<{
                                     readonly added: import("@elaraai/east").NullType;
                                     readonly recommended: import("@elaraai/east").NullType;
                                     readonly removed: import("@elaraai/east").NullType;
                                 }>;
+                                readonly confirmed: import("@elaraai/east").NullType;
+                                readonly "in-progress": import("@elaraai/east").NullType;
+                                readonly actual: import("@elaraai/east").NullType;
+                                readonly rejected: import("@elaraai/east").NullType;
                             }>;
-                            patch: import("@elaraai/east").VariantType<{
-                                readonly added: import("@elaraai/east").VariantType<{
-                                    unchanged: import("@elaraai/east").NullType;
-                                    replace: import("@elaraai/east").StructType<{
-                                        before: import("@elaraai/east").NullType;
-                                        after: import("@elaraai/east").NullType;
-                                    }>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly estimated: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
                                 }>;
-                                readonly recommended: import("@elaraai/east").VariantType<{
-                                    unchanged: import("@elaraai/east").NullType;
-                                    replace: import("@elaraai/east").StructType<{
-                                        before: import("@elaraai/east").NullType;
-                                        after: import("@elaraai/east").NullType;
+                            }>;
+                            readonly proposed: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").VariantType<{
+                                        readonly added: import("@elaraai/east").NullType;
+                                        readonly recommended: import("@elaraai/east").NullType;
+                                        readonly removed: import("@elaraai/east").NullType;
+                                    }>;
+                                    after: import("@elaraai/east").VariantType<{
+                                        readonly added: import("@elaraai/east").NullType;
+                                        readonly recommended: import("@elaraai/east").NullType;
+                                        readonly removed: import("@elaraai/east").NullType;
                                     }>;
                                 }>;
-                                readonly removed: import("@elaraai/east").VariantType<{
-                                    unchanged: import("@elaraai/east").NullType;
-                                    replace: import("@elaraai/east").StructType<{
-                                        before: import("@elaraai/east").NullType;
-                                        after: import("@elaraai/east").NullType;
+                                patch: import("@elaraai/east").VariantType<{
+                                    readonly added: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
+                                    }>;
+                                    readonly recommended: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
+                                    }>;
+                                    readonly removed: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
                                     }>;
                                 }>;
                             }>;
-                        }>;
-                        readonly confirmed: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        readonly "in-progress": import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                            readonly confirmed: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
-                        }>;
-                        readonly actual: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                            readonly "in-progress": import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
-                        }>;
-                        readonly rejected: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                            readonly actual: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            readonly rejected: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
                         }>;
-                    }>;
-                }>;
-                readonly sheets: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").FloatType;
-                        after: import("@elaraai/east").FloatType;
-                    }>;
-                }>;
-                readonly customer: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-                readonly stock: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").VariantType<{
-                            readonly coated: import("@elaraai/east").NullType;
-                            readonly uncoated: import("@elaraai/east").NullType;
-                            readonly board: import("@elaraai/east").NullType;
-                        }>;
-                        after: import("@elaraai/east").VariantType<{
-                            readonly coated: import("@elaraai/east").NullType;
-                            readonly uncoated: import("@elaraai/east").NullType;
-                            readonly board: import("@elaraai/east").NullType;
+                    }>;
+                    readonly sheets: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").FloatType;
+                            after: import("@elaraai/east").FloatType;
                         }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        readonly coated: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
+                    readonly customer: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
                         }>;
-                        readonly uncoated: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                    }>;
+                    readonly stock: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly coated: import("@elaraai/east").NullType;
+                                readonly uncoated: import("@elaraai/east").NullType;
+                                readonly board: import("@elaraai/east").NullType;
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly coated: import("@elaraai/east").NullType;
+                                readonly uncoated: import("@elaraai/east").NullType;
+                                readonly board: import("@elaraai/east").NullType;
                             }>;
                         }>;
-                        readonly board: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly coated: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            readonly uncoated: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            readonly board: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly due: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                    readonly due: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
                             }>;
                         }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-/** The benchmark jobs over their interval index: the rail's window and its exact count. */
-export declare const planBenchJobsByTime: import("@elaraai/e3").RecordIndexDef<"plan_bench_jobs_by_time", DictType<StringType, import("@elaraai/east").StructType<{
-    readonly title: StringType;
-    readonly start: OptionType<DateTimeType>;
-    readonly end: OptionType<DateTimeType>;
-    readonly press: OptionType<StringType>;
-    readonly state: import("@elaraai/east").VariantType<{
-        readonly estimated: import("@elaraai/east").NullType;
-        readonly proposed: import("@elaraai/east").VariantType<{
-            readonly added: import("@elaraai/east").NullType;
-            readonly recommended: import("@elaraai/east").NullType;
-            readonly removed: import("@elaraai/east").NullType;
-        }>;
-        readonly confirmed: import("@elaraai/east").NullType;
-        readonly "in-progress": import("@elaraai/east").NullType;
-        readonly actual: import("@elaraai/east").NullType;
-        readonly rejected: import("@elaraai/east").NullType;
-    }>;
-    readonly sheets: import("@elaraai/east").FloatType;
-    readonly customer: StringType;
-    readonly stock: import("@elaraai/east").VariantType<{
-        readonly coated: import("@elaraai/east").NullType;
-        readonly uncoated: import("@elaraai/east").NullType;
-        readonly board: import("@elaraai/east").NullType;
-    }>;
-    readonly due: OptionType<DateTimeType>;
-}>>, import("@elaraai/east").StructType<Record<never, never> & {
-    __interval: IntegerType;
-} & {
-    start: OptionType<DateTimeType>;
-}>, import("@elaraai/east").NullType, readonly ["start"]> & {
-    interval: {
-        readonly from: "start";
-        readonly to: "end";
-    };
-};
-/** The benchmark jobs by the press each is on and the weeks each touches: its cells. */
-export declare const planBenchJobsByPressWeek: import("@elaraai/e3").RecordIndexDef<"plan_bench_jobs_by_press_week", DictType<StringType, import("@elaraai/east").StructType<{
-    readonly title: StringType;
-    readonly start: OptionType<DateTimeType>;
-    readonly end: OptionType<DateTimeType>;
-    readonly press: OptionType<StringType>;
-    readonly state: import("@elaraai/east").VariantType<{
-        readonly estimated: import("@elaraai/east").NullType;
-        readonly proposed: import("@elaraai/east").VariantType<{
-            readonly added: import("@elaraai/east").NullType;
-            readonly recommended: import("@elaraai/east").NullType;
-            readonly removed: import("@elaraai/east").NullType;
-        }>;
-        readonly confirmed: import("@elaraai/east").NullType;
-        readonly "in-progress": import("@elaraai/east").NullType;
-        readonly actual: import("@elaraai/east").NullType;
-        readonly rejected: import("@elaraai/east").NullType;
-    }>;
-    readonly sheets: import("@elaraai/east").FloatType;
-    readonly customer: StringType;
-    readonly stock: import("@elaraai/east").VariantType<{
-        readonly coated: import("@elaraai/east").NullType;
-        readonly uncoated: import("@elaraai/east").NullType;
-        readonly board: import("@elaraai/east").NullType;
-    }>;
-    readonly due: OptionType<DateTimeType>;
-}>>, import("@elaraai/east").StructType<Record<never, never> & {
-    __tile: DateTimeType;
-} & {
-    press: OptionType<StringType>;
-}>, import("@elaraai/east").StructType<{
-    readonly title: StringType;
-    readonly start: OptionType<DateTimeType>;
-    readonly end: OptionType<DateTimeType>;
-    readonly press: OptionType<StringType>;
-    readonly state: import("@elaraai/east").VariantType<{
-        readonly estimated: import("@elaraai/east").NullType;
-        readonly proposed: import("@elaraai/east").VariantType<{
-            readonly added: import("@elaraai/east").NullType;
-            readonly recommended: import("@elaraai/east").NullType;
-            readonly removed: import("@elaraai/east").NullType;
-        }>;
-        readonly confirmed: import("@elaraai/east").NullType;
-        readonly "in-progress": import("@elaraai/east").NullType;
-        readonly actual: import("@elaraai/east").NullType;
-        readonly rejected: import("@elaraai/east").NullType;
-    }>;
-    readonly sheets: import("@elaraai/east").FloatType;
-    readonly customer: StringType;
-    readonly stock: import("@elaraai/east").VariantType<{
-        readonly coated: import("@elaraai/east").NullType;
-        readonly uncoated: import("@elaraai/east").NullType;
-        readonly board: import("@elaraai/east").NullType;
-    }>;
-    readonly due: OptionType<DateTimeType>;
-}>, readonly ["__tile", "press"]> & {
-    series: import("@elaraai/e3").TimeTileOf<{
-        readonly key: "press";
-        readonly from: "start";
-        readonly to: "end";
-        readonly tile: "week";
-    }>;
-};
-/** How busy each press is, a month at a time: the benchmark's shading. */
-export declare const planBenchJobsByPressMonth: import("@elaraai/e3").RecordIndexDef<"plan_bench_jobs_by_press_month", DictType<StringType, import("@elaraai/east").StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
@@ -1395,21 +1793,7 @@ export declare const planBenchJobsByPressMonth: import("@elaraai/e3").RecordInde
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, import("@elaraai/east").StructType<Record<never, never> & {
-    __tile: DateTimeType;
-} & {
-    press: OptionType<StringType>;
-}>, import("@elaraai/east").StructType<{
-    readonly count: IntegerType;
-    readonly ms: IntegerType;
-}>, readonly ["__tile", "press"]> & {
-    summary: import("@elaraai/e3").TimeTileOf<{
-        readonly key: "press";
-        readonly from: "start";
-        readonly to: "end";
-        readonly tile: "month";
-    }>;
-};
+}>>>>;
 /**
  * Print runs on a press, filed as the jobs are: the windows spec commits a
  * day of runs that fills a whole page of their day index, and one on the next
@@ -1441,9 +1825,10 @@ export declare const planWindowRuns: import("@elaraai/e3").RecordDef<DictType<St
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, [variant<"field", "records">, variant<"field", "plan_window_runs">]>;
-/** The runs' patch door: the spec's commit goes through it. */
-export declare const planWindowRunsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, import("@elaraai/east").StructType<{
+}>>, [variant<"field", "records">, variant<"field", "plan_window_runs">], import("@elaraai/e3").IndexesOf<{
+    plan_window_runs_by_day: import("@elaraai/e3").IndexDraft<DateTimeType, import("@elaraai/east").NullType, undefined, unknown>;
+    plan_window_runs_unscheduled: import("@elaraai/e3").IndexDraft<OptionType<DateTimeType>, import("@elaraai/east").NullType, undefined, unknown>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
@@ -1468,252 +1853,125 @@ export declare const planWindowRunsPatch: import("@elaraai/e3").MutationDef<"pat
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, [import("@elaraai/east").VariantType<{
-    unchanged: import("@elaraai/east").NullType;
-    replace: import("@elaraai/east").StructType<{
-        before: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly press: OptionType<StringType>;
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly estimated: import("@elaraai/east").NullType;
-                readonly proposed: import("@elaraai/east").VariantType<{
-                    readonly added: import("@elaraai/east").NullType;
-                    readonly recommended: import("@elaraai/east").NullType;
-                    readonly removed: import("@elaraai/east").NullType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[import("@elaraai/east").VariantType<{
+        unchanged: import("@elaraai/east").NullType;
+        replace: import("@elaraai/east").StructType<{
+            before: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
+                    }>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
                 }>;
-                readonly confirmed: import("@elaraai/east").NullType;
-                readonly "in-progress": import("@elaraai/east").NullType;
-                readonly actual: import("@elaraai/east").NullType;
-                readonly rejected: import("@elaraai/east").NullType;
-            }>;
-            readonly sheets: import("@elaraai/east").FloatType;
-            readonly customer: StringType;
-            readonly stock: import("@elaraai/east").VariantType<{
-                readonly coated: import("@elaraai/east").NullType;
-                readonly uncoated: import("@elaraai/east").NullType;
-                readonly board: import("@elaraai/east").NullType;
-            }>;
-            readonly due: OptionType<DateTimeType>;
-        }>>;
-        after: DictType<StringType, import("@elaraai/east").StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly press: OptionType<StringType>;
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly estimated: import("@elaraai/east").NullType;
-                readonly proposed: import("@elaraai/east").VariantType<{
-                    readonly added: import("@elaraai/east").NullType;
-                    readonly recommended: import("@elaraai/east").NullType;
-                    readonly removed: import("@elaraai/east").NullType;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
                 }>;
-                readonly confirmed: import("@elaraai/east").NullType;
-                readonly "in-progress": import("@elaraai/east").NullType;
-                readonly actual: import("@elaraai/east").NullType;
-                readonly rejected: import("@elaraai/east").NullType;
-            }>;
-            readonly sheets: import("@elaraai/east").FloatType;
-            readonly customer: StringType;
-            readonly stock: import("@elaraai/east").VariantType<{
-                readonly coated: import("@elaraai/east").NullType;
-                readonly uncoated: import("@elaraai/east").NullType;
-                readonly board: import("@elaraai/east").NullType;
-            }>;
-            readonly due: OptionType<DateTimeType>;
-        }>>;
-    }>;
-    patch: DictType<StringType, import("@elaraai/east").VariantType<{
-        delete: import("@elaraai/east").StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly press: OptionType<StringType>;
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly estimated: import("@elaraai/east").NullType;
-                readonly proposed: import("@elaraai/east").VariantType<{
-                    readonly added: import("@elaraai/east").NullType;
-                    readonly recommended: import("@elaraai/east").NullType;
-                    readonly removed: import("@elaraai/east").NullType;
+                readonly due: OptionType<DateTimeType>;
+            }>>;
+            after: DictType<StringType, import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
+                    }>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
                 }>;
-                readonly confirmed: import("@elaraai/east").NullType;
-                readonly "in-progress": import("@elaraai/east").NullType;
-                readonly actual: import("@elaraai/east").NullType;
-                readonly rejected: import("@elaraai/east").NullType;
-            }>;
-            readonly sheets: import("@elaraai/east").FloatType;
-            readonly customer: StringType;
-            readonly stock: import("@elaraai/east").VariantType<{
-                readonly coated: import("@elaraai/east").NullType;
-                readonly uncoated: import("@elaraai/east").NullType;
-                readonly board: import("@elaraai/east").NullType;
-            }>;
-            readonly due: OptionType<DateTimeType>;
-        }>;
-        insert: import("@elaraai/east").StructType<{
-            readonly title: StringType;
-            readonly start: OptionType<DateTimeType>;
-            readonly end: OptionType<DateTimeType>;
-            readonly press: OptionType<StringType>;
-            readonly state: import("@elaraai/east").VariantType<{
-                readonly estimated: import("@elaraai/east").NullType;
-                readonly proposed: import("@elaraai/east").VariantType<{
-                    readonly added: import("@elaraai/east").NullType;
-                    readonly recommended: import("@elaraai/east").NullType;
-                    readonly removed: import("@elaraai/east").NullType;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
                 }>;
-                readonly confirmed: import("@elaraai/east").NullType;
-                readonly "in-progress": import("@elaraai/east").NullType;
-                readonly actual: import("@elaraai/east").NullType;
-                readonly rejected: import("@elaraai/east").NullType;
-            }>;
-            readonly sheets: import("@elaraai/east").FloatType;
-            readonly customer: StringType;
-            readonly stock: import("@elaraai/east").VariantType<{
-                readonly coated: import("@elaraai/east").NullType;
-                readonly uncoated: import("@elaraai/east").NullType;
-                readonly board: import("@elaraai/east").NullType;
-            }>;
-            readonly due: OptionType<DateTimeType>;
+                readonly due: OptionType<DateTimeType>;
+            }>>;
         }>;
-        update: import("@elaraai/east").VariantType<{
-            unchanged: import("@elaraai/east").NullType;
-            replace: import("@elaraai/east").StructType<{
-                before: import("@elaraai/east").StructType<{
-                    readonly title: StringType;
-                    readonly start: OptionType<DateTimeType>;
-                    readonly end: OptionType<DateTimeType>;
-                    readonly press: OptionType<StringType>;
-                    readonly state: import("@elaraai/east").VariantType<{
-                        readonly estimated: import("@elaraai/east").NullType;
-                        readonly proposed: import("@elaraai/east").VariantType<{
-                            readonly added: import("@elaraai/east").NullType;
-                            readonly recommended: import("@elaraai/east").NullType;
-                            readonly removed: import("@elaraai/east").NullType;
-                        }>;
-                        readonly confirmed: import("@elaraai/east").NullType;
-                        readonly "in-progress": import("@elaraai/east").NullType;
-                        readonly actual: import("@elaraai/east").NullType;
-                        readonly rejected: import("@elaraai/east").NullType;
-                    }>;
-                    readonly sheets: import("@elaraai/east").FloatType;
-                    readonly customer: StringType;
-                    readonly stock: import("@elaraai/east").VariantType<{
-                        readonly coated: import("@elaraai/east").NullType;
-                        readonly uncoated: import("@elaraai/east").NullType;
-                        readonly board: import("@elaraai/east").NullType;
+        patch: DictType<StringType, import("@elaraai/east").VariantType<{
+            delete: import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
                     }>;
-                    readonly due: OptionType<DateTimeType>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
                 }>;
-                after: import("@elaraai/east").StructType<{
-                    readonly title: StringType;
-                    readonly start: OptionType<DateTimeType>;
-                    readonly end: OptionType<DateTimeType>;
-                    readonly press: OptionType<StringType>;
-                    readonly state: import("@elaraai/east").VariantType<{
-                        readonly estimated: import("@elaraai/east").NullType;
-                        readonly proposed: import("@elaraai/east").VariantType<{
-                            readonly added: import("@elaraai/east").NullType;
-                            readonly recommended: import("@elaraai/east").NullType;
-                            readonly removed: import("@elaraai/east").NullType;
-                        }>;
-                        readonly confirmed: import("@elaraai/east").NullType;
-                        readonly "in-progress": import("@elaraai/east").NullType;
-                        readonly actual: import("@elaraai/east").NullType;
-                        readonly rejected: import("@elaraai/east").NullType;
-                    }>;
-                    readonly sheets: import("@elaraai/east").FloatType;
-                    readonly customer: StringType;
-                    readonly stock: import("@elaraai/east").VariantType<{
-                        readonly coated: import("@elaraai/east").NullType;
-                        readonly uncoated: import("@elaraai/east").NullType;
-                        readonly board: import("@elaraai/east").NullType;
-                    }>;
-                    readonly due: OptionType<DateTimeType>;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
                 }>;
+                readonly due: OptionType<DateTimeType>;
             }>;
-            patch: import("@elaraai/east").StructType<{
-                readonly title: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-                readonly start: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
-                            }>;
-                        }>;
-                    }>;
-                }>;
-                readonly end: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
-                            }>;
-                        }>;
+            insert: import("@elaraai/east").StructType<{
+                readonly title: StringType;
+                readonly start: OptionType<DateTimeType>;
+                readonly end: OptionType<DateTimeType>;
+                readonly press: OptionType<StringType>;
+                readonly state: import("@elaraai/east").VariantType<{
+                    readonly estimated: import("@elaraai/east").NullType;
+                    readonly proposed: import("@elaraai/east").VariantType<{
+                        readonly added: import("@elaraai/east").NullType;
+                        readonly recommended: import("@elaraai/east").NullType;
+                        readonly removed: import("@elaraai/east").NullType;
                     }>;
+                    readonly confirmed: import("@elaraai/east").NullType;
+                    readonly "in-progress": import("@elaraai/east").NullType;
+                    readonly actual: import("@elaraai/east").NullType;
+                    readonly rejected: import("@elaraai/east").NullType;
                 }>;
-                readonly press: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<StringType>;
-                        after: OptionType<StringType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
-                        }>;
-                    }>;
+                readonly sheets: import("@elaraai/east").FloatType;
+                readonly customer: StringType;
+                readonly stock: import("@elaraai/east").VariantType<{
+                    readonly coated: import("@elaraai/east").NullType;
+                    readonly uncoated: import("@elaraai/east").NullType;
+                    readonly board: import("@elaraai/east").NullType;
                 }>;
-                readonly state: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").VariantType<{
+                readonly due: OptionType<DateTimeType>;
+            }>;
+            update: import("@elaraai/east").VariantType<{
+                unchanged: import("@elaraai/east").NullType;
+                replace: import("@elaraai/east").StructType<{
+                    before: import("@elaraai/east").StructType<{
+                        readonly title: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                        readonly press: OptionType<StringType>;
+                        readonly state: import("@elaraai/east").VariantType<{
                             readonly estimated: import("@elaraai/east").NullType;
                             readonly proposed: import("@elaraai/east").VariantType<{
                                 readonly added: import("@elaraai/east").NullType;
@@ -1725,7 +1983,21 @@ export declare const planWindowRunsPatch: import("@elaraai/e3").MutationDef<"pat
                             readonly actual: import("@elaraai/east").NullType;
                             readonly rejected: import("@elaraai/east").NullType;
                         }>;
-                        after: import("@elaraai/east").VariantType<{
+                        readonly sheets: import("@elaraai/east").FloatType;
+                        readonly customer: StringType;
+                        readonly stock: import("@elaraai/east").VariantType<{
+                            readonly coated: import("@elaraai/east").NullType;
+                            readonly uncoated: import("@elaraai/east").NullType;
+                            readonly board: import("@elaraai/east").NullType;
+                        }>;
+                        readonly due: OptionType<DateTimeType>;
+                    }>;
+                    after: import("@elaraai/east").StructType<{
+                        readonly title: StringType;
+                        readonly start: OptionType<DateTimeType>;
+                        readonly end: OptionType<DateTimeType>;
+                        readonly press: OptionType<StringType>;
+                        readonly state: import("@elaraai/east").VariantType<{
                             readonly estimated: import("@elaraai/east").NullType;
                             readonly proposed: import("@elaraai/east").VariantType<{
                                 readonly added: import("@elaraai/east").NullType;
@@ -1737,191 +2009,277 @@ export declare const planWindowRunsPatch: import("@elaraai/e3").MutationDef<"pat
                             readonly actual: import("@elaraai/east").NullType;
                             readonly rejected: import("@elaraai/east").NullType;
                         }>;
+                        readonly sheets: import("@elaraai/east").FloatType;
+                        readonly customer: StringType;
+                        readonly stock: import("@elaraai/east").VariantType<{
+                            readonly coated: import("@elaraai/east").NullType;
+                            readonly uncoated: import("@elaraai/east").NullType;
+                            readonly board: import("@elaraai/east").NullType;
+                        }>;
+                        readonly due: OptionType<DateTimeType>;
+                    }>;
+                }>;
+                patch: import("@elaraai/east").StructType<{
+                    readonly title: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly start: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        readonly estimated: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
-                            }>;
-                        }>;
-                        readonly proposed: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").VariantType<{
+                    readonly end: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly press: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<StringType>;
+                            after: OptionType<StringType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    readonly state: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly estimated: import("@elaraai/east").NullType;
+                                readonly proposed: import("@elaraai/east").VariantType<{
                                     readonly added: import("@elaraai/east").NullType;
                                     readonly recommended: import("@elaraai/east").NullType;
                                     readonly removed: import("@elaraai/east").NullType;
                                 }>;
-                                after: import("@elaraai/east").VariantType<{
+                                readonly confirmed: import("@elaraai/east").NullType;
+                                readonly "in-progress": import("@elaraai/east").NullType;
+                                readonly actual: import("@elaraai/east").NullType;
+                                readonly rejected: import("@elaraai/east").NullType;
+                            }>;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly estimated: import("@elaraai/east").NullType;
+                                readonly proposed: import("@elaraai/east").VariantType<{
                                     readonly added: import("@elaraai/east").NullType;
                                     readonly recommended: import("@elaraai/east").NullType;
                                     readonly removed: import("@elaraai/east").NullType;
                                 }>;
+                                readonly confirmed: import("@elaraai/east").NullType;
+                                readonly "in-progress": import("@elaraai/east").NullType;
+                                readonly actual: import("@elaraai/east").NullType;
+                                readonly rejected: import("@elaraai/east").NullType;
                             }>;
-                            patch: import("@elaraai/east").VariantType<{
-                                readonly added: import("@elaraai/east").VariantType<{
-                                    unchanged: import("@elaraai/east").NullType;
-                                    replace: import("@elaraai/east").StructType<{
-                                        before: import("@elaraai/east").NullType;
-                                        after: import("@elaraai/east").NullType;
-                                    }>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly estimated: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
                                 }>;
-                                readonly recommended: import("@elaraai/east").VariantType<{
-                                    unchanged: import("@elaraai/east").NullType;
-                                    replace: import("@elaraai/east").StructType<{
-                                        before: import("@elaraai/east").NullType;
-                                        after: import("@elaraai/east").NullType;
+                            }>;
+                            readonly proposed: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").VariantType<{
+                                        readonly added: import("@elaraai/east").NullType;
+                                        readonly recommended: import("@elaraai/east").NullType;
+                                        readonly removed: import("@elaraai/east").NullType;
+                                    }>;
+                                    after: import("@elaraai/east").VariantType<{
+                                        readonly added: import("@elaraai/east").NullType;
+                                        readonly recommended: import("@elaraai/east").NullType;
+                                        readonly removed: import("@elaraai/east").NullType;
                                     }>;
                                 }>;
-                                readonly removed: import("@elaraai/east").VariantType<{
-                                    unchanged: import("@elaraai/east").NullType;
-                                    replace: import("@elaraai/east").StructType<{
-                                        before: import("@elaraai/east").NullType;
-                                        after: import("@elaraai/east").NullType;
+                                patch: import("@elaraai/east").VariantType<{
+                                    readonly added: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
+                                    }>;
+                                    readonly recommended: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
+                                    }>;
+                                    readonly removed: import("@elaraai/east").VariantType<{
+                                        unchanged: import("@elaraai/east").NullType;
+                                        replace: import("@elaraai/east").StructType<{
+                                            before: import("@elaraai/east").NullType;
+                                            after: import("@elaraai/east").NullType;
+                                        }>;
                                     }>;
                                 }>;
                             }>;
-                        }>;
-                        readonly confirmed: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                            readonly confirmed: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
-                        }>;
-                        readonly "in-progress": import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                            readonly "in-progress": import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
-                        }>;
-                        readonly actual: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                            readonly actual: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
-                        }>;
-                        readonly rejected: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                            readonly rejected: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly sheets: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").FloatType;
-                        after: import("@elaraai/east").FloatType;
-                    }>;
-                }>;
-                readonly customer: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: StringType;
-                        after: StringType;
-                    }>;
-                }>;
-                readonly stock: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: import("@elaraai/east").VariantType<{
-                            readonly coated: import("@elaraai/east").NullType;
-                            readonly uncoated: import("@elaraai/east").NullType;
-                            readonly board: import("@elaraai/east").NullType;
+                    readonly sheets: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").FloatType;
+                            after: import("@elaraai/east").FloatType;
                         }>;
-                        after: import("@elaraai/east").VariantType<{
-                            readonly coated: import("@elaraai/east").NullType;
-                            readonly uncoated: import("@elaraai/east").NullType;
-                            readonly board: import("@elaraai/east").NullType;
+                    }>;
+                    readonly customer: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: StringType;
+                            after: StringType;
                         }>;
                     }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        readonly coated: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                    readonly stock: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: import("@elaraai/east").VariantType<{
+                                readonly coated: import("@elaraai/east").NullType;
+                                readonly uncoated: import("@elaraai/east").NullType;
+                                readonly board: import("@elaraai/east").NullType;
                             }>;
-                        }>;
-                        readonly uncoated: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                            after: import("@elaraai/east").VariantType<{
+                                readonly coated: import("@elaraai/east").NullType;
+                                readonly uncoated: import("@elaraai/east").NullType;
+                                readonly board: import("@elaraai/east").NullType;
                             }>;
                         }>;
-                        readonly board: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                        patch: import("@elaraai/east").VariantType<{
+                            readonly coated: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            readonly uncoated: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
+                            }>;
+                            readonly board: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly due: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
-                    }>;
-                    patch: import("@elaraai/east").VariantType<{
-                        none: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: import("@elaraai/east").NullType;
-                                after: import("@elaraai/east").NullType;
+                    readonly due: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
+                        }>;
+                        patch: import("@elaraai/east").VariantType<{
+                            none: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: import("@elaraai/east").NullType;
+                                    after: import("@elaraai/east").NullType;
+                                }>;
                             }>;
-                        }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: DateTimeType;
-                                after: DateTimeType;
+                            some: import("@elaraai/east").VariantType<{
+                                unchanged: import("@elaraai/east").NullType;
+                                replace: import("@elaraai/east").StructType<{
+                                    before: DateTimeType;
+                                    after: DateTimeType;
+                                }>;
                             }>;
                         }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-/** The runs by the days each touches (`Schedule.days`), as the jobs are. */
-export declare const planWindowRunsByDay: import("@elaraai/e3").RecordIndexDef<"plan_window_runs_by_day", DictType<StringType, import("@elaraai/east").StructType<{
-    readonly title: StringType;
-    readonly start: OptionType<DateTimeType>;
-    readonly end: OptionType<DateTimeType>;
-    readonly press: OptionType<StringType>;
-    readonly state: import("@elaraai/east").VariantType<{
-        readonly estimated: import("@elaraai/east").NullType;
-        readonly proposed: import("@elaraai/east").VariantType<{
-            readonly added: import("@elaraai/east").NullType;
-            readonly recommended: import("@elaraai/east").NullType;
-            readonly removed: import("@elaraai/east").NullType;
-        }>;
-        readonly confirmed: import("@elaraai/east").NullType;
-        readonly "in-progress": import("@elaraai/east").NullType;
-        readonly actual: import("@elaraai/east").NullType;
-        readonly rejected: import("@elaraai/east").NullType;
-    }>;
-    readonly sheets: import("@elaraai/east").FloatType;
-    readonly customer: StringType;
-    readonly stock: import("@elaraai/east").VariantType<{
-        readonly coated: import("@elaraai/east").NullType;
-        readonly uncoated: import("@elaraai/east").NullType;
-        readonly board: import("@elaraai/east").NullType;
-    }>;
-    readonly due: OptionType<DateTimeType>;
-}>>, DateTimeType, import("@elaraai/east").NullType, undefined>;
-/** The runs with no start, by when they are due (`Schedule.unscheduled`), as the jobs are. */
-export declare const planWindowRunsUnscheduled: import("@elaraai/e3").RecordIndexDef<"plan_window_runs_unscheduled", DictType<StringType, import("@elaraai/east").StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
@@ -1946,7 +2304,7 @@ export declare const planWindowRunsUnscheduled: import("@elaraai/e3").RecordInde
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, OptionType<DateTimeType>, import("@elaraai/east").NullType, undefined>;
+}>>>>;
 /**
  * A Plan read a window at a time (`Plan Builder Spec.md` §9.11, PB54–PB55,
  * #1039): 2,000 presses, paged 200 to a window as the canvas scrolls, the key