@elaraai/e3-ui 1.0.98 → 1.0.99

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

@@ -18,105 +18,111 @@ export declare const schematicSystems: import("@elaraai/e3").RecordDef<DictType<
     readonly order: IntegerType;
     readonly fixed: BooleanType;
     readonly dim: FloatType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_systems">]>;
-/** The systems' patch door: another session's change of a layer — its colour, say — which the floor redraws. */
-export declare const schematicSystemsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "schematic_systems">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
     readonly label: StringType;
     readonly colour: StringType;
     readonly order: IntegerType;
     readonly fixed: BooleanType;
     readonly dim: FloatType;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly label: StringType;
-            readonly colour: StringType;
-            readonly order: IntegerType;
-            readonly fixed: BooleanType;
-            readonly dim: FloatType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly label: StringType;
-            readonly colour: StringType;
-            readonly order: IntegerType;
-            readonly fixed: BooleanType;
-            readonly dim: FloatType;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly label: StringType;
-            readonly colour: StringType;
-            readonly order: IntegerType;
-            readonly fixed: BooleanType;
-            readonly dim: FloatType;
-        }>;
-        insert: StructType<{
-            readonly label: StringType;
-            readonly colour: StringType;
-            readonly order: IntegerType;
-            readonly fixed: BooleanType;
-            readonly dim: FloatType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly label: StringType;
+                readonly colour: StringType;
+                readonly order: IntegerType;
+                readonly fixed: BooleanType;
+                readonly dim: FloatType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly label: StringType;
+                readonly colour: StringType;
+                readonly order: IntegerType;
+                readonly fixed: BooleanType;
+                readonly dim: FloatType;
+            }>>;
         }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly label: StringType;
-                    readonly colour: StringType;
-                    readonly order: IntegerType;
-                    readonly fixed: BooleanType;
-                    readonly dim: FloatType;
-                }>;
-                after: StructType<{
-                    readonly label: StringType;
-                    readonly colour: StringType;
-                    readonly order: IntegerType;
-                    readonly fixed: BooleanType;
-                    readonly dim: FloatType;
-                }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly label: StringType;
+                readonly colour: StringType;
+                readonly order: IntegerType;
+                readonly fixed: BooleanType;
+                readonly dim: FloatType;
             }>;
-            patch: StructType<{
-                readonly label: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+            insert: StructType<{
+                readonly label: StringType;
+                readonly colour: StringType;
+                readonly order: IntegerType;
+                readonly fixed: BooleanType;
+                readonly dim: FloatType;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly label: StringType;
+                        readonly colour: StringType;
+                        readonly order: IntegerType;
+                        readonly fixed: BooleanType;
+                        readonly dim: FloatType;
+                    }>;
+                    after: StructType<{
+                        readonly label: StringType;
+                        readonly colour: StringType;
+                        readonly order: IntegerType;
+                        readonly fixed: BooleanType;
+                        readonly dim: FloatType;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly label: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly colour: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly colour: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly order: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: IntegerType;
-                        after: IntegerType;
+                    readonly order: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: IntegerType;
+                            after: IntegerType;
+                        }>;
                     }>;
-                }>;
-                readonly fixed: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: BooleanType;
-                        after: BooleanType;
+                    readonly fixed: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: BooleanType;
+                            after: BooleanType;
+                        }>;
                     }>;
-                }>;
-                readonly dim: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly dim: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly label: StringType;
+    readonly colour: StringType;
+    readonly order: IntegerType;
+    readonly fixed: BooleanType;
+    readonly dim: FloatType;
+}>>>>;
 export declare const FloorRack: StructType<{
     readonly name: StringType;
     readonly x: FloatType;
@@ -136,9 +142,9 @@ export declare const schematicFloorRacks: import("@elaraai/e3").RecordDef<DictTy
     readonly model: StringType;
     readonly kw: FloatType;
     readonly capacity: FloatType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_floor_racks">]>;
-/** The floor's racks' patch door: the handover's Save, and another session's moves of a rack, which the floor redraws. */
-export declare const schematicFloorRacksPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "schematic_floor_racks">], import("@elaraai/e3").IndexesOf<{
+    schematic_floor_racks_by_model: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["model"], unknown>;
+}, DictType<StringType, StructType<{
     readonly name: StringType;
     readonly x: FloatType;
     readonly y: FloatType;
@@ -147,136 +153,147 @@ export declare const schematicFloorRacksPatch: import("@elaraai/e3").MutationDef
     readonly model: StringType;
     readonly kw: FloatType;
     readonly capacity: FloatType;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly w: FloatType;
-            readonly h: FloatType;
-            readonly model: StringType;
-            readonly kw: FloatType;
-            readonly capacity: FloatType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly w: FloatType;
-            readonly h: FloatType;
-            readonly model: StringType;
-            readonly kw: FloatType;
-            readonly capacity: FloatType;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly name: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly w: FloatType;
-            readonly h: FloatType;
-            readonly model: StringType;
-            readonly kw: FloatType;
-            readonly capacity: FloatType;
-        }>;
-        insert: StructType<{
-            readonly name: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly w: FloatType;
-            readonly h: FloatType;
-            readonly model: StringType;
-            readonly kw: FloatType;
-            readonly capacity: FloatType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly model: StringType;
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly model: StringType;
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+            }>>;
         }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly name: StringType;
-                    readonly x: FloatType;
-                    readonly y: FloatType;
-                    readonly w: FloatType;
-                    readonly h: FloatType;
-                    readonly model: StringType;
-                    readonly kw: FloatType;
-                    readonly capacity: FloatType;
-                }>;
-                after: StructType<{
-                    readonly name: StringType;
-                    readonly x: FloatType;
-                    readonly y: FloatType;
-                    readonly w: FloatType;
-                    readonly h: FloatType;
-                    readonly model: StringType;
-                    readonly kw: FloatType;
-                    readonly capacity: FloatType;
-                }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly name: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly model: StringType;
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
             }>;
