@elaraai/e3-ui 1.0.97 → 1.0.99

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

@@ -22,10 +22,26 @@ export declare const planWindowPresses: import("@elaraai/e3").TaskDef<DictType<S
     readonly sheets_per_hour: import("@elaraai/east").FloatType;
 }>>, [variant<"field", "tasks">, variant<"field", "plan_window_presses">, variant<"field", "output">]>;
 /**
- * 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.
+ * The works' 2,000 presses as a record of their own (#1344): the presses
+ * `generateWindowPresses` makes, stored, so the rail narrows them — a resource
+ * kind's source of the slice is an index of its record.
  */
+export declare const planSeriesPresses: import("@elaraai/e3").RecordDef<DictType<StringType, import("@elaraai/east").StructType<{
+    readonly name: StringType;
+    readonly hall: StringType;
+    readonly sheets_per_hour: import("@elaraai/east").FloatType;
+}>>, [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;
+}>>>, 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>;
@@ -51,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>;
@@ -78,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;
@@ -335,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;
@@ -347,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;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    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;
+                                }>;
+                            }>;
+                        }>;
                     }>;
-                    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 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>;
                         }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: DateTimeType;
-                                after: 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;
+                                }>;
                             }>;
                         }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-/**
- * 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>;
@@ -534,22 +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 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`).
+ * 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 planWindowJobsByDay: import("@elaraai/e3").RecordIndexDef<"plan_window_jobs_by_day", 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>;
@@ -574,76 +660,91 @@ export declare const planWindowJobsByDay: import("@elaraai/e3").RecordIndexDef<"
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, DateTimeType, import("@elaraai/east").NullType, undefined> & {
-    interval: 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;
-        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;
+        node: IntegerType;
+        at: OptionType<DateTimeType>;
+    }>, import("@elaraai/east").NullType, readonly ["stock"], {
+        readonly interval: {
+            readonly from: "start";
+            readonly to: "end";
+        };
     }>;
-    readonly due: OptionType<DateTimeType>;
-}>>, OptionType<DateTimeType>, import("@elaraai/east").NullType, undefined> & {
-    interval: undefined;
-};
-/**
- * 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
- * day, so a window of the first day reads the page after it to find where the
- * day ends. Empty until the spec commits them.
- */
-export declare const planWindowRuns: import("@elaraai/e3").RecordDef<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;
+            }>;
+        }>;
+        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;
+    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";
+        }>;
     }>;
-    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<{
+}, DictType<StringType, import("@elaraai/east").StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
@@ -668,252 +769,698 @@ 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 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>;
             }>;
-            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;
+            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 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 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: 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;
+            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>;
                     }>;
-                    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;
+                    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 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;
+                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 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 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 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 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 start: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<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;
+                                }>;
+                            }>;
+                        }>;
                     }>;
-                    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 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;
                             }>;
                         }>;
-                        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 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 end: import("@elaraai/east").VariantType<{
-                    unchanged: import("@elaraai/east").NullType;
-                    replace: import("@elaraai/east").StructType<{
-                        before: OptionType<DateTimeType>;
-                        after: OptionType<DateTimeType>;
+                    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<{
-                        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 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;
                             }>;
                         }>;
-                        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 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 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;
-                            }>;
+                    readonly due: import("@elaraai/east").VariantType<{
+                        unchanged: import("@elaraai/east").NullType;
+                        replace: import("@elaraai/east").StructType<{
+                            before: OptionType<DateTimeType>;
+                            after: OptionType<DateTimeType>;
                         }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: StringType;
-                                after: 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: 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;
+            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>;
+}>>>>;
+/**
+ * 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
+ * benchmark (`E3_UI_PERF=1`) fills them through their patch door, twenty a
+ * week on each of the first two hundred of 50,000 presses over a quarter, and
+ * reads them a cell at a time.
+ */
+export declare const planBenchJobs: import("@elaraai/e3").RecordDef<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>;
+}>>, [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>;
+    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/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<{
-                    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;
+                }>;
+                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;
@@ -925,7 +1472,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;
@@ -937,164 +1498,309 @@ 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;
+                                }>;
+                            }>;
+                        }>;
+                    }>;
+                    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;
+                                }>;
+                            }>;
+                        }>;
                     }>;
