@elaraai/e3-ui 1.0.103 → 1.0.104

package/dist/src/utils/record-kind.d.ts

@@ -0,0 +1,625 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * A kind over the app's own record: what the Schematic's kinds (#1386) and the
+ * Flowchart's (#1500) share. A kind maps the fields of the app's row to the
+ * builder's roles and closes the record behind East functions over beast2
+ * bytes — its stored rows a read holds, each one's roles beside its bytes; a
+ * drafted row's roles; the fields an author's card sets, any field at any
+ * depth; the shared editing session over the record with its patch door; the
+ * record read by key; its history, its form, its own Details and the app's
+ * check — so a builder's payload is one type whatever the rows hold, and its
+ * renderer needs no row type.
+ *
+ * A kind's record is bound three ways, as each builder's binding check tells
+ * them apart: `Record.bind(record)` with its patch door, editable — read
+ * whole, or through its source of the builder's slice with `entries:
+ * Data.bindPaged(record)` beside it; `Data.bind(record)`, read only and whole;
+ * or `Data.bindPaged(record)`, read only, through its source. Each builder
+ * keeps its own check and its own words; what this module holds is the same
+ * for every builder.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, BlobType, BooleanType, DictType, FunctionType, IntegerType, OptionType, StringType, StructType, type EastType, type ExprType, type NullType, type SubtypeExprOrValue } from "@elaraai/east";
+import type { UIComponentType } from "@elaraai/east-ui";
+import { EditingReadinessType, type FieldHints } from "@elaraai/east-ui/internal";
+/** A record's commits, newest first, as its handle reads them. */
+export declare const KindHistoryType: FunctionType<[], OptionType<ArrayType<StructType<{
+    readonly hash: StringType;
+    readonly parent: OptionType<StringType>;
+    readonly state: StringType;
+    readonly mutation: StringType;
+    readonly actor: StringType;
+    readonly at: import("@elaraai/east").DateTimeType;
+    readonly delta: OptionType<StringType>;
+}>>>>;
+/** Type representing {@link KindHistoryType}. */
+export type KindHistoryType = typeof KindHistoryType;
+/** The author's check over drafted entries, one result each. */
+export declare const KindReadyType: FunctionType<[ArrayType<StructType<{
+    readonly id: StringType;
+    readonly entry: BlobType;
+}>>], ArrayType<import("@elaraai/east").VariantType<{
+    readonly ready: NullType;
+    readonly incomplete: ArrayType<StructType<{
+        readonly field: StringType;
+        readonly message: StringType;
+    }>>;
+    readonly invalid: ArrayType<StructType<{
+        readonly field: StringType;
+        readonly message: StringType;
+    }>>;
+}>>>;
+/** Type representing {@link KindReadyType}. */
+export type KindReadyType = typeof KindReadyType;
+/**
+ * What every kind over the app's record carries: how the record is read and
+ * written, and the inspector's form.
+ *
+ * @property editable - Whether the record is bound with its patch door: what its gestures, drops and edits write
+ * @property editing - The shared session over the record, with its patch door; `none` for a record bound read only
+ * @property entries - The record read by key, for a record read through its source or bound with `Data.bindPaged`; `none` for one read whole
+ * @property history - The record's commits, newest first; `none` for a record bound with `Data.bind` or `Data.bindPaged`
+ * @property fields - The inspector's form over the fields no role writes (`Fields`)
+ * @property inspector - The kind's own Details in place of its form, over bytes
+ * @property ready - The app's check on drafted rows, one result each
+ * @property set - The row with each field write applied in order — a field at any depth, its value as bytes at the field's type — and every other field as it was: what an author's card dropped on a row sets (#1390); `none` for a write naming no field of the row
+ * @property rowType - The record's row type
+ */
+export declare const KindSideFields: {
+    readonly editable: BooleanType;
+    readonly editing: OptionType<StructType<{
+        sourceId: StringType;
+        entryType: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            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: import("@elaraai/east").VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: 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;
+        }>>;
+        idField: OptionType<StringType>;
+        draftType: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            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: import("@elaraai/east").VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: 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;
+        }>>;
+        children: OptionType<StringType>;
+        keyType: OptionType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            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: import("@elaraai/east").VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: 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;
+        }>>>;
+        snapshot: OptionType<BlobType>;
+        readEntry: FunctionType<[StringType, IntegerType], OptionType<BlobType>>;
+        onPatch: OptionType<FunctionType<[BlobType], NullType>>;
+        onApply: OptionType<import("@elaraai/east").VariantType<{
+            readonly sync: FunctionType<[BlobType], import("@elaraai/east").VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+            readonly async: import("@elaraai/east").AsyncFunctionType<[BlobType], import("@elaraai/east").VariantType<{
+                readonly applied: StructType<{
+                    readonly revision: OptionType<StringType>;
+                }>;
+                readonly rejected: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+                readonly conflict: ArrayType<StructType<{
+                    readonly entry: StringType;
+                    readonly row: OptionType<IntegerType>;
+                    readonly field: OptionType<StringType>;
+                    readonly message: StringType;
+                }>>;
+            }>>;
+        }>>;
+        mode: import("@elaraai/east").VariantType<{
+            readonly batch: NullType;
+            readonly auto: NullType;
+        }>;
+    }>>;
+    readonly entries: OptionType<StructType<{
+        readonly revision: FunctionType<[], OptionType<StringType>>;
+        readonly refresh: FunctionType<[OptionType<StringType>], NullType>;
+        readonly entry: FunctionType<[StringType], OptionType<OptionType<BlobType>>>;
+        readonly last: FunctionType<[], OptionType<OptionType<StringType>>>;
+    }>>;
+    readonly history: OptionType<FunctionType<[], OptionType<ArrayType<StructType<{
+        readonly hash: StringType;
+        readonly parent: OptionType<StringType>;
+        readonly state: StringType;
+        readonly mutation: StringType;
+        readonly actor: StringType;
+        readonly at: import("@elaraai/east").DateTimeType;
+        readonly delta: OptionType<StringType>;
+    }>>>>>;
+    readonly fields: ArrayType<StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly label: StringType;
+        readonly help: OptionType<StringType>;
+        readonly group: OptionType<StringType>;
+        readonly type: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+            readonly Never: NullType;
+            readonly Null: NullType;
+            readonly Boolean: NullType;
+            readonly Integer: NullType;
+            readonly Float: NullType;
+            readonly String: NullType;
+            readonly DateTime: NullType;
+            readonly Blob: NullType;
+            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: import("@elaraai/east").VariantType<{
+                readonly ref: IntegerType;
+                readonly wrapper: StructType<{
+                    readonly id: 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 optional: BooleanType;
+        readonly editor: import("@elaraai/east").VariantType<{
+            readonly text: StructType<{
+                readonly placeholder: OptionType<StringType>;
+            }>;
+            readonly number: StructType<{
+                readonly unit: OptionType<StringType>;
+                readonly step: OptionType<import("@elaraai/east").FloatType>;
+                readonly min: OptionType<import("@elaraai/east").FloatType>;
+                readonly max: OptionType<import("@elaraai/east").FloatType>;
+            }>;
+            readonly checkbox: NullType;
+            readonly datetime: StructType<{
+                readonly precision: OptionType<import("@elaraai/east").VariantType<{
+                    readonly date: NullType;
+                    readonly time: NullType;
+                    readonly datetime: NullType;
+                }>>;
+            }>;
+            readonly select: ArrayType<StructType<{
+                readonly case: StringType;
+                readonly label: StringType;
+            }>>;
+            readonly tags: StructType<{
+                readonly options: ArrayType<StringType>;
+            }>;
+            readonly checklist: StructType<{
+                readonly text: StringType;
+                readonly done: StringType;
+            }>;
+            readonly reference: StructType<{
+                readonly of: StringType;
+            }>;
+            readonly readonly: NullType;
+        }>;
+    }>>;
+    readonly inspector: OptionType<FunctionType<[BlobType, FunctionType<[BlobType], NullType>], import("@elaraai/east").RecursiveType<import("@elaraai/east-ui").UIComponentNode>>>;
+    readonly ready: OptionType<FunctionType<[ArrayType<StructType<{
+        readonly id: StringType;
+        readonly entry: BlobType;
+    }>>], ArrayType<import("@elaraai/east").VariantType<{
+        readonly ready: NullType;
+        readonly incomplete: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+        readonly invalid: ArrayType<StructType<{
+            readonly field: StringType;
+            readonly message: StringType;
+        }>>;
+    }>>>>;
+    readonly set: FunctionType<[BlobType, ArrayType<StructType<{
+        readonly path: ArrayType<StringType>;
+        readonly value: BlobType;
+    }>>], OptionType<BlobType>>;
+    readonly rowType: import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
+        readonly Never: NullType;
+        readonly Null: NullType;
+        readonly Boolean: NullType;
+        readonly Integer: NullType;
+        readonly Float: NullType;
+        readonly String: NullType;
+        readonly DateTime: NullType;
+        readonly Blob: NullType;
+        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: import("@elaraai/east").VariantType<{
+            readonly ref: IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: 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;
+    }>>;
+};
+/** A kind's record, bound: how, its handle, and its row type. */
+export interface KindBinding {
+    /** `record`: `Record.bind` with its patch door, editable; `data`: `Data.bind`, read whole; `paged`: `Data.bindPaged`, read through a source. */
+    readonly form: "record" | "data" | "paged";
+    /** The binding's handle. */
+    readonly handle: ExprType<EastType>;
+    /** The record's row type. */
+    readonly rowType: StructType;
+}
+/** An accessor of a row and its key: what a computed role is. */
+export type KindAccessor<R extends EastType, T extends EastType> = (row: ExprType<R>, key: ExprType<StringType>) => SubtypeExprOrValue<T>;
+/** A kind's own Details: an East function over the row and its writer, as the Sheet's are. */
+export type KindRowInspector<R extends StructType> = SubtypeExprOrValue<FunctionType<[R, FunctionType<[R], NullType>], UIComponentType>>;
+/** A kind's rows, by key: what a read of it gives; `none` while it is in flight. */
+export type KindRowsRead = ExprType<FunctionType<[], OptionType<DictType<StringType, EastType>>>>;
+/**
+ * A kind's record read whole: its binding's `read()` — `Record.bind`'s or
+ * `Data.bind`'s — by key.
+ *
+ * @param handle - The record's binding
+ * @param rowType - Its row type
+ * @returns `()` → the record's rows, by key
+ */
+export declare function kindWholeRows(handle: ExprType<EastType>, rowType: StructType): KindRowsRead;
+/**
+ * A kind's narrowing read complete through its source of the builder's slice
+ * — the record slice's `PagedScan`, over `recordSliceReadPlatform` — answering
+ * `none` while a search or a page is in flight.
+ *
+ * Through its source a kind reads what its narrowing holds and nothing else:
+ * the source's choices, each as the rail holds it. Read with `every`, it reads
+ * every row through its source instead, and never the narrowing, so a choice
+ * reads none of its rows again: the renderer draws the rows the narrowing
+ * leaves out as context, from the source's shown keys. An entry's row is its
+ * `row` — the source joins it — or its `value`, for an index that carries the
+ * whole row.
+ *
+ * @param part - The kind's source of the slice, bound once in the builder's payload (`recordSources(…).bind($)`)
+ * @param source - The source's name
+ * @param rowType - The kind's record's row type
+ * @param where - The kind, as a refusal names it
+ * @param every - Whether it reads every row, the narrowing read nowhere: what the narrowing leaves out draws as context
+ * @param remedy - How the refusal of a source over another record names the source to give
+ * @returns `()` → the rows the narrowing holds — or every row — by key; `none` while a search or a page is in flight
+ * @throws {Error} When the source narrows another record, or reads neither its rows nor an index carrying them
+ */
+export declare function kindSourceRows(part: ExprType<StructType>, source: string, rowType: StructType, where: string, every: boolean, remedy: string): KindRowsRead;
+/**
+ * A field's type by name, refused naming the role when the row lacks it.
+ *
+ * @param rowType - The kind's row type
+ * @param where - The kind, as a refusal names it
+ * @returns `(role, name)` → the field's type
+ */
+export declare function fieldTypeOf(rowType: StructType, where: string): (role: string, name: string) => EastType;
+/**
+ * A role naming a field of one type: the field's name, refused naming the
+ * role, the field and its type.
+ *
+ * @param rowType - The kind's row type
+ * @param where - The kind, as a refusal names it
+ * @returns `(role, name, type, what)` → the field's name; `undefined` for a role not given
+ */
+export declare function roleField(rowType: StructType, where: string): (role: string, name: string | undefined, type: EastType, what: string) => string | undefined;
+/**
+ * An accessor role, reified once and held to the type it returns, naming the
+ * role and what it returns.
+ *
+ * @typeParam T - The type it returns
+ * @param rowType - The kind's row type
+ * @param where - The kind, as a refusal names it
+ * @param role - The role, as the refusal names it
+ * @param out - The type it returns
+ * @param what - What it returns, as the refusal says it
+ * @param fn - What the kind was given
+ * @returns The accessor, reified; `undefined` when not given
+ * @throws {Error} When it is no function, or returns another type
+ */
+export declare function accessorRole<T extends EastType>(rowType: StructType, where: string, role: string, out: T, what: string, fn: unknown): import("@elaraai/east").CallableFunctionExpr<[EastType, EastType], T> | undefined;
+/**
+ * A row of the record's type, field by field: each field `set` names from it,
+ * every other from `source`.
+ *
+ * @param rowType - The record's row type
+ * @param source - The row, or a card's values, the other fields are read from
+ * @param set - The fields written, by name
+ * @returns The row
+ */
+export declare function rowWith(rowType: StructType, source: unknown, set: Readonly<Record<string, unknown>>): ExprType<EastType>;
+/**
+ * The row's fields less those its roles write on a drop: what a card's values
+ * give.
+ *
+ * @param rowType - The record's row type
+ * @param placed - The fields a drop writes
+ * @returns The values' type
+ */
+export declare function valuesTypeOf(rowType: StructType, placed: readonly string[]): StructType;
+/**
+ * An accessor's value for a row, bound in the block; `otherwise` for a kind
+ * with no such accessor.
+ *
+ * @typeParam T - The type the accessor returns
+ * @param $ - The block
+ * @param fn - The accessor, reified; `undefined` for none
+ * @param row - The row
+ * @param key - Its key
+ * @param wrap - What the value becomes
+ * @param otherwise - The value without the accessor
+ * @returns The value
+ */
+export declare function called<T extends EastType>($: {
+    const: (value: unknown) => unknown;
+}, fn: ExprType<FunctionType<[EastType, EastType], T>> | undefined, row: unknown, key: unknown, wrap: (value: ExprType<T>) => unknown, otherwise: unknown): unknown;
+/**
+ * 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.
+ *
+ * @param read - The kind's read: whole, or through its source
+ * @param rolesOf - A row's roles, from it and its key
+ * @param EntryType - A stored row's type: its roles beside its bytes
+ * @returns `()` → the rows, by key; `none` while the read is in flight
+ */
+export declare function storedRows(read: ExprType<FunctionType<[], OptionType<DictType<StringType, EastType>>>>, rolesOf: ExprType<FunctionType<[EastType, StringType], EastType>>, EntryType: StructType): import("@elaraai/east").CallableFunctionExpr<[], OptionType<DictType<StringType, StructType>>>;
+/**
+ * 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
+ */
+export declare function rowsReadOf(rowType: StructType, rolesOf: ExprType<FunctionType<[EastType, StringType], EastType>>, EntryType: StructType): import("@elaraai/east").CallableFunctionExpr<[BlobType], DictType<StringType, StructType>>;
+/**
+ * A drafted row's roles, from its bytes and its key: what `rows` gives a
+ * stored one.
+ *
+ * @param rowType - The record's row type
+ * @param rolesOf - A row's roles, from it and its key
+ * @param RolesType - The roles' type
+ * @returns `(bytes, key)` → the roles
+ */
+export declare function readOf(rowType: StructType, rolesOf: ExprType<FunctionType<[EastType, StringType], EastType>>, RolesType: StructType): import("@elaraai/east").CallableFunctionExpr<[BlobType, StringType], StructType>;
+/**
+ * The app's check over drafted rows, one result each; a check that throws
+ * refuses its own row alone.
+ *
+ * @param rowType - The record's row type
+ * @param ready - The app's check over a row and its key
+ * @returns The check over bytes; `undefined` for none
+ */
+export declare function readyOf(rowType: StructType, ready: ((row: ExprType<StructType>, key: ExprType<StringType>) => unknown) | undefined): import("@elaraai/east").CallableFunctionExpr<[ArrayType<StructType<{
+    readonly id: StringType;
+    readonly entry: BlobType;
+}>>], ArrayType<import("@elaraai/east").VariantType<{
+    readonly ready: NullType;
+    readonly incomplete: ArrayType<StructType<{
+        readonly field: StringType;
+        readonly message: StringType;
+    }>>;
+    readonly invalid: ArrayType<StructType<{
+        readonly field: StringType;
+        readonly message: StringType;
+    }>>;
+}>>> | undefined;
+/**
+ * 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 a row sets — the
+ * fields its 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
+ */
+export declare function rowSetter(rowType: StructType): import("@elaraai/east").CallableFunctionExpr<[BlobType, ArrayType<StructType<{
+    readonly path: ArrayType<StringType>;
+    readonly value: BlobType;
+}>>], OptionType<BlobType>>;
+/**
+ * What every kind declares beside its roles, each typed over the record's
+ * row, as Schedule's kinds' are (#1391).
+ *
+ * @typeParam R - The record's row type
+ */
+export interface RecordSide<R extends StructType = StructType> {
+    /** A paged read of the record's own entries, for an editable record read through its source. */
+    entries?: unknown;
+    /** Hints for the inspector's form over the fields no role writes (`Fields`). */
+    fields?: FieldHints<R["fields"]>;
+    /** The app's check on a drafted row, over the row and its key: a refusal holds Save, naming the row and its field. */
+    ready?: (row: ExprType<R>, key: ExprType<StringType>) => SubtypeExprOrValue<typeof EditingReadinessType>;
+    /** The kind's own Details, in place of its form: an East function over the row and its writer. */
+    inspector?: KindRowInspector<R>;
+}
+/**
+ * A record's side of a kind on the wire ({@link KindSideFields}): 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.
+ *
+ * @typeParam R - The record's row type
+ * @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 carries
+ * @throws {Error} As `Fields.specs`, `rowInspector` and the patch door's check refuse
+ */
+export declare function recordSide<R extends StructType>(bound: KindBinding, entries: ExprType<EastType> | undefined, byKey: ExprType<EastType> | undefined, config: RecordSide<R>, omitted: readonly (string | undefined)[], where: string): Record<string, unknown>;
+//# sourceMappingURL=record-kind.d.ts.map

package/dist/src/utils/record-kind.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record-kind.d.ts","sourceRoot":"","sources":["../../../src/utils/record-kind.ts"],"names":[],"mappings":"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"}