-            patch: StructType<{
-                readonly name: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+            insert: StructType<{
+                readonly name: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly model: StringType;
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly name: StringType;
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
+                        readonly model: StringType;
+                        readonly kw: FloatType;
+                        readonly capacity: FloatType;
+                    }>;
+                    after: StructType<{
+                        readonly name: StringType;
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
+                        readonly model: StringType;
+                        readonly kw: FloatType;
+                        readonly capacity: FloatType;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly name: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly x: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly x: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly y: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly y: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly w: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly w: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly h: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly h: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly model: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly model: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly kw: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly kw: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly capacity: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly capacity: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+}>>>>;
 export declare const schematicFloor: import("@elaraai/east").ExampleDef<[], any>;
 /**
  * The same hall handed over to its install crew, who move its racks into
@@ -354,7 +371,35 @@ export declare const schematicShapeUnits: import("@elaraai/e3").RecordDef<DictTy
     }>>;
     readonly system: StringType;
     readonly tint: OptionType<StringType>;
-}>>, [variant<"field", "records">, variant<"field", "schematic_shape_units">]>;
+}>>, [variant<"field", "records">, variant<"field", "schematic_shape_units">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: StringType;
+    readonly radius: OptionType<FloatType>;
+    readonly outline: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+    }>>;
+    readonly system: StringType;
+    readonly tint: OptionType<StringType>;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: StringType;
+    readonly radius: OptionType<FloatType>;
+    readonly outline: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+    }>>;
+    readonly system: StringType;
+    readonly tint: OptionType<StringType>;
+}>>>>;
 export declare const schematicShapeAreas: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly x: FloatType;
@@ -373,7 +418,43 @@ export declare const schematicShapeAreas: import("@elaraai/e3").RecordDef<DictTy
         readonly bulge: FloatType;
     }>>;
     readonly system: StringType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_shape_areas">]>;
+}>>, [variant<"field", "records">, variant<"field", "schematic_shape_areas">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: VariantType<{
+        readonly hall: NullType;
+        readonly duct: StructType<{
+            readonly width: FloatType;
+        }>;
+    }>;
+    readonly corners: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+        readonly bulge: FloatType;
+    }>>;
+    readonly system: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: VariantType<{
+        readonly hall: NullType;
+        readonly duct: StructType<{
+            readonly width: FloatType;
+        }>;
+    }>;
+    readonly corners: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
+        readonly bulge: FloatType;
+    }>>;
+    readonly system: StringType;
+}>>>>;
 export declare const schematicShapes: import("@elaraai/east").ExampleDef<[], any>;
 /** A rack: placed by its centre, or unplaced until a drop places it. */
 export declare const DcRack: StructType<{
@@ -561,8 +642,60 @@ export declare const schematicRacks: import("@elaraai/e3").RecordDef<DictType<St
     readonly hall: StringType;
     readonly system: StringType;
     readonly owner: StringType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_racks">]>;
-export declare const schematicRacksPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "schematic_racks">], import("@elaraai/e3").IndexesOf<{
+    schematic_racks_by_name: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["name"], unknown>;
+    schematic_racks_by_hall: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["hall"], unknown>;
+    schematic_racks_by_owner: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["owner"], unknown>;
+    schematic_racks_by_area: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<Record<never, never>>;
+        area: IntegerType;
+    }>, StructType<{
+        readonly name: StringType;
+        readonly x: OptionType<FloatType>;
+        readonly y: OptionType<FloatType>;
+        readonly w: FloatType;
+        readonly h: FloatType;
+        readonly model: StringType;
+        readonly hall: StringType;
+        readonly system: StringType;
+        readonly owner: StringType;
+    }>, readonly [], {
+        readonly area: import("@elaraai/e3").AreaIndexOf<{
+            readonly x: "x";
+            readonly y: "y";
+            readonly width: "w";
+            readonly height: "h";
+            readonly at: "centre";
+            readonly cell: 0.01;
+        }>;
+    }>;
+    schematic_racks_by_owner_area: import("@elaraai/e3").IndexDraft<StructType<{
+        on: StructType<{
+            owner: StringType;
+        }>;
+        area: IntegerType;
+    }>, StructType<{
+        readonly name: StringType;
+        readonly x: OptionType<FloatType>;
+        readonly y: OptionType<FloatType>;
+        readonly w: FloatType;
+        readonly h: FloatType;
+        readonly model: StringType;
+        readonly hall: StringType;
+        readonly system: StringType;
+        readonly owner: StringType;
+    }>, readonly ["owner"], {
+        readonly area: import("@elaraai/e3").AreaIndexOf<{
+            readonly on: readonly ["owner"];
+            readonly x: "x";
+            readonly y: "y";
+            readonly width: "w";
+            readonly height: "h";
+            readonly at: "centre";
+            readonly cell: 0.01;
+        }>;
+    }>;
+}, DictType<StringType, StructType<{
     readonly name: StringType;
     readonly x: OptionType<FloatType>;
     readonly y: OptionType<FloatType>;
@@ -572,231 +705,183 @@ export declare const schematicRacksPatch: import("@elaraai/e3").MutationDef<"pat
     readonly hall: StringType;
     readonly system: StringType;
     readonly owner: StringType;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly x: OptionType<FloatType>;
-            readonly y: OptionType<FloatType>;
-            readonly w: FloatType;
-            readonly h: FloatType;
-            readonly model: StringType;
-            readonly hall: StringType;
-            readonly system: StringType;
-            readonly owner: StringType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly x: OptionType<FloatType>;
-            readonly y: OptionType<FloatType>;
-            readonly w: FloatType;
-            readonly h: FloatType;
-            readonly model: StringType;
-            readonly hall: StringType;
-            readonly system: StringType;
-            readonly owner: StringType;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly name: StringType;
-            readonly x: OptionType<FloatType>;
-            readonly y: OptionType<FloatType>;
-            readonly w: FloatType;
-            readonly h: FloatType;
-            readonly model: StringType;
-            readonly hall: StringType;
-            readonly system: StringType;
-            readonly owner: StringType;
-        }>;
-        insert: StructType<{
-            readonly name: StringType;
-            readonly x: OptionType<FloatType>;
-            readonly y: OptionType<FloatType>;
-            readonly w: FloatType;
-            readonly h: FloatType;
-            readonly model: StringType;
-            readonly hall: StringType;
-            readonly system: StringType;
-            readonly owner: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly x: OptionType<FloatType>;
+                readonly y: OptionType<FloatType>;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly model: StringType;
+                readonly hall: StringType;
+                readonly system: StringType;
+                readonly owner: StringType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly x: OptionType<FloatType>;
+                readonly y: OptionType<FloatType>;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly model: StringType;
+                readonly hall: StringType;
+                readonly system: StringType;
+                readonly owner: StringType;
+            }>>;
         }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly name: StringType;
-                    readonly x: OptionType<FloatType>;
-                    readonly y: OptionType<FloatType>;
-                    readonly w: FloatType;
-                    readonly h: FloatType;
-                    readonly model: StringType;
-                    readonly hall: StringType;
-                    readonly system: StringType;
-                    readonly owner: StringType;
-                }>;
-                after: StructType<{
-                    readonly name: StringType;
-                    readonly x: OptionType<FloatType>;
-                    readonly y: OptionType<FloatType>;
-                    readonly w: FloatType;
-                    readonly h: FloatType;
-                    readonly model: StringType;
-                    readonly hall: StringType;
-                    readonly system: StringType;
-                    readonly owner: StringType;
-                }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly name: StringType;
+                readonly x: OptionType<FloatType>;
+                readonly y: OptionType<FloatType>;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly model: StringType;
+                readonly hall: StringType;
+                readonly system: StringType;
+                readonly owner: StringType;
             }>;
-            patch: StructType<{
-                readonly name: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+            insert: StructType<{
+                readonly name: StringType;
+                readonly x: OptionType<FloatType>;
+                readonly y: OptionType<FloatType>;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly model: StringType;
+                readonly hall: StringType;
+                readonly system: StringType;
+                readonly owner: StringType;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly name: StringType;
+                        readonly x: OptionType<FloatType>;
+                        readonly y: OptionType<FloatType>;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
+                        readonly model: StringType;
+                        readonly hall: StringType;
+                        readonly system: StringType;
+                        readonly owner: StringType;
+                    }>;
+                    after: StructType<{
+                        readonly name: StringType;
+                        readonly x: OptionType<FloatType>;
+                        readonly y: OptionType<FloatType>;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
+                        readonly model: StringType;
+                        readonly hall: StringType;
+                        readonly system: StringType;
+                        readonly owner: StringType;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly name: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly x: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: OptionType<FloatType>;
-                        after: OptionType<FloatType>;
-                    }>;
-                    patch: VariantType<{
-                        none: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                    readonly x: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<FloatType>;
+                            after: OptionType<FloatType>;
                         }>;
-                        some: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: FloatType;
-                                after: FloatType;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: FloatType;
+                                    after: FloatType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly y: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: OptionType<FloatType>;
-                        after: OptionType<FloatType>;
-                    }>;
-                    patch: VariantType<{
-                        none: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                    readonly y: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<FloatType>;
+                            after: OptionType<FloatType>;
                         }>;
-                        some: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: FloatType;
-                                after: FloatType;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: FloatType;
+                                    after: FloatType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly w: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly w: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly h: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly h: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly model: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly model: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly hall: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly hall: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly system: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly system: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly owner: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly owner: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-export declare const schematicRacksByName: import("@elaraai/e3").RecordIndexDef<"schematic_racks_by_name", DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly x: OptionType<FloatType>;
-    readonly y: OptionType<FloatType>;
-    readonly w: FloatType;
-    readonly h: FloatType;
-    readonly model: StringType;
-    readonly hall: StringType;
-    readonly system: StringType;
-    readonly owner: StringType;
-}>>, StringType, NullType, readonly ["name"]>;
-export declare const schematicRacksByHall: import("@elaraai/e3").RecordIndexDef<"schematic_racks_by_hall", DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly x: OptionType<FloatType>;
-    readonly y: OptionType<FloatType>;
-    readonly w: FloatType;
-    readonly h: FloatType;
-    readonly model: StringType;
-    readonly hall: StringType;
-    readonly system: StringType;
-    readonly owner: StringType;
-}>>, StringType, NullType, readonly ["hall"]>;
-export declare const schematicRacksByOwner: import("@elaraai/e3").RecordIndexDef<"schematic_racks_by_owner", DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly x: OptionType<FloatType>;
-    readonly y: OptionType<FloatType>;
-    readonly w: FloatType;
-    readonly h: FloatType;
-    readonly model: StringType;
-    readonly hall: StringType;
-    readonly system: StringType;
-    readonly owner: StringType;
-}>>, StringType, NullType, readonly ["owner"]>;
-/**
- * The racks filed by their boxes at a 1 cm cell, for a floor read a window at a time (#1393): what a window reads whatever
- * the rail chooses, and the racks with no position, under its unplaced clause, which the Backlog pages.
- */
-export declare const schematicRacksByArea: import("@elaraai/e3").RecordIndexDef<"schematic_racks_by_area", DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly x: OptionType<FloatType>;
-    readonly y: OptionType<FloatType>;
-    readonly w: FloatType;
-    readonly h: FloatType;
-    readonly model: StringType;
-    readonly hall: StringType;
-    readonly system: StringType;
-    readonly owner: StringType;
-}>>, StructType<Record<never, never> & {
-    __area: IntegerType;
-}>, StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
     readonly name: StringType;
     readonly x: OptionType<FloatType>;
     readonly y: OptionType<FloatType>;
@@ -806,53 +891,16 @@ export declare const schematicRacksByArea: import("@elaraai/e3").RecordIndexDef<
     readonly hall: StringType;
     readonly system: StringType;
     readonly owner: StringType;
