@elaraai/e3-ui 1.0.102 → 1.0.103

package/dist/src/schematic/types.d.ts

@@ -1358,76 +1358,6 @@ export type SchematicTemplateType = typeof SchematicTemplateType;
  * @property roles - Which of the kind's cards' roles they give: what a card keeps the place of, a placeholder, while its details row is read (#1398)
  */
 export declare const SchematicKindDetailsType: StructType<{
-    readonly rows: OptionType<FunctionType<[], OptionType<DictType<StringType, StructType<{
-        readonly roles: StructType<{
-            readonly status: OptionType<StructType<{
-                readonly label: StringType;
-                readonly tone: VariantType<{
-                    readonly success: NullType;
-                    readonly warning: NullType;
-                    readonly danger: NullType;
-                    readonly info: NullType;
-                    readonly neutral: NullType;
-                }>;
-                readonly ring: BooleanType;
-            }>>;
-            readonly meter: OptionType<StructType<{
-                readonly value: FloatType;
-                readonly max: FloatType;
-            }>>;
-            readonly metric: OptionType<StringType>;
-            readonly sublabel: OptionType<StringType>;
-        }>;
-        readonly row: BlobType;
-    }>>>>>;
-    readonly rowsOf: FunctionType<[BlobType], DictType<StringType, StructType<{
-        readonly roles: StructType<{
-            readonly status: OptionType<StructType<{
-                readonly label: StringType;
-                readonly tone: VariantType<{
-                    readonly success: NullType;
-                    readonly warning: NullType;
-                    readonly danger: NullType;
-                    readonly info: NullType;
-                    readonly neutral: NullType;
-                }>;
-                readonly ring: BooleanType;
-            }>>;
-            readonly meter: OptionType<StructType<{
-                readonly value: FloatType;
-                readonly max: FloatType;
-            }>>;
-            readonly metric: OptionType<StringType>;
-            readonly sublabel: OptionType<StringType>;
-        }>;
-        readonly row: BlobType;
-    }>>>;
-    readonly paged: OptionType<StringType>;
-    readonly read: FunctionType<[BlobType, StringType], StructType<{
-        readonly status: OptionType<StructType<{
-            readonly label: StringType;
-            readonly tone: VariantType<{
-                readonly success: NullType;
-                readonly warning: NullType;
-                readonly danger: NullType;
-                readonly info: NullType;
-                readonly neutral: NullType;
-            }>;
-            readonly ring: BooleanType;
-        }>>;
-        readonly meter: OptionType<StructType<{
-            readonly value: FloatType;
-            readonly max: FloatType;
-        }>>;
-        readonly metric: OptionType<StringType>;
-        readonly sublabel: OptionType<StringType>;
-    }>>;
-    readonly roles: StructType<{
-        readonly status: BooleanType;
-        readonly meter: BooleanType;
-        readonly metric: BooleanType;
-        readonly sublabel: BooleanType;
-    }>;
     readonly editable: BooleanType;
     readonly editing: OptionType<StructType<{
         sourceId: StringType;
@@ -1762,96 +1692,8 @@ export declare const SchematicKindDetailsType: StructType<{
         readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
         readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
     }>>;
-}>;
-/** Type representing a kind's details. */
-export type SchematicKindDetailsType = typeof SchematicKindDetailsType;
-/**
- * One item kind, closed (§4.1, §4.8).
- *
- * @property backlog - Whether its `x` and `y` are Options: its rows with no position are its backlog
- * @property status - How each case of its status shows
- * @property rows - Its stored items a read holds, by key, each its roles and its row: its record read whole, or its narrowing read complete through its source
- * @property rowsOf - Its rows a reader read by area, or by key, as bytes, made its stored items: a window's (#1393)
- * @property paged - The `id` of the paged read its rows are read by key through, for a kind read through its source: what
- *   a reader asks the far ends of the links and nets touching its window of, all of a window's in one request (#1393);
- *   `none` for a kind read whole
- * @property box - The fields its box is, at its centre: what an area index it is read by names (§11.4)
- * @property read - A drafted row's roles, from its bytes and its key
- * @property write - The row with its position written — `none`, unplaced — and every other field as it was; `none` where it can't be: no position for a kind with no backlog
- * @property create - A new row at a position, every other field from a template's values or its type's default; `none` as `write` refuses
- * @property templates - Its templates
- * @property templatesSource - The slice's source its templates list names
- */
-export declare const SchematicItemKindType: StructType<{
-    readonly backlog: BooleanType;
-    readonly status: ArrayType<StructType<{
-        readonly case: StringType;
-        readonly status: StructType<{
-            readonly label: StringType;
-            readonly tone: VariantType<{
-                readonly success: NullType;
-                readonly warning: NullType;
-                readonly danger: NullType;
-                readonly info: NullType;
-                readonly neutral: NullType;
-            }>;
-            readonly ring: BooleanType;
-        }>;
-    }>>;
-    readonly rows: FunctionType<[], OptionType<DictType<StringType, StructType<{
+    readonly rows: OptionType<FunctionType<[], OptionType<DictType<StringType, StructType<{
         readonly roles: StructType<{
-            readonly position: OptionType<StructType<{
-                /** World x */
-                readonly x: FloatType;
-                /** World y */
-                readonly y: FloatType;
-            }>>;
-            readonly label: StringType;
-            readonly width: OptionType<FloatType>;
-            readonly height: OptionType<FloatType>;
-            readonly footprint: OptionType<VariantType<{
-                /** The entity's box itself. */
-                readonly rect: NullType;
-                /** A circle centred on the anchor; `radius` in world units. */
-                readonly circle: StructType<{
-                    /** Circle radius in world units. */
-                    readonly radius: FloatType;
-                }>;
-                /** An open, arc-aware polyline about the anchor; optional band width. */
-                readonly polyline: StructType<{
-                    /** Vertices, offsets from the anchor, in order (each carries a DXF bulge). */
-                    readonly vertices: ArrayType<StructType<{
-                        /** Offset from the anchor along x, in world units */
-                        readonly x: FloatType;
-                        /** Offset from the anchor along y, in world units */
-                        readonly y: FloatType;
-                        /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`) */
-                        readonly bulge: FloatType;
-                    }>>;
-                    /** Optional band width in world units — the stroke widens into a duct bank / aisle. */
-                    readonly width: OptionType<FloatType>;
-                }>;
-                /** A closed, arc-aware polygon about the anchor (>= 3 vertices, auto-closed). */
-                readonly polygon: StructType<{
-                    /** Boundary vertices, offsets from the anchor, in order (each carries a DXF bulge). */
-                    readonly vertices: ArrayType<StructType<{
-                        /** Offset from the anchor along x, in world units */
-                        readonly x: FloatType;
-                        /** Offset from the anchor along y, in world units */
-                        readonly y: FloatType;
-                        /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`) */
-                        readonly bulge: FloatType;
-                    }>>;
-                }>;
-            }>>;
-            readonly layer: OptionType<StringType>;
-            readonly icon: OptionType<StringType>;
-            readonly sublabel: OptionType<StringType>;
-            readonly metric: OptionType<StringType>;
-            readonly meter: OptionType<StructType<{
-                readonly value: FloatType;
-                readonly max: FloatType;
-            }>>;
             readonly status: OptionType<StructType<{
                 readonly label: StringType;
                 readonly tone: VariantType<{
@@ -1863,80 +1705,17 @@ export declare const SchematicItemKindType: StructType<{
                 }>;
                 readonly ring: BooleanType;
             }>>;
-            readonly tone: OptionType<VariantType<{
-                /** Brand teal */
-                readonly brand: NullType;
-                /** Foreground ink */
-                readonly ink: NullType;
-                /** Muted foreground */
-                readonly muted: NullType;
-                /** Status ok */
-                readonly success: NullType;
-                /** Status warn */
-                readonly warning: NullType;
-                /** Status bad */
-                readonly danger: NullType;
+            readonly meter: OptionType<StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
             }>>;
-            readonly color: OptionType<StringType>;
-            readonly weight: OptionType<FloatType>;
-            readonly fillOpacity: OptionType<FloatType>;
+            readonly metric: OptionType<StringType>;
+            readonly sublabel: OptionType<StringType>;
         }>;
         readonly row: BlobType;
-    }>>>>;
+    }>>>>>;
     readonly rowsOf: FunctionType<[BlobType], DictType<StringType, StructType<{
         readonly roles: StructType<{
-            readonly position: OptionType<StructType<{
-                /** World x */
-                readonly x: FloatType;
-                /** World y */
-                readonly y: FloatType;
-            }>>;
-            readonly label: StringType;
-            readonly width: OptionType<FloatType>;
-            readonly height: OptionType<FloatType>;
-            readonly footprint: OptionType<VariantType<{
-                /** The entity's box itself. */
-                readonly rect: NullType;
-                /** A circle centred on the anchor; `radius` in world units. */
-                readonly circle: StructType<{
-                    /** Circle radius in world units. */
-                    readonly radius: FloatType;
-                }>;
-                /** An open, arc-aware polyline about the anchor; optional band width. */
-                readonly polyline: StructType<{
-                    /** Vertices, offsets from the anchor, in order (each carries a DXF bulge). */
-                    readonly vertices: ArrayType<StructType<{
-                        /** Offset from the anchor along x, in world units */
-                        readonly x: FloatType;
-                        /** Offset from the anchor along y, in world units */
-                        readonly y: FloatType;
-                        /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`) */
-                        readonly bulge: FloatType;
-                    }>>;
-                    /** Optional band width in world units — the stroke widens into a duct bank / aisle. */
-                    readonly width: OptionType<FloatType>;
-                }>;
-                /** A closed, arc-aware polygon about the anchor (>= 3 vertices, auto-closed). */
-                readonly polygon: StructType<{
-                    /** Boundary vertices, offsets from the anchor, in order (each carries a DXF bulge). */
-                    readonly vertices: ArrayType<StructType<{
-                        /** Offset from the anchor along x, in world units */
-                        readonly x: FloatType;
-                        /** Offset from the anchor along y, in world units */
-                        readonly y: FloatType;
-                        /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`) */
-                        readonly bulge: FloatType;
-                    }>>;
-                }>;
-            }>>;
-            readonly layer: OptionType<StringType>;
-            readonly icon: OptionType<StringType>;
-            readonly sublabel: OptionType<StringType>;
-            readonly metric: OptionType<StringType>;
-            readonly meter: OptionType<StructType<{
-                readonly value: FloatType;
-                readonly max: FloatType;
-            }>>;
             readonly status: OptionType<StructType<{
                 readonly label: StringType;
                 readonly tone: VariantType<{
@@ -1948,86 +1727,17 @@ export declare const SchematicItemKindType: StructType<{
                 }>;
                 readonly ring: BooleanType;
             }>>;
-            readonly tone: OptionType<VariantType<{
-                /** Brand teal */
-                readonly brand: NullType;
-                /** Foreground ink */
-                readonly ink: NullType;
-                /** Muted foreground */
-                readonly muted: NullType;
-                /** Status ok */
-                readonly success: NullType;
-                /** Status warn */
-                readonly warning: NullType;
-                /** Status bad */
-                readonly danger: NullType;
+            readonly meter: OptionType<StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
             }>>;
-            readonly color: OptionType<StringType>;
-            readonly weight: OptionType<FloatType>;
-            readonly fillOpacity: OptionType<FloatType>;
+            readonly metric: OptionType<StringType>;
+            readonly sublabel: OptionType<StringType>;
         }>;
         readonly row: BlobType;
     }>>>;
     readonly paged: OptionType<StringType>;
-    readonly box: StructType<{
-        readonly x: StringType;
-        readonly y: StringType;
-        readonly width: OptionType<StringType>;
-        readonly height: OptionType<StringType>;
-    }>;
     readonly read: FunctionType<[BlobType, StringType], StructType<{
-        readonly position: OptionType<StructType<{
-            /** World x */
-            readonly x: FloatType;
-            /** World y */
-            readonly y: FloatType;
-        }>>;
-        readonly label: StringType;
-        readonly width: OptionType<FloatType>;
-        readonly height: OptionType<FloatType>;
-        readonly footprint: OptionType<VariantType<{
-            /** The entity's box itself. */
-            readonly rect: NullType;
-            /** A circle centred on the anchor; `radius` in world units. */
-            readonly circle: StructType<{
-                /** Circle radius in world units. */
-                readonly radius: FloatType;
-            }>;
-            /** An open, arc-aware polyline about the anchor; optional band width. */
-            readonly polyline: StructType<{
-                /** Vertices, offsets from the anchor, in order (each carries a DXF bulge). */
-                readonly vertices: ArrayType<StructType<{
-                    /** Offset from the anchor along x, in world units */
-                    readonly x: FloatType;
-                    /** Offset from the anchor along y, in world units */
-                    readonly y: FloatType;
-                    /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`) */
-                    readonly bulge: FloatType;
-                }>>;
-                /** Optional band width in world units — the stroke widens into a duct bank / aisle. */
-                readonly width: OptionType<FloatType>;
-            }>;
-            /** A closed, arc-aware polygon about the anchor (>= 3 vertices, auto-closed). */
-            readonly polygon: StructType<{
-                /** Boundary vertices, offsets from the anchor, in order (each carries a DXF bulge). */
-                readonly vertices: ArrayType<StructType<{
-                    /** Offset from the anchor along x, in world units */
-                    readonly x: FloatType;
-                    /** Offset from the anchor along y, in world units */
-                    readonly y: FloatType;
-                    /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`) */
-                    readonly bulge: FloatType;
-                }>>;
-            }>;
-        }>>;
-        readonly layer: OptionType<StringType>;
-        readonly icon: OptionType<StringType>;
-        readonly sublabel: OptionType<StringType>;
-        readonly metric: OptionType<StringType>;
-        readonly meter: OptionType<StructType<{
-            readonly value: FloatType;
-            readonly max: FloatType;
-        }>>;
         readonly status: OptionType<StructType<{
             readonly label: StringType;
             readonly tone: VariantType<{
@@ -2039,44 +1749,40 @@ export declare const SchematicItemKindType: StructType<{
             }>;
             readonly ring: BooleanType;
         }>>;
-        readonly tone: OptionType<VariantType<{
-            /** Brand teal */
-            readonly brand: NullType;
-            /** Foreground ink */
-            readonly ink: NullType;
-            /** Muted foreground */
-            readonly muted: NullType;
-            /** Status ok */
-            readonly success: NullType;
-            /** Status warn */
-            readonly warning: NullType;
-            /** Status bad */
-            readonly danger: NullType;
+        readonly meter: OptionType<StructType<{
+            readonly value: FloatType;
+            readonly max: FloatType;
         }>>;
-        readonly color: OptionType<StringType>;
-        readonly weight: OptionType<FloatType>;
-        readonly fillOpacity: OptionType<FloatType>;
-    }>>;
-    readonly write: FunctionType<[BlobType, OptionType<StructType<{
-        /** World x */
-        readonly x: FloatType;
-        /** World y */
-        readonly y: FloatType;
-    }>>], OptionType<BlobType>>;
-    readonly create: FunctionType<[OptionType<StructType<{
-        /** World x */
-        readonly x: FloatType;
-        /** World y */
-        readonly y: FloatType;
-    }>>, OptionType<BlobType>], OptionType<BlobType>>;
-    readonly templates: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly name: StringType;
-        readonly group: OptionType<StringType>;
-        readonly icon: OptionType<StringType>;
-        readonly values: BlobType;
+        readonly metric: OptionType<StringType>;
+        readonly sublabel: OptionType<StringType>;
     }>>;
-    readonly templatesSource: OptionType<StringType>;
+    readonly roles: StructType<{
+        readonly status: BooleanType;
+        readonly meter: BooleanType;
+        readonly metric: BooleanType;
+        readonly sublabel: BooleanType;
+    }>;
+}>;
+/** Type representing a kind's details. */
+export type SchematicKindDetailsType = typeof SchematicKindDetailsType;
+/**
+ * One item kind, closed (§4.1, §4.8).
+ *
+ * @property backlog - Whether its `x` and `y` are Options: its rows with no position are its backlog
+ * @property status - How each case of its status shows
+ * @property rows - Its stored items a read holds, by key, each its roles and its row: its record read whole, or its narrowing read complete through its source
+ * @property rowsOf - Its rows a reader read by area, or by key, as bytes, made its stored items: a window's (#1393)
+ * @property paged - The `id` of the paged read its rows are read by key through, for a kind read through its source: what
+ *   a reader asks the far ends of the links and nets touching its window of, all of a window's in one request (#1393);
+ *   `none` for a kind read whole
+ * @property box - The fields its box is, at its centre: what an area index it is read by names (§11.4)
+ * @property read - A drafted row's roles, from its bytes and its key
+ * @property write - The row with its position written — `none`, unplaced — and every other field as it was; `none` where it can't be: no position for a kind with no backlog
+ * @property create - A new row at a position, every other field from a template's values or its type's default; `none` as `write` refuses
+ * @property templates - Its templates
+ * @property templatesSource - The slice's source its templates list names
+ */
+export declare const SchematicItemKindType: StructType<{
     readonly editable: BooleanType;
     readonly editing: OptionType<StructType<{
         sourceId: StringType;
@@ -2415,76 +2121,6 @@ export declare const SchematicItemKindType: StructType<{
     readonly name: StringType;
     readonly icon: StringType;
     readonly details: OptionType<StructType<{
-        readonly rows: OptionType<FunctionType<[], OptionType<DictType<StringType, StructType<{
-            readonly roles: StructType<{
-                readonly status: OptionType<StructType<{
-                    readonly label: StringType;
-                    readonly tone: VariantType<{
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                        readonly info: NullType;
-                        readonly neutral: NullType;
-                    }>;
-                    readonly ring: BooleanType;
-                }>>;
-                readonly meter: OptionType<StructType<{
-                    readonly value: FloatType;
-                    readonly max: FloatType;
-                }>>;
-                readonly metric: OptionType<StringType>;
-                readonly sublabel: OptionType<StringType>;
-            }>;
-            readonly row: BlobType;
-        }>>>>>;
-        readonly rowsOf: FunctionType<[BlobType], DictType<StringType, StructType<{
-            readonly roles: StructType<{
-                readonly status: OptionType<StructType<{
-                    readonly label: StringType;
-                    readonly tone: VariantType<{
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                        readonly info: NullType;
-                        readonly neutral: NullType;
-                    }>;
-                    readonly ring: BooleanType;
-                }>>;
-                readonly meter: OptionType<StructType<{
-                    readonly value: FloatType;
-                    readonly max: FloatType;
-                }>>;
-                readonly metric: OptionType<StringType>;
-                readonly sublabel: OptionType<StringType>;
-            }>;
-            readonly row: BlobType;
-        }>>>;
-        readonly paged: OptionType<StringType>;
-        readonly read: FunctionType<[BlobType, StringType], StructType<{
-            readonly status: OptionType<StructType<{
-                readonly label: StringType;
-                readonly tone: VariantType<{
-                    readonly success: NullType;
-                    readonly warning: NullType;
-                    readonly danger: NullType;
-                    readonly info: NullType;
-                    readonly neutral: NullType;
-                }>;
-                readonly ring: BooleanType;
-            }>>;
-            readonly meter: OptionType<StructType<{
-                readonly value: FloatType;
-                readonly max: FloatType;
-            }>>;
-            readonly metric: OptionType<StringType>;
-            readonly sublabel: OptionType<StringType>;
-        }>>;
-        readonly roles: StructType<{
-            readonly status: BooleanType;
-            readonly meter: BooleanType;
-            readonly metric: BooleanType;
-            readonly sublabel: BooleanType;
-        }>;
         readonly editable: BooleanType;
         readonly editing: OptionType<StructType<{
             sourceId: StringType;
@@ -2819,70 +2455,104 @@ export declare const SchematicItemKindType: StructType<{
             readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
             readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
         }>>;
-    }>>;
-}>;
-/** Type representing an item kind. */
-export type SchematicItemKindType = typeof SchematicItemKindType;
-/**
- * One zone kind, closed (§4.2, §4.8). Zones take no gesture on the canvas:
- * their fields are edited through the inspector.
- *
- * @property rows - Its stored zones a read holds, by key, each its roles and its row: its record read whole, or its narrowing read complete through its source
- * @property rowsOf - Its rows a reader read by area, as bytes, made its stored zones: a window's (#1393)
- * @property box - The fields its box is, at its corner: what an area index it is read by names (§11.4)
- * @property read - A drafted row's roles, from its bytes and its key
- */
-export declare const SchematicZoneKindType: StructType<{
-    readonly rows: FunctionType<[], OptionType<DictType<StringType, StructType<{
-        readonly roles: StructType<{
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly width: FloatType;
-            readonly height: FloatType;
-            readonly label: StringType;
-            readonly pattern: VariantType<{
-                /** Dashed boundary with an eyebrow label (halls, cages) */
-                readonly outline: StructType<{
-                    /** Stroke tone (default `muted`) */
-                    readonly tone: OptionType<VariantType<{
-                        /** Brand teal */
-                        readonly brand: NullType;
-                        /** Foreground ink */
-                        readonly ink: NullType;
-                        /** Muted foreground */
-                        readonly muted: NullType;
-                        /** Status ok */
-                        readonly success: NullType;
-                        /** Status warn */
-                        readonly warning: NullType;
-                        /** Status bad */
-                        readonly danger: NullType;
-                    }>>;
-                }>;
-                /** Hatched band (hot and cold aisles, exclusion zones) */
-                readonly hatch: StructType<{
-                    /** Hatch-line tone (default `muted`) */
-                    readonly tone: OptionType<VariantType<{
-                        /** Brand teal */
-                        readonly brand: NullType;
-                        /** Foreground ink */
-                        readonly ink: NullType;
-                        /** Muted foreground */
-                        readonly muted: NullType;
-                        /** Status ok */
+        readonly rows: OptionType<FunctionType<[], OptionType<DictType<StringType, StructType<{
+            readonly roles: StructType<{
+                readonly status: OptionType<StructType<{
+                    readonly label: StringType;
+                    readonly tone: VariantType<{
                         readonly success: NullType;
-                        /** Status warn */
                         readonly warning: NullType;
-                        /** Status bad */
                         readonly danger: NullType;
-                    }>>;
-                    /** Line spacing in pixels (default 8) */
-                    readonly spacing: OptionType<FloatType>;
-                    /** Line angle in degrees (default 45) */
-                    readonly angle: OptionType<FloatType>;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly ring: BooleanType;
+                }>>;
+                readonly meter: OptionType<StructType<{
+                    readonly value: FloatType;
+                    readonly max: FloatType;
+                }>>;
+                readonly metric: OptionType<StringType>;
+                readonly sublabel: OptionType<StringType>;
+            }>;
+            readonly row: BlobType;
+        }>>>>>;
+        readonly rowsOf: FunctionType<[BlobType], DictType<StringType, StructType<{
+            readonly roles: StructType<{
+                readonly status: OptionType<StructType<{
+                    readonly label: StringType;
+                    readonly tone: VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly ring: BooleanType;
+                }>>;
+                readonly meter: OptionType<StructType<{
+                    readonly value: FloatType;
+                    readonly max: FloatType;
+                }>>;
+                readonly metric: OptionType<StringType>;
+                readonly sublabel: OptionType<StringType>;
+            }>;
+            readonly row: BlobType;
+        }>>>;
+        readonly paged: OptionType<StringType>;
+        readonly read: FunctionType<[BlobType, StringType], StructType<{
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
                 }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly meter: OptionType<StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
+            }>>;
+            readonly metric: OptionType<StringType>;
+            readonly sublabel: OptionType<StringType>;
+        }>>;
+        readonly roles: StructType<{
+            readonly status: BooleanType;
+            readonly meter: BooleanType;
+            readonly metric: BooleanType;
+            readonly sublabel: BooleanType;
+        }>;
+    }>>;
+    readonly backlog: BooleanType;
+    readonly status: ArrayType<StructType<{
+        readonly case: StringType;
+        readonly status: StructType<{
+            readonly label: StringType;
+            readonly tone: VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
             }>;
-            readonly geometry: OptionType<VariantType<{
+            readonly ring: BooleanType;
+        }>;
+    }>>;
+    readonly rows: FunctionType<[], OptionType<DictType<StringType, StructType<{
+        readonly roles: StructType<{
+            readonly position: OptionType<StructType<{
+                /** World x */
+                readonly x: FloatType;
+                /** World y */
+                readonly y: FloatType;
+            }>>;
+            readonly label: StringType;
+            readonly width: OptionType<FloatType>;
+            readonly height: OptionType<FloatType>;
+            readonly footprint: OptionType<VariantType<{
                 /** The entity's box itself. */
                 readonly rect: NullType;
                 /** A circle centred on the anchor; `radius` in world units. */
@@ -2918,6 +2588,24 @@ export declare const SchematicZoneKindType: StructType<{
                 }>;
             }>>;
             readonly layer: OptionType<StringType>;
+            readonly icon: OptionType<StringType>;
+            readonly sublabel: OptionType<StringType>;
+            readonly metric: OptionType<StringType>;
+            readonly meter: OptionType<StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
+            }>>;
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
             readonly tone: OptionType<VariantType<{
                 /** Brand teal */
                 readonly brand: NullType;
@@ -2933,61 +2621,23 @@ export declare const SchematicZoneKindType: StructType<{
                 readonly danger: NullType;
             }>>;
             readonly color: OptionType<StringType>;
-            readonly fillOpacity: OptionType<FloatType>;
             readonly weight: OptionType<FloatType>;
+            readonly fillOpacity: OptionType<FloatType>;
         }>;
         readonly row: BlobType;
     }>>>>;
     readonly rowsOf: FunctionType<[BlobType], DictType<StringType, StructType<{
         readonly roles: StructType<{
-            readonly x: FloatType;
-            readonly y: FloatType;
-            readonly width: FloatType;
-            readonly height: FloatType;
+            readonly position: OptionType<StructType<{
+                /** World x */
+                readonly x: FloatType;
+                /** World y */
+                readonly y: FloatType;
+            }>>;
             readonly label: StringType;
-            readonly pattern: VariantType<{
-                /** Dashed boundary with an eyebrow label (halls, cages) */
-                readonly outline: StructType<{
-                    /** Stroke tone (default `muted`) */
-                    readonly tone: OptionType<VariantType<{
-                        /** Brand teal */
-                        readonly brand: NullType;
-                        /** Foreground ink */
-                        readonly ink: NullType;
-                        /** Muted foreground */
-                        readonly muted: NullType;
-                        /** Status ok */
-                        readonly success: NullType;
-                        /** Status warn */
-                        readonly warning: NullType;
-                        /** Status bad */
-                        readonly danger: NullType;
-                    }>>;
-                }>;
-                /** Hatched band (hot and cold aisles, exclusion zones) */
-                readonly hatch: StructType<{
-                    /** Hatch-line tone (default `muted`) */
-                    readonly tone: OptionType<VariantType<{
-                        /** Brand teal */
-                        readonly brand: NullType;
-                        /** Foreground ink */
-                        readonly ink: NullType;
-                        /** Muted foreground */
-                        readonly muted: NullType;
-                        /** Status ok */
-                        readonly success: NullType;
-                        /** Status warn */
-                        readonly warning: NullType;
-                        /** Status bad */
-                        readonly danger: NullType;
-                    }>>;
-                    /** Line spacing in pixels (default 8) */
-                    readonly spacing: OptionType<FloatType>;
-                    /** Line angle in degrees (default 45) */
-                    readonly angle: OptionType<FloatType>;
-                }>;
-            }>;
-            readonly geometry: OptionType<VariantType<{
+            readonly width: OptionType<FloatType>;
+            readonly height: OptionType<FloatType>;
+            readonly footprint: OptionType<VariantType<{
                 /** The entity's box itself. */
                 readonly rect: NullType;
                 /** A circle centred on the anchor; `radius` in world units. */
@@ -3023,6 +2673,24 @@ export declare const SchematicZoneKindType: StructType<{
                 }>;
             }>>;
             readonly layer: OptionType<StringType>;
+            readonly icon: OptionType<StringType>;
+            readonly sublabel: OptionType<StringType>;
+            readonly metric: OptionType<StringType>;
+            readonly meter: OptionType<StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
+            }>>;
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
             readonly tone: OptionType<VariantType<{
                 /** Brand teal */
                 readonly brand: NullType;
@@ -3038,11 +2706,12 @@ export declare const SchematicZoneKindType: StructType<{
                 readonly danger: NullType;
             }>>;
             readonly color: OptionType<StringType>;
-            readonly fillOpacity: OptionType<FloatType>;
             readonly weight: OptionType<FloatType>;
+            readonly fillOpacity: OptionType<FloatType>;
         }>;
         readonly row: BlobType;
     }>>>;
+    readonly paged: OptionType<StringType>;
     readonly box: StructType<{
         readonly x: StringType;
         readonly y: StringType;
@@ -3050,54 +2719,16 @@ export declare const SchematicZoneKindType: StructType<{
         readonly height: OptionType<StringType>;
     }>;
     readonly read: FunctionType<[BlobType, StringType], StructType<{
-        readonly x: FloatType;
-        readonly y: FloatType;
-        readonly width: FloatType;
-        readonly height: FloatType;
+        readonly position: OptionType<StructType<{
+            /** World x */
+            readonly x: FloatType;
+            /** World y */
+            readonly y: FloatType;
+        }>>;
         readonly label: StringType;
-        readonly pattern: VariantType<{
-            /** Dashed boundary with an eyebrow label (halls, cages) */
-            readonly outline: StructType<{
-                /** Stroke tone (default `muted`) */
-                readonly tone: OptionType<VariantType<{
-                    /** Brand teal */
-                    readonly brand: NullType;
-                    /** Foreground ink */
-                    readonly ink: NullType;
-                    /** Muted foreground */
-                    readonly muted: NullType;
-                    /** Status ok */
-                    readonly success: NullType;
-                    /** Status warn */
-                    readonly warning: NullType;
-                    /** Status bad */
-                    readonly danger: NullType;
-                }>>;
-            }>;
-            /** Hatched band (hot and cold aisles, exclusion zones) */
-            readonly hatch: StructType<{
-                /** Hatch-line tone (default `muted`) */
-                readonly tone: OptionType<VariantType<{
-                    /** Brand teal */
-                    readonly brand: NullType;
-                    /** Foreground ink */
-                    readonly ink: NullType;
-                    /** Muted foreground */
-                    readonly muted: NullType;
-                    /** Status ok */
-                    readonly success: NullType;
-                    /** Status warn */
-                    readonly warning: NullType;
-                    /** Status bad */
-                    readonly danger: NullType;
-                }>>;
-                /** Line spacing in pixels (default 8) */
-                readonly spacing: OptionType<FloatType>;
-                /** Line angle in degrees (default 45) */
-                readonly angle: OptionType<FloatType>;
-            }>;
-        }>;
-        readonly geometry: OptionType<VariantType<{
+        readonly width: OptionType<FloatType>;
+        readonly height: OptionType<FloatType>;
+        readonly footprint: OptionType<VariantType<{
             /** The entity's box itself. */
             readonly rect: NullType;
             /** A circle centred on the anchor; `radius` in world units. */
@@ -3133,24 +2764,75 @@ export declare const SchematicZoneKindType: StructType<{
             }>;
         }>>;
         readonly layer: OptionType<StringType>;
-        readonly tone: OptionType<VariantType<{
-            /** Brand teal */
-            readonly brand: NullType;
-            /** Foreground ink */
-            readonly ink: NullType;
-            /** Muted foreground */
-            readonly muted: NullType;
-            /** Status ok */
-            readonly success: NullType;
-            /** Status warn */
-            readonly warning: NullType;
+        readonly icon: OptionType<StringType>;
+        readonly sublabel: OptionType<StringType>;
+        readonly metric: OptionType<StringType>;
+        readonly meter: OptionType<StructType<{
+            readonly value: FloatType;
+            readonly max: FloatType;
+        }>>;
+        readonly status: OptionType<StructType<{
+            readonly label: StringType;
+            readonly tone: VariantType<{
+                readonly success: NullType;
+                readonly warning: NullType;
+                readonly danger: NullType;
+                readonly info: NullType;
+                readonly neutral: NullType;
+            }>;
+            readonly ring: BooleanType;
+        }>>;
+        readonly tone: OptionType<VariantType<{
+            /** Brand teal */
+            readonly brand: NullType;
+            /** Foreground ink */
+            readonly ink: NullType;
+            /** Muted foreground */
+            readonly muted: NullType;
+            /** Status ok */
+            readonly success: NullType;
+            /** Status warn */
+            readonly warning: NullType;
             /** Status bad */
             readonly danger: NullType;
         }>>;
         readonly color: OptionType<StringType>;
-        readonly fillOpacity: OptionType<FloatType>;
         readonly weight: OptionType<FloatType>;
+        readonly fillOpacity: OptionType<FloatType>;
+    }>>;
+    readonly write: FunctionType<[BlobType, OptionType<StructType<{
+        /** World x */
+        readonly x: FloatType;
+        /** World y */
+        readonly y: FloatType;
+    }>>], OptionType<BlobType>>;
+    readonly create: FunctionType<[OptionType<StructType<{
+        /** World x */
+        readonly x: FloatType;
+        /** World y */
+        readonly y: FloatType;
+    }>>, OptionType<BlobType>], OptionType<BlobType>>;
+    readonly templates: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+        readonly group: OptionType<StringType>;
+        readonly icon: OptionType<StringType>;
+        readonly values: BlobType;
     }>>;
+    readonly templatesSource: OptionType<StringType>;
+}>;
+/** Type representing an item kind. */
+export type SchematicItemKindType = typeof SchematicItemKindType;
+/**
+ * One zone kind, closed (§4.2, §4.8). Zones take no gesture on the canvas:
+ * their fields are edited through the inspector.
+ *
+ * @property rows - Its stored zones a read holds, by key, each its roles and its row: its record read whole, or its narrowing read complete through its source
+ * @property rowsOf - Its rows a reader read by area, as bytes, made its stored zones: a window's (#1393)
+ * @property box - The fields its box is, at its corner: what an area index it is read by names (§11.4)
+ * @property read - A drafted row's roles, from its bytes and its key
+ */
+export declare const SchematicZoneKindType: StructType<{
     readonly editable: BooleanType;
     readonly editing: OptionType<StructType<{
         sourceId: StringType;
@@ -3489,76 +3171,6 @@ export declare const SchematicZoneKindType: StructType<{
     readonly name: StringType;
     readonly icon: StringType;
     readonly details: OptionType<StructType<{
-        readonly rows: OptionType<FunctionType<[], OptionType<DictType<StringType, StructType<{
-            readonly roles: StructType<{
-                readonly status: OptionType<StructType<{
-                    readonly label: StringType;
-                    readonly tone: VariantType<{
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                        readonly info: NullType;
-                        readonly neutral: NullType;
-                    }>;
-                    readonly ring: BooleanType;
-                }>>;
-                readonly meter: OptionType<StructType<{
-                    readonly value: FloatType;
-                    readonly max: FloatType;
-                }>>;
-                readonly metric: OptionType<StringType>;
-                readonly sublabel: OptionType<StringType>;
-            }>;
-            readonly row: BlobType;
-        }>>>>>;
-        readonly rowsOf: FunctionType<[BlobType], DictType<StringType, StructType<{
-            readonly roles: StructType<{
-                readonly status: OptionType<StructType<{
-                    readonly label: StringType;
-                    readonly tone: VariantType<{
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                        readonly info: NullType;
-                        readonly neutral: NullType;
-                    }>;
-                    readonly ring: BooleanType;
-                }>>;
-                readonly meter: OptionType<StructType<{
-                    readonly value: FloatType;
-                    readonly max: FloatType;
-                }>>;
-                readonly metric: OptionType<StringType>;
-                readonly sublabel: OptionType<StringType>;
-            }>;
-            readonly row: BlobType;
-        }>>>;
-        readonly paged: OptionType<StringType>;
-        readonly read: FunctionType<[BlobType, StringType], StructType<{
-            readonly status: OptionType<StructType<{
-                readonly label: StringType;
-                readonly tone: VariantType<{
-                    readonly success: NullType;
-                    readonly warning: NullType;
-                    readonly danger: NullType;
-                    readonly info: NullType;
-                    readonly neutral: NullType;
-                }>;
-                readonly ring: BooleanType;
-            }>>;
-            readonly meter: OptionType<StructType<{
-                readonly value: FloatType;
-                readonly max: FloatType;
-            }>>;
-            readonly metric: OptionType<StringType>;
-            readonly sublabel: OptionType<StringType>;
-        }>>;
-        readonly roles: StructType<{
-            readonly status: BooleanType;
-            readonly meter: BooleanType;
-            readonly metric: BooleanType;
-            readonly sublabel: BooleanType;
-        }>;
         readonly editable: BooleanType;
         readonly editing: OptionType<StructType<{
             sourceId: StringType;
@@ -3893,48 +3505,88 @@ export declare const SchematicZoneKindType: StructType<{
             readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
             readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
         }>>;
-    }>>;
-}>;
-/** Type representing a zone kind. */
-export type SchematicZoneKindType = typeof SchematicZoneKindType;
-/**
- * One link kind, closed (§4.3, §4.8).
- *
- * @property ends - The item slots each end holds keys of
- * @property rows - Its stored links a read holds, by key, each its roles and its row
- * @property read - A drafted row's roles, from its bytes and its key
- * @property write - The row with its ends written and every other field as it was; `none` for an end of a slot its field holds no keys of
- * @property create - A new link between two items, every other field from a template's values or its type's default; `none` as `write` refuses
- * @property templates - Its templates, which retype a link they are dropped on
- * @property templatesSource - The slice's source its templates list names
- */
-export declare const SchematicLinkKindType: StructType<{
-    readonly ends: StructType<{
-        readonly from: ArrayType<StringType>;
-        readonly to: ArrayType<StringType>;
-    }>;
-    readonly rows: FunctionType<[], OptionType<DictType<StringType, StructType<{
-        readonly roles: StructType<{
-            readonly from: StructType<{
-                readonly kind: StringType;
-                readonly key: StringType;
+        readonly rows: OptionType<FunctionType<[], OptionType<DictType<StringType, StructType<{
+            readonly roles: StructType<{
+                readonly status: OptionType<StructType<{
+                    readonly label: StringType;
+                    readonly tone: VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly ring: BooleanType;
+                }>>;
+                readonly meter: OptionType<StructType<{
+                    readonly value: FloatType;
+                    readonly max: FloatType;
+                }>>;
+                readonly metric: OptionType<StringType>;
+                readonly sublabel: OptionType<StringType>;
             }>;
-            readonly to: StructType<{
-                readonly kind: StringType;
-                readonly key: StringType;
+            readonly row: BlobType;
+        }>>>>>;
+        readonly rowsOf: FunctionType<[BlobType], DictType<StringType, StructType<{
+            readonly roles: StructType<{
+                readonly status: OptionType<StructType<{
+                    readonly label: StringType;
+                    readonly tone: VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly ring: BooleanType;
+                }>>;
+                readonly meter: OptionType<StructType<{
+                    readonly value: FloatType;
+                    readonly max: FloatType;
+                }>>;
+                readonly metric: OptionType<StringType>;
+                readonly sublabel: OptionType<StringType>;
             }>;
-            readonly via: ArrayType<StructType<{
-                /** World x */
-                readonly x: FloatType;
-                /** World y */
-                readonly y: FloatType;
+            readonly row: BlobType;
+        }>>>;
+        readonly paged: OptionType<StringType>;
+        readonly read: FunctionType<[BlobType, StringType], StructType<{
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly meter: OptionType<StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
             }>>;
-            readonly label: OptionType<StringType>;
             readonly metric: OptionType<StringType>;
-            readonly style: VariantType<{
-                /** A physical run (fibre, power cable) */
-                readonly solid: StructType<{
-                    /** Stroke tone (default: the links' muted ink, #1403) */
+            readonly sublabel: OptionType<StringType>;
+        }>>;
+        readonly roles: StructType<{
+            readonly status: BooleanType;
+            readonly meter: BooleanType;
+            readonly metric: BooleanType;
+            readonly sublabel: BooleanType;
+        }>;
+    }>>;
+    readonly rows: FunctionType<[], OptionType<DictType<StringType, StructType<{
+        readonly roles: StructType<{
+            readonly x: FloatType;
+            readonly y: FloatType;
+            readonly width: FloatType;
+            readonly height: FloatType;
+            readonly label: StringType;
+            readonly pattern: VariantType<{
+                /** Dashed boundary with an eyebrow label (halls, cages) */
+                readonly outline: StructType<{
+                    /** Stroke tone (default `muted`) */
                     readonly tone: OptionType<VariantType<{
                         /** Brand teal */
                         readonly brand: NullType;
@@ -3949,12 +3601,10 @@ export declare const SchematicLinkKindType: StructType<{
                         /** Status bad */
                         readonly danger: NullType;
                     }>>;
-                    /** Stroke width in pixels (default 2.5) */
-                    readonly weight: OptionType<FloatType>;
                 }>;
-                /** A routing / logical connection */
-                readonly dashed: StructType<{
-                    /** Stroke tone (default: the links' muted ink, #1403) */
+                /** Hatched band (hot and cold aisles, exclusion zones) */
+                readonly hatch: StructType<{
+                    /** Hatch-line tone (default `muted`) */
                     readonly tone: OptionType<VariantType<{
                         /** Brand teal */
                         readonly brand: NullType;
@@ -3969,44 +3619,189 @@ export declare const SchematicLinkKindType: StructType<{
                         /** Status bad */
                         readonly danger: NullType;
                     }>>;
-                    /** Stroke width in pixels (default 1.5) */
-                    readonly weight: OptionType<FloatType>;
+                    /** Line spacing in pixels (default 8) */
+                    readonly spacing: OptionType<FloatType>;
+                    /** Line angle in degrees (default 45) */
+                    readonly angle: OptionType<FloatType>;
                 }>;
             }>;
-            readonly route: VariantType<{
-                /** Axis-aligned with rounded corners */
-                readonly orthogonal: StructType<{
-                    /** Corner radius in pixels (default 8) */
-                    readonly corner: OptionType<FloatType>;
+            readonly geometry: OptionType<VariantType<{
+                /** The entity's box itself. */
+                readonly rect: NullType;
+                /** A circle centred on the anchor; `radius` in world units. */
+                readonly circle: StructType<{
+                    /** Circle radius in world units. */
+                    readonly radius: FloatType;
+                }>;
+                /** An open, arc-aware polyline about the anchor; optional band width. */
+                readonly polyline: StructType<{
+                    /** Vertices, offsets from the anchor, in order (each carries a DXF bulge). */
+                    readonly vertices: ArrayType<StructType<{
+                        /** Offset from the anchor along x, in world units */
+                        readonly x: FloatType;
+                        /** Offset from the anchor along y, in world units */
+                        readonly y: FloatType;
+                        /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`) */
+                        readonly bulge: FloatType;
+                    }>>;
+                    /** Optional band width in world units — the stroke widens into a duct bank / aisle. */
+                    readonly width: OptionType<FloatType>;
+                }>;
+                /** A closed, arc-aware polygon about the anchor (>= 3 vertices, auto-closed). */
+                readonly polygon: StructType<{
+                    /** Boundary vertices, offsets from the anchor, in order (each carries a DXF bulge). */
+                    readonly vertices: ArrayType<StructType<{
+                        /** Offset from the anchor along x, in world units */
+                        readonly x: FloatType;
+                        /** Offset from the anchor along y, in world units */
+                        readonly y: FloatType;
+                        /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`) */
+                        readonly bulge: FloatType;
+                    }>>;
+                }>;
+            }>>;
+            readonly layer: OptionType<StringType>;
+            readonly tone: OptionType<VariantType<{
+                /** Brand teal */
+                readonly brand: NullType;
+                /** Foreground ink */
+                readonly ink: NullType;
+                /** Muted foreground */
+                readonly muted: NullType;
+                /** Status ok */
+                readonly success: NullType;
+                /** Status warn */
+                readonly warning: NullType;
+                /** Status bad */
+                readonly danger: NullType;
+            }>>;
+            readonly color: OptionType<StringType>;
+            readonly fillOpacity: OptionType<FloatType>;
+            readonly weight: OptionType<FloatType>;
+        }>;
+        readonly row: BlobType;
+    }>>>>;
+    readonly rowsOf: FunctionType<[BlobType], DictType<StringType, StructType<{
+        readonly roles: StructType<{
+            readonly x: FloatType;
+            readonly y: FloatType;
+            readonly width: FloatType;
+            readonly height: FloatType;
+            readonly label: StringType;
+            readonly pattern: VariantType<{
+                /** Dashed boundary with an eyebrow label (halls, cages) */
+                readonly outline: StructType<{
+                    /** Stroke tone (default `muted`) */
+                    readonly tone: OptionType<VariantType<{
+                        /** Brand teal */
+                        readonly brand: NullType;
+                        /** Foreground ink */
+                        readonly ink: NullType;
+                        /** Muted foreground */
+                        readonly muted: NullType;
+                        /** Status ok */
+                        readonly success: NullType;
+                        /** Status warn */
+                        readonly warning: NullType;
+                        /** Status bad */
+                        readonly danger: NullType;
+                    }>>;
+                }>;
+                /** Hatched band (hot and cold aisles, exclusion zones) */
+                readonly hatch: StructType<{
+                    /** Hatch-line tone (default `muted`) */
+                    readonly tone: OptionType<VariantType<{
+                        /** Brand teal */
+                        readonly brand: NullType;
+                        /** Foreground ink */
+                        readonly ink: NullType;
+                        /** Muted foreground */
+                        readonly muted: NullType;
+                        /** Status ok */
+                        readonly success: NullType;
+                        /** Status warn */
+                        readonly warning: NullType;
+                        /** Status bad */
+                        readonly danger: NullType;
+                    }>>;
+                    /** Line spacing in pixels (default 8) */
+                    readonly spacing: OptionType<FloatType>;
+                    /** Line angle in degrees (default 45) */
+                    readonly angle: OptionType<FloatType>;
                 }>;
-                /** Straight segments between anchors */
-                readonly direct: NullType;
             }>;
+            readonly geometry: OptionType<VariantType<{
+                /** The entity's box itself. */
+                readonly rect: NullType;
+                /** A circle centred on the anchor; `radius` in world units. */
+                readonly circle: StructType<{
+                    /** Circle radius in world units. */
+                    readonly radius: FloatType;
+                }>;
+                /** An open, arc-aware polyline about the anchor; optional band width. */
+                readonly polyline: StructType<{
+                    /** Vertices, offsets from the anchor, in order (each carries a DXF bulge). */
+                    readonly vertices: ArrayType<StructType<{
+                        /** Offset from the anchor along x, in world units */
+                        readonly x: FloatType;
+                        /** Offset from the anchor along y, in world units */
+                        readonly y: FloatType;
+                        /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`) */
+                        readonly bulge: FloatType;
+                    }>>;
+                    /** Optional band width in world units — the stroke widens into a duct bank / aisle. */
+                    readonly width: OptionType<FloatType>;
+                }>;
+                /** A closed, arc-aware polygon about the anchor (>= 3 vertices, auto-closed). */
+                readonly polygon: StructType<{
+                    /** Boundary vertices, offsets from the anchor, in order (each carries a DXF bulge). */
+                    readonly vertices: ArrayType<StructType<{
+                        /** Offset from the anchor along x, in world units */
+                        readonly x: FloatType;
+                        /** Offset from the anchor along y, in world units */
+                        readonly y: FloatType;
+                        /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`) */
+                        readonly bulge: FloatType;
+                    }>>;
+                }>;
+            }>>;
             readonly layer: OptionType<StringType>;
+            readonly tone: OptionType<VariantType<{
+                /** Brand teal */
+                readonly brand: NullType;
+                /** Foreground ink */
+                readonly ink: NullType;
+                /** Muted foreground */
+                readonly muted: NullType;
+                /** Status ok */
+                readonly success: NullType;
+                /** Status warn */
+                readonly warning: NullType;
+                /** Status bad */
+                readonly danger: NullType;
+            }>>;
+            readonly color: OptionType<StringType>;
+            readonly fillOpacity: OptionType<FloatType>;
+            readonly weight: OptionType<FloatType>;
         }>;
         readonly row: BlobType;
-    }>>>>;
+    }>>>;
+    readonly box: StructType<{
+        readonly x: StringType;
+        readonly y: StringType;
+        readonly width: OptionType<StringType>;
+        readonly height: OptionType<StringType>;
+    }>;
     readonly read: FunctionType<[BlobType, StringType], StructType<{
-        readonly from: StructType<{
-            readonly kind: StringType;
-            readonly key: StringType;
-        }>;
-        readonly to: StructType<{
-            readonly kind: StringType;
-            readonly key: StringType;
-        }>;
-        readonly via: ArrayType<StructType<{
-            /** World x */
-            readonly x: FloatType;
-            /** World y */
-            readonly y: FloatType;
-        }>>;
-        readonly label: OptionType<StringType>;
-        readonly metric: OptionType<StringType>;
-        readonly style: VariantType<{
-            /** A physical run (fibre, power cable) */
-            readonly solid: StructType<{
-                /** Stroke tone (default: the links' muted ink, #1403) */
+        readonly x: FloatType;
+        readonly y: FloatType;
+        readonly width: FloatType;
+        readonly height: FloatType;
+        readonly label: StringType;
+        readonly pattern: VariantType<{
+            /** Dashed boundary with an eyebrow label (halls, cages) */
+            readonly outline: StructType<{
+                /** Stroke tone (default `muted`) */
                 readonly tone: OptionType<VariantType<{
                     /** Brand teal */
                     readonly brand: NullType;
@@ -4021,12 +3816,10 @@ export declare const SchematicLinkKindType: StructType<{
                     /** Status bad */
                     readonly danger: NullType;
                 }>>;
-                /** Stroke width in pixels (default 2.5) */
-                readonly weight: OptionType<FloatType>;
             }>;
-            /** A routing / logical connection */
-            readonly dashed: StructType<{
-                /** Stroke tone (default: the links' muted ink, #1403) */
+            /** Hatched band (hot and cold aisles, exclusion zones) */
+            readonly hatch: StructType<{
+                /** Hatch-line tone (default `muted`) */
                 readonly tone: OptionType<VariantType<{
                     /** Brand teal */
                     readonly brand: NullType;
@@ -4041,49 +3834,81 @@ export declare const SchematicLinkKindType: StructType<{
                     /** Status bad */
                     readonly danger: NullType;
                 }>>;
-                /** Stroke width in pixels (default 1.5) */
-                readonly weight: OptionType<FloatType>;
+                /** Line spacing in pixels (default 8) */
+                readonly spacing: OptionType<FloatType>;
+                /** Line angle in degrees (default 45) */
+                readonly angle: OptionType<FloatType>;
             }>;
         }>;
-        readonly route: VariantType<{
-            /** Axis-aligned with rounded corners */
-            readonly orthogonal: StructType<{
-                /** Corner radius in pixels (default 8) */
-                readonly corner: OptionType<FloatType>;
+        readonly geometry: OptionType<VariantType<{
+            /** The entity's box itself. */
+            readonly rect: NullType;
+            /** A circle centred on the anchor; `radius` in world units. */
+            readonly circle: StructType<{
+                /** Circle radius in world units. */
+                readonly radius: FloatType;
             }>;
-            /** Straight segments between anchors */
-            readonly direct: NullType;
-        }>;
+            /** An open, arc-aware polyline about the anchor; optional band width. */
+            readonly polyline: StructType<{
+                /** Vertices, offsets from the anchor, in order (each carries a DXF bulge). */
+                readonly vertices: ArrayType<StructType<{
+                    /** Offset from the anchor along x, in world units */
+                    readonly x: FloatType;
+                    /** Offset from the anchor along y, in world units */
+                    readonly y: FloatType;
+                    /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`) */
+                    readonly bulge: FloatType;
+                }>>;
+                /** Optional band width in world units — the stroke widens into a duct bank / aisle. */
+                readonly width: OptionType<FloatType>;
+            }>;
+            /** A closed, arc-aware polygon about the anchor (>= 3 vertices, auto-closed). */
+            readonly polygon: StructType<{
+                /** Boundary vertices, offsets from the anchor, in order (each carries a DXF bulge). */
+                readonly vertices: ArrayType<StructType<{
+                    /** Offset from the anchor along x, in world units */
+                    readonly x: FloatType;
+                    /** Offset from the anchor along y, in world units */
+                    readonly y: FloatType;
+                    /** DXF bulge for the edge to the next vertex (0 = straight; `tan(includedAngle / 4)`) */
+                    readonly bulge: FloatType;
+                }>>;
+            }>;
+        }>>;
         readonly layer: OptionType<StringType>;
+        readonly tone: OptionType<VariantType<{
+            /** Brand teal */
+            readonly brand: NullType;
+            /** Foreground ink */
+            readonly ink: NullType;
+            /** Muted foreground */
+            readonly muted: NullType;
+            /** Status ok */
+            readonly success: NullType;
+            /** Status warn */
+            readonly warning: NullType;
+            /** Status bad */
+            readonly danger: NullType;
+        }>>;
+        readonly color: OptionType<StringType>;
+        readonly fillOpacity: OptionType<FloatType>;
+        readonly weight: OptionType<FloatType>;
     }>>;
-    readonly write: FunctionType<[BlobType, StructType<{
-        readonly from: StructType<{
-            readonly kind: StringType;
-            readonly key: StringType;
-        }>;
-        readonly to: StructType<{
-            readonly kind: StringType;
-            readonly key: StringType;
-        }>;
-    }>], OptionType<BlobType>>;
-    readonly create: FunctionType<[StructType<{
-        readonly from: StructType<{
-            readonly kind: StringType;
-            readonly key: StringType;
-        }>;
-        readonly to: StructType<{
-            readonly kind: StringType;
-            readonly key: StringType;
-        }>;
-    }>, OptionType<BlobType>], OptionType<BlobType>>;
-    readonly templates: ArrayType<StructType<{
-        readonly key: StringType;
-        readonly name: StringType;
-        readonly group: OptionType<StringType>;
-        readonly icon: OptionType<StringType>;
-        readonly values: BlobType;
-    }>>;
-    readonly templatesSource: OptionType<StringType>;
+}>;
+/** Type representing a zone kind. */
+export type SchematicZoneKindType = typeof SchematicZoneKindType;
+/**
+ * One link kind, closed (§4.3, §4.8).
+ *
+ * @property ends - The item slots each end holds keys of
+ * @property rows - Its stored links a read holds, by key, each its roles and its row
+ * @property read - A drafted row's roles, from its bytes and its key
+ * @property write - The row with its ends written and every other field as it was; `none` for an end of a slot its field holds no keys of
+ * @property create - A new link between two items, every other field from a template's values or its type's default; `none` as `write` refuses
+ * @property templates - Its templates, which retype a link they are dropped on
+ * @property templatesSource - The slice's source its templates list names
+ */
+export declare const SchematicLinkKindType: StructType<{
     readonly editable: BooleanType;
     readonly editing: OptionType<StructType<{
         sourceId: StringType;
@@ -4388,110 +4213,40 @@ export declare const SchematicLinkKindType: StructType<{
         readonly Ref: import("@elaraai/east").RecursiveTypeMarker;
         readonly Array: import("@elaraai/east").RecursiveTypeMarker;
         readonly Set: import("@elaraai/east").RecursiveTypeMarker;
-        readonly Dict: StructType<{
-            readonly key: import("@elaraai/east").RecursiveTypeMarker;
-            readonly value: import("@elaraai/east").RecursiveTypeMarker;
-        }>;
-        readonly Struct: ArrayType<StructType<{
-            readonly name: StringType;
-            readonly type: import("@elaraai/east").RecursiveTypeMarker;
-        }>>;
-        readonly Variant: ArrayType<StructType<{
-            readonly name: StringType;
-            readonly type: import("@elaraai/east").RecursiveTypeMarker;
-        }>>;
-        readonly Recursive: VariantType<{
-            readonly ref: import("@elaraai/east").IntegerType;
-            readonly wrapper: StructType<{
-                readonly id: import("@elaraai/east").IntegerType;
-                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
-            }>;
-        }>;
-        readonly Function: StructType<{
-            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
-            readonly output: import("@elaraai/east").RecursiveTypeMarker;
-        }>;
-        readonly AsyncFunction: StructType<{
-            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
-            readonly output: import("@elaraai/east").RecursiveTypeMarker;
-        }>;
-        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
-        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
-    }>>;
-    readonly key: StringType;
-    readonly name: StringType;
-    readonly icon: StringType;
-    readonly details: OptionType<StructType<{
-        readonly rows: OptionType<FunctionType<[], OptionType<DictType<StringType, StructType<{
-            readonly roles: StructType<{
-                readonly status: OptionType<StructType<{
-                    readonly label: StringType;
-                    readonly tone: VariantType<{
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                        readonly info: NullType;
-                        readonly neutral: NullType;
-                    }>;
-                    readonly ring: BooleanType;
-                }>>;
-                readonly meter: OptionType<StructType<{
-                    readonly value: FloatType;
-                    readonly max: FloatType;
-                }>>;
-                readonly metric: OptionType<StringType>;
-                readonly sublabel: OptionType<StringType>;
-            }>;
-            readonly row: BlobType;
-        }>>>>>;
-        readonly rowsOf: FunctionType<[BlobType], DictType<StringType, StructType<{
-            readonly roles: StructType<{
-                readonly status: OptionType<StructType<{
-                    readonly label: StringType;
-                    readonly tone: VariantType<{
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                        readonly info: NullType;
-                        readonly neutral: NullType;
-                    }>;
-                    readonly ring: BooleanType;
-                }>>;
-                readonly meter: OptionType<StructType<{
-                    readonly value: FloatType;
-                    readonly max: FloatType;
-                }>>;
-                readonly metric: OptionType<StringType>;
-                readonly sublabel: OptionType<StringType>;
-            }>;
-            readonly row: BlobType;
-        }>>>;
-        readonly paged: OptionType<StringType>;
-        readonly read: FunctionType<[BlobType, StringType], StructType<{
-            readonly status: OptionType<StructType<{
-                readonly label: StringType;
-                readonly tone: VariantType<{
-                    readonly success: NullType;
-                    readonly warning: NullType;
-                    readonly danger: NullType;
-                    readonly info: NullType;
-                    readonly neutral: NullType;
-                }>;
-                readonly ring: BooleanType;
-            }>>;
-            readonly meter: OptionType<StructType<{
-                readonly value: FloatType;
-                readonly max: FloatType;
-            }>>;
-            readonly metric: OptionType<StringType>;
-            readonly sublabel: OptionType<StringType>;
+        readonly Dict: StructType<{
+            readonly key: import("@elaraai/east").RecursiveTypeMarker;
+            readonly value: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Struct: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
         }>>;
-        readonly roles: StructType<{
-            readonly status: BooleanType;
-            readonly meter: BooleanType;
-            readonly metric: BooleanType;
-            readonly sublabel: BooleanType;
+        readonly Variant: ArrayType<StructType<{
+            readonly name: StringType;
+            readonly type: import("@elaraai/east").RecursiveTypeMarker;
+        }>>;
+        readonly Recursive: VariantType<{
+            readonly ref: import("@elaraai/east").IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: import("@elaraai/east").IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
         }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    readonly key: StringType;
+    readonly name: StringType;
+    readonly icon: StringType;
+    readonly details: OptionType<StructType<{
         readonly editable: BooleanType;
         readonly editing: OptionType<StructType<{
             sourceId: StringType;
@@ -4826,36 +4581,91 @@ export declare const SchematicLinkKindType: StructType<{
             readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
             readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
         }>>;
+        readonly rows: OptionType<FunctionType<[], OptionType<DictType<StringType, StructType<{
+            readonly roles: StructType<{
+                readonly status: OptionType<StructType<{
+                    readonly label: StringType;
+                    readonly tone: VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly ring: BooleanType;
+                }>>;
+                readonly meter: OptionType<StructType<{
+                    readonly value: FloatType;
+                    readonly max: FloatType;
+                }>>;
+                readonly metric: OptionType<StringType>;
+                readonly sublabel: OptionType<StringType>;
+            }>;
+            readonly row: BlobType;
+        }>>>>>;
+        readonly rowsOf: FunctionType<[BlobType], DictType<StringType, StructType<{
+            readonly roles: StructType<{
+                readonly status: OptionType<StructType<{
+                    readonly label: StringType;
+                    readonly tone: VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly ring: BooleanType;
+                }>>;
+                readonly meter: OptionType<StructType<{
+                    readonly value: FloatType;
+                    readonly max: FloatType;
+                }>>;
+                readonly metric: OptionType<StringType>;
+                readonly sublabel: OptionType<StringType>;
+            }>;
+            readonly row: BlobType;
+        }>>>;
+        readonly paged: OptionType<StringType>;
+        readonly read: FunctionType<[BlobType, StringType], StructType<{
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly meter: OptionType<StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
+            }>>;
+            readonly metric: OptionType<StringType>;
+            readonly sublabel: OptionType<StringType>;
+        }>>;
+        readonly roles: StructType<{
+            readonly status: BooleanType;
+            readonly meter: BooleanType;
+            readonly metric: BooleanType;
+            readonly sublabel: BooleanType;
+        }>;
     }>>;
-}>;
-/** Type representing a link kind. */
-export type SchematicLinkKindType = typeof SchematicLinkKindType;
-/**
- * One net kind, closed (§4.4, §4.8).
- *
- * @property sides - The item slot each side holds keys of
- * @property rows - Its stored nets a read holds, by key, each its roles and its row
- * @property read - A drafted row's roles, from its bytes and its key
- * @property write - The row with its sides written and every other field as it was; `none` for a member of a slot a side holds no keys of
- * @property create - A new net, every other field from a template's values or its type's default; `none` as `write` refuses
- * @property templates - Its templates
- * @property templatesSource - The slice's source its templates list names
- */
-export declare const SchematicNetKindType: StructType<{
-    readonly sides: StructType<{
-        readonly sources: StringType;
-        readonly destinations: StringType;
+    readonly ends: StructType<{
+        readonly from: ArrayType<StringType>;
+        readonly to: ArrayType<StringType>;
     }>;
     readonly rows: FunctionType<[], OptionType<DictType<StringType, StructType<{
         readonly roles: StructType<{
-            readonly sources: ArrayType<StructType<{
+            readonly from: StructType<{
                 readonly kind: StringType;
                 readonly key: StringType;
-            }>>;
-            readonly destinations: ArrayType<StructType<{
+            }>;
+            readonly to: StructType<{
                 readonly kind: StringType;
                 readonly key: StringType;
-            }>>;
+            }>;
             readonly via: ArrayType<StructType<{
                 /** World x */
                 readonly x: FloatType;
@@ -4920,14 +4730,14 @@ export declare const SchematicNetKindType: StructType<{
         readonly row: BlobType;
     }>>>>;
     readonly read: FunctionType<[BlobType, StringType], StructType<{
-        readonly sources: ArrayType<StructType<{
+        readonly from: StructType<{
             readonly kind: StringType;
             readonly key: StringType;
-        }>>;
-        readonly destinations: ArrayType<StructType<{
+        }>;
+        readonly to: StructType<{
             readonly kind: StringType;
             readonly key: StringType;
-        }>>;
+        }>;
         readonly via: ArrayType<StructType<{
             /** World x */
             readonly x: FloatType;
@@ -4990,24 +4800,24 @@ export declare const SchematicNetKindType: StructType<{
         readonly layer: OptionType<StringType>;
     }>>;
     readonly write: FunctionType<[BlobType, StructType<{
-        readonly sources: ArrayType<StructType<{
+        readonly from: StructType<{
             readonly kind: StringType;
             readonly key: StringType;
-        }>>;
-        readonly destinations: ArrayType<StructType<{
+        }>;
+        readonly to: StructType<{
             readonly kind: StringType;
             readonly key: StringType;
-        }>>;
+        }>;
     }>], OptionType<BlobType>>;
     readonly create: FunctionType<[StructType<{
-        readonly sources: ArrayType<StructType<{
+        readonly from: StructType<{
             readonly kind: StringType;
             readonly key: StringType;
-        }>>;
-        readonly destinations: ArrayType<StructType<{
+        }>;
+        readonly to: StructType<{
             readonly kind: StringType;
             readonly key: StringType;
-        }>>;
+        }>;
     }>, OptionType<BlobType>], OptionType<BlobType>>;
     readonly templates: ArrayType<StructType<{
         readonly key: StringType;
@@ -5017,6 +4827,21 @@ export declare const SchematicNetKindType: StructType<{
         readonly values: BlobType;
     }>>;
     readonly templatesSource: OptionType<StringType>;
+}>;
+/** Type representing a link kind. */
+export type SchematicLinkKindType = typeof SchematicLinkKindType;
+/**
+ * One net kind, closed (§4.4, §4.8).
+ *
+ * @property sides - The item slot each side holds keys of
+ * @property rows - Its stored nets a read holds, by key, each its roles and its row
+ * @property read - A drafted row's roles, from its bytes and its key
+ * @property write - The row with its sides written and every other field as it was; `none` for a member of a slot a side holds no keys of
+ * @property create - A new net, every other field from a template's values or its type's default; `none` as `write` refuses
+ * @property templates - Its templates
+ * @property templatesSource - The slice's source its templates list names
+ */
+export declare const SchematicNetKindType: StructType<{
     readonly editable: BooleanType;
     readonly editing: OptionType<StructType<{
         sourceId: StringType;
@@ -5344,87 +5169,17 @@ export declare const SchematicNetKindType: StructType<{
             readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
             readonly output: import("@elaraai/east").RecursiveTypeMarker;
         }>;
-        readonly AsyncFunction: StructType<{
-            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
-            readonly output: import("@elaraai/east").RecursiveTypeMarker;
-        }>;
-        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
-        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
-    }>>;
-    readonly key: StringType;
-    readonly name: StringType;
-    readonly icon: StringType;
-    readonly details: OptionType<StructType<{
-        readonly rows: OptionType<FunctionType<[], OptionType<DictType<StringType, StructType<{
-            readonly roles: StructType<{
-                readonly status: OptionType<StructType<{
-                    readonly label: StringType;
-                    readonly tone: VariantType<{
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                        readonly info: NullType;
-                        readonly neutral: NullType;
-                    }>;
-                    readonly ring: BooleanType;
-                }>>;
-                readonly meter: OptionType<StructType<{
-                    readonly value: FloatType;
-                    readonly max: FloatType;
-                }>>;
-                readonly metric: OptionType<StringType>;
-                readonly sublabel: OptionType<StringType>;
-            }>;
-            readonly row: BlobType;
-        }>>>>>;
-        readonly rowsOf: FunctionType<[BlobType], DictType<StringType, StructType<{
-            readonly roles: StructType<{
-                readonly status: OptionType<StructType<{
-                    readonly label: StringType;
-                    readonly tone: VariantType<{
-                        readonly success: NullType;
-                        readonly warning: NullType;
-                        readonly danger: NullType;
-                        readonly info: NullType;
-                        readonly neutral: NullType;
-                    }>;
-                    readonly ring: BooleanType;
-                }>>;
-                readonly meter: OptionType<StructType<{
-                    readonly value: FloatType;
-                    readonly max: FloatType;
-                }>>;
-                readonly metric: OptionType<StringType>;
-                readonly sublabel: OptionType<StringType>;
-            }>;
-            readonly row: BlobType;
-        }>>>;
-        readonly paged: OptionType<StringType>;
-        readonly read: FunctionType<[BlobType, StringType], StructType<{
-            readonly status: OptionType<StructType<{
-                readonly label: StringType;
-                readonly tone: VariantType<{
-                    readonly success: NullType;
-                    readonly warning: NullType;
-                    readonly danger: NullType;
-                    readonly info: NullType;
-                    readonly neutral: NullType;
-                }>;
-                readonly ring: BooleanType;
-            }>>;
-            readonly meter: OptionType<StructType<{
-                readonly value: FloatType;
-                readonly max: FloatType;
-            }>>;
-            readonly metric: OptionType<StringType>;
-            readonly sublabel: OptionType<StringType>;
-        }>>;
-        readonly roles: StructType<{
-            readonly status: BooleanType;
-            readonly meter: BooleanType;
-            readonly metric: BooleanType;
-            readonly sublabel: BooleanType;
-        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    readonly key: StringType;
+    readonly name: StringType;
+    readonly icon: StringType;
+    readonly details: OptionType<StructType<{
         readonly editable: BooleanType;
         readonly editing: OptionType<StructType<{
             sourceId: StringType;
@@ -5759,7 +5514,252 @@ export declare const SchematicNetKindType: StructType<{
             readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
             readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
         }>>;
+        readonly rows: OptionType<FunctionType<[], OptionType<DictType<StringType, StructType<{
+            readonly roles: StructType<{
+                readonly status: OptionType<StructType<{
+                    readonly label: StringType;
+                    readonly tone: VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly ring: BooleanType;
+                }>>;
+                readonly meter: OptionType<StructType<{
+                    readonly value: FloatType;
+                    readonly max: FloatType;
+                }>>;
+                readonly metric: OptionType<StringType>;
+                readonly sublabel: OptionType<StringType>;
+            }>;
+            readonly row: BlobType;
+        }>>>>>;
+        readonly rowsOf: FunctionType<[BlobType], DictType<StringType, StructType<{
+            readonly roles: StructType<{
+                readonly status: OptionType<StructType<{
+                    readonly label: StringType;
+                    readonly tone: VariantType<{
+                        readonly success: NullType;
+                        readonly warning: NullType;
+                        readonly danger: NullType;
+                        readonly info: NullType;
+                        readonly neutral: NullType;
+                    }>;
+                    readonly ring: BooleanType;
+                }>>;
+                readonly meter: OptionType<StructType<{
+                    readonly value: FloatType;
+                    readonly max: FloatType;
+                }>>;
+                readonly metric: OptionType<StringType>;
+                readonly sublabel: OptionType<StringType>;
+            }>;
+            readonly row: BlobType;
+        }>>>;
+        readonly paged: OptionType<StringType>;
+        readonly read: FunctionType<[BlobType, StringType], StructType<{
+            readonly status: OptionType<StructType<{
+                readonly label: StringType;
+                readonly tone: VariantType<{
+                    readonly success: NullType;
+                    readonly warning: NullType;
+                    readonly danger: NullType;
+                    readonly info: NullType;
+                    readonly neutral: NullType;
+                }>;
+                readonly ring: BooleanType;
+            }>>;
+            readonly meter: OptionType<StructType<{
+                readonly value: FloatType;
+                readonly max: FloatType;
+            }>>;
+            readonly metric: OptionType<StringType>;
+            readonly sublabel: OptionType<StringType>;
+        }>>;
+        readonly roles: StructType<{
+            readonly status: BooleanType;
+            readonly meter: BooleanType;
+            readonly metric: BooleanType;
+            readonly sublabel: BooleanType;
+        }>;
+    }>>;
+    readonly sides: StructType<{
+        readonly sources: StringType;
+        readonly destinations: StringType;
+    }>;
+    readonly rows: FunctionType<[], OptionType<DictType<StringType, StructType<{
+        readonly roles: StructType<{
+            readonly sources: ArrayType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+            readonly destinations: ArrayType<StructType<{
+                readonly kind: StringType;
+                readonly key: StringType;
+            }>>;
+            readonly via: ArrayType<StructType<{
+                /** World x */
+                readonly x: FloatType;
+                /** World y */
+                readonly y: FloatType;
+            }>>;
+            readonly label: OptionType<StringType>;
+            readonly metric: OptionType<StringType>;
+            readonly style: VariantType<{
+                /** A physical run (fibre, power cable) */
+                readonly solid: StructType<{
+                    /** Stroke tone (default: the links' muted ink, #1403) */
+                    readonly tone: OptionType<VariantType<{
+                        /** Brand teal */
+                        readonly brand: NullType;
+                        /** Foreground ink */
+                        readonly ink: NullType;
+                        /** Muted foreground */
+                        readonly muted: NullType;
+                        /** Status ok */
+                        readonly success: NullType;
+                        /** Status warn */
+                        readonly warning: NullType;
+                        /** Status bad */
+                        readonly danger: NullType;
+                    }>>;
+                    /** Stroke width in pixels (default 2.5) */
+                    readonly weight: OptionType<FloatType>;
+                }>;
+                /** A routing / logical connection */
+                readonly dashed: StructType<{
+                    /** Stroke tone (default: the links' muted ink, #1403) */
+                    readonly tone: OptionType<VariantType<{
+                        /** Brand teal */
+                        readonly brand: NullType;
+                        /** Foreground ink */
+                        readonly ink: NullType;
+                        /** Muted foreground */
+                        readonly muted: NullType;
+                        /** Status ok */
+                        readonly success: NullType;
+                        /** Status warn */
+                        readonly warning: NullType;
+                        /** Status bad */
+                        readonly danger: NullType;
+                    }>>;
+                    /** Stroke width in pixels (default 1.5) */
+                    readonly weight: OptionType<FloatType>;
+                }>;
+            }>;
+            readonly route: VariantType<{
+                /** Axis-aligned with rounded corners */
+                readonly orthogonal: StructType<{
+                    /** Corner radius in pixels (default 8) */
+                    readonly corner: OptionType<FloatType>;
+                }>;
+                /** Straight segments between anchors */
+                readonly direct: NullType;
+            }>;
+            readonly layer: OptionType<StringType>;
+        }>;
+        readonly row: BlobType;
+    }>>>>;
+    readonly read: FunctionType<[BlobType, StringType], StructType<{
+        readonly sources: ArrayType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly destinations: ArrayType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly via: ArrayType<StructType<{
+            /** World x */
+            readonly x: FloatType;
+            /** World y */
+            readonly y: FloatType;
+        }>>;
+        readonly label: OptionType<StringType>;
+        readonly metric: OptionType<StringType>;
+        readonly style: VariantType<{
+            /** A physical run (fibre, power cable) */
+            readonly solid: StructType<{
+                /** Stroke tone (default: the links' muted ink, #1403) */
+                readonly tone: OptionType<VariantType<{
+                    /** Brand teal */
+                    readonly brand: NullType;
+                    /** Foreground ink */
+                    readonly ink: NullType;
+                    /** Muted foreground */
+                    readonly muted: NullType;
+                    /** Status ok */
+                    readonly success: NullType;
+                    /** Status warn */
+                    readonly warning: NullType;
+                    /** Status bad */
+                    readonly danger: NullType;
+                }>>;
+                /** Stroke width in pixels (default 2.5) */
+                readonly weight: OptionType<FloatType>;
+            }>;
+            /** A routing / logical connection */
+            readonly dashed: StructType<{
+                /** Stroke tone (default: the links' muted ink, #1403) */
+                readonly tone: OptionType<VariantType<{
+                    /** Brand teal */
+                    readonly brand: NullType;
+                    /** Foreground ink */
+                    readonly ink: NullType;
+                    /** Muted foreground */
+                    readonly muted: NullType;
+                    /** Status ok */
+                    readonly success: NullType;
+                    /** Status warn */
+                    readonly warning: NullType;
+                    /** Status bad */
+                    readonly danger: NullType;
+                }>>;
+                /** Stroke width in pixels (default 1.5) */
+                readonly weight: OptionType<FloatType>;
+            }>;
+        }>;
+        readonly route: VariantType<{
+            /** Axis-aligned with rounded corners */
+            readonly orthogonal: StructType<{
+                /** Corner radius in pixels (default 8) */
+                readonly corner: OptionType<FloatType>;
+            }>;
+            /** Straight segments between anchors */
+            readonly direct: NullType;
+        }>;
+        readonly layer: OptionType<StringType>;
+    }>>;
+    readonly write: FunctionType<[BlobType, StructType<{
+        readonly sources: ArrayType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly destinations: ArrayType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+    }>], OptionType<BlobType>>;
+    readonly create: FunctionType<[StructType<{
+        readonly sources: ArrayType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+        readonly destinations: ArrayType<StructType<{
+            readonly kind: StringType;
+            readonly key: StringType;
+        }>>;
+    }>, OptionType<BlobType>], OptionType<BlobType>>;
+    readonly templates: ArrayType<StructType<{
+        readonly key: StringType;
+        readonly name: StringType;
+        readonly group: OptionType<StringType>;
+        readonly icon: OptionType<StringType>;
+        readonly values: BlobType;
     }>>;
+    readonly templatesSource: OptionType<StringType>;
 }>;
 /** Type representing a net kind. */
 export type SchematicNetKindType = typeof SchematicNetKindType;