@elaraai/e3-types 1.0.84 → 1.0.85

package/dist/src/api.d.ts

@@ -1012,6 +1012,9 @@ export declare const DatasetStatusInfoType: StructType<{
  * @property peakBytes - The highest peak resident memory, in bytes, a runner
  *   of the execution the status comes from reached: the one the output came
  *   from, or the failure; `none` when it recorded none, or while it runs
+ * @property stopped - Why the latest attempt over the task's current inputs
+ *   stopped, when it was cancelled or interrupted and the task therefore reads
+ *   `ready`; `none` otherwise
  */
 export declare const TaskStatusInfoType: StructType<{
     readonly name: StringType;
@@ -1053,6 +1056,16 @@ export declare const TaskStatusInfoType: StructType<{
     readonly output: StringType;
     readonly dependsOn: ArrayType<StringType>;
     readonly peakBytes: OptionType<IntegerType>;
+    readonly stopped: OptionType<StructType<{
+        readonly kind: VariantType<{
+            readonly aborted: NullType;
+            readonly yielded: NullType;
+            readonly owner_gone: NullType;
+            readonly host: StringType;
+            readonly unrecorded: NullType;
+        }>;
+        readonly message: StringType;
+    }>>;
 }>;
 /**
  * Summary counts for workspace status.
@@ -1145,6 +1158,16 @@ export declare const WorkspaceStatusResultType: StructType<{
         readonly output: StringType;
         readonly dependsOn: ArrayType<StringType>;
         readonly peakBytes: OptionType<IntegerType>;
+        readonly stopped: OptionType<StructType<{
+            readonly kind: VariantType<{
+                readonly aborted: NullType;
+                readonly yielded: NullType;
+                readonly owner_gone: NullType;
+                readonly host: StringType;
+                readonly unrecorded: NullType;
+            }>;
+            readonly message: StringType;
+        }>>;
     }>>;
     readonly summary: StructType<{
         /** Dataset status counts */
@@ -1283,11 +1306,19 @@ export declare const TaskDetailsType: StructType<{
  * Request to start dataflow execution. The run takes the server's budget of
  * cores and memory, which it shares with everything else the server runs.
  *
- * @property force - Force re-execution of all tasks
- * @property filter - Filter to specific task names (glob pattern)
+ * @property force - The tasks the run re-executes even where the cache holds
+ *   their results: none, all, or the tasks named ({@link DataflowForceType}).
+ *   A start naming a task the graph does not have, or one the filter's run set
+ *   leaves out, is refused before anything runs.
+ * @property filter - One task's exact name: the run runs that task and its
+ *   dependency closure, and no other task
  */
 export declare const DataflowRequestType: StructType<{
-    readonly force: BooleanType;
+    readonly force: VariantType<{
+        readonly none: NullType;
+        readonly all: NullType;
+        readonly tasks: ArrayType<StringType>;
+    }>;
     readonly filter: OptionType<StringType>;
 }>;
 /**
@@ -1306,6 +1337,28 @@ export declare const LogChunkType: StructType<{
     readonly totalSize: IntegerType;
     readonly complete: BooleanType;
 }>;
+/**
+ * Chunk of a task's log, as the logs route serves it: a {@link LogChunkType}'s
+ * fields, and the execution it was read from. A client polling the log reads
+ * on from its offset, starts over when the execution changes, and stops
+ * reading once the execution has ended and its log is read.
+ *
+ * @property inputsHash - The execution's inputs hash, which a request names,
+ *   with its id, to read on from the same execution
+ * @property executionId - The execution's id
+ * @property ended - True once the execution is recorded as anything but
+ *   running: its log grows no more
+ */
+export declare const TaskLogChunkType: StructType<{
+    readonly data: StringType;
+    readonly offset: IntegerType;
+    readonly size: IntegerType;
+    readonly totalSize: IntegerType;
+    readonly complete: BooleanType;
+    readonly inputsHash: StringType;
+    readonly executionId: StringType;
+    readonly ended: BooleanType;
+}>;
 /**
  * Result of executing a single task.
  *
@@ -1520,12 +1573,32 @@ export declare const SplitProgressType: StructType<{
  * DataflowExecutionStateType in dataflow.ts which stores the full
  * execution state on disk.
  *
+ * A poll names a cursor (`since`), the sequence number of the last event it
+ * has, and is served the run's events past it, at most its `limit`, and never
+ * more than {@link DATAFLOW_POLL_EVENTS_MAX}; the response's `nextSeq` is the
+ * cursor of the poll after it. A poll that has every event reads no event of
+ * the run, so a client polls on a timer for the whole run at the cost of what
+ * is new.
+ *
+ * The response names the run (`runId`) and where its events end (`lastSeq`).
+ * A cursor counts a run's own events, so a client that sees another run starts
+ * from 0. A poll whose `nextSeq` is before `lastSeq` left events for the next,
+ * which a client reads before it takes a run's end as its last word; and a
+ * client opens a running run's feed near its tail from `lastSeq`, or follows
+ * its progress with polls that ask for no events (`limit` 0).
+ *
+ * @property runId - The run's id, a UUIDv7
  * @property status - Current execution status
  * @property startedAt - ISO timestamp when execution started
  * @property completedAt - ISO timestamp when execution finished (if done)
  * @property summary - Execution summary (available when complete)
- * @property events - Task events (may be paginated via offset/limit)
- * @property totalEvents - Total number of events (for pagination)
+ * @property events - The run's task events past the poll's cursor, at most
+ *   its limit, in the order they happened
+ * @property nextSeq - The cursor past the events served, which the next poll
+ *   passes as `since`: the poll's own when it served none
+ * @property lastSeq - The sequence number of the run's last event when the
+ *   poll read it, 0 while it has none: the cursor of a poll that has every
+ *   event
  * @property budget - The server's budget now, where it has one: a server whose
  *   runners hold none, as a remote backend's, serves `none`
  * @property waiting - The tasks and units of the run waiting for room, while it
@@ -1534,6 +1607,7 @@ export declare const SplitProgressType: StructType<{
  *   stores it
  */
 export declare const ApiDataflowExecutionStateType: StructType<{
+    readonly runId: StringType;
     readonly status: VariantType<{
         readonly running: NullType;
         readonly completed: NullType;
@@ -1600,7 +1674,8 @@ export declare const ApiDataflowExecutionStateType: StructType<{
             readonly reserves: IntegerType;
         }>;
     }>>;
-    readonly totalEvents: IntegerType;
+    readonly nextSeq: IntegerType;
+    readonly lastSeq: IntegerType;
     readonly budget: OptionType<StructType<{
         readonly cores: IntegerType;
         readonly memory: IntegerType;
@@ -1630,10 +1705,18 @@ export declare const ApiDataflowExecutionStateType: StructType<{
         readonly units: IntegerType;
     }>>;
 }>;
+/**
+ * The most events a poll of a run is served ({@link ApiDataflowExecutionStateType}):
+ * a poll that names no `limit`, or a larger one, is served this many, so an
+ * answer stays within what a host's response may hold however long the run. A
+ * client reads on from the answer's `nextSeq`.
+ */
+export declare const DATAFLOW_POLL_EVENTS_MAX = 1000;
 /**
  * Execution status for history listing: `cancelled` when e3 stopped the
- * execution because its run was aborted, `interrupted` when the orchestrator
- * that owned it exited before it finished.
+ * execution because the signal it ran under was aborted, `interrupted` when
+ * it can no longer finish — its runner and its owner are gone, its host says
+ * so, or its run yielded mid-stage. Each says why in its item's `reason`.
  */
 export declare const ExecutionHistoryStatusType: VariantType<{
     readonly running: NullType;
@@ -1644,9 +1727,12 @@ export declare const ExecutionHistoryStatusType: VariantType<{
     readonly interrupted: NullType;
 }>;
 /**
- * A single execution in task history.
+ * A single execution in task history: a run of the task, never a split task's
+ * unit. The history lists them the latest first, a page at a time.
  *
  * @property inputsHash - Hash of concatenated inputs (execution identifier)
+ * @property executionId - The run's id, a UUIDv7: the next page is the runs
+ *   before the last one's
  * @property inputHashes - Individual input object hashes
  * @property status - Execution outcome
  * @property startedAt - ISO timestamp when execution started
@@ -1655,9 +1741,11 @@ export declare const ExecutionHistoryStatusType: VariantType<{
  * @property exitCode - Process exit code (if failed)
  * @property peakBytes - The highest peak resident memory, in bytes, a runner
  *   of the execution reached, when it succeeded or failed and one reported it
+ * @property reason - Why it stopped, when it was cancelled or interrupted
  */
 export declare const ExecutionListItemType: StructType<{
     readonly inputsHash: StringType;
+    readonly executionId: StringType;
     readonly inputHashes: ArrayType<StringType>;
     readonly status: VariantType<{
         readonly running: NullType;
@@ -1672,7 +1760,29 @@ export declare const ExecutionListItemType: StructType<{
     readonly duration: OptionType<IntegerType>;
     readonly exitCode: OptionType<IntegerType>;
     readonly peakBytes: OptionType<IntegerType>;
+    readonly reason: OptionType<StructType<{
+        readonly kind: VariantType<{
+            readonly aborted: NullType;
+            readonly yielded: NullType;
+            readonly owner_gone: NullType;
+            readonly host: StringType;
+            readonly unrecorded: NullType;
+        }>;
+        readonly message: StringType;
+    }>>;
 }>;
+/**
+ * The runs a page of a task's history holds when its request names no
+ * `limit`.
+ */
+export declare const TASK_EXECUTIONS_PAGE_DEFAULT = 100;
+/**
+ * The most runs a page of a task's history holds ({@link ExecutionListItemType}):
+ * a request naming a larger `limit` is served this many, so a page stays
+ * within what a host's response may hold. A client reads on with the last
+ * run's id as `before`.
+ */
+export declare const TASK_EXECUTIONS_PAGE_MAX = 1000;
 /**
  * Tree branch kind variant.
  *
@@ -1839,8 +1949,8 @@ export declare const DiagnosticType: StructType<{
  *
  * `inputs` names what the call read: each dataset argument's path and the hash
  * it was pinned at, in argument order, so an answer can be reproduced and a
- * stale one noticed. It is empty for a named function call, for a one-shot
- * with value arguments only, and for an `invalid` result.
+ * stale one noticed. It is empty for a call with value arguments only, and for
+ * an `invalid` result.
  */
 export declare const ExecuteResultType: StructType<{
     readonly outcome: VariantType<{
@@ -1877,9 +1987,30 @@ export declare const ExecuteResultType: StructType<{
         readonly hash: StringType;
     }>>;
 }>;
-/** Named function call. Positional args, one beast2-encoded value per param. */
+/**
+ * A call's argument: a beast2-encoded value, or a dataset of the workspace the
+ * call runs in, resolved and pinned by its content hash at launch and named in
+ * the result's `inputs`. A named function call and a one-shot take it alike.
+ */
+export declare const CallArgType: VariantType<{
+    readonly value: BlobType;
+    readonly dataset: ArrayType<VariantType<{
+        readonly field: StringType;
+    }>>;
+}>;
+/**
+ * Named function call. Positional args, one per param: a value, or a dataset
+ * of the workspace ({@link CallArgType}). The package-scoped route has no
+ * workspace to read a dataset from, and answers a dataset argument `invalid`;
+ * the workspace-scoped route pins it, as a one-shot's is.
+ */
 export declare const FunctionCallRequestType: StructType<{
-    readonly args: ArrayType<BlobType>;
+    readonly args: ArrayType<VariantType<{
+        readonly value: BlobType;
+        readonly dataset: ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>;
+    }>>;
     readonly runner: OptionType<VariantType<{
         readonly east_node: StructType<{
             readonly platforms: ArrayType<StringType>;
@@ -2309,10 +2440,25 @@ export declare const MutationResultType: StructType<{
         }>;
     }>;
 }>;
+/**
+ * When a record applied one step of its migration chain.
+ *
+ * @property at - When the step was applied: the time of the deploy that
+ *   applied it; `none` for a step a record applied before e3 kept the time
+ * @property commit - The commit that applied it: its `$migrate:<name>` commit,
+ *   or the `$init` or `$reset` commit that counted the chain applied; `none`
+ *   once a compaction has cut it from the chain, or for a step a record applied
+ *   before e3 kept it
+ */
+export declare const RecordMigrationAppliedType: StructType<{
+    readonly at: OptionType<DateTimeType>;
+    readonly commit: OptionType<StringType>;
+}>;
 /**
  * A record's callable surface, returned by `describe` so dynamic callers can
- * encode mutation arguments and read through its indexes. The mutation
- * `argTypes` are the EXTRA parameters after the implicit current state.
+ * encode mutation arguments and read through its indexes, and a console can
+ * show the record whole without reading its history. The mutation `argTypes`
+ * are the EXTRA parameters after the implicit current state.
  */
 export declare const RecordSignatureType: StructType<{
     readonly name: StringType;
@@ -2459,6 +2605,111 @@ export declare const RecordSignatureType: StructType<{
         }>>;
         /** Whether a row may hold several index keys. */
         readonly multi: BooleanType;
+        /** Whether the record's head state holds the index, built under the
+         *  declaration the deployed package carries. A deploy, a reindex and a
+         *  system commit build what the state lacks; a read through an index the
+         *  state holds no build of answers `index_not_found`. */
+        readonly built: BooleanType;
+    }>>;
+    /** The migration chain the record declares, in order. A deployed record
+     *  has applied every step, since a deploy migrates it or is refused. */
+    readonly migrations: ArrayType<StructType<{
+        readonly name: StringType;
+        /** The step's form — `value`, `rows` or `rekey` — which says what it
+         *  runs over: the whole state, its rows, or its rows under new keys. */
+        readonly form: StringType;
+        /** 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: 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;
+        }>>;
+        /** 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: 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;
+        }>>;
+        /** When the record applied the step, and the commit that did; `none`
+         *  when it has not applied it. */
+        readonly applied: OptionType<StructType<{
+            readonly at: OptionType<DateTimeType>;
+            readonly commit: OptionType<StringType>;
+        }>>;
     }>>;
 }>;
 /** One commit in a record's history (its hash plus the commit fields). */
@@ -2473,6 +2724,195 @@ export declare const RecordCommitInfoType: StructType<{
      *  changed without diffing two states. */
     readonly delta: OptionType<StringType>;
 }>;
+/**
+ * One argument of a record's commit, as the history previews it.
+ *
+ * @property type - The argument's own East type, as its encoding carries it
+ * @property bytes - Its encoded size
+ * @property text - Its value printed as East text, cut at
+ *   {@link RECORD_ARG_TEXT_CHARS} characters; empty for an argument over
+ *   {@link RECORD_ARG_TEXT_BYTES}, which is not printed, and for one that
+ *   cannot be
+ * @property truncated - Whether `text` holds less than the whole value
+ */
+export declare const RecordArgPreviewType: StructType<{
+    readonly type: 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: 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 bytes: IntegerType;
+    readonly text: StringType;
+    readonly truncated: BooleanType;
+}>;
+/**
+ * A record commit's arguments, as the history previews them.
+ *
+ * @property hash - The arguments' object, which the objects route serves
+ *   whole: a beast2 `Array<Blob>` of the encoded arguments, in order
+ * @property bytes - The object's size
+ * @property values - Each argument's preview, in order; empty when the object
+ *   is over {@link RECORD_ARGS_READ_BYTES}, which the history does not read,
+ *   or holds arguments that are not East values, as a system commit may
+ *   record its caller's
+ */
+export declare const RecordCommitArgsType: StructType<{
+    readonly hash: StringType;
+    readonly bytes: IntegerType;
+    readonly values: ArrayType<StructType<{
+        readonly type: 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: 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 bytes: IntegerType;
+        readonly text: StringType;
+        readonly truncated: BooleanType;
+    }>>;
+}>;
+/**
+ * One commit in a record's history, as the history route answers it: a
+ * {@link RecordCommitInfoType}'s fields, and a preview of its arguments, so a
+ * history says what a commit set as well as which mutation ran.
+ * `RecordCommitInfoType` stays without them: e3-ui's record binding and the
+ * pages built on it carry it in their East types.
+ */
+export declare const RecordHistoryCommitType: StructType<{
+    readonly hash: StringType;
+    readonly parent: OptionType<StringType>;
+    readonly state: StringType;
+    readonly mutation: StringType;
+    readonly actor: StringType;
+    readonly at: DateTimeType;
+    /** The delta this commit applied, when it wrote one. */
+    readonly delta: OptionType<StringType>;
+    /** The commit's arguments, previewed; `none` for a commit with none. */
+    readonly args: OptionType<StructType<{
+        readonly hash: StringType;
+        readonly bytes: IntegerType;
+        readonly values: ArrayType<StructType<{
+            readonly type: 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: 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 bytes: IntegerType;
+            readonly text: StringType;
+            readonly truncated: BooleanType;
+        }>>;
+    }>>;
+}>;
 /** A page of a record's commit history, newest first. */
 export declare const RecordHistoryResultType: StructType<{
     readonly commits: ArrayType<StructType<{
@@ -2482,11 +2922,71 @@ export declare const RecordHistoryResultType: StructType<{
         readonly mutation: StringType;
         readonly actor: StringType;
         readonly at: DateTimeType;
-        /** The delta this commit applied, when it wrote one — so history shows WHAT
-         *  changed without diffing two states. */
+        /** The delta this commit applied, when it wrote one. */
         readonly delta: OptionType<StringType>;
+        /** The commit's arguments, previewed; `none` for a commit with none. */
+        readonly args: OptionType<StructType<{
+            readonly hash: StringType;
+            readonly bytes: IntegerType;
+            readonly values: ArrayType<StructType<{
+                readonly type: 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: 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 bytes: IntegerType;
+                readonly text: StringType;
+                readonly truncated: BooleanType;
+            }>>;
+        }>>;
     }>>;
 }>;
+/** The characters of an argument's East text a history preview keeps. */
+export declare const RECORD_ARG_TEXT_CHARS = 256;
+/** The encoded size, in bytes, past which a history preview prints no text
+ *  of an argument, only its type and size. */
+export declare const RECORD_ARG_TEXT_BYTES: number;
+/** The size, in bytes, past which a history reads no commit's arguments'
+ *  object, and previews none of them: a page reads at most this much of
+ *  arguments per commit, however large a patch is. */
+export declare const RECORD_ARGS_READ_BYTES: number;
 export type Error = ValueTypeOf<typeof ErrorType>;
 export type RepositoryStatus = ValueTypeOf<typeof RepositoryStatusType>;
 export type GcRequest = ValueTypeOf<typeof GcRequestType>;
@@ -2520,6 +3020,7 @@ export type TaskListItem = ValueTypeOf<typeof TaskListItemType>;
 export type TaskDetails = ValueTypeOf<typeof TaskDetailsType>;
 export type DataflowRequest = ValueTypeOf<typeof DataflowRequestType>;
 export type LogChunk = ValueTypeOf<typeof LogChunkType>;
+export type TaskLogChunk = ValueTypeOf<typeof TaskLogChunkType>;
 export type TaskExecutionResult = ValueTypeOf<typeof TaskExecutionResultType>;
 export type DataflowResult = ValueTypeOf<typeof DataflowResultType>;
 export type DataflowEvent = ValueTypeOf<typeof DataflowEventType>;
@@ -2537,6 +3038,7 @@ export type DatasetStatusDetail = ValueTypeOf<typeof DatasetStatusDetailType>;
 export type ExecuteLimits = ValueTypeOf<typeof ExecuteLimitsType>;
 export type Diagnostic = ValueTypeOf<typeof DiagnosticType>;
 export type ExecuteResult = ValueTypeOf<typeof ExecuteResultType>;
+export type CallArg = ValueTypeOf<typeof CallArgType>;
 export type FunctionCallRequest = ValueTypeOf<typeof FunctionCallRequestType>;
 export type FunctionSignature = ValueTypeOf<typeof FunctionSignatureType>;
 export type OneShotRequest = ValueTypeOf<typeof OneShotRequestType>;
@@ -2547,7 +3049,11 @@ export type SplitCallStatus = ValueTypeOf<typeof SplitCallStatusType>;
 export type SplitCallPlan = ValueTypeOf<typeof SplitCallPlanType>;
 export type MutationCallRequest = ValueTypeOf<typeof MutationCallRequestType>;
 export type MutationResult = ValueTypeOf<typeof MutationResultType>;
+export type RecordMigrationApplied = ValueTypeOf<typeof RecordMigrationAppliedType>;
 export type RecordSignature = ValueTypeOf<typeof RecordSignatureType>;
 export type RecordCommitInfo = ValueTypeOf<typeof RecordCommitInfoType>;
+export type RecordArgPreview = ValueTypeOf<typeof RecordArgPreviewType>;
+export type RecordCommitArgs = ValueTypeOf<typeof RecordCommitArgsType>;
+export type RecordHistoryCommit = ValueTypeOf<typeof RecordHistoryCommitType>;
 export type RecordHistoryResult = ValueTypeOf<typeof RecordHistoryResultType>;
 //# sourceMappingURL=api.d.ts.map