-}>, readonly ["__area"]> & {
-    area: import("@elaraai/e3").AreaIndexOf<{
-        readonly x: "x";
-        readonly y: "y";
-        readonly width: "w";
-        readonly height: "h";
-        readonly at: "centre";
-        readonly cell: 0.01;
+}>>>>;
+export declare const schematicRackLoads: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+    readonly alarm: VariantType<{
+        readonly ok: NullType;
+        readonly warm: NullType;
+        readonly hot: NullType;
     }>;
-};
-/** Beside it, a choice of owners and the window — or the racks with no position — in one read. */
-export declare const schematicRacksByOwnerArea: import("@elaraai/e3").RecordIndexDef<"schematic_racks_by_owner_area", DictType<StringType, StructType<{
-    readonly name: StringType;
-    readonly x: OptionType<FloatType>;
-    readonly y: OptionType<FloatType>;
-    readonly w: FloatType;
-    readonly h: FloatType;
-    readonly model: StringType;
-    readonly hall: StringType;
-    readonly system: StringType;
-    readonly owner: StringType;
-}>>, StructType<{
-    owner: StringType;
-} & {
-    __area: IntegerType;
-}>, StructType<{
-    readonly name: StringType;
-    readonly x: OptionType<FloatType>;
-    readonly y: OptionType<FloatType>;
-    readonly w: FloatType;
-    readonly h: FloatType;
-    readonly model: StringType;
-    readonly hall: StringType;
-    readonly system: StringType;
-    readonly owner: StringType;
-}>, readonly ["owner", "__area"]> & {
-    area: import("@elaraai/e3").AreaIndexOf<{
-        readonly on: readonly ["owner"];
-        readonly x: "x";
-        readonly y: "y";
-        readonly width: "w";
-        readonly height: "h";
-        readonly at: "centre";
-        readonly cell: 0.01;
-    }>;
-};
-export declare const schematicRackLoads: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "schematic_rack_loads">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
     readonly kw: FloatType;
     readonly capacity: FloatType;
     readonly alarm: VariantType<{
@@ -860,136 +908,136 @@ export declare const schematicRackLoads: import("@elaraai/e3").RecordDef<DictTyp
         readonly warm: NullType;
         readonly hot: NullType;
     }>;
-}>>, [variant<"field", "records">, variant<"field", "schematic_rack_loads">]>;
-/** The racks' loads' patch door: a rack's capacity edited in the inspector's details. */
-export declare const schematicRackLoadsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
-    readonly kw: FloatType;
-    readonly capacity: FloatType;
-    readonly alarm: VariantType<{
-        readonly ok: NullType;
-        readonly warm: NullType;
-        readonly hot: NullType;
-    }>;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly kw: FloatType;
-            readonly capacity: FloatType;
-            readonly alarm: VariantType<{
-                readonly ok: NullType;
-                readonly warm: NullType;
-                readonly hot: NullType;
-            }>;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly kw: FloatType;
-            readonly capacity: FloatType;
-            readonly alarm: VariantType<{
-                readonly ok: NullType;
-                readonly warm: NullType;
-                readonly hot: NullType;
-            }>;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly kw: FloatType;
-            readonly capacity: FloatType;
-            readonly alarm: VariantType<{
-                readonly ok: NullType;
-                readonly warm: NullType;
-                readonly hot: NullType;
-            }>;
-        }>;
-        insert: StructType<{
-            readonly kw: FloatType;
-            readonly capacity: FloatType;
-            readonly alarm: VariantType<{
-                readonly ok: NullType;
-                readonly warm: NullType;
-                readonly hot: NullType;
-            }>;
-        }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly kw: FloatType;
-                    readonly capacity: FloatType;
-                    readonly alarm: VariantType<{
-                        readonly ok: NullType;
-                        readonly warm: NullType;
-                        readonly hot: NullType;
-                    }>;
-                }>;
-                after: StructType<{
-                    readonly kw: FloatType;
-                    readonly capacity: FloatType;
-                    readonly alarm: VariantType<{
-                        readonly ok: NullType;
-                        readonly warm: NullType;
-                        readonly hot: NullType;
-                    }>;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+                readonly alarm: VariantType<{
+                    readonly ok: NullType;
+                    readonly warm: NullType;
+                    readonly hot: NullType;
                 }>;
-            }>;
-            patch: StructType<{
-                readonly kw: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
-                    }>;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+                readonly alarm: VariantType<{
+                    readonly ok: NullType;
+                    readonly warm: NullType;
+                    readonly hot: NullType;
                 }>;
-                readonly capacity: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
-                    }>;
+            }>>;
+        }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+                readonly alarm: VariantType<{
+                    readonly ok: NullType;
+                    readonly warm: NullType;
+                    readonly hot: NullType;
                 }>;
+            }>;
+            insert: StructType<{
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
                 readonly alarm: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: VariantType<{
+                    readonly ok: NullType;
+                    readonly warm: NullType;
+                    readonly hot: NullType;
+                }>;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly kw: FloatType;
+                        readonly capacity: FloatType;
+                        readonly alarm: VariantType<{
                             readonly ok: NullType;
                             readonly warm: NullType;
                             readonly hot: NullType;
                         }>;
-                        after: VariantType<{
+                    }>;
+                    after: StructType<{
+                        readonly kw: FloatType;
+                        readonly capacity: FloatType;
+                        readonly alarm: VariantType<{
                             readonly ok: NullType;
                             readonly warm: NullType;
                             readonly hot: NullType;
                         }>;
                     }>;
-                    patch: VariantType<{
-                        readonly ok: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                }>;
+                patch: StructType<{
+                    readonly kw: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly capacity: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
                         }>;
-                        readonly warm: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                    }>;
+                    readonly alarm: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: VariantType<{
+                                readonly ok: NullType;
+                                readonly warm: NullType;
+                                readonly hot: NullType;
+                            }>;
+                            after: VariantType<{
+                                readonly ok: NullType;
+                                readonly warm: NullType;
+                                readonly hot: NullType;
                             }>;
                         }>;
-                        readonly hot: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                        patch: VariantType<{
+                            readonly ok: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly warm: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly hot: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
                             }>;
                         }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+    readonly alarm: VariantType<{
+        readonly ok: NullType;
+        readonly warm: NullType;
+        readonly hot: NullType;
+    }>;
+}>>>>;
 export declare const schematicFrames: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly x: FloatType;
@@ -998,7 +1046,23 @@ export declare const schematicFrames: import("@elaraai/e3").RecordDef<DictType<S
     readonly h: FloatType;
     readonly kind: StringType;
     readonly system: StringType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_frames">]>;
+}>>, [variant<"field", "records">, variant<"field", "schematic_frames">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: StringType;
+    readonly system: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: StringType;
+    readonly system: StringType;
+}>>>>;
 export declare const schematicPdus: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly x: FloatType;
@@ -1007,7 +1071,23 @@ export declare const schematicPdus: import("@elaraai/e3").RecordDef<DictType<Str
     readonly h: FloatType;
     readonly kind: StringType;
     readonly system: StringType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_pdus">]>;
+}>>, [variant<"field", "records">, variant<"field", "schematic_pdus">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: StringType;
+    readonly system: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: StringType;
+    readonly system: StringType;
+}>>>>;
 export declare const schematicCooling: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly x: FloatType;
@@ -1017,8 +1097,7 @@ export declare const schematicCooling: import("@elaraai/e3").RecordDef<DictType<
     readonly radius: FloatType;
     readonly setpoint: FloatType;
     readonly system: StringType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_cooling">]>;
-export declare const schematicCoolingPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "schematic_cooling">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
     readonly name: StringType;
     readonly x: FloatType;
     readonly y: FloatType;
@@ -1027,136 +1106,147 @@ export declare const schematicCoolingPatch: import("@elaraai/e3").MutationDef<"p
     readonly radius: FloatType;
     readonly setpoint: FloatType;
     readonly system: StringType;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly w: FloatType;
-            readonly h: FloatType;
-            readonly radius: FloatType;
-            readonly setpoint: FloatType;
-            readonly system: StringType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly name: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly w: FloatType;
-            readonly h: FloatType;
-            readonly radius: FloatType;
-            readonly setpoint: FloatType;
-            readonly system: StringType;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly name: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly w: FloatType;
-            readonly h: FloatType;
-            readonly radius: FloatType;
-            readonly setpoint: FloatType;
-            readonly system: StringType;
-        }>;
-        insert: StructType<{
-            readonly name: StringType;
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly w: FloatType;
-            readonly h: FloatType;
-            readonly radius: FloatType;
-            readonly setpoint: FloatType;
-            readonly system: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly radius: FloatType;
+                readonly setpoint: FloatType;
+                readonly system: StringType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly radius: FloatType;
+                readonly setpoint: FloatType;
+                readonly system: StringType;
+            }>>;
         }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly name: StringType;
-                    readonly x: FloatType;
-                    readonly y: FloatType;
-                    readonly w: FloatType;
-                    readonly h: FloatType;
-                    readonly radius: FloatType;
-                    readonly setpoint: FloatType;
-                    readonly system: StringType;
-                }>;
-                after: StructType<{
-                    readonly name: StringType;
-                    readonly x: FloatType;
-                    readonly y: FloatType;
-                    readonly w: FloatType;
-                    readonly h: FloatType;
-                    readonly radius: FloatType;
-                    readonly setpoint: FloatType;
-                    readonly system: StringType;
-                }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly name: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly radius: FloatType;
+                readonly setpoint: FloatType;
+                readonly system: StringType;
+            }>;
+            insert: StructType<{
+                readonly name: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly radius: FloatType;
+                readonly setpoint: FloatType;
+                readonly system: StringType;
             }>;
