@elaraai/e3-types 1.0.79 → 1.0.80

package/dist/src/record.d.ts

@@ -10,12 +10,13 @@
  * a content-addressed commit object, so a record's history is a git-style chain
  * — the audit trail of who changed what, when, superseding which state.
  *
- * The record's current state is an ordinary `value` dataset ref (its `hash`
- * points at the plain state blob), so every existing read path — task inputs,
- * `e3 get`, the UI `Data.bind` read — works on records unchanged. Only the
- * write protocol differs.
+ * The record's current state is an ordinary `value` dataset ref. Its `hash`
+ * names the state or, once the record declares an index, a `$record` state
+ * naming it, and every read path resolves it, so task inputs, `e3 get` and the
+ * UI `Data.bind` read work on records unchanged. Only the write protocol
+ * differs.
  */
-import { StructType, StringType, OptionType, DateTimeType, ArrayType, DictType, ValueTypeOf } from '@elaraai/east';
+import { ArrayType, BooleanType, DateTimeType, DictType, FunctionType, NullType, OptionType, StringType, StructType, VariantType, type EastType, type EastTypeValue, type PatchTypeOf, type ValueTypeOf } from '@elaraai/east';
 /**
  * A single commit in a record's history.
  *
@@ -37,9 +38,58 @@ export declare const RecordCommitType: StructType<{
     readonly actor: StringType;
     /** Commit wall-clock time. */
     readonly at: DateTimeType;
+    /** The mutation delta this commit applied: one sorted collection of the
+     *  primary and index changes, addressed by key. History then shows WHAT
+     *  changed without diffing two states, and an undo can be synthesised from
+     *  it. No state depends on it — every state past and present reads
+     *  identically if every delta were deleted — but it is a collection like any
+     *  other, a manifest naming segment objects, so a collector walks it as a
+     *  value rather than marking it as a leaf the way it marks `args`. */
+    readonly delta: OptionType<StringType>;
 }>;
 export type RecordCommitType = typeof RecordCommitType;
 export type RecordCommit = ValueTypeOf<typeof RecordCommitType>;
+/**
+ * Decode a `RecordCommit`.
+ *
+ * @remarks
+ * Stored state, so it changes by hard cutover: a repository an older e3 wrote
+ * is re-created rather than read, and this says so.
+ *
+ * @param data - the stored bytes
+ * @returns the commit
+ * @throws {Error} When the bytes are not a current commit — one an older e3
+ *   wrote, whose repository is re-created.
+ */
+export declare function decodeRecordCommit(data: Uint8Array): RecordCommit;
+/**
+ * How a mutation says what it changed.
+ *
+ * - `reduce` — `(State, …Args) => State`, the original surface. Its body and
+ *   its diff see the whole state, so its RUNNER cost stays O(state); only its
+ *   write, on a Dict or Set record, is O(touched).
+ * - `edit` — `(State, …Args, Edit) => Null`, the lazy write: the body reads the
+ *   state it is given, lazily, and writes through an `edit` capability, so the
+ *   body reads only the entries it touches and the commit rewrites only the
+ *   segments they live in. The state reaches the runner as its manifest, the
+ *   segments linked, so nothing on the way reads it whole either.
+ * - `patch` — no body; the argument is `PatchType(State)`. What an interactive
+ *   edit from a view sends. On a record with no index a patch of per-key
+ *   changes runs nothing at all, the only write whose cost is independent of
+ *   the record's size.
+ *
+ * @remarks
+ * A variant, so a mutation object decodes only with one of these: a form this
+ * e3 does not know is refused where the object is read, not run as another.
+ */
+export declare const MutationFormType: VariantType<{
+    readonly edit: NullType;
+    readonly patch: NullType;
+    readonly reduce: NullType;
+}>;
+export type MutationFormType = typeof MutationFormType;
+/** A {@link MutationFormType} by its name, as the SDK's definitions carry it. */
+export type MutationForm = ValueTypeOf<typeof MutationFormType>['type'];
 /**
  * A mutation: the write half of the function machinery (CQRS — `e3.function`
  * is the read/query half). A mutation is a pure East reducer
@@ -51,15 +101,15 @@ export declare const MutationObjectType: StructType<{
     /** Hash of the encoded EastIR bundle (encodeEastIR), like a function's bodyIr. */
     readonly bodyIr: StringType;
     /** The EXTRA positional parameter types after the state parameter. */
