@elaraai/e3-types 1.0.79 → 1.0.81

package/dist/src/api.d.ts

@@ -89,6 +89,13 @@ export declare const DatasetTypeMismatchErrorType: StructType<{
     readonly path: StringType;
     readonly message: StringType;
 }>;
+/** A name e3 would make a path of that cannot be one path segment: a
+ *  repository's, a workspace's, or a package's name or version. */
+export declare const InvalidNameErrorType: StructType<{
+    readonly kind: StringType;
+    readonly name: StringType;
+    readonly message: StringType;
+}>;
 export declare const ErrorType: VariantType<{
     readonly repository_not_found: StructType<{
         readonly repo: StringType;
@@ -153,6 +160,11 @@ export declare const ErrorType: VariantType<{
         readonly path: StringType;
         readonly message: StringType;
     }>;
+    readonly invalid_name: StructType<{
+        readonly kind: StringType;
+        readonly name: StringType;
+        readonly message: StringType;
+    }>;
 }>;
 export declare const ResponseType: <T extends EastType>(successType: T) => VariantType<{
     readonly success: T;
@@ -220,6 +232,11 @@ export declare const ResponseType: <T extends EastType>(successType: T) => Varia
             readonly path: StringType;
             readonly message: StringType;
         }>;
+        readonly invalid_name: StructType<{
+            readonly kind: StringType;
+            readonly name: StringType;
+            readonly message: StringType;
+        }>;
     }>;
 }>;
 /**
@@ -241,10 +258,16 @@ export declare const RepositoryStatusType: StructType<{
  *
  * @property dryRun - If true, report what would be deleted without deleting
  * @property minAge - Minimum age in milliseconds for objects to be considered for deletion
+ * @property keepRuns - The runs of each workspace kept however old, the latest
+ *   first; the server's default when `none`
+ * @property keepDays - The days of runs and executions kept however many; the
+ *   server's default when `none`
  */
 export declare const GcRequestType: StructType<{
     readonly dryRun: BooleanType;
     readonly minAge: OptionType<IntegerType>;
+    readonly keepRuns: OptionType<IntegerType>;
+    readonly keepDays: OptionType<IntegerType>;
 }>;
 /**
  * Garbage collection result.
@@ -254,6 +277,9 @@ export declare const GcRequestType: StructType<{
  * @property retainedObjects - Number of objects still referenced
  * @property skippedYoung - Number of objects skipped due to minAge
  * @property bytesFreed - Total bytes freed by deletion
+ * @property deletedRuns - Number of dataflow run records deleted
+ * @property deletedExecutions - Number of execution attempts deleted, each with
+ *   its owner record and logs
  */
 export declare const GcResultType: StructType<{
     readonly deletedObjects: IntegerType;
@@ -261,6 +287,8 @@ export declare const GcResultType: StructType<{
     readonly retainedObjects: IntegerType;
     readonly skippedYoung: IntegerType;
     readonly bytesFreed: IntegerType;
+    readonly deletedRuns: IntegerType;
+    readonly deletedExecutions: IntegerType;
 }>;
 /**
  * Status of an async operation.
@@ -301,6 +329,8 @@ export declare const GcStatusResultType: StructType<{
         readonly retainedObjects: IntegerType;
         readonly skippedYoung: IntegerType;
         readonly bytesFreed: IntegerType;
+        readonly deletedRuns: IntegerType;
+        readonly deletedExecutions: IntegerType;
     }>>;
     readonly error: OptionType<StringType>;
 }>;
@@ -411,13 +441,442 @@ export declare const WorkspaceInfoType: StructType<{
     readonly packageName: OptionType<StringType>;
     readonly packageVersion: OptionType<StringType>;
 }>;
+/**
+ * What a deploy does with a record it cannot keep as it is.
+ *
+ * - `migrate`: run the migrations the workspace has not applied, and refuse a
+ *   record no migration carries to the package's type
+ * - `fail`: run none, and refuse a record with migrations to run, for a
+ *   workspace whose migrations go through their own change control
+ * - `reset`: reset a record it can neither keep nor migrate to the package's
+ *   initial value, under a `$reset` commit, so the reset is in its history
+ */
+export declare const SchemaPolicyType: VariantType<{
+    readonly migrate: NullType;
+    readonly fail: NullType;
+    readonly reset: NullType;
+}>;
 /**
  * Request to deploy a package to a workspace.
  *
  * @property packageRef - Package reference in format "name" or "name@version"
+ * @property schema - What the deploy does with a record it cannot keep as it is
+ * @property allowDropRecords - Whether a record the package no longer declares
+ *   may be dropped, with its state and history
+ * @property plan - Say what the deploy would do, and write nothing
  */
 export declare const WorkspaceDeployRequestType: StructType<{
     readonly packageRef: StringType;
+    readonly schema: VariantType<{
+        readonly migrate: NullType;
+        readonly fail: NullType;
+        readonly reset: NullType;
+    }>;
+    readonly allowDropRecords: BooleanType;
+    readonly plan: BooleanType;
+}>;
+/**
+ * What a deploy decided for one record.
+ *
+ * @property record - The record's dataset ref path
+ * @property action - What the deploy does to it:
+ *   - `mint`: the workspace does not hold it, so it is minted from the
+ *     package's initial value
+ *   - `keep`: kept as the workspace holds it; `deploy` when the package under
+ *     it changed, which a `$deploy` commit records in its history
+ *   - `migrate`: migrated by the steps the workspace has not applied, in order
+ *   - `reset`: reset to the package's initial value under the `reset` policy,
+ *     and why it could not be kept or migrated
+ *   - `drop`: the package does not declare it, so it is dropped, with its
+ *     state and history
+ *   - `refused`: refused, and why, with the fix: the deploy writes nothing
+ */
+export declare const RecordPlanType: StructType<{
+    readonly record: StringType;
+    readonly action: VariantType<{
+        readonly mint: NullType;
+        readonly keep: StructType<{
+            readonly deploy: BooleanType;
+        }>;
+        readonly migrate: StructType<{
+            readonly steps: ArrayType<StringType>;
+        }>;
+        readonly reset: StructType<{
+            readonly reason: StringType;
+        }>;
+        readonly drop: NullType;
+        readonly refused: StructType<{
+            readonly reason: StringType;
+        }>;
+    }>;
+}>;
+/**
+ * What a deploy decided for one of a record's indexes.
+ *
+ * @property record - The record's dataset ref path
+ * @property index - The index's name
+ * @property action - `build` when the state names no index under the
+ *   package's declaration, `drop` when it names one the package does not
+ *   declare, and `keep` when the two agree and nothing runs
+ */
+export declare const RecordIndexPlanType: StructType<{
+    readonly record: StringType;
+    readonly index: StringType;
+    readonly action: VariantType<{
+        readonly build: NullType;
+        readonly drop: NullType;
+        readonly keep: NullType;
+    }>;
+}>;
+/**
+ * The step a deploy is at with one record.
+ *
+ * - `waiting`: its turn has not come, or it needs nothing but the deploy's
+ *   commit
+ * - `migrating`: running migration step `step` of the `steps` it owes, `name`
+ * - `indexing`: building `index`, the `build`th of the `builds` it owes
+ * - `done`: its migrations and index builds have run
+ */
+export declare const RecordDeployStepType: VariantType<{
+    readonly waiting: NullType;
+    readonly migrating: StructType<{
+        readonly name: StringType;
+        readonly step: IntegerType;
+        readonly steps: IntegerType;
+    }>;
+    readonly indexing: StructType<{
+        readonly index: StringType;
+        readonly build: IntegerType;
+        readonly builds: IntegerType;
+    }>;
+    readonly done: NullType;
+}>;
+/**
+ * One record a deploy is deploying.
+ *
+ * @property plan - What the deploy decided for it
+ * @property indexes - The indexes the package declares for it
+ * @property step - How far the deploy has got with it
+ */
+export declare const RecordDeployStateType: StructType<{
+    readonly plan: StructType<{
+        readonly record: StringType;
+        readonly action: VariantType<{
+            readonly mint: NullType;
+            readonly keep: StructType<{
+                readonly deploy: BooleanType;
+            }>;
+            readonly migrate: StructType<{
+                readonly steps: ArrayType<StringType>;
+            }>;
+            readonly reset: StructType<{
+                readonly reason: StringType;
+            }>;
+            readonly drop: NullType;
+            readonly refused: StructType<{
+                readonly reason: StringType;
+            }>;
+        }>;
+    }>;
+    readonly indexes: ArrayType<StringType>;
+    readonly step: VariantType<{
+        readonly waiting: NullType;
+        readonly migrating: StructType<{
+            readonly name: StringType;
+            readonly step: IntegerType;
+            readonly steps: IntegerType;
+        }>;
+        readonly indexing: StructType<{
+            readonly index: StringType;
+            readonly build: IntegerType;
+            readonly builds: IntegerType;
+        }>;
+        readonly done: NullType;
+    }>;
+}>;
+/**
+ * How far a deploy has got, for a client to show while it runs.
+ *
+ * @property package - The package it deploys
+ * @property startedAt - When it began taking its files in
+ * @property files - Each file source it takes in, in the package's order
+ * @property records - Each record it deploys, in the package's order, and
+ *   each it drops
+ */
+export declare const DeployProgressType: StructType<{
+    readonly package: StructType<{
+        readonly name: StringType;
+        readonly version: StringType;
+    }>;
+    readonly startedAt: DateTimeType;
+    readonly files: ArrayType<StructType<{
+        readonly path: StringType;
+        readonly step: VariantType<{
+            readonly waiting: NullType;
+            readonly hashing: NullType;
+            readonly taking_in: StructType<{
+                readonly pieces: IntegerType;
+                readonly done: IntegerType;
+            }>;
+            readonly done: VariantType<{
+                readonly known: NullType;
+                readonly carried: NullType;
+                readonly taken: ArrayType<StringType>;
+            }>;
+        }>;
+        readonly bytes: IntegerType;
+        readonly total: IntegerType;
+    }>>;
+    readonly records: ArrayType<StructType<{
+        readonly plan: StructType<{
+            readonly record: StringType;
+            readonly action: VariantType<{
+                readonly mint: NullType;
+                readonly keep: StructType<{
+                    readonly deploy: BooleanType;
+                }>;
+                readonly migrate: StructType<{
+                    readonly steps: ArrayType<StringType>;
+                }>;
+                readonly reset: StructType<{
+                    readonly reason: StringType;
+                }>;
+                readonly drop: NullType;
+                readonly refused: StructType<{
+                    readonly reason: StringType;
+                }>;
+            }>;
+        }>;
+        readonly indexes: ArrayType<StringType>;
+        readonly step: VariantType<{
+            readonly waiting: NullType;
+            readonly migrating: StructType<{
+                readonly name: StringType;
+                readonly step: IntegerType;
+                readonly steps: IntegerType;
+            }>;
+            readonly indexing: StructType<{
+                readonly index: StringType;
+                readonly build: IntegerType;
+                readonly builds: IntegerType;
+            }>;
+            readonly done: NullType;
+        }>;
+    }>>;
+}>;
+/**
+ * What a deploy did, or under `plan` would do.
+ *
+ * @property records - What it decided for each record
+ * @property indexes - What it decided for each index of the records it keeps
+ * @property warnings - The inputs it left unassigned, and why: a server never
+ *   reads a `file` source, whose path is on the client's machine
+ */
+export declare const WorkspaceDeployResultType: StructType<{
+    readonly records: ArrayType<StructType<{
+        readonly record: StringType;
+        readonly action: VariantType<{
+            readonly mint: NullType;
+            readonly keep: StructType<{
+                readonly deploy: BooleanType;
+            }>;
+            readonly migrate: StructType<{
+                readonly steps: ArrayType<StringType>;
+            }>;
+            readonly reset: StructType<{
+                readonly reason: StringType;
+            }>;
+            readonly drop: NullType;
+            readonly refused: StructType<{
+                readonly reason: StringType;
+            }>;
+        }>;
+    }>>;
+    readonly indexes: ArrayType<StructType<{
+        readonly record: StringType;
+        readonly index: StringType;
+        readonly action: VariantType<{
+            readonly build: NullType;
+            readonly drop: NullType;
+            readonly keep: NullType;
+        }>;
+    }>>;
+    readonly warnings: ArrayType<StringType>;
+}>;
+/**
+ * A deploy job's progress: `pending` until it starts, then `deploying`, with
+ * how far it has got once it has said.
+ */
+export declare const WorkspaceDeployProgressType: VariantType<{
+    readonly pending: NullType;
+    readonly deploying: OptionType<StructType<{
+        readonly package: StructType<{
+            readonly name: StringType;
+            readonly version: StringType;
+        }>;
+        readonly startedAt: DateTimeType;
+        readonly files: ArrayType<StructType<{
+            readonly path: StringType;
+            readonly step: VariantType<{
+                readonly waiting: NullType;
+                readonly hashing: NullType;
+                readonly taking_in: StructType<{
+                    readonly pieces: IntegerType;
+                    readonly done: IntegerType;
+                }>;
+                readonly done: VariantType<{
+                    readonly known: NullType;
+                    readonly carried: NullType;
+                    readonly taken: ArrayType<StringType>;
+                }>;
+            }>;
+            readonly bytes: IntegerType;
+            readonly total: IntegerType;
+        }>>;
+        readonly records: ArrayType<StructType<{
+            readonly plan: StructType<{
+                readonly record: StringType;
+                readonly action: VariantType<{
+                    readonly mint: NullType;
+                    readonly keep: StructType<{
+                        readonly deploy: BooleanType;
+                    }>;
+                    readonly migrate: StructType<{
+                        readonly steps: ArrayType<StringType>;
+                    }>;
+                    readonly reset: StructType<{
+                        readonly reason: StringType;
+                    }>;
+                    readonly drop: NullType;
+                    readonly refused: StructType<{
+                        readonly reason: StringType;
+                    }>;
+                }>;
+            }>;
+            readonly indexes: ArrayType<StringType>;
+            readonly step: VariantType<{
+                readonly waiting: NullType;
+                readonly migrating: StructType<{
+                    readonly name: StringType;
+                    readonly step: IntegerType;
+                    readonly steps: IntegerType;
+                }>;
+                readonly indexing: StructType<{
+                    readonly index: StringType;
+                    readonly build: IntegerType;
+                    readonly builds: IntegerType;
+                }>;
+                readonly done: NullType;
+            }>;
+        }>>;
+    }>>;
+}>;
+/**
+ * A deploy job's status.
+ *
+ * - `processing`: still running, and how far it has got
+ * - `completed`: what the deploy did
+ * - `failed`: why it did not
+ */
+export declare const WorkspaceDeployStatusType: VariantType<{
+    readonly processing: VariantType<{
+        readonly pending: NullType;
+        readonly deploying: OptionType<StructType<{
+            readonly package: StructType<{
+                readonly name: StringType;
+                readonly version: StringType;
+            }>;
+            readonly startedAt: DateTimeType;
+            readonly files: ArrayType<StructType<{
+                readonly path: StringType;
+                readonly step: VariantType<{
+                    readonly waiting: NullType;
+                    readonly hashing: NullType;
+                    readonly taking_in: StructType<{
+                        readonly pieces: IntegerType;
+                        readonly done: IntegerType;
+                    }>;
+                    readonly done: VariantType<{
+                        readonly known: NullType;
+                        readonly carried: NullType;
+                        readonly taken: ArrayType<StringType>;
+                    }>;
+                }>;
+                readonly bytes: IntegerType;
+                readonly total: IntegerType;
+            }>>;
+            readonly records: ArrayType<StructType<{
+                readonly plan: StructType<{
+                    readonly record: StringType;
+                    readonly action: VariantType<{
+                        readonly mint: NullType;
+                        readonly keep: StructType<{
+                            readonly deploy: BooleanType;
+                        }>;
+                        readonly migrate: StructType<{
+                            readonly steps: ArrayType<StringType>;
+                        }>;
+                        readonly reset: StructType<{
+                            readonly reason: StringType;
+                        }>;
+                        readonly drop: NullType;
+                        readonly refused: StructType<{
+                            readonly reason: StringType;
+                        }>;
+                    }>;
+                }>;
+                readonly indexes: ArrayType<StringType>;
+                readonly step: VariantType<{
+                    readonly waiting: NullType;
+                    readonly migrating: StructType<{
+                        readonly name: StringType;
+                        readonly step: IntegerType;
+                        readonly steps: IntegerType;
+                    }>;
+                    readonly indexing: StructType<{
+                        readonly index: StringType;
+                        readonly build: IntegerType;
+                        readonly builds: IntegerType;
+                    }>;
+                    readonly done: NullType;
+                }>;
+            }>>;
+        }>>;
+    }>;
+    readonly completed: StructType<{
+        readonly records: ArrayType<StructType<{
+            readonly record: StringType;
+            readonly action: VariantType<{
+                readonly mint: NullType;
+                readonly keep: StructType<{
+                    readonly deploy: BooleanType;
+                }>;
+                readonly migrate: StructType<{
+                    readonly steps: ArrayType<StringType>;
+                }>;
+                readonly reset: StructType<{
+                    readonly reason: StringType;
+                }>;
+                readonly drop: NullType;
+                readonly refused: StructType<{
+                    readonly reason: StringType;
+                }>;
+            }>;
+        }>>;
+        readonly indexes: ArrayType<StructType<{
+            readonly record: StringType;
+            readonly index: StringType;
+            readonly action: VariantType<{
+                readonly build: NullType;
+                readonly drop: NullType;
+                readonly keep: NullType;
+            }>;
+        }>>;
+        readonly warnings: ArrayType<StringType>;
+    }>;
+    readonly failed: StructType<{
+        readonly message: StringType;
+    }>;
 }>;
 /**
  * Workspace export request body.
@@ -550,6 +1009,9 @@ export declare const DatasetStatusInfoType: StructType<{
  * @property inputs - Dataset paths this task reads from
  * @property output - Dataset path this task writes to
  * @property dependsOn - Names of tasks that must complete before this one
+ * @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
  */
 export declare const TaskStatusInfoType: StructType<{
     readonly name: StringType;
@@ -590,6 +1052,7 @@ export declare const TaskStatusInfoType: StructType<{
     readonly inputs: ArrayType<StringType>;
     readonly output: StringType;
     readonly dependsOn: ArrayType<StringType>;
+    readonly peakBytes: OptionType<IntegerType>;
 }>;
 /**
  * Summary counts for workspace status.
@@ -681,6 +1144,7 @@ export declare const WorkspaceStatusResultType: StructType<{
         readonly inputs: ArrayType<StringType>;
         readonly output: StringType;
         readonly dependsOn: ArrayType<StringType>;
+        readonly peakBytes: OptionType<IntegerType>;
     }>>;
     readonly summary: StructType<{
         /** Dataset status counts */
@@ -708,44 +1172,109 @@ export declare const WorkspaceStatusResultType: StructType<{
  *
  * @property name - Task name
  * @property hash - Task definition hash
- * @property kind - Task kind: "ui" (e3-ui `ui()`), other future kinds; none for plain tasks / old packages
+ * @property role - What the task's output is for: data, or a ui with what it
+ *   binds
  */
 export declare const TaskListItemType: StructType<{
     readonly name: StringType;
     readonly hash: StringType;
-    readonly kind: OptionType<StringType>;
+    readonly role: VariantType<{
+        readonly data: NullType;
+        readonly ui: StructType<{
+            readonly paths: ArrayType<ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>>;
+            readonly functions: ArrayType<StringType>;
+            readonly records: ArrayType<StringType>;
+            readonly pages: ArrayType<ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>>;
+        }>;
+    }>;
 }>;
 /**
- * Detailed task information.
+ * Detailed task information: the task object's fields.
  *
  * @property name - Task name
  * @property hash - Task definition hash
- * @property commandIr - East IR for the task's command
- * @property inputs - Tree paths for task inputs
- * @property output - Tree path for task output
+ * @property body - What the task runs: an East program, or a command
+ * @property runner - The runtime it runs on
+ * @property inputs - The datasets it reads, each with its partition
+ * @property output - Where its output goes, and how it is made
+ * @property role - What its output is for: data, or a ui with what it binds
  */
 export declare const TaskDetailsType: StructType<{
     readonly name: StringType;
     readonly hash: StringType;
-    readonly commandIr: StringType;
-    readonly inputs: ArrayType<ArrayType<VariantType<{
-        readonly field: StringType;
-    }>>>;
-    readonly output: ArrayType<VariantType<{
-        readonly field: StringType;
+    readonly body: VariantType<{
+        readonly east: StructType<{
+            readonly program: StringType;
+        }>;
+        readonly command: StructType<{
+            readonly commandIr: StringType;
+        }>;
+    }>;
+    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>;
+        }>;
+    }>;
+    readonly inputs: ArrayType<StructType<{
+        readonly path: ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>;
+        readonly partition: OptionType<StructType<{
+            readonly by: ArrayType<StringType>;
+        }>>;
     }>>;
-    readonly kind: OptionType<StringType>;
-    readonly metadata: OptionType<BlobType>;
+    readonly output: StructType<{
+        readonly path: ArrayType<VariantType<{
+            readonly field: StringType;
+        }>>;
+        readonly kind: VariantType<{
+            readonly value: NullType;
+            readonly array: NullType;
+            readonly set: NullType;
+            readonly dict: StructType<{
+                readonly merge: OptionType<StringType>;
+            }>;
+            readonly fold: StructType<{
+                readonly zero: StringType;
+                readonly combine: StringType;
+            }>;
+        }>;
+    }>;
+    readonly role: VariantType<{
+        readonly data: NullType;
+        readonly ui: StructType<{
+            readonly paths: ArrayType<ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>>;
+            readonly functions: ArrayType<StringType>;
+            readonly records: ArrayType<StringType>;
+            readonly pages: ArrayType<ArrayType<VariantType<{
+                readonly field: StringType;
+            }>>>;
+        }>;
+    }>;
 }>;
 /**
- * Request to start dataflow execution.
+ * 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 concurrency - Maximum parallel tasks (default: 4)
  * @property force - Force re-execution of all tasks
  * @property filter - Filter to specific task names (glob pattern)
  */
 export declare const DataflowRequestType: StructType<{
-    readonly concurrency: OptionType<IntegerType>;
     readonly force: BooleanType;
     readonly filter: OptionType<StringType>;
 }>;
@@ -826,11 +1355,15 @@ export declare const DataflowResultType: StructType<{
  * Dataflow event types for API polling.
  *
  * - `start`: Task started executing
- * - `complete`: Task executed and succeeded
+ * - `complete`: Task executed and succeeded, with the highest peak memory its
+ *   runners reached when they reported one
  * - `cached`: Task result retrieved from cache (no execution)
  * - `failed`: Task exited with non-zero code
  * - `error`: Internal error during task execution
  * - `input_unavailable`: Task couldn't run because inputs not available
+ * - `requeued`: A unit of a split task was stopped — by the budget's guard, or
+ *   its cgroup's cap — and runs again once the memory it reserves fits: the
+ *   unit, why, the most it was measured using and what it reserves, in bytes
  */
 export declare const DataflowEventType: VariantType<{
     readonly start: StructType<{
@@ -841,6 +1374,7 @@ export declare const DataflowEventType: VariantType<{
         readonly task: StringType;
         readonly timestamp: StringType;
         readonly duration: FloatType;
+        readonly peakBytes: OptionType<IntegerType>;
     }>;
     readonly cached: StructType<{
         readonly task: StringType;
@@ -862,6 +1396,25 @@ export declare const DataflowEventType: VariantType<{
         readonly timestamp: StringType;
         readonly reason: StringType;
     }>;
+    readonly requeued: StructType<{
+        readonly task: StringType;
+        readonly timestamp: StringType;
+        readonly unit: StructType<{
+            readonly merge: OptionType<StructType<{
+                readonly level: IntegerType;
+                readonly levels: IntegerType;
+            }>>;
+            readonly index: IntegerType;
+            readonly units: IntegerType;
+        }>;
+        readonly reason: VariantType<{
+            readonly budget: NullType;
+            readonly machine: NullType;
+            readonly cap: NullType;
+        }>;
+        readonly peak: IntegerType;
+        readonly reserves: IntegerType;
+    }>;
 }>;
 /**
  * Execution status for API polling responses.
@@ -890,6 +1443,62 @@ export declare const DataflowExecutionSummaryType: StructType<{
     readonly skipped: IntegerType;
     readonly duration: FloatType;
 }>;
+/**
+ * A server's budget of cores and memory, which every runner it spawns takes
+ * from, and what its runners hold of it now.
+ *
+ * @property cores - Runner processes at once
+ * @property memory - Bytes of memory the runners may hold between them
+ * @property coresInUse - Runner processes holding the budget now
+ * @property memoryInUse - Bytes the runners hold now, each at the larger of
+ *   its reservation and what it was last measured using
+ */
+export declare const DataflowBudgetType: StructType<{
+    readonly cores: IntegerType;
+    readonly memory: IntegerType;
+    readonly coresInUse: IntegerType;
+    readonly memoryInUse: IntegerType;
+}>;
+/**
+ * A task, or a unit of a split task, waiting for room in the server's budget.
+ *
+ * @property task - The task
+ * @property unit - The unit, for a split task's; `none` for a task run as one
+ * @property needs - The memory, in bytes, it waits to reserve; 0 when it
+ *   waits for a core alone
+ * @property since - ISO timestamp when it began waiting
+ */
+export declare const UnitWaitType: StructType<{
+    readonly task: StringType;
+    readonly unit: OptionType<StructType<{
+        readonly merge: OptionType<StructType<{
+            readonly level: IntegerType;
+            readonly levels: IntegerType;
+        }>>;
+        readonly index: IntegerType;
+        readonly units: IntegerType;
+    }>>;
+    readonly needs: IntegerType;
+    readonly since: StringType;
+}>;
+/**
+ * A split task's progress through the stage it is in.
+ *
+ * @property task - The task
+ * @property merge - The merge level, from 1, and the levels the merges take;
+ *   `none` while its pieces run
+ * @property done - The stage's units that have finished
+ * @property units - The stage's units
+ */
+export declare const SplitProgressType: StructType<{
+    readonly task: StringType;
+    readonly merge: OptionType<StructType<{
+        readonly level: IntegerType;
+        readonly levels: IntegerType;
+    }>>;
+    readonly done: IntegerType;
+    readonly units: IntegerType;
+}>;
 /**
  * Dataflow execution state returned by API polling.
  *
@@ -905,6 +1514,12 @@ export declare const DataflowExecutionSummaryType: StructType<{
  * @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 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
+ *   runs; nothing stores them
+ * @property splits - Each split task's progress, while the run runs; nothing
+ *   stores it
  */
 export declare const ApiDataflowExecutionStateType: StructType<{
     readonly status: VariantType<{
@@ -931,6 +1546,7 @@ export declare const ApiDataflowExecutionStateType: StructType<{
             readonly task: StringType;
             readonly timestamp: StringType;
             readonly duration: FloatType;
+            readonly peakBytes: OptionType<IntegerType>;
         }>;
         readonly cached: StructType<{
             readonly task: StringType;
@@ -952,17 +1568,68 @@ export declare const ApiDataflowExecutionStateType: StructType<{
             readonly timestamp: StringType;
             readonly reason: StringType;
         }>;
+        readonly requeued: StructType<{
+            readonly task: StringType;
+            readonly timestamp: StringType;
+            readonly unit: StructType<{
+                readonly merge: OptionType<StructType<{
+                    readonly level: IntegerType;
+                    readonly levels: IntegerType;
+                }>>;
+                readonly index: IntegerType;
+                readonly units: IntegerType;
+            }>;
+            readonly reason: VariantType<{
+                readonly budget: NullType;
+                readonly machine: NullType;
+                readonly cap: NullType;
+            }>;
+            readonly peak: IntegerType;
+            readonly reserves: IntegerType;
+        }>;
     }>>;
     readonly totalEvents: IntegerType;
+    readonly budget: OptionType<StructType<{
+        readonly cores: IntegerType;
+        readonly memory: IntegerType;
+        readonly coresInUse: IntegerType;
+        readonly memoryInUse: IntegerType;
+    }>>;
+    readonly waiting: ArrayType<StructType<{
+        readonly task: StringType;
+        readonly unit: OptionType<StructType<{
+            readonly merge: OptionType<StructType<{
+                readonly level: IntegerType;
+                readonly levels: IntegerType;
+            }>>;
+            readonly index: IntegerType;
+            readonly units: IntegerType;
+        }>>;
+        readonly needs: IntegerType;
+        readonly since: StringType;
+    }>>;
+    readonly splits: ArrayType<StructType<{
+        readonly task: StringType;
+        readonly merge: OptionType<StructType<{
+            readonly level: IntegerType;
+            readonly levels: IntegerType;
+        }>>;
+        readonly done: IntegerType;
+        readonly units: IntegerType;
+    }>>;
 }>;
 /**
- * Execution status for history listing.
+ * 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.
  */
 export declare const ExecutionHistoryStatusType: VariantType<{
     readonly running: NullType;
     readonly success: NullType;
     readonly failed: NullType;
     readonly error: NullType;
+    readonly cancelled: NullType;
+    readonly interrupted: NullType;
 }>;
 /**
  * A single execution in task history.
@@ -974,6 +1641,8 @@ export declare const ExecutionHistoryStatusType: VariantType<{
  * @property completedAt - ISO timestamp when execution finished (if done)
  * @property duration - Execution duration in milliseconds (if done)
  * @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
  */
 export declare const ExecutionListItemType: StructType<{
     readonly inputsHash: StringType;
@@ -983,11 +1652,14 @@ export declare const ExecutionListItemType: StructType<{
         readonly success: NullType;
         readonly failed: NullType;
         readonly error: NullType;
+        readonly cancelled: NullType;
+        readonly interrupted: NullType;
     }>;
     readonly startedAt: StringType;
     readonly completedAt: OptionType<StringType>;
     readonly duration: OptionType<IntegerType>;
     readonly exitCode: OptionType<IntegerType>;
+    readonly peakBytes: OptionType<IntegerType>;
 }>;
 /**
  * Tree branch kind variant.
@@ -1001,7 +1673,9 @@ export declare const TreeKindType: VariantType<{
  * A list entry -- either a dataset leaf or a tree branch.
  *
  * Used by the `?list=true&status=true` endpoints to return both
- * tree structure entries and dataset leaves in a single flat list.
+ * tree structure entries and dataset leaves in a single flat list. A dataset's
+ * `size` is what its value weighs in the store, as its status reports it: for
+ * a collection, its segments and its manifest.
  */
 export declare const ListEntryType: VariantType<{
     readonly dataset: StructType<{
@@ -1065,7 +1739,8 @@ export declare const ListEntryType: VariantType<{
  * @property type - East type of the dataset
  * @property refType - Ref type: "unassigned", "null", or "value"
  * @property hash - Object hash (None if unassigned/null)
- * @property size - Size in bytes (None if unassigned)
+ * @property size - Bytes the value weighs in the store: for a collection, its
+ *   segments and its manifest (None if unassigned)
  */
 export declare const DatasetStatusDetailType: StructType<{
     readonly path: StringType;
@@ -1114,10 +1789,9 @@ export declare const DatasetStatusDetailType: StructType<{
     readonly refType: StringType;
     readonly hash: OptionType<StringType>;
     readonly size: OptionType<IntegerType>;
-    /** Segment and element counts of a stored collection, read from the blob's
-     *  trailing index — so a re-pointed input is inspectable without decoding
-     *  it. `none` for a non-collection or an unset dataset. Appended LAST, per
-     *  the positional struct rule. */
+    /** Segment and element counts of a stored collection, read from its
+     *  manifest — so a re-pointed input is inspectable without decoding it.
+     *  `none` for a non-collection or an unset dataset. */
     readonly segments: OptionType<IntegerType>;
     readonly rows: OptionType<IntegerType>;
 }>;
@@ -1344,6 +2018,10 @@ export declare const OneShotRequestType: StructType<{
 /**
  * A record mutation call. Positional args (after the implicit current state),
  * one beast2-encoded value per declared parameter.
+ *
+ * Of the limits, `timeoutMs` bounds each run of the mutation's program and
+ * `maxLogBytes` the stderr a failure returns. `maxResultBytes` does not apply:
+ * a mutation's output is stored as segments and never read whole.
  */
 export declare const MutationCallRequestType: StructType<{
     readonly args: ArrayType<BlobType>;
@@ -1359,10 +2037,11 @@ export declare const MutationCallRequestType: StructType<{
  *
  * - `committed`: the new commit + state hashes
  * - `invalid`: record/mutation lookup or arity error; nothing ran
- * - `failed`: the reducer process exited non-zero (incl. a reducer `$.error`; see stderr)
- * - `too_large`: the new state exceeded the result cap
- * - `timed_out`: the reducer exceeded its time budget
- * - `conflict`: the compare-and-swap lost the race `attempts` times
+ * - `failed`: the mutation's program failed (incl. a body's `$.error`; see stderr)
+ * - `timed_out`: the program exceeded its time budget
+ * - `conflict`: the compare-and-swap lost the race `attempts` times, or the
+ *   write disagreed with the state it landed on — then `detail` names the key,
+ *   and resubmitting the same write cannot help
  */
 export declare const MutationResultType: StructType<{
     readonly outcome: VariantType<{
@@ -1377,24 +2056,20 @@ export declare const MutationResultType: StructType<{
             readonly exitCode: IntegerType;
             readonly stderr: StringType;
         }>;
-        readonly too_large: StructType<{
-            readonly bytes: IntegerType;
-            readonly limit: IntegerType;
-            readonly stderr: StringType;
-        }>;
         readonly timed_out: StructType<{
             readonly ms: IntegerType;
             readonly stderr: StringType;
         }>;
         readonly conflict: StructType<{
             readonly attempts: IntegerType;
+            readonly detail: OptionType<StringType>;
         }>;
     }>;
 }>;
 /**
  * A record's callable surface, returned by `describe` so dynamic callers can
- * encode mutation arguments. The mutation `argTypes` are the EXTRA parameters
- * after the implicit current state.
+ * encode mutation arguments and read through its indexes. The mutation
+ * `argTypes` are the EXTRA parameters after the implicit current state.
  */
 export declare const RecordSignatureType: StructType<{
     readonly name: StringType;
@@ -1442,6 +2117,105 @@ export declare const RecordSignatureType: StructType<{
             readonly Vector: import("@elaraai/east").RecursiveTypeMarker;
             readonly Matrix: import("@elaraai/east").RecursiveTypeMarker;
         }>>>;
+        /** The write form — `reduce`, `edit` or `patch` — which says what the
+         *  arguments MEAN: a `patch` mutation's one argument is a
+         *  `PatchType(State)`, not a value of the record's own type. */
+        readonly form: StringType;
+    }>>;
+    /** The indexes the record declares. A page read through one is decoded by
+     *  `indexWindowType(K, keyType, valueType, V)` over the record's
+     *  `Dict<K, V>`, and a key search through one takes a `keyType` key. */
+    readonly indexes: ArrayType<StructType<{
+        readonly name: StringType;
+        /** The index key's type. */
+        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: 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 covering projection's type: `Null` when the index projects
+         *  nothing, and a read joins the rows instead. */
+        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: 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;
+        }>>;
+        /** Whether a row may hold several index keys. */
+        readonly multi: BooleanType;
     }>>;
 }>;
 /** One commit in a record's history (its hash plus the commit fields). */
@@ -1452,6 +2226,9 @@ export declare const RecordCommitInfoType: 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. */
+    readonly delta: OptionType<StringType>;
 }>;
 /** A page of a record's commit history, newest first. */
 export declare const RecordHistoryResultType: StructType<{
@@ -1462,6 +2239,9 @@ 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. */
+        readonly delta: OptionType<StringType>;
     }>>;
 }>;
 export type Error = ValueTypeOf<typeof ErrorType>;
@@ -1477,6 +2257,16 @@ export type PackageDetails = ValueTypeOf<typeof PackageDetailsType>;
 export type WorkspaceInfo = ValueTypeOf<typeof WorkspaceInfoType>;
 export type WorkspaceCreateRequest = ValueTypeOf<typeof WorkspaceCreateRequestType>;
 export type WorkspaceDeployRequest = ValueTypeOf<typeof WorkspaceDeployRequestType>;
+/** A {@link SchemaPolicyType} by its name, as a deploy's options take it. */
+export type SchemaPolicy = ValueTypeOf<typeof SchemaPolicyType>['type'];
+export type RecordPlan = ValueTypeOf<typeof RecordPlanType>;
+export type RecordIndexPlan = ValueTypeOf<typeof RecordIndexPlanType>;
+export type RecordDeployStep = ValueTypeOf<typeof RecordDeployStepType>;
+export type RecordDeployState = ValueTypeOf<typeof RecordDeployStateType>;
+export type DeployProgress = ValueTypeOf<typeof DeployProgressType>;
+export type WorkspaceDeployResult = ValueTypeOf<typeof WorkspaceDeployResultType>;
+export type WorkspaceDeployProgress = ValueTypeOf<typeof WorkspaceDeployProgressType>;
+export type WorkspaceDeployStatus = ValueTypeOf<typeof WorkspaceDeployStatusType>;
 export type DatasetStatus = ValueTypeOf<typeof DatasetStatusType>;
 export type TaskStatus = ValueTypeOf<typeof TaskStatusType>;
 export type DatasetStatusInfo = ValueTypeOf<typeof DatasetStatusInfoType>;
@@ -1492,6 +2282,9 @@ export type DataflowResult = ValueTypeOf<typeof DataflowResultType>;
 export type DataflowEvent = ValueTypeOf<typeof DataflowEventType>;
 export type ApiExecutionStatus = ValueTypeOf<typeof ApiExecutionStatusType>;
 export type DataflowExecutionSummary = ValueTypeOf<typeof DataflowExecutionSummaryType>;
+export type DataflowBudget = ValueTypeOf<typeof DataflowBudgetType>;
+export type UnitWait = ValueTypeOf<typeof UnitWaitType>;
+export type SplitProgress = ValueTypeOf<typeof SplitProgressType>;
 export type ApiDataflowExecutionState = ValueTypeOf<typeof ApiDataflowExecutionStateType>;
 export type ExecutionHistoryStatus = ValueTypeOf<typeof ExecutionHistoryStatusType>;
 export type ExecutionListItem = ValueTypeOf<typeof ExecutionListItemType>;