-            patch: StructType<{
-                readonly name: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly name: StringType;
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
+                        readonly radius: FloatType;
+                        readonly setpoint: FloatType;
+                        readonly system: StringType;
+                    }>;
+                    after: StructType<{
+                        readonly name: StringType;
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
+                        readonly radius: FloatType;
+                        readonly setpoint: FloatType;
+                        readonly system: StringType;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly name: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly x: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly x: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly y: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly y: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly w: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly w: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly h: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly h: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly radius: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly radius: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly setpoint: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: FloatType;
-                        after: FloatType;
+                    readonly setpoint: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
                     }>;
-                }>;
-                readonly system: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly system: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly radius: FloatType;
+    readonly setpoint: FloatType;
+    readonly system: StringType;
+}>>>>;
 export declare const schematicAreas: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly x: FloatType;
@@ -1169,7 +1259,31 @@ export declare const schematicAreas: import("@elaraai/e3").RecordDef<DictType<St
         readonly hot: NullType;
     }>;
     readonly system: StringType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_areas">]>;
+}>>, [variant<"field", "records">, variant<"field", "schematic_areas">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: VariantType<{
+        readonly room: NullType;
+        readonly cold: NullType;
+        readonly hot: NullType;
+    }>;
+    readonly system: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly kind: VariantType<{
+        readonly room: NullType;
+        readonly cold: NullType;
+        readonly hot: NullType;
+    }>;
+    readonly system: StringType;
+}>>>>;
 export declare const schematicFibre: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly from: VariantType<{
         readonly rack: StringType;
@@ -1190,8 +1304,9 @@ export declare const schematicFibre: import("@elaraai/e3").RecordDef<DictType<St
         readonly logical: NullType;
     }>;
     readonly system: StringType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_fibre">]>;
-export declare const schematicFibrePatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "schematic_fibre">], import("@elaraai/e3").IndexesOf<{
+    schematic_fibre_by_system: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["system"], unknown>;
+}, DictType<StringType, StructType<{
     readonly from: VariantType<{
         readonly rack: StringType;
         readonly frame: StringType;
@@ -1211,347 +1326,344 @@ export declare const schematicFibrePatch: import("@elaraai/e3").MutationDef<"pat
         readonly logical: NullType;
     }>;
     readonly system: StringType;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly from: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly to: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly path: ArrayType<StructType<{
-                readonly x: FloatType;
-                readonly y: FloatType;
-            }>>;
-            readonly label: OptionType<StringType>;
-            readonly speed: OptionType<StringType>;
-            readonly cable: VariantType<{
-                readonly fibre: NullType;
-                readonly logical: NullType;
-            }>;
-            readonly system: StringType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly from: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly to: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly path: ArrayType<StructType<{
-                readonly x: FloatType;
-                readonly y: FloatType;
-            }>>;
-            readonly label: OptionType<StringType>;
-            readonly speed: OptionType<StringType>;
-            readonly cable: VariantType<{
-                readonly fibre: NullType;
-                readonly logical: NullType;
-            }>;
-            readonly system: StringType;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly from: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly to: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly path: ArrayType<StructType<{
-                readonly x: FloatType;
-                readonly y: FloatType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly from: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly to: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly path: ArrayType<StructType<{
+                    readonly x: FloatType;
+                    readonly y: FloatType;
+                }>>;
+                readonly label: OptionType<StringType>;
+                readonly speed: OptionType<StringType>;
+                readonly cable: VariantType<{
+                    readonly fibre: NullType;
+                    readonly logical: NullType;
+                }>;
+                readonly system: StringType;
             }>>;
-            readonly label: OptionType<StringType>;
-            readonly speed: OptionType<StringType>;
-            readonly cable: VariantType<{
-                readonly fibre: NullType;
-                readonly logical: NullType;
-            }>;
-            readonly system: StringType;
-        }>;
-        insert: StructType<{
-            readonly from: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly to: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly path: ArrayType<StructType<{
-                readonly x: FloatType;
-                readonly y: FloatType;
+            after: DictType<StringType, StructType<{
+                readonly from: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly to: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly path: ArrayType<StructType<{
+                    readonly x: FloatType;
+                    readonly y: FloatType;
+                }>>;
+                readonly label: OptionType<StringType>;
+                readonly speed: OptionType<StringType>;
+                readonly cable: VariantType<{
+                    readonly fibre: NullType;
+                    readonly logical: NullType;
+                }>;
+                readonly system: StringType;
             }>>;
-            readonly label: OptionType<StringType>;
-            readonly speed: OptionType<StringType>;
-            readonly cable: VariantType<{
-                readonly fibre: NullType;
-                readonly logical: NullType;
-            }>;
-            readonly system: StringType;
         }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly from: VariantType<{
-                        readonly rack: StringType;
-                        readonly frame: StringType;
-                    }>;
-                    readonly to: VariantType<{
-                        readonly rack: StringType;
-                        readonly frame: StringType;
-                    }>;
-                    readonly path: ArrayType<StructType<{
-                        readonly x: FloatType;
-                        readonly y: FloatType;
-                    }>>;
-                    readonly label: OptionType<StringType>;
-                    readonly speed: OptionType<StringType>;
-                    readonly cable: VariantType<{
-                        readonly fibre: NullType;
-                        readonly logical: NullType;
-                    }>;
-                    readonly system: StringType;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly from: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
                 }>;
-                after: StructType<{
-                    readonly from: VariantType<{
-                        readonly rack: StringType;
-                        readonly frame: StringType;
-                    }>;
-                    readonly to: VariantType<{
-                        readonly rack: StringType;
-                        readonly frame: StringType;
-                    }>;
-                    readonly path: ArrayType<StructType<{
-                        readonly x: FloatType;
-                        readonly y: FloatType;
-                    }>>;
-                    readonly label: OptionType<StringType>;
-                    readonly speed: OptionType<StringType>;
-                    readonly cable: VariantType<{
-                        readonly fibre: NullType;
-                        readonly logical: NullType;
-                    }>;
-                    readonly system: StringType;
+                readonly to: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly path: ArrayType<StructType<{
+                    readonly x: FloatType;
+                    readonly y: FloatType;
+                }>>;
+                readonly label: OptionType<StringType>;
+                readonly speed: OptionType<StringType>;
+                readonly cable: VariantType<{
+                    readonly fibre: NullType;
+                    readonly logical: NullType;
                 }>;
+                readonly system: StringType;
             }>;