-    readonly argTypes: ArrayType<import("@elaraai/east").RecursiveType<import("@elaraai/east").VariantType<{
-        readonly Never: import("@elaraai/east").NullType;
-        readonly Null: import("@elaraai/east").NullType;
-        readonly Boolean: import("@elaraai/east").NullType;
-        readonly Integer: import("@elaraai/east").NullType;
-        readonly Float: import("@elaraai/east").NullType;
-        readonly String: import("@elaraai/east").NullType;
-        readonly DateTime: import("@elaraai/east").NullType;
-        readonly Blob: import("@elaraai/east").NullType;
+    readonly argTypes: ArrayType<import("@elaraai/east").RecursiveType<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;
@@ -75,7 +125,7 @@ export declare const MutationObjectType: StructType<{
             readonly name: StringType;
             readonly type: import("@elaraai/east").RecursiveTypeMarker;
         }>>;
-        readonly Recursive: import("@elaraai/east").VariantType<{
+        readonly Recursive: VariantType<{
             readonly ref: import("@elaraai/east").IntegerType;
             readonly wrapper: StructType<{
                 readonly id: import("@elaraai/east").IntegerType;
@@ -93,8 +143,8 @@ export declare const MutationObjectType: StructType<{
         readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
         readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
     }>>>;
-    /** Author-chosen runtime; resolved to argv by runnerToArgv. */
-    readonly runner: import("@elaraai/east").VariantType<{
+    /** Author-chosen runtime the mutation's unit runs on. */
+    readonly runner: VariantType<{
         readonly east_node: StructType<{
             readonly platforms: ArrayType<StringType>;
         }>;
@@ -108,19 +158,533 @@ export declare const MutationObjectType: StructType<{
             readonly command: ArrayType<StringType>;
         }>;
     }>;
+    /** Which write form this is — see {@link MutationFormType}. */
+    readonly form: VariantType<{
+        readonly edit: NullType;
+        readonly patch: NullType;
+        readonly reduce: NullType;
+    }>;
+    /** Hash of the generated program's IR bundle: the one thing that actually
+     *  runs, whatever the form. For the `patch` form `bodyIr` names it too,
+     *  there being no author body. */
+    readonly programIr: StringType;
 }>;
 export type MutationObjectType = typeof MutationObjectType;
 export type MutationObject = ValueTypeOf<typeof MutationObjectType>;
+/**
+ * Decode a `MutationObject`.
+ *
+ * @remarks
+ * A package-borne wire, so it changes by hard cutover: a package exported by
+ * an older SDK is re-exported with the current one, and this says so.
+ *
+ * @param data - the stored bytes
+ * @returns the mutation object
+ * @throws {Error} When the bytes are not a current mutation object — a package
+ *   exported by an older SDK, which is re-exported with the current one.
+ */
+export declare function decodeMutationObject(data: Uint8Array): MutationObject;
+/**
+ * A secondary index over a record: an East function of an entry, and the
+ * collection it builds.
+ *
+ * An index is a second canonical collection whose sort order IS the query
+ * order, stored as a segment manifest exactly like the primary and maintained
+ * inside the same commit — so a view by an attribute of the row, or by a
+ * related entity a row names many of, is a page rather than a scan.
+ *
+ * The functions are pure for the reason a reducer is: they run again on every
+ * commit and in every bulk build, and a maintained index must equal a rebuilt
+ * one to the byte.
+ */
+export declare const RecordIndexObjectType: StructType<{
+    /** Hash of the encoded EastIR bundle: `(K, V) -> IK`, or `-> Set<IK>` when
+     *  {@link multi}. */
+    readonly keyIr: StringType;
+    /** Declared with `keys` (a Set return) rather than `key`: one entry per
+     *  element, so a row that names five resources appears under five keys. */
+    readonly multi: BooleanType;
+    /** Hash of the covering projection's IR bundle, `(K, V) -> P`; none when the
+     *  index carries no value and `P` is Null. */
+    readonly valueIr: OptionType<StringType>;
+    /** `IK` — the index key an entry sorts under. */
+    readonly keyType: import("@elaraai/east").RecursiveType<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: VariantType<{
+            readonly ref: import("@elaraai/east").IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: import("@elaraai/east").IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    /** `P` — the covering projection's type; Null when there is none. */
+    readonly valueType: import("@elaraai/east").RecursiveType<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: VariantType<{
+            readonly ref: import("@elaraai/east").IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: import("@elaraai/east").IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    /** Hash of the generated build program's IR bundle: `(piece, emit) =>
+     *  Null`, which emits the index entries of a piece of the primary, in any
+     *  order. */
+    readonly buildIr: StringType;
+    /** Author-chosen runtime the index's functions run on. */
+    readonly runner: VariantType<{
+        readonly east_node: StructType<{
+            readonly platforms: ArrayType<StringType>;
+        }>;
+        readonly east_py: StructType<{
+            readonly platforms: ArrayType<StringType>;
+        }>;
+        readonly east_c: StructType<{
+            readonly platforms: ArrayType<StringType>;
+        }>;
+        readonly custom: StructType<{
+            readonly command: ArrayType<StringType>;
+        }>;
+    }>;
+}>;
+export type RecordIndexObjectType = typeof RecordIndexObjectType;
+export type RecordIndexObject = ValueTypeOf<typeof RecordIndexObjectType>;
+/**
+ * How a migration says what it changes.
+ *
+ * - `value` — `(Old) => New`, the whole state: one unit, whose runner opens the
+ *   state lazily, so it costs what the body reads.
+ * - `rows` — a Dict's rows, `(K, V1) => V2` with the keys unchanged, or an
+ *   Array's elements, `(T1) => T2` in order: a task split over the state, a
+ *   piece at a time.
+ * - `rekey` — a Dict's entries, `(K1, V1) => { key: K2, value: V2 }`, or a
+ *   Set's elements, `(T1) => T2`: the same split task, whose pieces' outputs
+ *   merge by key. Two rows landing on one key fail, naming it; two elements
+ *   landing on one are one element.
+ *
+ * @remarks
+ * A variant, so a migration object decodes only with one of these: a deploy
+ * never runs a step of a form it does not know as another.
+ */
+export declare const MigrationFormType: VariantType<{
+    readonly rekey: NullType;
+    readonly rows: NullType;
+    readonly value: NullType;
+}>;
+export type MigrationFormType = typeof MigrationFormType;
+/** A {@link MigrationFormType} by its name, as the SDK's definitions carry it. */
+export type MigrationForm = ValueTypeOf<typeof MigrationFormType>['type'];
+/**
+ * A migration: one step of a record's declared chain, which a deploy runs over
+ * a workspace's state that has not applied it.
+ *
+ * @remarks
+ * A step changes the record's type, or keeps the type and changes its values.
+ * The chain is the record object's `migrations`, in order, and a workspace's
+ * record ref names the steps it has applied by name, never by this object's
+ * hash: the hash covers the step's IR, which carries source locations and
+ * changes with the SDK that exported it, so an unchanged step would read as
+ * edited.
+ */
+export declare const MigrationObjectType: StructType<{
+    /** Which form this is — see {@link MigrationFormType}. */
+    readonly form: VariantType<{
+        readonly rekey: NullType;
+        readonly rows: NullType;
+        readonly value: NullType;
+    }>;
+    /** The record's type before the step. */
+    readonly from: import("@elaraai/east").RecursiveType<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: VariantType<{
+            readonly ref: import("@elaraai/east").IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: import("@elaraai/east").IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    /** The record's type after it. */
+    readonly to: import("@elaraai/east").RecursiveType<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: VariantType<{
+            readonly ref: import("@elaraai/east").IntegerType;
+            readonly wrapper: StructType<{
+                readonly id: import("@elaraai/east").IntegerType;
+                readonly inner: import("@elaraai/east").RecursiveTypeMarker;
+            }>;
+        }>;
+        readonly Function: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly AsyncFunction: StructType<{
+            readonly inputs: ArrayType<import("@elaraai/east").RecursiveTypeMarker>;
+            readonly output: import("@elaraai/east").RecursiveTypeMarker;
+        }>;
+        readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
+        readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
+    }>>;
+    /** Hash of the author's function's IR bundle, which a `value` step runs. */
+    readonly bodyIr: StringType;
+    /** Hash of the generated program's IR bundle, `(piece, emit) => Null`,
+     *  which a `rows` or `rekey` step runs over each piece of the state; empty
+     *  for a `value` step. */
+    readonly programIr: StringType;
+    /** Author-chosen runtime the step runs on. */
+    readonly runner: VariantType<{
+        readonly east_node: StructType<{
+            readonly platforms: ArrayType<StringType>;
+        }>;
+        readonly east_py: StructType<{
+            readonly platforms: ArrayType<StringType>;
+        }>;
+        readonly east_c: StructType<{
+            readonly platforms: ArrayType<StringType>;
+        }>;
+        readonly custom: StructType<{
+            readonly command: ArrayType<StringType>;
+        }>;
+    }>;
+}>;
+export type MigrationObjectType = typeof MigrationObjectType;
+export type MigrationObject = ValueTypeOf<typeof MigrationObjectType>;
+/**
+ * Decode a `MigrationObject`.
+ *
+ * @remarks
+ * A package-borne wire, so it changes by hard cutover: a package exported by
+ * an older SDK is re-exported with the current one, and this says so.
+ *
+ * @param data - the stored bytes
+ * @returns the migration object
+ * @throws {Error} When the bytes are not a current migration object — a
+ *   package exported by an older SDK, which is re-exported with the current
+ *   one.
+ */
+export declare function decodeMigrationObject(data: Uint8Array): MigrationObject;
 /**
  * Record object stored in the object store, referenced by name from
- * `PackageObject.records`. Carries the record's dataset path and its mutations.
+ * `PackageObject.records`. Carries the record's dataset path, its mutations,
+ * its secondary indexes and its migration chain.
  */
 export declare const RecordObjectType: StructType<{
     /** refPath of the record's dataset, e.g. `records/orders`. */
     readonly path: StringType;
     /** Mutations by name -> MutationObject hash. */
     readonly mutations: DictType<StringType, StringType>;
+    /** Secondary indexes by name -> RecordIndexObject hash. */
+    readonly indexes: DictType<StringType, StringType>;
+    /** The declared migration chain, in order: each step's name, an identifier
+     *  unique on the record, and its MigrationObject hash. Empty when the
+     *  record declares none. */
+    readonly migrations: ArrayType<StructType<{
+        readonly name: StringType;
+        readonly migration: StringType;
+    }>>;
 }>;
 export type RecordObjectType = typeof RecordObjectType;
 export type RecordObject = ValueTypeOf<typeof RecordObjectType>;
+/**
+ * Decode a `RecordObject`.
+ *
+ * @remarks
+ * A package-borne wire, so it changes by hard cutover: a package exported by
+ * an older SDK is re-exported with the current one, and this says so.
+ *
+ * @param data - the stored bytes
+ * @returns the record object
+ * @throws {Error} When the bytes are not a current record object — a package
+ *   exported by an older SDK, which is re-exported with the current one.
+ */
+export declare function decodeRecordObject(data: Uint8Array): RecordObject;
+/** The `kind` tag a record's state object carries once the record has an
+ *  index: what tells a reader that the ref names a table of manifests rather
+ *  than one of them. */
+export declare const RECORD_STATE_KIND = "$record";
+/**
+ * A record's state when it has secondary indexes: one small object naming the
+ * primary's manifest and every index's.
+ *
+ * @remarks
+ * One state object, one commit, one conditional ref write — so the primary and
+ * every index are consistent at every commit, history carries them, reading at
+ * an older commit resolves them, compaction keeps them by copying one hash,
+ * and the collector walks them. A record with no index keeps the plain
+ * manifest, so this is additive: the door that resolves a record's state
+ * accepts either.
+ */
+export declare const RecordStateType: StructType<{
+    /** Always {@link RECORD_STATE_KIND}. */
+    readonly kind: StringType;
+    /** CollectionManifest hash of the primary. */
+    readonly primary: StringType;
+    /** Index name -> the manifest it is held in and the index object it was
+     *  built under. Deploy compares the second against the package's to decide
+     *  whether an index is built, dropped or kept. */
+    readonly indexes: DictType<StringType, StructType<{
+        /** CollectionManifest hash of the index collection. */
+        readonly manifest: StringType;
+        /** RecordIndexObject hash the index was built under. */
+        readonly index: StringType;
+    }>>;
+}>;
+export type RecordStateType = typeof RecordStateType;
+export type RecordState = ValueTypeOf<typeof RecordStateType>;
+/**
+ * Whether a decoded object is a record's `$record` state.
+ *
+ * @remarks
+ * Matched on the exact field set plus the tag, as every object recognizer is:
+ * a record's own state is an arbitrary user struct flowing through the same
+ * dispatch, and misreading one as a state table would probe its fields as
+ * object hashes.
+ *
+ * @param typeValue - the object's decoded root type
+ * @param value - the decoded value, when the tag is to be checked too
+ * @returns whether the object is a record state
+ */
+export declare function isRecordStateType(typeValue: EastTypeValue, value?: unknown): boolean;
+/**
+ * The collection an index is held in: `Dict<{ik, k}, P>`.
+ *
+ * @remarks
+ * `ik` first, so every entry with one index key is a contiguous run — ordered
+ * by primary key inside it — and a RANGE of index keys is one contiguous run
+ * too. `k` makes the entry unique and gives the run its inner order.
+ *
+ * @param keyType - the record's primary key type, `K`
+ * @param indexKeyType - the index key the function computes, `IK`
+ * @param valueType - the covering projection's type, `P`
+ * @returns the index collection's East type
+ */
+export declare function indexCollectionType(keyType: EastType, indexKeyType: EastType, valueType: EastType): EastType;
+/**
+ * The op type of one target's changes: what one touched key carries.
+ *
+ * @remarks
+ * Exactly the op type of that target's own `PatchType`, which is what makes
+ * applying a delta's run for one target literally
+ * `applyFor(targetType)(segment, variant('patch', ops))` — `ConflictError` and
+ * all — rather than a second apply implementation that could disagree with the
+ * first.
+ *
+ * @param collectionType - the target's collection type (a Dict or a Set)
+ * @returns the op variant for one key of it
+ * @throws {Error} When the type is not a Dict or a Set — the kinds whose
+ *   patches are sparse and addressed by key.
+ */
+export declare function patchOpsType(collectionType: EastType): EastType;
+/** One target of a mutation delta: its name, its key and its op type. */
+export interface DeltaTarget {
+    /** `primary`, or an index name. */
+    name: string;
+    /** The key the target is addressed by — `K` for the primary, `{ik, k}` for
+     *  an index. */
+    keyType: EastType;
+    /** The target's own collection type, whose patch ops the arm carries. */
+    collectionType: EastType;
+}
+/**
+ * The case of a mutation delta that says the write went stale: its key says
+ * what went stale, in words, and its op is Null.
+ *
+ * @remarks
+ * A write reaches the record two ways — the program emits a delta and the
+ * engine applies it, or the engine applies the client's patch directly — and
+ * both meet the same situation: an op that disagrees with the state it lands
+ * on. The apply reports it as a conflict, which a caller retries. A program
+ * that meets it — a patch whose `before` the record no longer holds, an
+ * update of a row that no longer matches, a delete of a key the record does
+ * not hold — emits one of these rather than failing, which a caller would not
+ * retry. The name sorts before every target's, since index names are
+ * identifiers, so a stale delta says so in its first entry.
+ */
+export declare const DELTA_CONFLICT = "$conflict";
+/**
+ * The type of a mutation delta: every target's changes in ONE sorted
+ * collection.
+ *
+ * @remarks
+ * One variant case per target — `primary` plus one per declared index, which
+ * is why `primary` is a reserved index name — and {@link DELTA_CONFLICT}, which
+ * sorts first. Canonical order puts every target's ops in one contiguous run,
+ * in that target's own key order, so the apply takes the delta one target at
+ * a time, a segment at a time, and a delta is a pageable collection like any
+ * other.
+ *
+ * Derived on demand and never stored as a type: a delta blob is
+ * self-describing, and deriving it means it cannot drift from the record's
+ * declarations.
+ *
+ * @param targets - the primary and each index, in canonical case order
+ * @returns `Dict<DeltaKey, DeltaOp>`
+ */
+export declare function mutationDeltaType(targets: readonly DeltaTarget[]): EastType;
+/**
+ * The `edit` capability an edit-form mutation writes through.
+ *
+ * @remarks
+ * An edit body reads the state it is given — lazily, the frozen pager-backed
+ * value every runner already serves — and writes through these three
+ * functions; it never returns a state, so its commit rewrites only the
+ * segments the entries it touched live in.
+ *
+ * Repeated edits of one key fold: `set` after anything is that `set`; `update`
+ * after `set` applies to the set value; `update` after `update` composes;
+ * `delete` after anything is `delete`. A `set` of the value the state already
+ * holds is no change, and a `delete` or `update` of a key the state does not
+ * hold is a conflict naming the key, as an apply's would be.
+ *
+ * The Dict overload carries the struct's shape into TypeScript, so a body that
+ * declares `editTypeOf(record.type)` as its last parameter gets `edit.set`,
+ * `edit.delete` and `edit.update` typed against the record's own key and row.
+ *
+ * @param recordType - the record's state type, a Dict
+ * @returns the struct of edit functions
+ * @throws {Error} When the record's root is not a Dict.
+ */
+export declare function editTypeOf<K extends EastType, V extends EastType>(recordType: DictType<K, V>): StructType<{
+    set: FunctionType<[K, V], NullType>;
+    delete: FunctionType<[K], NullType>;
+    update: FunctionType<[K, PatchTypeOf<V>], NullType>;
+}>;
+export declare function editTypeOf(recordType: EastType): EastType;
+/**
+ * One window of an index read: an ORDERED array, never a dict.
+ *
+ * @remarks
+ * A Dict value re-sorts by its own key, which would throw away the index order
+ * the page was asked for — so the wire type of an index window is positional,
+ * in index order, carrying every key the client may need. Whatever renders an
+ * index-ordered view consumes this shape; it is a contract the data layer sets
+ * and the UI meets, not the reverse.
+ *
+ * @param keyType - the record's primary key type, `K`
+ * @param indexKeyType - the index key, `IK`
+ * @param valueType - the covering projection's type, `P`
+ * @param rowType - the record's row type, `V`
+ * @returns the window's East type
+ */
+export declare function indexWindowType(keyType: EastType, indexKeyType: EastType, valueType: EastType, rowType: EastType): EastType;
 //# sourceMappingURL=record.d.ts.map

package/dist/src/record.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../src/record.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,SAAS,EAAE,QAAQ,EAAgB,WAAW,EAAE,MAAM,eAAe,CAAC;AAGjI;;;;;;;GAOG;AACH,eAAO,MAAM,gBAAgB;IAC3B,yDAAyD;;IAEzD,6EAA6E;;IAE7E,4EAA4E;;IAE5E,iFAAiF;;IAEjF,2EAA2E;;IAE3E,8BAA8B;;EAE9B,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AACvD,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB;IAC7B,kFAAkF;;IAElF,sEAAsE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAEtE,+DAA+D;;;;;;;;;;;;;;;EAE/D,CAAC;AACH,MAAM,MAAM,kBAAkB,GAAG,OAAO,kBAAkB,CAAC;AAC3D,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,gBAAgB;IAC3B,8DAA8D;;IAE9D,gDAAgD;;EAEhD,CAAC;AACH,MAAM,MAAM,gBAAgB,GAAG,OAAO,gBAAgB,CAAC;AACvD,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC"}
+{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../src/record.ts"],"names":[],"mappings":"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"}