@elaraai/e3-ui 1.0.97 → 1.0.98

package/dist/src/schematic/kinds.js

@@ -0,0 +1,1027 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The Schematic's kinds (#1386, #1401, `Schematic Builder Spec.md` §1, §4.1–§4.5):
+ * `Schematic.items`, `zones`, `links`, `nets` and `details`. Each takes the
+ * app's own record and maps its fields to the Schematic's roles, as Schedule's
+ * kinds do (#1365): the Schematic stores nothing in a shape of its own.
+ *
+ * - **A role is a field of the app's row, named** (SC1). Its type is checked
+ *   against the role when the code compiles, and again at build: a field the
+ *   row lacks, or one of another type, is refused, naming the role, the field
+ *   and the field's type. A role the app computes — a sub-label, a meter, a
+ *   tone — is an accessor `(row, key) => …`, reified once and called per row.
+ *   So is a role whose value is one of the Schematic's own types — a
+ *   footprint, a zone's shape, a pattern, a style: the accessor builds it with
+ *   the shape helpers from the row's own fields, so the app's record holds
+ *   only its own types (D35).
+ * - **A gesture writes only the fields its roles map** (SC2): a move writes
+ *   an item's `x` and `y`, a Connect a link's `from` and `to`, a net's Shift
+ *   session its `sources` and `destinations`, and every other field of the row
+ *   reads back as it was.
+ * - **Geometry is drawn about its entity's anchor** (D22, SC35): a footprint
+ *   needs the item's box, `width` and `height`, or it is refused.
+ * - **How a kind is bound follows how it is read** (§1, rule 4; SC33):
+ *   editable bound `Record.bind(record, [e3.mutation.patch(record)])` — read
+ *   whole, or through its source of the slice with `entries:
+ *   Data.bindPaged(record)` beside it — and read only bound `Data.bind(record)`,
+ *   read whole, or `Data.bindPaged(record)`, read through its source. Every
+ *   other form is refused, naming the one to use. A kind's details are bound
+ *   as their kind is read.
+ *
+ * A kind closes the record behind East functions over beast2 bytes (§4.8): its
+ * stored rows a read holds, each one's roles beside its bytes; a drafted row's
+ * roles; a gesture's write and a new row; the fields an author's card sets,
+ * any field at any depth (#1390); the shared editing session over the
+ * record with its patch door; the record read by key; its history, its form,
+ * its own inspector and the app's check. So the payload is one type whatever
+ * the rows hold, and the renderer needs no row type. A kind's record is keyed
+ * by String: its entities are named by their keys, and a link's ends hold
+ * them.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, AsyncFunctionType, BlobType, DictType, East, Expr, FloatType, OptionType, PatchType, SetType, StringType, StructType, defaultValue, isTypeEqual, none, printType, some, toEastTypeValue, variant, } from "@elaraai/east";
+import { EditingReadinessType, Fields, FieldSpecType, resolveRowSource } from "@elaraai/east-ui/internal";
+import { RecordOutcomeType } from "../bind/record.js";
+import { scheduleAccessor } from "../schedule/accessor.js";
+import { checkKeyField, fieldOf, fieldSetters, keyFieldRef, keyFieldSlots, keyFieldValue } from "../schedule/fields.js";
+import { scheduleEntriesSeam, scheduleRecordSession } from "../schedule/session.js";
+import { ScheduleEntriesType, ScheduleFieldWriteType, ScheduleReadyEntryType } from "../schedule/types.js";
+import { checkEntries, optionOf, scheduleEntryByKey, scheduleLastKey, typeText } from "../schedule/window.js";
+import { RowInspectorType, rowInspector } from "../utils/row-inspector.js";
+import { checkedSchematicTemplates, isSchematicTemplates } from "./templates.js";
+import { SchematicDetailsEntryType, SchematicDetailsRolesType, SchematicKindDetailsType, SchematicEndsType, SchematicGeometryType, SchematicItemEntryType, SchematicItemKindType, SchematicItemType, SchematicLinkEntryType, SchematicLinkKindType, SchematicLinkStyleType, SchematicLinkType, SchematicMeterType, SchematicNetEntryType, SchematicNetKindType, SchematicNetType, SchematicPointType, SchematicRefType, SchematicRouteType, SchematicSidesType, SchematicStatusCasesFor, SchematicStatusType, SchematicTemplateType, SchematicToneType, SchematicZoneEntryType, SchematicZoneKindType, SchematicZonePatternType, SchematicZoneType, } from "./types.js";
+import { schematicSourceRows, schematicWholeRows } from "./window.js";
+/** The binding forms, as the refusals name them. */
+const FORMS = "Record.bind(record, [e3.mutation.patch(record)]) to edit it, or Data.bind(record) or Data.bindPaged(record) to read it only";
+/**
+ * Tells a kind's binding by its handle's East struct (`bind/sources.ts`'
+ * rule): a `page` field is `Data.bindPaged`'s, a `mutate` field
+ * `Record.bind`'s — checked for its patch door — and any other `Data.bind`'s.
+ *
+ * @param record - What the kind was given
+ * @param where - The kind, as a refusal names it
+ * @returns The binding
+ * @throws {Error} Naming the forms to use: anything but a binding of a record of structs keyed by String, a paged read of
+ *   an index's window or one naming no snapshot, and a `Record.bind` without its patch door
+ */
+function boundOf(record, where) {
+    const refuse = (why) => { throw new Error(`${where}: \`record\` is the app's record, bound — ${FORMS}${why}`); };
+    if (!(record instanceof Expr))
+        return refuse("");
+    const type = Expr.type(record);
+    const fields = type.type === "Struct" ? type.fields : undefined;
+    if (fields === undefined)
+        return refuse(` — and this is ${printType(type)}`);
+    let form;
+    let recordType;
+    if (fields["page"] !== undefined) {
+        form = "paged";
+        if (fields["indexes"] !== undefined) {
+            return refuse(" — and this paged read serves the record's indexes: bind its own entries, Data.bindPaged(record), and name the indexed read " +
+                "as the kind's source of the slice");
+        }
+        const resolved = resolveRowSource(record, where);
+        if (resolved.kind !== "paged") {
+            return refuse(" — and this paged read serves an index's window: bind the record's own entries, Data.bindPaged(record)");
+        }
+        recordType = resolved.collectionType;
+    }
+    else {
+        form = fields["mutate"] !== undefined ? "record" : "data";
+        const read = fields["read"];
+        if (read === undefined || read.type !== "Function" || read.inputs.length !== 0 || fields["binding"] === undefined)
+            return refuse("");
+        recordType = read.output;
+    }
+    if (recordType.type !== "Dict" || !isTypeEqual(recordType.key, StringType) || recordType.value.type !== "Struct") {
+        throw new Error(`${where}: a Schematic kind's record holds its entities by String key, each a struct — and this one holds ${typeText(recordType)}`);
+    }
+    const rowType = recordType.value;
+    if (form === "paged") {
+        // A paged read of the record's own entries, at the snapshot every read of it is at.
+        checkEntries(record, StringType, rowType, `${where}: \`record\``);
+    }
+    if (form === "record") {
+        // The patch door: e3.mutation.patch's, the mutation named `patch` taking the record's patch.
+        const commit = fields["commit"];
+        const door = commit?.type === "Struct" ? commit.fields["patch"] : undefined;
+        if (door === undefined || !isTypeEqual(door, AsyncFunctionType([StringType, PatchType(recordType)], RecordOutcomeType))) {
+            throw new Error(`${where}: \`record\` is bound without its patch door — ${FORMS}`);
+        }
+    }
+    return { form, handle: record, rowType };
+}
+/**
+ * A kind's reads, as its binding and its source of the slice decide them
+ * (SC33): whole, or through its source; and the record read by key.
+ *
+ * @param bound - The kind's binding
+ * @param entries - Its `entries`, checked
+ * @param slot - Its slot
+ * @param part - Its source of the slice, when the slice names one after its slot
+ * @param where - The kind, as a refusal names it
+ * @param every - Whether, read through its source, it reads every row: under `narrowed="dim"` (§10.3)
+ * @returns `()` → its rows, by key, and the paged read its rows are read by key through, if any
+ * @throws {Error} Naming the form to use, for each binding its read does not take
+ */
+function readsOf(bound, entries, slot, part, where, every) {
+    if (part === undefined) {
+        if (bound.form === "paged") {
+            throw new Error(`${where}: a paged binding has no whole read — read it through its source of the slice, slot "${slot}": ` +
+                `slice={{ slice: Slice.bindRecords(key, { ${slot}: { source: Data.bindPaged(record, { indexes }) } }) }} — or bind Data.bind(record) to read it whole`);
+        }
+        if (entries !== undefined) {
+            throw new Error(`${where}: \`entries\` reads the record by key beside its source of the slice — name one "${slot}", ` +
+                `or leave \`entries\` out: a kind read whole reads its rows from the record`);
+        }
+        return { rows: schematicWholeRows(bound.handle, bound.rowType), byKey: undefined };
+    }
+    if (bound.form === "data") {
+        throw new Error(`${where}: Data.bind(record) reads the record whole, which a source of the slice exists to avoid — ` +
+            `bind it Data.bindPaged(record) to read it through its source "${slot}", or Record.bind(record, [e3.mutation.patch(record)]) with entries to edit it`);
+    }
+    if (bound.form === "record" && entries === undefined) {
+        throw new Error(`${where}: the slice's source "${slot}" reads only its narrowing — and a row is read by its key, the inspector's, a gesture's ` +
+            "original and Save's confirmation: give `entries: Data.bindPaged(record)` beside it, the record's own entries");
+    }
+    return { rows: schematicSourceRows(part, slot, bound.rowType, where, every), byKey: bound.form === "paged" ? bound.handle : entries };
+}
+/**
+ * Checks a kind's `entries` where it declares them: for a record bound to be
+ * edited, a paged read of its own entries.
+ *
+ * @param bound - The kind's binding
+ * @param entries - What the kind was given
+ * @param where - The kind, as a refusal names it
+ * @returns The paged read, checked; `undefined` for none
+ * @throws {Error} When a read-only binding is given `entries`, or they are no paged read of the record's own entries
+ */
+function entriesOf(bound, entries, where) {
+    if (entries === undefined)
+        return undefined;
+    if (bound.form !== "record") {
+        throw new Error(`${where}: \`entries\` reads an editable record by key — a kind bound ${bound.form === "data" ? "Data.bind" : "Data.bindPaged"} ` +
+            `${bound.form === "data" ? "is read whole" : "reads by key through its own binding"}: leave \`entries\` out`);
+    }
+    return checkEntries(entries, StringType, bound.rowType, `${where}: \`entries\``);
+}
+// ============================================================================
+// Shared parts
+// ============================================================================
+/** A field's type by name, refused naming the role when the row lacks it. */
+function fieldTypeOf(rowType, where) {
+    const fields = rowType.fields;
+    return (role, name) => {
+        const type = fields[name];
+        if (type === undefined)
+            throw new Error(`${where}: \`${role}\` names "${name}", a field the row does not have (${Object.keys(fields).join(", ")})`);
+        return type;
+    };
+}
+/** A role naming a field of one type: the field's name, refused naming the role, the field and its type (SC1). */
+function roleField(rowType, where) {
+    const typeOf = fieldTypeOf(rowType, where);
+    return (role, name, type, what) => {
+        if (name === undefined)
+            return undefined;
+        const held = typeOf(role, name);
+        if (!isTypeEqual(held, type))
+            throw new Error(`${where}: \`${role}\` names ${what} — "${name}" holds ${typeText(held)}`);
+        return name;
+    };
+}
+/** An accessor role, reified once and held to the type it returns, naming the role and what it returns (SC1). */
+function accessorRole(rowType, where, role, out, what, fn) {
+    if (fn === undefined)
+        return undefined;
+    if (typeof fn !== "function")
+        throw new Error(`${where}: \`${role}\` is an accessor, (row, key) => ${what}`);
+    return scheduleAccessor(rowType, StringType, out, fn, (returns) => `${where}: \`${role}\` returns ${what} — and this one returns ${returns}`);
+}
+/** A row of the record's type, field by field: each field `set` names from it, every other from `source`. */
+function rowWith(rowType, source, set) {
+    return East.value(Object.fromEntries(Object.keys(rowType.fields).map((f) => [f, set[f] ?? fieldOf(source, f)])), rowType);
+}
+/** The row's fields less those a drop places: what a template gives. */
+function valuesTypeOf(rowType, placed) {
+    return StructType(Object.fromEntries(Object.entries(rowType.fields).filter(([name]) => !placed.includes(name))));
+}
+/** Checks a `status` role: a variant field every row holds, a Status per case. */
+function statusOf(rowType, where, config) {
+    if (config === undefined)
+        return undefined;
+    const type = fieldTypeOf(rowType, where)("status.field", config.field);
+    if (type.type !== "Variant" || optionOf(type) !== undefined) {
+        throw new Error(`${where}: \`status.field\` names a variant field every row holds, a Status per case — "${config.field}" holds ${typeText(type)}`);
+    }
+    return {
+        field: config.field,
+        cases: Object.keys(type.cases),
+        table: East.value(config.cases, SchematicStatusCasesFor(type)),
+    };
+}
+/** The status a row shows, by its case: the table's Status for it, the table bound once in the block. */
+function statusShown($, status, row) {
+    if (status === undefined)
+        return East.value(none, OptionType(SchematicStatusType));
+    const table = $.const(status.table);
+    return fieldOf(row, status.field).match(Object.fromEntries(status.cases.map((c) => [c, (_$) => East.value(some(fieldOf(table, c)), OptionType(SchematicStatusType))])));
+}
+/** An accessor's value for a row, bound in the block; `otherwise` for a kind with no such accessor. */
+function called($, fn, row, key, wrap, otherwise) {
+    if (fn === undefined)
+        return otherwise;
+    const bound = $.const(fn);
+    return wrap(bound(row, key));
+}
+/**
+ * A kind's stored rows a read holds, by key: each one's roles, read in the
+ * pass that reads the row, beside its bytes. The renderer puts its drafts in
+ * place itself, as the Roster's and the Allocation's do.
+ */
+function storedRows(read, rolesOf, EntryType) {
+    const Rows = DictType(StringType, EntryType);
+    return East.function([], OptionType(Rows), ($) => {
+        const readRows = $.const(read);
+        const roles = $.const(rolesOf);
+        const result = $.let(East.value(none, OptionType(Rows)), OptionType(Rows));
+        $.match(readRows(), {
+            some: ($2, held) => {
+                const out = $2.let(new Map(), Rows);
+                $2.for(held, ($3, row, key) => {
+                    $3(out.insert(key, East.value({ roles: roles(row, key), row: East.Blob.encodeBeast(row, "v2") }, EntryType)));
+                });
+                $2.assign(result, some(out));
+            },
+        });
+        return result;
+    });
+}
+/**
+ * The rows a reader read of a record by area or by key, made its stored rows
+ * (#1393): each row's roles, read in the pass that reads it, beside its bytes,
+ * as `rows` gives them — from the rows as beast2 bytes of an `Array` of
+ * `{ key, row }` at the record's row type, which the reader encodes from what
+ * it read.
+ *
+ * @param rowType - The record's row type
+ * @param rolesOf - A row's roles, from it and its key
+ * @param EntryType - A stored row's type: its roles beside its bytes
+ * @returns `(bytes)` → the rows, by key
+ */
+function rowsReadOf(rowType, rolesOf, EntryType) {
+    const Read = ArrayType(StructType({ key: StringType, row: rowType }));
+    const Rows = DictType(StringType, EntryType);
+    return East.function([BlobType], Rows, ($, bytes) => {
+        const roles = $.const(rolesOf);
+        const read = $.const(bytes.decodeBeast(Read, "v2"));
+        const out = $.let(new Map(), Rows);
+        $.for(read, ($2, entry) => {
+            $2(out.insert(entry.key, East.value({ roles: roles(entry.row, entry.key), row: East.Blob.encodeBeast(entry.row, "v2") }, EntryType)));
+        });
+        return out;
+    });
+}
+/** A drafted row's roles, from its bytes and its key: what `rows` gives a stored one. */
+function readOf(rowType, rolesOf, RolesType) {
+    return East.function([BlobType, StringType], RolesType, ($, bytes, key) => {
+        const roles = $.const(rolesOf);
+        return roles(bytes.decodeBeast(rowType, "v2"), key);
+    });
+}
+/** The app's check over drafted rows, one result each; a check that throws refuses its own row alone. */
+function readyOf(rowType, ready) {
+    if (ready === undefined)
+        return undefined;
+    const author = East.function([rowType, StringType], EditingReadinessType, ($, row, key) => $.const(ready(row, key), EditingReadinessType));
+    return East.function([ArrayType(ScheduleReadyEntryType)], ArrayType(EditingReadinessType), ($, batch) => {
+        const check = $.const(author);
+        return batch.map(($2, item) => {
+            const result = $2.let(variant("ready", null), EditingReadinessType);
+            $2.try(($3) => {
+                $3.assign(result, check(item.entry.decodeBeast(rowType, "v2"), item.id));
+            }).catch(($3, message) => {
+                $3.assign(result, variant("invalid", [{ field: "", message: East.str `Readiness check failed: ${message}` }]));
+            });
+            return result;
+        });
+    });
+}
+/**
+ * The row with each of a card's field writes applied in order, and every other
+ * field as it was (#1390): what an author's card dropped on an entity sets —
+ * the fields its `Schematic.patch` sets, each a field at any depth, its value
+ * as bytes at the field's type — through the setter Schedule's kinds write an
+ * inspector's edit with (`fieldSetters`).
+ *
+ * @param rowType - The record's row type
+ * @returns `(bytes, writes)` → the row written; `none` when a write names no field of the row
+ */
+function rowSetter(rowType) {
+    const setters = fieldSetters(rowType);
+    return East.function([BlobType, ArrayType(ScheduleFieldWriteType)], OptionType(BlobType), ($, bytes, writes) => {
+        // Each setter's path as East holds it: a field is named by its steps, never by text a dotted name could mimic.
+        const fns = setters.map((setter) => ({ path: $.const([...setter.path], ArrayType(StringType)), set: $.const(setter.set) }));
+        const row = $.let(bytes.decodeBeast(rowType, "v2"), rowType);
+        const named = $.let(true);
+        $.for(writes, ($2, write) => {
+            const found = $2.let(false);
+            for (const fn of fns) {
+                $2.if(East.equal(write.path, fn.path), ($3) => {
+                    $3.assign(row, fn.set(row, write.value));
+                    $3.assign(found, true);
+                });
+            }
+            $2.if(found.not(), ($3) => { $3.assign(named, false); });
+        });
+        return named.ifElse((_$2) => East.value(some(East.Blob.encodeBeast(row, "v2")), OptionType(BlobType)), (_$2) => East.value(none, OptionType(BlobType)));
+    });
+}
+/**
+ * A record's side of a kind on the wire: whether it is editable, its session
+ * and its read by key, its history, its form, its own Details, the app's
+ * check, and the setter an author's card writes its fields through.
+ *
+ * @param bound - The record's binding
+ * @param entries - Its `entries`, checked
+ * @param byKey - The paged read its rows are read by key through, if any
+ * @param config - Its form's hints, its check and its own Details
+ * @param omitted - The fields its roles write, which its form leaves out
+ * @param where - The kind, as a refusal names it
+ * @returns The fields every kind and details record carry
+ * @throws {Error} As `Fields.specs`, `rowInspector` and the patch door's check refuse
+ */
+function recordSide(bound, entries, byKey, config, omitted, where) {
+    const rowType = bound.rowType;
+    const form = Fields.specs(rowType, (config.fields ?? {}), [...new Set(omitted.filter((name) => name !== undefined))]);
+    const inspector = config.inspector === undefined ? undefined : rowInspector(config.inspector, rowType, `${where}: \`inspector\` is the kind's own Details — an East.function over the row and its writer: ` +
+        "East.function([RowType, FunctionType([RowType], NullType)], UIComponentType, ($, row, update) => …), RowType the record's row");
+    // Typed over the kind's row, as its author wrote it: called over the row the check decodes.
+    const ready = readyOf(rowType, config.ready);
+    let editing = none;
+    let seam;
+    let history = none;
+    if (bound.form === "record") {
+        // The shared session over the record (Schedule's `session.ts`): whole-entry drafts, keyed batches, Save through
+        // its patch door — its base the record's snapshot, or, read through a source, its revision.
+        const session = scheduleRecordSession(bound.handle, StringType, rowType, byKey === undefined ? undefined : entries);
+        const built = session.build();
+        editing = some(built.editing);
+        seam = built.entries;
+        history = some(session.history);
+    }
+    else if (byKey !== undefined) {
+        // Read only through `Data.bindPaged`: the record read by key through that binding itself.
+        seam = scheduleEntriesSeam(byKey, scheduleEntryByKey(byKey, StringType, rowType), scheduleLastKey(byKey, StringType));
+    }
+    return {
+        editable: bound.form === "record",
+        editing,
+        entries: seam ?? East.value(none, OptionType(ScheduleEntriesType)),
+        history,
+        fields: East.value(form, ArrayType(FieldSpecType)),
+        inspector: inspector === undefined ? East.value(none, OptionType(RowInspectorType)) : some(inspector),
+        ready: ready === undefined ? none : some(ready),
+        set: rowSetter(rowType),
+        rowType: toEastTypeValue(rowType),
+    };
+}
+/**
+ * A shape role, an accessor over the row's own fields (D35): refused when it
+ * names a field, as the Schematic's own type would then live in the app's row.
+ *
+ * @param rowType - The kind's row type
+ * @param where - The kind, as a refusal names it
+ * @param role - `footprint` or `geometry`
+ * @param fn - What the kind was given
+ * @returns The accessor, reified; `undefined` when not given
+ * @throws {Error} When it names a field, is no function, or returns another type, naming the accessor to write
+ */
+function shapeRole(rowType, where, role, fn) {
+    const example = role === "footprint" ? "footprint: (unit) => some(Schematic.circle(unit.radius))" : "geometry: (area) => some(Schematic.polygon(area.corners))";
+    if (typeof fn === "string") {
+        throw new Error(`${where}: \`${role}\` is an accessor over the row's own fields, built with Schematic.circle, polygon, polyline or rect — ` +
+            `${example}: a role naming "${fn}", a field that holds Schematic.Types.Geometry, is gone, so the app's record keeps its own types`);
+    }
+    return accessorRole(rowType, where, role, OptionType(SchematicGeometryType), `an Option of a Schematic.Types.Geometry, built with Schematic.circle, polygon, polyline or rect (${example})`, fn);
+}
+/** The card roles a kind's details may give: refused when the kind gives them too. */
+const CARD_ROLES = ["status", "meter", "metric", "sublabel"];
+// ============================================================================
+// Schematic.details
+// ============================================================================
+/** The key a Schematic's declarations carry their sort under. */
+export const SCHEMATIC_DEF = Symbol("Schematic.def");
+/**
+ * Declares a kind's details (§4.5): a record of the app's keyed as its kind
+ * is — a rack's power, a cooling unit's alarm — which the inspector shows
+ * beside the row and the cards on screen draw: its status, its bar, its figure
+ * and its second line. A kind's row with no details row shows none, and its
+ * card draws no bar.
+ *
+ * @typeParam R - The details record's row type
+ * @typeParam SF - Its status field
+ * @param record - The details record, bound as its kind is read: read whole beside a kind read whole —
+ *   `Data.bind(record)`, or `Record.bind(record, [patch])`; by key beside a kind read through its source —
+ *   `Data.bindPaged(record)`, or `Record.bind(record, [patch])` with `entries`
+ * @param config - Its card roles, its form, its own Details and its `entries`
+ * @returns The details, for a kind's `details`
+ * @throws {Error} Naming the role or the binding: a role naming a field the row lacks or of another type, an accessor
+ *   returning another type, and a record that is no binding of a record of structs keyed by String
+ */
+export function schematicDetails(record, config) {
+    const where = "Schematic.details";
+    const bound = boundOf(record, where);
+    const rowType = bound.rowType;
+    const entries = entriesOf(bound, config.entries, where);
+    const status = statusOf(rowType, where, config.status);
+    const meter = accessorRole(rowType, where, "meter", SchematicMeterType, "a Schematic.Types.Meter, { value, max }", config.meter);
+    const metric = accessorRole(rowType, where, "metric", OptionType(StringType), "an Option of a String", config.metric);
+    const sublabel = accessorRole(rowType, where, "sublabel", StringType, "a String", config.sublabel);
+    const rolesOf = East.function([rowType, StringType], SchematicDetailsRolesType, ($, row, key) => East.value({
+        status: statusShown($, status, row),
+        meter: called($, meter, row, key, (m) => some(m), none),
+        metric: called($, metric, row, key, (m) => m, none),
+        sublabel: called($, sublabel, row, key, (s) => some(s), none),
+    }, SchematicDetailsRolesType));
+    return {
+        [SCHEMATIC_DEF]: "details",
+        roles: CARD_ROLES.filter((role) => config[role] !== undefined),
+        build(kind, throughSource) {
+            const at = `${where} of ${kind}`;
+            if (!throughSource) {
+                if (bound.form === "paged") {
+                    throw new Error(`${at}: beside a kind read whole, its details are read whole — bind them Data.bind(record), ` +
+                        "or Record.bind(record, [e3.mutation.patch(record)]) to edit them");
+                }
+                if (entries !== undefined) {
+                    throw new Error(`${at}: \`entries\` reads the details by key beside a kind read through its source — this kind is read whole, ` +
+                        "and its details with it: leave `entries` out");
+                }
+            }
+            else {
+                if (bound.form === "data") {
+                    throw new Error(`${at}: beside a kind read through its source, its details are read by key — bind them Data.bindPaged(record), ` +
+                        "or Record.bind(record, [e3.mutation.patch(record)]) with entries: Data.bindPaged(record) to edit them");
+                }
+                if (bound.form === "record" && entries === undefined) {
+                    throw new Error(`${at}: beside a kind read through its source, its details are read by key — give \`entries: Data.bindPaged(record)\` ` +
+                        "beside Record.bind, the details record's own entries");
+                }
+            }
+            const byKey = throughSource ? (bound.form === "paged" ? bound.handle : entries) : undefined;
+            const side = recordSide(bound, entries, byKey, config, [], at);
+            return East.value({
+                ...side,
+                rows: throughSource ? none : some(storedRows(schematicWholeRows(bound.handle, rowType), rolesOf, SchematicDetailsEntryType)),
+                rowsOf: rowsReadOf(rowType, rolesOf, SchematicDetailsEntryType),
+                // The paged read the details are read by key through: a reader asks a window's cards' rows of it, in one request (#1393).
+                paged: byKey === undefined ? none : some(fieldOf(byKey, "id")),
+                read: readOf(rowType, rolesOf, SchematicDetailsRolesType),
+                // The card roles they give: what a card keeps the place of while its details row is read (#1398).
+                roles: { status: status !== undefined, meter: meter !== undefined, metric: metric !== undefined, sublabel: sublabel !== undefined },
+            }, SchematicKindDetailsType);
+        },
+    };
+}
+/** Whether a kind's `details` is `Schematic.details`'. */
+function isDetails(details) {
+    return typeof details === "object" && details !== null && SCHEMATIC_DEF in details && details[SCHEMATIC_DEF] === "details";
+}
+/** Checks a kind's details: `Schematic.details`', and no card role given in both places. */
+function detailsOf(details, given, where) {
+    if (details === undefined)
+        return undefined;
+    if (!isDetails(details))
+        throw new Error(`${where}: \`details\` is Schematic.details(record, { status, meter, metric, sublabel }) over a record of the app's keyed as the kind is`);
+    const both = details.roles.filter((role) => given.includes(role));
+    if (both.length > 0) {
+        throw new Error(`${where}: \`${both[0]}\` is given here and by the kind's details — a card draws one; give it in one place`);
+    }
+    return details;
+}
+/** Checks a kind's templates: a templates record's, `Schematic.templates`', never a list written in the code. */
+function templatesOf(templates, where) {
+    if (templates === undefined)
+        return undefined;
+    if (!isSchematicTemplates(templates)) {
+        throw new Error(`${where}: templates are records — Schematic.templates(templates.read(), { name, values, source }) over a record of the app's, ` +
+            "its source one of the slice's");
+    }
+    return templates;
+}
+/**
+ * Declares an item kind (see the module docs and §4.1).
+ *
+ * @typeParam R - The record's row type
+ * @typeParam X - The `x` field
+ * @typeParam Y - The `y` field
+ * @typeParam SF - The status field, when it has one
+ * @param record - The app's record of items: `Record.bind(record, [e3.mutation.patch(record)])` to edit it, or `Data.bind(record)`
+ *   or `Data.bindPaged(record)` to read it only (§1, rule 4)
+ * @param config - Its name and icon, the fields its roles are, its accessors, and its details, templates, form, Details and check
+ * @returns The kind, for the Schematic's `items`, by slot
+ * @throws {Error} Naming the role or the binding (SC1, SC33, SC35): a role naming a field the row lacks, or one of another
+ *   type; `x` and `y` of different types; an accessor returning another type; a `footprint` naming a field rather than
+ *   an accessor building the shape (D35), or without `width` and `height`; a status, a meter, a metric or a second line given both here and by its details; templates written in
+ *   the code, or giving other fields than every field but `x` and `y`; and a record that is no binding of a record of
+ *   structs keyed by String, a `Record.bind` without its patch door, or `entries` beside a read-only binding
+ */
+export function schematicItems(record, config) {
+    const where = `Schematic.items: "${config.name}"`;
+    const bound = boundOf(record, where);
+    const rowType = bound.rowType;
+    const typeOf = fieldTypeOf(rowType, where);
+    const role = roleField(rowType, where);
+    const entries = entriesOf(bound, config.entries, where);
+    if (typeof config.icon !== "string" && typeof config.icon !== "function")
+        throw new Error(`${where}: \`icon\` is a Font Awesome solid icon's name, or an accessor giving each card's`);
+    // The centre: Float fields, or both Options of Float, which give the kind a backlog.
+    const xType = typeOf("x", config.x);
+    const yType = typeOf("y", config.y);
+    const isPlace = (t) => isTypeEqual(t, FloatType) || isTypeEqual(t, OptionType(FloatType));
+    for (const [prop, name, type] of [["x", config.x, xType], ["y", config.y, yType]]) {
+        if (!isPlace(type))
+            throw new Error(`${where}: \`${prop}\` names a Float field, or an Option of one — "${name}" holds ${typeText(type)}`);
+    }
+    if (!isTypeEqual(xType, yType)) {
+        throw new Error(`${where}: \`x\` and \`y\` are both Float fields, or both Options of Float — "${config.x}" holds ${typeText(xType)} and "${config.y}" ${typeText(yType)}`);
+    }
+    if (config.x === config.y)
+        throw new Error(`${where}: \`x\` and \`y\` both name "${config.x}" — an item's centre is two fields`);
+    const backlog = optionOf(xType) !== undefined;
+    // The roles that are fields.
+    const labelField = typeof config.label === "string" ? role("label", config.label, StringType, "a String field") : undefined;
+    const labelOf = typeof config.label === "function" ? accessorRole(rowType, where, "label", StringType, "a String", config.label) : undefined;
+    if (labelField === undefined && labelOf === undefined)
+        throw new Error(`${where}: \`label\` names a String field, or is an accessor giving a String`);
+    const widthField = role("width", config.width, FloatType, "a Float field");
+    const heightField = role("height", config.height, FloatType, "a Float field");
+    const footprintOf = shapeRole(rowType, where, "footprint", config.footprint);
+    // Geometry is drawn about the item's centre, inside its box (D22, SC35): a footprint needs the box.
+    if (footprintOf !== undefined && (widthField === undefined || heightField === undefined)) {
+        throw new Error(`${where}: \`footprint\` is drawn about the item's centre, inside its box — give \`width\` and \`height\` with it, the box's Float fields`);
+    }
+    const layerField = role("layer", config.layer, StringType, "a String field");
+    const status = statusOf(rowType, where, config.status);
+    // The roles the app computes.
+    const iconOf = typeof config.icon === "function" ? accessorRole(rowType, where, "icon", StringType, "a String, a Font Awesome solid icon's name", config.icon) : undefined;
+    const sublabelOf = accessorRole(rowType, where, "sublabel", StringType, "a String", config.sublabel);
+    const metricOf = accessorRole(rowType, where, "metric", OptionType(StringType), "an Option of a String", config.metric);
+    const meterOf = accessorRole(rowType, where, "meter", SchematicMeterType, "a Schematic.Types.Meter, { value, max }", config.meter);
+    const toneOf = accessorRole(rowType, where, "tone", OptionType(SchematicToneType), "an Option of a Schematic.Types.Tone", config.tone);
+    const colorOf = accessorRole(rowType, where, "color", OptionType(StringType), "an Option of a String, a theme colour token", config.color);
+    const weightOf = accessorRole(rowType, where, "weight", OptionType(FloatType), "an Option of a Float", config.weight);
+    const fillOf = accessorRole(rowType, where, "fillOpacity", OptionType(FloatType), "an Option of a Float", config.fillOpacity);
+    const details = detailsOf(config.details, CARD_ROLES.filter((r) => config[r] !== undefined), where);
+    // The templates: every field but the centre.
+    const ValuesType = valuesTypeOf(rowType, [config.x, config.y]);
+    const templates = templatesOf(config.templates, where);
+    const templateRows = templates === undefined ? East.value([], ArrayType(SchematicTemplateType))
+        : checkedSchematicTemplates(templates, ValuesType, `\`${config.x}\` and \`${config.y}\``, where);
+    // One item's roles, from its row and its key.
+    const rolesOf = East.function([rowType, StringType], SchematicItemType, ($, row, key) => {
+        const PointOption = OptionType(SchematicPointType);
+        let position;
+        if (backlog) {
+            const xs = fieldOf(row, config.x);
+            const ys = fieldOf(row, config.y);
+            position = $.let(xs.match({
+                none: (_$2) => East.value(none, PointOption),
+                some: (_$2, x) => ys.match({
+                    none: (_$3) => East.value(none, PointOption),
+                    some: (_$3, y) => East.value(some({ x, y }), PointOption),
+                }),
+            }), PointOption);
+        }
+        else {
+            position = East.value(some({ x: fieldOf(row, config.x), y: fieldOf(row, config.y) }), PointOption);
+        }
+        const label = labelField !== undefined ? fieldOf(row, labelField) : called($, labelOf, row, key, (l) => l, "");
+        const icon = typeof config.icon === "string" ? some(config.icon) : called($, iconOf, row, key, (i) => some(i), none);
+        return East.value({
+            position,
+            label,
+            width: widthField === undefined ? none : some(fieldOf(row, widthField)),
+            height: heightField === undefined ? none : some(fieldOf(row, heightField)),
+            footprint: called($, footprintOf, row, key, (f) => f, none),
+            layer: layerField === undefined ? none : some(fieldOf(row, layerField)),
+            icon,
+            sublabel: called($, sublabelOf, row, key, (s) => some(s), none),
+            metric: called($, metricOf, row, key, (m) => m, none),
+            meter: called($, meterOf, row, key, (m) => some(m), none),
+            status: statusShown($, status, row),
+            tone: called($, toneOf, row, key, (t) => t, none),
+            color: called($, colorOf, row, key, (c) => c, none),
+            weight: called($, weightOf, row, key, (w) => w, none),
+            fillOpacity: called($, fillOf, row, key, (f) => f, none),
+        }, SchematicItemType);
+    });
+    // A row with its centre written from a position, every other field from `source`: none, a backlog kind's row
+    // unplaced; `none` for no position on a kind with no backlog.
+    const placed = (source, position) => {
+        const at = (x, y) => East.value(some(East.Blob.encodeBeast(rowWith(rowType, source, { [config.x]: x, [config.y]: y }), "v2")), OptionType(BlobType));
+        if (backlog) {
+            return position.match({
+                none: (_$2) => at(East.value(none, OptionType(FloatType)), East.value(none, OptionType(FloatType))),
+                some: (_$2, p) => at(East.value(some(p.x), OptionType(FloatType)), East.value(some(p.y), OptionType(FloatType))),
+            });
+        }
+        return position.match({
+            none: (_$2) => East.value(none, OptionType(BlobType)),
+            some: (_$2, p) => at(p.x, p.y),
+        });
+    };
+    // The row with its centre written — none, unplaced — and every other field as it was (SC2).
+    const write = East.function([BlobType, OptionType(SchematicPointType)], OptionType(BlobType), ($, bytes, position) => {
+        const row = $.const(bytes.decodeBeast(rowType, "v2"));
+        return placed(row, position);
+    });
+    // A new row at a position, every other field from a template's values, or its type's default.
+    const blank = East.value(defaultValue(ValuesType), ValuesType);
+    const create = East.function([OptionType(SchematicPointType), OptionType(BlobType)], OptionType(BlobType), ($, position, values) => {
+        const given = $.const(values.match({
+            some: (_$2, bytes) => bytes.decodeBeast(ValuesType, "v2"),
+            none: (_$2) => blank,
+        }));
+        return placed(given, position);
+    });
+    return {
+        [SCHEMATIC_DEF]: "items",
+        rowType,
+        name: config.name,
+        backlog,
+        hasTemplates: templates !== undefined,
+        templatesSource: templates?.source,
+        build(slot, part, every = false) {
+            const { rows, byKey } = readsOf(bound, entries, slot, part, where, every);
+            const side = recordSide(bound, entries, byKey, config, [config.x, config.y, labelField, widthField, heightField, layerField, status?.field], where);
+            return East.value({
+                ...side,
+                key: slot,
+                name: config.name,
+                icon: typeof config.icon === "string" ? config.icon : "",
+                details: details === undefined ? none : some(details.build(slot, part !== undefined)),
+                backlog,
+                status: status === undefined ? [] : status.cases.map((c) => ({ case: c, status: fieldOf(status.table, c) })),
+                rows: storedRows(rows, rolesOf, SchematicItemEntryType),
+                rowsOf: rowsReadOf(rowType, rolesOf, SchematicItemEntryType),
+                // The paged read the kind's rows are read by key through: a reader asks the far ends of the links and nets
+                // touching its window of it, all of a window's in one request, whether or not its source joins its rows (#1393).
+                paged: byKey === undefined ? none : some(fieldOf(byKey, "id")),
+                box: {
+                    x: config.x, y: config.y,
+                    width: widthField === undefined ? none : some(widthField), height: heightField === undefined ? none : some(heightField),
+                },
+                read: readOf(rowType, rolesOf, SchematicItemType),
+                write,
+                create,
+                templates: templateRows,
+                templatesSource: templates?.source === undefined ? none : some(templates.source),
+            }, SchematicItemKindType);
+        },
+    };
+}
+/**
+ * Declares a zone kind (§4.2).
+ *
+ * @typeParam R - The record's row type
+ * @param record - The app's record of zones, bound as §1, rule 4 says
+ * @param config - Its name and icon, the fields its box and label are, its pattern and shape, and its details, form, Details and check
+ * @returns The kind, for the Schematic's `zones`, by slot
+ * @throws {Error} Naming the role or the binding, as `Schematic.items` does, and a `geometry` naming a field rather than an
+ *   accessor building the shape (D35)
+ */
+export function schematicZones(record, config) {
+    const where = `Schematic.zones: "${config.name}"`;
+    const bound = boundOf(record, where);
+    const rowType = bound.rowType;
+    const role = roleField(rowType, where);
+    const entries = entriesOf(bound, config.entries, where);
+    if (typeof config.icon !== "string")
+        throw new Error(`${where}: \`icon\` is a Font Awesome solid icon's name`);
+    if ("templates" in config)
+        throw new Error(`${where}: zones take no templates — a zone is added through its record, and edited in the inspector`);
+    const xField = role("x", config.x, FloatType, "a Float field");
+    const yField = role("y", config.y, FloatType, "a Float field");
+    const widthField = role("width", config.width, FloatType, "a Float field");
+    const heightField = role("height", config.height, FloatType, "a Float field");
+    for (const [prop, name] of [["x", xField], ["y", yField], ["width", widthField], ["height", heightField]]) {
+        if (name === undefined)
+            throw new Error(`${where}: \`${prop}\` names a Float field of the zone's box`);
+    }
+    const labelField = typeof config.label === "string" ? role("label", config.label, StringType, "a String field") : undefined;
+    const labelOf = typeof config.label === "function" ? accessorRole(rowType, where, "label", StringType, "a String", config.label) : undefined;
+    if (labelField === undefined && labelOf === undefined)
+        throw new Error(`${where}: \`label\` names a String field, or is an accessor giving a String`);
+    const geometryOf = shapeRole(rowType, where, "geometry", config.geometry);
+    const layerField = role("layer", config.layer, StringType, "a String field");
+    const patternOf = accessorRole(rowType, where, "pattern", SchematicZonePatternType, "a Schematic.Types.ZonePattern", config.pattern);
+    const toneOf = accessorRole(rowType, where, "tone", OptionType(SchematicToneType), "an Option of a Schematic.Types.Tone", config.tone);
+    const colorOf = accessorRole(rowType, where, "color", OptionType(StringType), "an Option of a String, a theme colour token", config.color);
+    const fillOf = accessorRole(rowType, where, "fillOpacity", OptionType(FloatType), "an Option of a Float", config.fillOpacity);
+    const weightOf = accessorRole(rowType, where, "weight", OptionType(FloatType), "an Option of a Float", config.weight);
+    const details = detailsOf(config.details, [], where);
+    const outline = East.value(variant("outline", { tone: none }), SchematicZonePatternType);
+    const rolesOf = East.function([rowType, StringType], SchematicZoneType, ($, row, key) => East.value({
+        x: fieldOf(row, xField), y: fieldOf(row, yField), width: fieldOf(row, widthField), height: fieldOf(row, heightField),
+        label: labelField !== undefined ? fieldOf(row, labelField) : called($, labelOf, row, key, (l) => l, ""),
+        pattern: called($, patternOf, row, key, (p) => p, outline),
+        geometry: called($, geometryOf, row, key, (g) => g, none),
+        layer: layerField === undefined ? none : some(fieldOf(row, layerField)),
+        tone: called($, toneOf, row, key, (t) => t, none),
+        color: called($, colorOf, row, key, (c) => c, none),
+        fillOpacity: called($, fillOf, row, key, (f) => f, none),
+        weight: called($, weightOf, row, key, (w) => w, none),
+    }, SchematicZoneType));
+    return {
+        [SCHEMATIC_DEF]: "zones",
+        rowType,
+        name: config.name,
+        hasTemplates: false,
+        templatesSource: undefined,
+        build(slot, part, every = false) {
+            const { rows, byKey } = readsOf(bound, entries, slot, part, where, every);
+            const side = recordSide(bound, entries, byKey, config, [xField, yField, widthField, heightField, labelField, layerField], where);
+            return East.value({
+                ...side,
+                key: slot,
+                name: config.name,
+                icon: config.icon,
+                details: details === undefined ? none : some(details.build(slot, part !== undefined)),
+                rows: storedRows(rows, rolesOf, SchematicZoneEntryType),
+                rowsOf: rowsReadOf(rowType, rolesOf, SchematicZoneEntryType),
+                box: { x: xField, y: yField, width: some(widthField), height: some(heightField) },
+                read: readOf(rowType, rolesOf, SchematicZoneType),
+            }, SchematicZoneKindType);
+        },
+    };
+}
+/** Checks a link's or a net's drawing roles. */
+function edgeRoles(rowType, where, config) {
+    const role = roleField(rowType, where);
+    return {
+        viaField: role("via", config.via, ArrayType(SchematicPointType), "an Array of { x, y } Floats field"),
+        layerField: role("layer", config.layer, StringType, "a String field"),
+        labelOf: accessorRole(rowType, where, "label", OptionType(StringType), "an Option of a String", config.label),
+        metricOf: accessorRole(rowType, where, "metric", OptionType(StringType), "an Option of a String", config.metric),
+        styleOf: accessorRole(rowType, where, "style", SchematicLinkStyleType, "a Schematic.Types.LinkStyle", config.style),
+        routeOf: accessorRole(rowType, where, "route", SchematicRouteType, "a Schematic.Types.Route", config.route),
+    };
+}
+/** A link's or a net's drawing roles, for a row. */
+function edgeShown($, edge, row, key) {
+    return {
+        via: edge.viaField === undefined ? East.value([], ArrayType(SchematicPointType)) : fieldOf(row, edge.viaField),
+        label: called($, edge.labelOf, row, key, (l) => l, none),
+        metric: called($, edge.metricOf, row, key, (m) => m, none),
+        style: called($, edge.styleOf, row, key, (s) => s, East.value(variant("solid", { tone: none, weight: none }), SchematicLinkStyleType)),
+        route: called($, edge.routeOf, row, key, (r) => r, East.value(variant("orthogonal", { corner: none }), SchematicRouteType)),
+        layer: edge.layerField === undefined ? none : some(fieldOf(row, edge.layerField)),
+    };
+}
+/**
+ * Declares a link kind (§4.3).
+ *
+ * @typeParam R - The record's row type
+ * @typeParam FF - The `from` field
+ * @typeParam TF - The `to` field
+ * @param record - The app's record of links, bound as §1, rule 4 says
+ * @param config - Its name and icon, its ends, its drawing roles, and its details, templates, form, Details and check
+ * @returns The kind, for the Schematic's `links`, by slot
+ * @throws {Error} Naming the role or the binding, as `Schematic.items` does: an end of neither a String field nor a
+ *   variant of String cases — an Option among them, a link having both its ends — or whose `of` names no item slot,
+ *   and `from` and `to` naming one field
+ */
+export function schematicLinks(record, config) {
+    const where = `Schematic.links: "${config.name}"`;
+    const bound = boundOf(record, where);
+    const rowType = bound.rowType;
+    const fields = rowType.fields;
+    const typeOf = fieldTypeOf(rowType, where);
+    const entries = entriesOf(bound, config.entries, where);
+    if (typeof config.icon !== "string")
+        throw new Error(`${where}: \`icon\` is a Font Awesome solid icon's name`);
+    const end = (prop, given) => {
+        if (given === undefined || typeof given.field !== "string")
+            throw new Error(`${where}: \`${prop}\` is { field, of } — the field holding an item's key, and the item slot it holds keys of`);
+        const checked = checkKeyField(given.field, typeOf(`${prop}.field`, given.field), given.of, { where, prop, noun: "item" });
+        if (checked.optional) {
+            throw new Error(`${where}: a link has both its ends — \`${prop}.field\` names a String field or a variant of String cases, ` +
+                `and "${given.field}" holds ${typeText(fields[given.field])}`);
+        }
+        return checked;
+    };
+    const from = end("from", config.from);
+    const to = end("to", config.to);
+    if (from.field === to.field)
+        throw new Error(`${where}: \`from\` and \`to\` both name "${from.field}" — a link's ends are two fields`);
+    const edge = edgeRoles(rowType, where, config);
+    const details = detailsOf(config.details, [], where);
+    const ValuesType = valuesTypeOf(rowType, [from.field, to.field]);
+    const templates = templatesOf(config.templates, where);
+    const templateRows = templates === undefined ? East.value([], ArrayType(SchematicTemplateType))
+        : checkedSchematicTemplates(templates, ValuesType, `\`${from.field}\` and \`${to.field}\``, where);
+    const fromRef = keyFieldRef(from, rowType);
+    const toRef = keyFieldRef(to, rowType);
+    const fromValue = keyFieldValue(from, fields[from.field]);
+    const toValue = keyFieldValue(to, fields[to.field]);
+    const rolesOf = East.function([rowType, StringType], SchematicLinkType, ($, row, key) => {
+        const fromOf = $.const(fromRef);
+        const toOf = $.const(toRef);
+        return East.value({
+            from: fromOf(row).unwrap(),
+            to: toOf(row).unwrap(),
+            ...edgeShown($, edge, row, key),
+        }, SchematicLinkType);
+    });
+    // A row with its ends written from `ends`, every other field from `source`; `none` for an end of a slot the field holds no keys of.
+    const ended = ($, source, ends) => {
+        const fromOf = $.const(fromValue);
+        const toOf = $.const(toValue);
+        const result = $.let(East.value(none, OptionType(BlobType)), OptionType(BlobType));
+        $.match(fromOf(some(ends.from)), {
+            some: ($2, f) => {
+                $2.match(toOf(some(ends.to)), {
+                    some: ($3, t) => {
+                        $3.assign(result, East.value(some(East.Blob.encodeBeast(rowWith(rowType, source, { [from.field]: f, [to.field]: t }), "v2")), OptionType(BlobType)));
+                    },
+                });
+            },
+        });
+        return result;
+    };
+    const write = East.function([BlobType, SchematicEndsType], OptionType(BlobType), ($, bytes, ends) => {
+        const row = $.const(bytes.decodeBeast(rowType, "v2"));
+        return ended($, row, ends);
+    });
+    const blank = East.value(defaultValue(ValuesType), ValuesType);
+    const create = East.function([SchematicEndsType, OptionType(BlobType)], OptionType(BlobType), ($, ends, values) => {
+        const given = $.const(values.match({
+            some: (_$2, bytes) => bytes.decodeBeast(ValuesType, "v2"),
+            none: (_$2) => blank,
+        }));
+        return ended($, given, ends);
+    });
+    return {
+        [SCHEMATIC_DEF]: "links",
+        rowType,
+        name: config.name,
+        ends: { from: keyFieldSlots(from), to: keyFieldSlots(to) },
+        hasTemplates: templates !== undefined,
+        templatesSource: templates?.source,
+        build(slot, part, every = false) {
+            const { rows, byKey } = readsOf(bound, entries, slot, part, where, every);
+            const side = recordSide(bound, entries, byKey, config, [from.field, to.field, edge.viaField, edge.layerField], where);
+            return East.value({
+                ...side,
+                key: slot,
+                name: config.name,
+                icon: config.icon,
+                details: details === undefined ? none : some(details.build(slot, part !== undefined)),
+                ends: { from: keyFieldSlots(from), to: keyFieldSlots(to) },
+                rows: storedRows(rows, rolesOf, SchematicLinkEntryType),
+                read: readOf(rowType, rolesOf, SchematicLinkType),
+                write,
+                create,
+                templates: templateRows,
+                templatesSource: templates?.source === undefined ? none : some(templates.source),
+            }, SchematicLinkKindType);
+        },
+    };
+}
+/**
+ * Declares a net kind (§4.4).
+ *
+ * @typeParam R - The record's row type
+ * @typeParam SRC - The `sources` field
+ * @typeParam DST - The `destinations` field
+ * @param record - The app's record of nets, bound as §1, rule 4 says
+ * @param config - Its name and icon, its sides, its drawing roles, and its details, templates, form, Details and check
+ * @returns The kind, for the Schematic's `nets`, by slot
+ * @throws {Error} Naming the role or the binding, as `Schematic.items` does: a side of neither a Set nor an Array of
+ *   String, whose `of` names no item slot, and both sides naming one field
+ */
+export function schematicNets(record, config) {
+    const where = `Schematic.nets: "${config.name}"`;
+    const bound = boundOf(record, where);
+    const rowType = bound.rowType;
+    const fields = rowType.fields;
+    const typeOf = fieldTypeOf(rowType, where);
+    const entries = entriesOf(bound, config.entries, where);
+    if (typeof config.icon !== "string")
+        throw new Error(`${where}: \`icon\` is a Font Awesome solid icon's name`);
+    const side = (prop, given) => {
+        if (given === undefined || typeof given.field !== "string")
+            throw new Error(`${where}: \`${prop}\` is { field, of } — a Set or an Array of String field of items' keys, and the item slot they are keys of`);
+        const type = typeOf(`${prop}.field`, given.field);
+        const set = isTypeEqual(type, SetType(StringType));
+        if (!set && !isTypeEqual(type, ArrayType(StringType))) {
+            throw new Error(`${where}: \`${prop}.field\` names a Set or an Array of String field, its items' keys — "${given.field}" holds ${typeText(type)}`);
+        }
+        if (typeof given.of !== "string" || given.of === "")
+            throw new Error(`${where}: \`${prop}.of\` names the item slot "${given.field}" holds keys of`);
+        return { field: given.field, of: given.of, set };
+    };
+    const sources = side("sources", config.sources);
+    const destinations = side("destinations", config.destinations);
+    if (sources.field === destinations.field)
+        throw new Error(`${where}: \`sources\` and \`destinations\` both name "${sources.field}" — a net's sides are two fields`);
+    const edge = edgeRoles(rowType, where, config);
+    const details = detailsOf(config.details, [], where);
+    const ValuesType = valuesTypeOf(rowType, [sources.field, destinations.field]);
+    const templates = templatesOf(config.templates, where);
+    const templateRows = templates === undefined ? East.value([], ArrayType(SchematicTemplateType))
+        : checkedSchematicTemplates(templates, ValuesType, `\`${sources.field}\` and \`${destinations.field}\``, where);
+    // A side's members, as references to the items of its slot.
+    const membersOf = (s, row) => {
+        const held = fieldOf(row, s.field);
+        const ref = (key) => East.value({ kind: s.of, key }, SchematicRefType);
+        return s.set
+            ? held.toArray((_$, key) => ref(key))
+            : held.map((_$, key) => ref(key));
+    };
+    const rolesOf = East.function([rowType, StringType], SchematicNetType, ($, row, key) => East.value({
+        sources: membersOf(sources, row),
+        destinations: membersOf(destinations, row),
+        ...edgeShown($, edge, row, key),
+    }, SchematicNetType));
+    // A side's field value from its members; `none` when one is of another slot.
+    const sideValue = (s) => East.function([ArrayType(SchematicRefType)], OptionType(fields[s.field]), ($, refs) => {
+        const taken = $.let(true);
+        $.for(refs, ($2, r) => { $2.if(r.kind.notEquals(s.of), ($3) => { $3.assign(taken, false); }); });
+        const value = s.set ? refs.toSet((_$2, r) => r.key) : refs.map((_$2, r) => r.key);
+        return taken.ifElse((_$2) => East.value(some(value), OptionType(fields[s.field])), (_$2) => East.value(none, OptionType(fields[s.field])));
+    });
+    const sourcesValue = sideValue(sources);
+    const destinationsValue = sideValue(destinations);
+    // A row with its sides written from `sides`, every other field from `source`; `none` for a member of another slot.
+    const sided = ($, source, sidesOf) => {
+        const srcOf = $.const(sourcesValue);
+        const dstOf = $.const(destinationsValue);
+        const result = $.let(East.value(none, OptionType(BlobType)), OptionType(BlobType));
+        $.match(srcOf(sidesOf.sources), {
+            some: ($2, s) => {
+                $2.match(dstOf(sidesOf.destinations), {
+                    some: ($3, d) => {
+                        $3.assign(result, East.value(some(East.Blob.encodeBeast(rowWith(rowType, source, { [sources.field]: s, [destinations.field]: d }), "v2")), OptionType(BlobType)));
+                    },
+                });
+            },
+        });
+        return result;
+    };
+    const write = East.function([BlobType, SchematicSidesType], OptionType(BlobType), ($, bytes, sidesOf) => {
+        const row = $.const(bytes.decodeBeast(rowType, "v2"));
+        return sided($, row, sidesOf);
+    });
+    const blank = East.value(defaultValue(ValuesType), ValuesType);
+    const create = East.function([SchematicSidesType, OptionType(BlobType)], OptionType(BlobType), ($, sidesOf, values) => {
+        const given = $.const(values.match({
+            some: (_$2, bytes) => bytes.decodeBeast(ValuesType, "v2"),
+            none: (_$2) => blank,
+        }));
+        return sided($, given, sidesOf);
+    });
+    return {
+        [SCHEMATIC_DEF]: "nets",
+        rowType,
+        name: config.name,
+        sides: { sources: sources.of, destinations: destinations.of },
+        hasTemplates: templates !== undefined,
+        templatesSource: templates?.source,
+        build(slot, part, every = false) {
+            const { rows, byKey } = readsOf(bound, entries, slot, part, where, every);
+            const sideOf = recordSide(bound, entries, byKey, config, [sources.field, destinations.field, edge.viaField, edge.layerField], where);
+            return East.value({
+                ...sideOf,
+                key: slot,
+                name: config.name,
+                icon: config.icon,
+                details: details === undefined ? none : some(details.build(slot, part !== undefined)),
+                sides: { sources: sources.of, destinations: destinations.of },
+                rows: storedRows(rows, rolesOf, SchematicNetEntryType),
+                read: readOf(rowType, rolesOf, SchematicNetType),
+                write,
+                create,
+                templates: templateRows,
+                templatesSource: templates?.source === undefined ? none : some(templates.source),
+            }, SchematicNetKindType);
+        },
+    };
+}
+/**
+ * Whether something is a Schematic kind of the sort given.
+ *
+ * @param value - What a slot holds
+ * @param sort - The sort the slot takes
+ * @returns Whether it is one
+ */
+export function isSchematicKind(value, sort) {
+    return typeof value === "object" && value !== null && SCHEMATIC_DEF in value && value[SCHEMATIC_DEF] === sort;
+}
+//# sourceMappingURL=kinds.js.map