-            patch: StructType<{
+            insert: StructType<{
                 readonly from: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly to: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly path: ArrayType<StructType<{
+                    readonly x: FloatType;
+                    readonly y: FloatType;
+                }>>;
+                readonly label: OptionType<StringType>;
+                readonly speed: OptionType<StringType>;
+                readonly cable: VariantType<{
+                    readonly fibre: NullType;
+                    readonly logical: NullType;
+                }>;
+                readonly system: StringType;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly from: VariantType<{
                             readonly rack: StringType;
                             readonly frame: StringType;
                         }>;
-                        after: VariantType<{
+                        readonly to: VariantType<{
                             readonly rack: StringType;
                             readonly frame: StringType;
                         }>;
-                    }>;
-                    patch: VariantType<{
-                        readonly rack: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
-                        }>;
-                        readonly frame: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
+                        readonly path: ArrayType<StructType<{
+                            readonly x: FloatType;
+                            readonly y: FloatType;
+                        }>>;
+                        readonly label: OptionType<StringType>;
+                        readonly speed: OptionType<StringType>;
+                        readonly cable: VariantType<{
+                            readonly fibre: NullType;
+                            readonly logical: NullType;
                         }>;
+                        readonly system: StringType;
                     }>;
-                }>;
-                readonly to: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: VariantType<{
+                    after: StructType<{
+                        readonly from: VariantType<{
                             readonly rack: StringType;
                             readonly frame: StringType;
                         }>;
-                        after: VariantType<{
+                        readonly to: VariantType<{
                             readonly rack: StringType;
                             readonly frame: StringType;
                         }>;
+                        readonly path: ArrayType<StructType<{
+                            readonly x: FloatType;
+                            readonly y: FloatType;
+                        }>>;
+                        readonly label: OptionType<StringType>;
+                        readonly speed: OptionType<StringType>;
+                        readonly cable: VariantType<{
+                            readonly fibre: NullType;
+                            readonly logical: NullType;
+                        }>;
+                        readonly system: StringType;
                     }>;
-                    patch: VariantType<{
-                        readonly rack: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
+                }>;
+                patch: StructType<{
+                    readonly from: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: VariantType<{
+                                readonly rack: StringType;
+                                readonly frame: StringType;
+                            }>;
+                            after: VariantType<{
+                                readonly rack: StringType;
+                                readonly frame: StringType;
                             }>;
                         }>;
-                        readonly frame: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
+                        patch: VariantType<{
+                            readonly rack: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                            readonly frame: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly path: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: ArrayType<StructType<{
-                            readonly x: FloatType;
-                            readonly y: FloatType;
-                        }>>;
-                        after: ArrayType<StructType<{
-                            readonly x: FloatType;
-                            readonly y: FloatType;
-                        }>>;
+                    readonly to: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: VariantType<{
+                                readonly rack: StringType;
+                                readonly frame: StringType;
+                            }>;
+                            after: VariantType<{
+                                readonly rack: StringType;
+                                readonly frame: StringType;
+                            }>;
+                        }>;
+                        patch: VariantType<{
+                            readonly rack: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                            readonly frame: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
                     }>;
-                    patch: ArrayType<StructType<{
-                        key: IntegerType;
-                        offset: IntegerType;
-                        operation: VariantType<{
-                            delete: StructType<{
+                    readonly path: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: ArrayType<StructType<{
                                 readonly x: FloatType;
                                 readonly y: FloatType;
-                            }>;
-                            insert: StructType<{
+                            }>>;
+                            after: ArrayType<StructType<{
                                 readonly x: FloatType;
                                 readonly y: FloatType;
-                            }>;
-                            update: VariantType<{
-                                unchanged: NullType;
-                                replace: StructType<{
-                                    before: StructType<{
-                                        readonly x: FloatType;
-                                        readonly y: FloatType;
-                                    }>;
-                                    after: StructType<{
-                                        readonly x: FloatType;
-                                        readonly y: FloatType;
-                                    }>;
+                            }>>;
+                        }>;
+                        patch: ArrayType<StructType<{
+                            key: IntegerType;
+                            offset: IntegerType;
+                            operation: VariantType<{
+                                delete: StructType<{
+                                    readonly x: FloatType;
+                                    readonly y: FloatType;
                                 }>;
-                                patch: StructType<{
-                                    readonly x: VariantType<{
-                                        unchanged: NullType;
-                                        replace: StructType<{
-                                            before: FloatType;
-                                            after: FloatType;
+                                insert: StructType<{
+                                    readonly x: FloatType;
+                                    readonly y: FloatType;
+                                }>;
+                                update: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: StructType<{
+                                            readonly x: FloatType;
+                                            readonly y: FloatType;
+                                        }>;
+                                        after: StructType<{
+                                            readonly x: FloatType;
+                                            readonly y: FloatType;
                                         }>;
                                     }>;
-                                    readonly y: VariantType<{
-                                        unchanged: NullType;
-                                        replace: StructType<{
-                                            before: FloatType;
-                                            after: FloatType;
+                                    patch: StructType<{
+                                        readonly x: VariantType<{
+                                            unchanged: NullType;
+                                            replace: StructType<{
+                                                before: FloatType;
+                                                after: FloatType;
+                                            }>;
+                                        }>;
+                                        readonly y: VariantType<{
+                                            unchanged: NullType;
+                                            replace: StructType<{
+                                                before: FloatType;
+                                                after: FloatType;
+                                            }>;
                                         }>;
                                     }>;
                                 }>;
                             }>;
+                        }>>;
+                    }>;
+                    readonly label: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<StringType>;
+                            after: OptionType<StringType>;
                         }>;
-                    }>>;
-                }>;
-                readonly label: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: OptionType<StringType>;
-                        after: OptionType<StringType>;
-                    }>;
-                    patch: VariantType<{
-                        none: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
                             }>;
-                        }>;
-                        some: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly speed: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: OptionType<StringType>;
-                        after: OptionType<StringType>;
-                    }>;
-                    patch: VariantType<{
-                        none: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                    readonly speed: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<StringType>;
+                            after: OptionType<StringType>;
                         }>;
-                        some: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly cable: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: VariantType<{
-                            readonly fibre: NullType;
-                            readonly logical: NullType;
-                        }>;
-                        after: VariantType<{
-                            readonly fibre: NullType;
-                            readonly logical: NullType;
-                        }>;
-                    }>;
-                    patch: VariantType<{
-                        readonly fibre: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                    readonly cable: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: VariantType<{
+                                readonly fibre: NullType;
+                                readonly logical: NullType;
+                            }>;
+                            after: VariantType<{
+                                readonly fibre: NullType;
+                                readonly logical: NullType;
                             }>;
                         }>;
-                        readonly logical: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                        patch: VariantType<{
+                            readonly fibre: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly logical: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly system: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly system: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
-/**
- * The fibre runs by system, for a floor whose rail narrows its runs through a source of their own: a run read complete
- * through its narrowing, a run a draft changed that a choice leaves out waiting in its session (#1391).
- */
-export declare const schematicFibreBySystem: import("@elaraai/e3").RecordIndexDef<"schematic_fibre_by_system", DictType<StringType, StructType<{
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
     readonly from: VariantType<{
         readonly rack: StringType;
         readonly frame: StringType;
@@ -1571,7 +1683,7 @@ export declare const schematicFibreBySystem: import("@elaraai/e3").RecordIndexDe
         readonly logical: NullType;
     }>;
     readonly system: StringType;
-}>>, StringType, NullType, readonly ["system"]>;
+}>>>>;
 /** The fibre runs of a floor whose cabling is frozen: the same runs, which no Save changes. */
 export declare const schematicFrozenFibre: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly from: VariantType<{
@@ -1593,9 +1705,7 @@ export declare const schematicFrozenFibre: import("@elaraai/e3").RecordDef<DictT
         readonly logical: NullType;
     }>;
     readonly system: StringType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_frozen_fibre">]>;
-/** The frozen floor's door, a checked one: it refuses every change, naming why — what a Save over it is answered. */
-export declare const schematicFrozenFibrePatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "schematic_frozen_fibre">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
     readonly from: VariantType<{
         readonly rack: StringType;
         readonly frame: StringType;
@@ -1615,569 +1725,622 @@ export declare const schematicFrozenFibrePatch: import("@elaraai/e3").MutationDe
         readonly logical: NullType;
     }>;
     readonly system: StringType;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly from: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly to: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly path: ArrayType<StructType<{
-                readonly x: FloatType;
-                readonly y: FloatType;
-            }>>;
-            readonly label: OptionType<StringType>;
-            readonly speed: OptionType<StringType>;
-            readonly cable: VariantType<{
-                readonly fibre: NullType;
-                readonly logical: NullType;
-            }>;
-            readonly system: StringType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly from: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly to: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly path: ArrayType<StructType<{
-                readonly x: FloatType;
-                readonly y: FloatType;
-            }>>;
-            readonly label: OptionType<StringType>;
-            readonly speed: OptionType<StringType>;
-            readonly cable: VariantType<{
-                readonly fibre: NullType;
-                readonly logical: NullType;
-            }>;
-            readonly system: StringType;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly from: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly to: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly path: ArrayType<StructType<{
-                readonly x: FloatType;
-                readonly y: FloatType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly from: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly to: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly path: ArrayType<StructType<{
+                    readonly x: FloatType;
+                    readonly y: FloatType;
+                }>>;
+                readonly label: OptionType<StringType>;
+                readonly speed: OptionType<StringType>;
+                readonly cable: VariantType<{
+                    readonly fibre: NullType;
+                    readonly logical: NullType;
+                }>;
+                readonly system: StringType;
             }>>;
-            readonly label: OptionType<StringType>;
-            readonly speed: OptionType<StringType>;
-            readonly cable: VariantType<{
-                readonly fibre: NullType;
-                readonly logical: NullType;
-            }>;
-            readonly system: StringType;
-        }>;
-        insert: StructType<{
-            readonly from: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly to: VariantType<{
-                readonly rack: StringType;
-                readonly frame: StringType;
-            }>;
-            readonly path: ArrayType<StructType<{
-                readonly x: FloatType;
-                readonly y: FloatType;
+            after: DictType<StringType, StructType<{
+                readonly from: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly to: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly path: ArrayType<StructType<{
+                    readonly x: FloatType;
+                    readonly y: FloatType;
+                }>>;
+                readonly label: OptionType<StringType>;
+                readonly speed: OptionType<StringType>;
+                readonly cable: VariantType<{
+                    readonly fibre: NullType;
+                    readonly logical: NullType;
+                }>;
+                readonly system: StringType;
             }>>;
-            readonly label: OptionType<StringType>;
-            readonly speed: OptionType<StringType>;
-            readonly cable: VariantType<{
-                readonly fibre: NullType;
-                readonly logical: NullType;
-            }>;
-            readonly system: StringType;
         }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly from: VariantType<{
-                        readonly rack: StringType;
-                        readonly frame: StringType;
-                    }>;
-                    readonly to: VariantType<{
-                        readonly rack: StringType;
-                        readonly frame: StringType;
-                    }>;
-                    readonly path: ArrayType<StructType<{
-                        readonly x: FloatType;
-                        readonly y: FloatType;
-                    }>>;
-                    readonly label: OptionType<StringType>;
-                    readonly speed: OptionType<StringType>;
-                    readonly cable: VariantType<{
-                        readonly fibre: NullType;
-                        readonly logical: NullType;
-                    }>;
-                    readonly system: StringType;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly from: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
                 }>;