-                    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 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>;
                         }>;
-                        some: import("@elaraai/east").VariantType<{
-                            unchanged: import("@elaraai/east").NullType;
-                            replace: import("@elaraai/east").StructType<{
-                                before: DateTimeType;
-                                after: 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;
+            readonly removed: import("@elaraai/east").NullType;
         }>;
-    }>>;
-}>]>;
-/** 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 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>;
+}>>>>;
+/**
+ * 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
+ * day, so a window of the first day reads the page after it to find where the
+ * day ends. Empty until the spec commits them.
+ */
+export declare const planWindowRuns: import("@elaraai/e3").RecordDef<DictType<StringType, import("@elaraai/east").StructType<{
     readonly title: StringType;
     readonly start: OptionType<DateTimeType>;
     readonly end: OptionType<DateTimeType>;
@@ -1119,11 +1825,10 @@ export declare const planWindowRunsByDay: import("@elaraai/e3").RecordIndexDef<"
         readonly board: import("@elaraai/east").NullType;
     }>;
     readonly due: OptionType<DateTimeType>;
-}>>, DateTimeType, import("@elaraai/east").NullType, undefined> & {
-    interval: 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<{
+}>>, [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>;
@@ -1148,22 +1853,492 @@ 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> & {
-    interval: undefined;
-};
+}>>>, 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;
+            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>;
+}>>>>;
 /**
- * A Plan read a window at a time (`Plan Builder Spec.md` §9.11, PB54–PB55):
- * 2,000 presses, paged 200 to a window as the canvas scrolls, the key search
- * seeking a press by its key; and the jobs on them narrowed through the Plan's
- * one rail (#1344) — its `job` source reads them through their interval
- * index, only the jobs overlapping the window in view, each once, and the
- * backlog, which the library's Backlog tab lists, through its Unset start. The
- * source's range is the window: the toolbar's dates, a pan and the horizon
- * brush write it, and a pan reads the jobs it brings in. One job — the
- * inspector's, a draft's — is read by its key through the record's own
+ * 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
+ * search seeking a press by its key; and the jobs on them read a cell at a
+ * time through the Plan's one rail (#1344) — its `job` source lists the jobs'
+ * interval index, their series index and their summary, and the Plan reads the
+ * rest itself: the jobs of the fifty presses around the rows in view over the
+ * weeks the window touches, two requests however many cells — their searches,
+ * then their entries — so a pan within the weeks it holds reads nothing, and a
+ * scroll into the next fifty presses reads theirs. Its toolbar zooms from a day
+ * to a quarter, and zoomed out past what it draws, it shades each press's
+ * months from the summary instead: the share of each month the press is
+ * booked. The source's range is the window — the toolbar's dates, a pan and
+ * the horizon brush write it — its exact count the interval index's, and the
+ * backlog, which the library's Backlog tab lists, its Unset start's. One job —
+ * the inspector's, a draft's — is read by its key through the record's own
  * entries. Neither the presses nor the jobs are ever read whole, and Save
  * commits through the jobs' patch door, its drafts checked against the
- * revision they were drafted at.
+ * revision they were drafted at. An event kind on paged presses is read so, or
+ * refused: a source listing the interval index alone is, naming both indexes.
  */
 export declare const planWindows: import("@elaraai/east").ExampleDef<[], any>;
+/**
+ * The Plan of `planWindows`, its presses narrowed by hall (#1344): the presses
+ * are a record of their own, paged on the canvas, and the rail's `presses`
+ * source — named after the kind's slot — narrows them through their hall
+ * index. The canvas pages the narrowing's presses themselves, in the index's
+ * order, 200 to a window: a hall chosen reads its presses alone, its count is
+ * the hall's, and the jobs' cells are read for the presses of the hall in view
+ * alone — so a works of a million presses, each with a year of jobs, reads what
+ * is on screen. A choice keeps the view the last one drew until its own presses
+ * land, and the press at the top of the view where the hall holds it. Every
+ * edit is a draft of the jobs' session whatever the halls chosen, and Save
+ * commits it through their patch door.
+ */
+export declare const planSeriesByHall: import("@elaraai/east").ExampleDef<[], any>;
 //# sourceMappingURL=plan-windows.examples.d.ts.map