-                after: StructType<{
-                    readonly from: VariantType<{
-                        readonly rack: StringType;
-                        readonly frame: StringType;
-                    }>;
-                    readonly to: VariantType<{
-                        readonly rack: StringType;
-                        readonly frame: StringType;
-                    }>;
-                    readonly path: ArrayType<StructType<{
-                        readonly x: FloatType;
-                        readonly y: FloatType;
-                    }>>;
-                    readonly label: OptionType<StringType>;
-                    readonly speed: OptionType<StringType>;
-                    readonly cable: VariantType<{
-                        readonly fibre: NullType;
-                        readonly logical: NullType;
-                    }>;
-                    readonly system: StringType;
+                readonly to: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly path: ArrayType<StructType<{
+                    readonly x: FloatType;
+                    readonly y: FloatType;
+                }>>;
+                readonly label: OptionType<StringType>;
+                readonly speed: OptionType<StringType>;
+                readonly cable: VariantType<{
+                    readonly fibre: NullType;
+                    readonly logical: NullType;
                 }>;
+                readonly system: StringType;
             }>;
-            patch: StructType<{
+            insert: StructType<{
                 readonly from: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly to: VariantType<{
+                    readonly rack: StringType;
+                    readonly frame: StringType;
+                }>;
+                readonly path: ArrayType<StructType<{
+                    readonly x: FloatType;
+                    readonly y: FloatType;
+                }>>;
+                readonly label: OptionType<StringType>;
+                readonly speed: OptionType<StringType>;
+                readonly cable: VariantType<{
+                    readonly fibre: NullType;
+                    readonly logical: NullType;
+                }>;
+                readonly system: StringType;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly from: VariantType<{
                             readonly rack: StringType;
                             readonly frame: StringType;
                         }>;
-                        after: VariantType<{
+                        readonly to: VariantType<{
                             readonly rack: StringType;
                             readonly frame: StringType;
                         }>;
-                    }>;
-                    patch: VariantType<{
-                        readonly rack: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
-                        }>;
-                        readonly frame: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
+                        readonly path: ArrayType<StructType<{
+                            readonly x: FloatType;
+                            readonly y: FloatType;
+                        }>>;
+                        readonly label: OptionType<StringType>;
+                        readonly speed: OptionType<StringType>;
+                        readonly cable: VariantType<{
+                            readonly fibre: NullType;
+                            readonly logical: NullType;
                         }>;
+                        readonly system: StringType;
                     }>;
-                }>;
-                readonly to: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: VariantType<{
+                    after: StructType<{
+                        readonly from: VariantType<{
                             readonly rack: StringType;
                             readonly frame: StringType;
                         }>;
-                        after: VariantType<{
+                        readonly to: VariantType<{
                             readonly rack: StringType;
                             readonly frame: StringType;
                         }>;
+                        readonly path: ArrayType<StructType<{
+                            readonly x: FloatType;
+                            readonly y: FloatType;
+                        }>>;
+                        readonly label: OptionType<StringType>;
+                        readonly speed: OptionType<StringType>;
+                        readonly cable: VariantType<{
+                            readonly fibre: NullType;
+                            readonly logical: NullType;
+                        }>;
+                        readonly system: StringType;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly from: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: VariantType<{
+                                readonly rack: StringType;
+                                readonly frame: StringType;
+                            }>;
+                            after: VariantType<{
+                                readonly rack: StringType;
+                                readonly frame: StringType;
+                            }>;
+                        }>;
+                        patch: VariantType<{
+                            readonly rack: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                            readonly frame: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                        }>;
                     }>;
-                    patch: VariantType<{
-                        readonly rack: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
+                    readonly to: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: VariantType<{
+                                readonly rack: StringType;
+                                readonly frame: StringType;
+                            }>;
+                            after: VariantType<{
+                                readonly rack: StringType;
+                                readonly frame: StringType;
                             }>;
                         }>;
-                        readonly frame: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
+                        patch: VariantType<{
+                            readonly rack: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
+                            }>;
+                            readonly frame: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly path: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: ArrayType<StructType<{
-                            readonly x: FloatType;
-                            readonly y: FloatType;
-                        }>>;
-                        after: ArrayType<StructType<{
-                            readonly x: FloatType;
-                            readonly y: FloatType;
-                        }>>;
-                    }>;
-                    patch: ArrayType<StructType<{
-                        key: IntegerType;
-                        offset: IntegerType;
-                        operation: VariantType<{
-                            delete: StructType<{
+                    readonly path: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: ArrayType<StructType<{
                                 readonly x: FloatType;
                                 readonly y: FloatType;
-                            }>;
-                            insert: StructType<{
+                            }>>;
+                            after: ArrayType<StructType<{
                                 readonly x: FloatType;
                                 readonly y: FloatType;
-                            }>;
-                            update: VariantType<{
-                                unchanged: NullType;
-                                replace: StructType<{
-                                    before: StructType<{
-                                        readonly x: FloatType;
-                                        readonly y: FloatType;
-                                    }>;
-                                    after: StructType<{
-                                        readonly x: FloatType;
-                                        readonly y: FloatType;
-                                    }>;
+                            }>>;
+                        }>;
+                        patch: ArrayType<StructType<{
+                            key: IntegerType;
+                            offset: IntegerType;
+                            operation: VariantType<{
+                                delete: StructType<{
+                                    readonly x: FloatType;
+                                    readonly y: FloatType;
                                 }>;
-                                patch: StructType<{
-                                    readonly x: VariantType<{
-                                        unchanged: NullType;
-                                        replace: StructType<{
-                                            before: FloatType;
-                                            after: FloatType;
+                                insert: StructType<{
+                                    readonly x: FloatType;
+                                    readonly y: FloatType;
+                                }>;
+                                update: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: StructType<{
+                                            readonly x: FloatType;
+                                            readonly y: FloatType;
+                                        }>;
+                                        after: StructType<{
+                                            readonly x: FloatType;
+                                            readonly y: FloatType;
                                         }>;
                                     }>;
-                                    readonly y: VariantType<{
-                                        unchanged: NullType;
-                                        replace: StructType<{
-                                            before: FloatType;
-                                            after: FloatType;
+                                    patch: StructType<{
+                                        readonly x: VariantType<{
+                                            unchanged: NullType;
+                                            replace: StructType<{
+                                                before: FloatType;
+                                                after: FloatType;
+                                            }>;
+                                        }>;
+                                        readonly y: VariantType<{
+                                            unchanged: NullType;
+                                            replace: StructType<{
+                                                before: FloatType;
+                                                after: FloatType;
+                                            }>;
                                         }>;
                                     }>;
                                 }>;
                             }>;
+                        }>>;
+                    }>;
+                    readonly label: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<StringType>;
+                            after: OptionType<StringType>;
                         }>;
-                    }>>;
-                }>;
-                readonly label: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: OptionType<StringType>;
-                        after: OptionType<StringType>;
-                    }>;
-                    patch: VariantType<{
-                        none: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
                             }>;
-                        }>;
-                        some: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly speed: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: OptionType<StringType>;
-                        after: OptionType<StringType>;
-                    }>;
-                    patch: VariantType<{
-                        none: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
+                    readonly speed: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<StringType>;
+                            after: OptionType<StringType>;
                         }>;
-                        some: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
+                        patch: VariantType<{
+                            none: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            some: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: StringType;
+                                    after: StringType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly cable: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: VariantType<{
-                            readonly fibre: NullType;
-                            readonly logical: NullType;
-                        }>;
-                        after: VariantType<{
-                            readonly fibre: NullType;
-                            readonly logical: NullType;
-                        }>;
-                    }>;
-                    patch: VariantType<{
-                        readonly fibre: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                    readonly cable: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: VariantType<{
+                                readonly fibre: NullType;
+                                readonly logical: NullType;
+                            }>;
+                            after: VariantType<{
+                                readonly fibre: NullType;
+                                readonly logical: NullType;
                             }>;
                         }>;
-                        readonly logical: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
+                        patch: VariantType<{
+                            readonly fibre: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
+                            }>;
+                            readonly logical: VariantType<{
+                                unchanged: NullType;
+                                replace: StructType<{
+                                    before: NullType;
+                                    after: NullType;
+                                }>;
                             }>;
                         }>;
                     }>;
-                }>;
-                readonly system: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly system: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly from: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly to: VariantType<{
+        readonly rack: StringType;
+        readonly frame: StringType;
+    }>;
+    readonly path: ArrayType<StructType<{
+        readonly x: FloatType;
+        readonly y: FloatType;
     }>>;
-}>]>;
+    readonly label: OptionType<StringType>;
+    readonly speed: OptionType<StringType>;
+    readonly cable: VariantType<{
+        readonly fibre: NullType;
+        readonly logical: NullType;
+    }>;
+    readonly system: StringType;
+}>>>>;
 export declare const schematicFeeds: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly supply: ArrayType<StringType>;
     readonly racks: ArrayType<StringType>;
     readonly label: StringType;
     readonly load: StringType;
     readonly system: StringType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_feeds">]>;
-export declare const schematicFeedsPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "schematic_feeds">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
     readonly supply: ArrayType<StringType>;
     readonly racks: ArrayType<StringType>;
     readonly label: StringType;
     readonly load: StringType;
     readonly system: StringType;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly supply: ArrayType<StringType>;
-            readonly racks: ArrayType<StringType>;
-            readonly label: StringType;
-            readonly load: StringType;
-            readonly system: StringType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly supply: ArrayType<StringType>;
-            readonly racks: ArrayType<StringType>;
-            readonly label: StringType;
-            readonly load: StringType;
-            readonly system: StringType;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly supply: ArrayType<StringType>;
-            readonly racks: ArrayType<StringType>;
-            readonly label: StringType;
-            readonly load: StringType;
-            readonly system: StringType;
-        }>;
-        insert: StructType<{
-            readonly supply: ArrayType<StringType>;
-            readonly racks: ArrayType<StringType>;
-            readonly label: StringType;
-            readonly load: StringType;
-            readonly system: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly supply: ArrayType<StringType>;
+                readonly racks: ArrayType<StringType>;
+                readonly label: StringType;
+                readonly load: StringType;
+                readonly system: StringType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly supply: ArrayType<StringType>;
+                readonly racks: ArrayType<StringType>;
+                readonly label: StringType;
+                readonly load: StringType;
+                readonly system: StringType;
+            }>>;
         }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly supply: ArrayType<StringType>;
-                    readonly racks: ArrayType<StringType>;
-                    readonly label: StringType;
-                    readonly load: StringType;
-                    readonly system: StringType;
-                }>;
-                after: StructType<{
-                    readonly supply: ArrayType<StringType>;
-                    readonly racks: ArrayType<StringType>;
-                    readonly label: StringType;
-                    readonly load: StringType;
-                    readonly system: StringType;
-                }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly supply: ArrayType<StringType>;
+                readonly racks: ArrayType<StringType>;
+                readonly label: StringType;
+                readonly load: StringType;
+                readonly system: StringType;
             }>;
-            patch: StructType<{
-                readonly supply: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: ArrayType<StringType>;
-                        after: ArrayType<StringType>;
-                    }>;
-                    patch: ArrayType<StructType<{
-                        key: IntegerType;
-                        offset: IntegerType;
-                        operation: VariantType<{
-                            delete: StringType;
-                            insert: StringType;
-                            update: VariantType<{
-                                unchanged: NullType;
-                                replace: StructType<{
-                                    before: StringType;
-                                    after: StringType;
+            insert: StructType<{
+                readonly supply: ArrayType<StringType>;
+                readonly racks: ArrayType<StringType>;
+                readonly label: StringType;
+                readonly load: StringType;
+                readonly system: StringType;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly supply: ArrayType<StringType>;
+                        readonly racks: ArrayType<StringType>;
+                        readonly label: StringType;
+                        readonly load: StringType;
+                        readonly system: StringType;
+                    }>;
+                    after: StructType<{
+                        readonly supply: ArrayType<StringType>;
+                        readonly racks: ArrayType<StringType>;
+                        readonly label: StringType;
+                        readonly load: StringType;
+                        readonly system: StringType;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly supply: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: ArrayType<StringType>;
+                            after: ArrayType<StringType>;
+                        }>;
+                        patch: ArrayType<StructType<{
+                            key: IntegerType;
+                            offset: IntegerType;
+                            operation: VariantType<{
+                                delete: StringType;
+                                insert: StringType;
+                                update: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: StringType;
+                                        after: StringType;
+                                    }>;
                                 }>;
                             }>;
+                        }>>;
+                    }>;
+                    readonly racks: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: ArrayType<StringType>;
+                            after: ArrayType<StringType>;
                         }>;
-                    }>>;
-                }>;
-                readonly racks: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: ArrayType<StringType>;
-                        after: ArrayType<StringType>;
-                    }>;
-                    patch: ArrayType<StructType<{
-                        key: IntegerType;
-                        offset: IntegerType;
-                        operation: VariantType<{
-                            delete: StringType;
-                            insert: StringType;
-                            update: VariantType<{
-                                unchanged: NullType;
-                                replace: StructType<{
-                                    before: StringType;
-                                    after: StringType;
+                        patch: ArrayType<StructType<{
+                            key: IntegerType;
+                            offset: IntegerType;
+                            operation: VariantType<{
+                                delete: StringType;
+                                insert: StringType;
+                                update: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: StringType;
+                                        after: StringType;
+                                    }>;
                                 }>;
                             }>;
+                        }>>;
+                    }>;
+                    readonly label: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
                         }>;
-                    }>>;
-                }>;
-                readonly label: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
                     }>;
-                }>;
-                readonly load: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly load: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
-                }>;
-                readonly system: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly system: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly supply: ArrayType<StringType>;
+    readonly racks: ArrayType<StringType>;
+    readonly label: StringType;
+    readonly load: StringType;
+    readonly system: StringType;
+}>>>>;
 /** The floor's fibre trunks: none yet — a Shift-connect from racks to a frame gathers their runs into one. */
 export declare const schematicTrunks: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly racks: ArrayType<StringType>;
     readonly frames: ArrayType<StringType>;
     readonly label: OptionType<StringType>;
     readonly system: StringType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_trunks">]>;
-export declare const schematicTrunksPatch: import("@elaraai/e3").MutationDef<"patch", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "schematic_trunks">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
     readonly racks: ArrayType<StringType>;
     readonly frames: ArrayType<StringType>;
     readonly label: OptionType<StringType>;
     readonly system: StringType;
-}>>, [VariantType<{
-    unchanged: NullType;
-    replace: StructType<{
-        before: DictType<StringType, StructType<{
-            readonly racks: ArrayType<StringType>;
-            readonly frames: ArrayType<StringType>;
-            readonly label: OptionType<StringType>;
-            readonly system: StringType;
-        }>>;
-        after: DictType<StringType, StructType<{
-            readonly racks: ArrayType<StringType>;
-            readonly frames: ArrayType<StringType>;
-            readonly label: OptionType<StringType>;
-            readonly system: StringType;
-        }>>;
-    }>;
-    patch: DictType<StringType, VariantType<{
-        delete: StructType<{
-            readonly racks: ArrayType<StringType>;
-            readonly frames: ArrayType<StringType>;
-            readonly label: OptionType<StringType>;
-            readonly system: StringType;
-        }>;
-        insert: StructType<{
-            readonly racks: ArrayType<StringType>;
-            readonly frames: ArrayType<StringType>;
-            readonly label: OptionType<StringType>;
-            readonly system: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly racks: ArrayType<StringType>;
+                readonly frames: ArrayType<StringType>;
+                readonly label: OptionType<StringType>;
+                readonly system: StringType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly racks: ArrayType<StringType>;
+                readonly frames: ArrayType<StringType>;
+                readonly label: OptionType<StringType>;
+                readonly system: StringType;
+            }>>;
         }>;
-        update: VariantType<{
-            unchanged: NullType;
-            replace: StructType<{
-                before: StructType<{
-                    readonly racks: ArrayType<StringType>;
-                    readonly frames: ArrayType<StringType>;
-                    readonly label: OptionType<StringType>;
-                    readonly system: StringType;
-                }>;
-                after: StructType<{
-                    readonly racks: ArrayType<StringType>;
-                    readonly frames: ArrayType<StringType>;
-                    readonly label: OptionType<StringType>;
-                    readonly system: StringType;
-                }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly racks: ArrayType<StringType>;
+                readonly frames: ArrayType<StringType>;
+                readonly label: OptionType<StringType>;
+                readonly system: StringType;
             }>;
-            patch: StructType<{
-                readonly racks: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: ArrayType<StringType>;
-                        after: ArrayType<StringType>;
-                    }>;
-                    patch: ArrayType<StructType<{
-                        key: IntegerType;
-                        offset: IntegerType;
-                        operation: VariantType<{
-                            delete: StringType;
-                            insert: StringType;
-                            update: VariantType<{
+            insert: StructType<{
+                readonly racks: ArrayType<StringType>;
+                readonly frames: ArrayType<StringType>;
+                readonly label: OptionType<StringType>;
+                readonly system: StringType;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly racks: ArrayType<StringType>;
+                        readonly frames: ArrayType<StringType>;
+                        readonly label: OptionType<StringType>;
+                        readonly system: StringType;
+                    }>;
+                    after: StructType<{
+                        readonly racks: ArrayType<StringType>;
+                        readonly frames: ArrayType<StringType>;
+                        readonly label: OptionType<StringType>;
+                        readonly system: StringType;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly racks: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: ArrayType<StringType>;
+                            after: ArrayType<StringType>;
+                        }>;
+                        patch: ArrayType<StructType<{
+                            key: IntegerType;
+                            offset: IntegerType;
+                            operation: VariantType<{
+                                delete: StringType;
+                                insert: StringType;
+                                update: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: StringType;
+                                        after: StringType;
+                                    }>;
+                                }>;
+                            }>;
+                        }>>;
+                    }>;
+                    readonly frames: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: ArrayType<StringType>;
+                            after: ArrayType<StringType>;
+                        }>;
+                        patch: ArrayType<StructType<{
+                            key: IntegerType;
+                            offset: IntegerType;
+                            operation: VariantType<{
+                                delete: StringType;
+                                insert: StringType;
+                                update: VariantType<{
+                                    unchanged: NullType;
+                                    replace: StructType<{
+                                        before: StringType;
+                                        after: StringType;
+                                    }>;
+                                }>;
+                            }>;
+                        }>>;
+                    }>;
+                    readonly label: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: OptionType<StringType>;
+                            after: OptionType<StringType>;
+                        }>;
+                        patch: VariantType<{
+                            none: VariantType<{
                                 unchanged: NullType;
                                 replace: StructType<{
-                                    before: StringType;
-                                    after: StringType;
+                                    before: NullType;
+                                    after: NullType;
                                 }>;
                             }>;
-                        }>;
-                    }>>;
-                }>;
-                readonly frames: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: ArrayType<StringType>;
-                        after: ArrayType<StringType>;
-                    }>;
-                    patch: ArrayType<StructType<{
-                        key: IntegerType;
-                        offset: IntegerType;
-                        operation: VariantType<{
-                            delete: StringType;
-                            insert: StringType;
-                            update: VariantType<{
+                            some: VariantType<{
                                 unchanged: NullType;
                                 replace: StructType<{
                                     before: StringType;
@@ -2185,42 +2348,24 @@ export declare const schematicTrunksPatch: import("@elaraai/e3").MutationDef<"pa
                                 }>;
                             }>;
                         }>;
-                    }>>;
-                }>;
-                readonly label: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: OptionType<StringType>;
-                        after: OptionType<StringType>;
-                    }>;
-                    patch: VariantType<{
-                        none: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: NullType;
-                                after: NullType;
-                            }>;
-                        }>;
-                        some: VariantType<{
-                            unchanged: NullType;
-                            replace: StructType<{
-                                before: StringType;
-                                after: StringType;
-                            }>;
-                        }>;
                     }>;
-                }>;
-                readonly system: VariantType<{
-                    unchanged: NullType;
-                    replace: StructType<{
-                        before: StringType;
-                        after: StringType;
+                    readonly system: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
                     }>;
                 }>;
             }>;
-        }>;
-    }>>;
-}>]>;
+        }>>;
+    }>]>;
+}, DictType<StringType, StructType<{
+    readonly racks: ArrayType<StringType>;
+    readonly frames: ArrayType<StringType>;
+    readonly label: OptionType<StringType>;
+    readonly system: StringType;
+}>>>>;
 export declare const schematicRackTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly group: StringType;
@@ -2233,8 +2378,21 @@ export declare const schematicRackTemplates: import("@elaraai/e3").RecordDef<Dic
         readonly system: StringType;
         readonly owner: StringType;
     }>;
-}>>, [variant<"field", "records">, variant<"field", "schematic_rack_templates">]>;
-export declare const schematicRackTemplatesByGroup: import("@elaraai/e3").RecordIndexDef<"schematic_rack_templates_by_group", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "schematic_rack_templates">], import("@elaraai/e3").IndexesOf<{
+    schematic_rack_templates_by_group: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["group"], unknown>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly group: StringType;
+    readonly values: StructType<{
+        readonly name: StringType;
+        readonly w: FloatType;
+        readonly h: FloatType;
+        readonly model: StringType;
+        readonly hall: StringType;
+        readonly system: StringType;
+        readonly owner: StringType;
+    }>;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
     readonly name: StringType;
     readonly group: StringType;
     readonly values: StructType<{
@@ -2246,7 +2404,7 @@ export declare const schematicRackTemplatesByGroup: import("@elaraai/e3").Record
         readonly system: StringType;
         readonly owner: StringType;
     }>;
-}>>, StringType, NullType, readonly ["group"]>;
+}>>>>;
 export declare const schematicFibreTemplates: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly system: StringType;
@@ -2263,8 +2421,25 @@ export declare const schematicFibreTemplates: import("@elaraai/e3").RecordDef<Di
         }>;
         readonly system: StringType;
     }>;
-}>>, [variant<"field", "records">, variant<"field", "schematic_fibre_templates">]>;
-export declare const schematicFibreTemplatesBySystem: import("@elaraai/e3").RecordIndexDef<"schematic_fibre_templates_by_system", DictType<StringType, StructType<{
+}>>, [variant<"field", "records">, variant<"field", "schematic_fibre_templates">], import("@elaraai/e3").IndexesOf<{
+    schematic_fibre_templates_by_system: import("@elaraai/e3").IndexDraft<StringType, NullType, readonly ["system"], unknown>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly system: StringType;
+    readonly values: StructType<{
+        readonly path: ArrayType<StructType<{
+            readonly x: FloatType;
+            readonly y: FloatType;
+        }>>;
+        readonly label: OptionType<StringType>;
+        readonly speed: OptionType<StringType>;
+        readonly cable: VariantType<{
+            readonly fibre: NullType;
+            readonly logical: NullType;
+        }>;
+        readonly system: StringType;
+    }>;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
     readonly name: StringType;
     readonly system: StringType;
     readonly values: StructType<{
@@ -2280,10 +2455,186 @@ export declare const schematicFibreTemplatesBySystem: import("@elaraai/e3").Reco
         }>;
         readonly system: StringType;
     }>;
-}>>, StringType, NullType, readonly ["system"]>;
+}>>>>;
 export declare const schematicOwners: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
     readonly name: StringType;
     readonly contact: StringType;
-}>>, [variant<"field", "records">, variant<"field", "schematic_owners">]>;
+}>>, [variant<"field", "records">, variant<"field", "schematic_owners">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly contact: StringType;
+}>>>, import("@elaraai/e3").MutationsOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly contact: StringType;
+}>>>>;
 export declare const schematicDataCentre: import("@elaraai/east").ExampleDef<[], any>;
+/** The racks the conflicts example edits, in a record of their own, so no other example's edits meet them. */
+export declare const schematicConflictRacks: import("@elaraai/e3").RecordDef<DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+}>>, [variant<"field", "records">, variant<"field", "schematic_conflict_racks">], import("@elaraai/e3").IndexesOf<Record<never, never>, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+}>>>, import("@elaraai/e3").MutationsOf<{
+    patch: import("@elaraai/e3").MutationDraft<[VariantType<{
+        unchanged: NullType;
+        replace: StructType<{
+            before: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly model: StringType;
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+            }>>;
+            after: DictType<StringType, StructType<{
+                readonly name: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly model: StringType;
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+            }>>;
+        }>;
+        patch: DictType<StringType, VariantType<{
+            delete: StructType<{
+                readonly name: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly model: StringType;
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+            }>;
+            insert: StructType<{
+                readonly name: StringType;
+                readonly x: FloatType;
+                readonly y: FloatType;
+                readonly w: FloatType;
+                readonly h: FloatType;
+                readonly model: StringType;
+                readonly kw: FloatType;
+                readonly capacity: FloatType;
+            }>;
+            update: VariantType<{
+                unchanged: NullType;
+                replace: StructType<{
+                    before: StructType<{
+                        readonly name: StringType;
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
+                        readonly model: StringType;
+                        readonly kw: FloatType;
+                        readonly capacity: FloatType;
+                    }>;
+                    after: StructType<{
+                        readonly name: StringType;
+                        readonly x: FloatType;
+                        readonly y: FloatType;
+                        readonly w: FloatType;
+                        readonly h: FloatType;
+                        readonly model: StringType;
+                        readonly kw: FloatType;
+                        readonly capacity: FloatType;
+                    }>;
+                }>;
+                patch: StructType<{
+                    readonly name: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly x: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly y: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly w: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly h: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly model: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: StringType;
+                            after: StringType;
+                        }>;
+                    }>;
+                    readonly kw: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                    readonly capacity: VariantType<{
+                        unchanged: NullType;
+                        replace: StructType<{
+                            before: FloatType;
+                            after: FloatType;
+                        }>;
+                    }>;
+                }>;
+            }>;
+        }>>;
+    }>]>;
+    elsewhere: import("@elaraai/e3").MutationDraft<[]>;
+}, DictType<StringType, StructType<{
+    readonly name: StringType;
+    readonly x: FloatType;
+    readonly y: FloatType;
+    readonly w: FloatType;
+    readonly h: FloatType;
+    readonly model: StringType;
+    readonly kw: FloatType;
+    readonly capacity: FloatType;
+}>>>>;
+/**
+ * Your edits meeting someone else's save, in one window: edit, then press
+ * Someone else saves, which saves another person's change to the same racks —
+ * every rack half a metre to the right. A rack you moved sideways too is a
+ * conflict, waiting for you to choose; a rack you moved only up or down, or
+ * whose fields you changed in the panel, combines with theirs. Each press
+ * saves their change again.
+ */
+export declare const schematicConflicts: import("@elaraai/east").ExampleDef<[], any>;
 //# sourceMappingURL=schematic.examples.d.ts.map