@elaraai/e3-types 1.0.80 → 1.0.81

package/dist/src/intake.d.ts

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * How far a file being taken into the store has got: a deploy's file source,
+ * or an upload's delivery as its commit takes it in.
+ *
+ * A file is hashed first, since its SHA-256 is how the store knows a delivery
+ * it already holds, and then taken in: a collection by intake units on the
+ * runners, a piece of its segments each, and any other value as the object the
+ * file is.
+ */
+import { ArrayType, IntegerType, NullType, StringType, StructType, VariantType, type ValueTypeOf } from '@elaraai/east';
+/**
+ * The step a file being taken in is at.
+ */
+export declare const IntakeStepType: VariantType<{
+    /** Not started: a deploy takes a bounded number of files in at once */
+    readonly waiting: NullType;
+    /** Being read for its SHA-256, by which the store knows a delivery it
+     *  already holds */
+    readonly hashing: NullType;
+    /** Being taken in by intake units: its `pieces`, and how many are `done` */
+    readonly taking_in: StructType<{
+        readonly pieces: IntegerType;
+        readonly done: IntegerType;
+    }>;
+    /** In the store: one it already held; a value that is not a collection,
+     *  carried as the object the file is; or a collection, taken in by the
+     *  runners named, in the order each first took a piece in — none when every
+     *  piece was taken in before, by an intake that stopped part way */
+    readonly done: VariantType<{
+        readonly known: NullType;
+        readonly carried: NullType;
+        readonly taken: ArrayType<StringType>;
+    }>;
+}>;
+export type IntakeStep = ValueTypeOf<typeof IntakeStepType>;
+/**
+ * A file being taken into the store.
+ */
+export declare const IntakeFileType: StructType<{
+    /** The dataset it becomes, as `inputs/<name>` */
+    readonly path: StringType;
+    /** The step it is at */
+    readonly step: VariantType<{
+        /** Not started: a deploy takes a bounded number of files in at once */
+        readonly waiting: NullType;
+        /** Being read for its SHA-256, by which the store knows a delivery it
+         *  already holds */
+        readonly hashing: NullType;
+        /** Being taken in by intake units: its `pieces`, and how many are `done` */
+        readonly taking_in: StructType<{
+            readonly pieces: IntegerType;
+            readonly done: IntegerType;
+        }>;
+        /** In the store: one it already held; a value that is not a collection,
+         *  carried as the object the file is; or a collection, taken in by the
+         *  runners named, in the order each first took a piece in — none when every
+         *  piece was taken in before, by an intake that stopped part way */
+        readonly done: VariantType<{
+            readonly known: NullType;
+            readonly carried: NullType;
+            readonly taken: ArrayType<StringType>;
+        }>;
+    }>;
+    /** Bytes of the file its step has covered: read for its hash, or covered by
+     *  the pieces taken in; its size once it is done */
+    readonly bytes: IntegerType;
+    /** The file's size */
+    readonly total: IntegerType;
+}>;
+export type IntakeFile = ValueTypeOf<typeof IntakeFileType>;
+//# sourceMappingURL=intake.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"intake.d.ts","sourceRoot":"","sources":["../../src/intake.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;GAQG;AAEH,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAExH;;GAEG;AACH,eAAO,MAAM,cAAc;IACzB,uEAAuE;;IAEvE;wBACoB;;IAEpB,4EAA4E;;;;;IAE5E;;;wEAGoE;;;;;;EAEpE,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC;AAE5D;;GAEG;AACH,eAAO,MAAM,cAAc;IACzB,iDAAiD;;IAEjD,wBAAwB;;QAtBxB,uEAAuE;;QAEvE;4BACoB;;QAEpB,4EAA4E;;;;;QAE5E;;;4EAGoE;;;;;;;IAcpE;wDACoD;;IAEpD,sBAAsB;;EAEtB,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/src/intake.js

@@ -0,0 +1,46 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * How far a file being taken into the store has got: a deploy's file source,
+ * or an upload's delivery as its commit takes it in.
+ *
+ * A file is hashed first, since its SHA-256 is how the store knows a delivery
+ * it already holds, and then taken in: a collection by intake units on the
+ * runners, a piece of its segments each, and any other value as the object the
+ * file is.
+ */
+import { ArrayType, IntegerType, NullType, StringType, StructType, VariantType } from '@elaraai/east';
+/**
+ * The step a file being taken in is at.
+ */
+export const IntakeStepType = VariantType({
+    /** Not started: a deploy takes a bounded number of files in at once */
+    waiting: NullType,
+    /** Being read for its SHA-256, by which the store knows a delivery it
+     *  already holds */
+    hashing: NullType,
+    /** Being taken in by intake units: its `pieces`, and how many are `done` */
+    taking_in: StructType({ pieces: IntegerType, done: IntegerType }),
+    /** In the store: one it already held; a value that is not a collection,
+     *  carried as the object the file is; or a collection, taken in by the
+     *  runners named, in the order each first took a piece in — none when every
+     *  piece was taken in before, by an intake that stopped part way */
+    done: VariantType({ known: NullType, carried: NullType, taken: ArrayType(StringType) }),
+});
+/**
+ * A file being taken into the store.
+ */
+export const IntakeFileType = StructType({
+    /** The dataset it becomes, as `inputs/<name>` */
+    path: StringType,
+    /** The step it is at */
+    step: IntakeStepType,
+    /** Bytes of the file its step has covered: read for its hash, or covered by
+     *  the pieces taken in; its size once it is done */
+    bytes: IntegerType,
+    /** The file's size */
+    total: IntegerType,
+});
+//# sourceMappingURL=intake.js.map

package/dist/src/intake.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"intake.js","sourceRoot":"","sources":["../../src/intake.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;GAQG;AAEH,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAoB,MAAM,eAAe,CAAC;AAExH;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,WAAW,CAAC;IACxC,uEAAuE;IACvE,OAAO,EAAE,QAAQ;IACjB;wBACoB;IACpB,OAAO,EAAE,QAAQ;IACjB,4EAA4E;IAC5E,SAAS,EAAE,UAAU,CAAC,EAAE,MAAM,EAAE,WAAW,EAAE,IAAI,EAAE,WAAW,EAAE,CAAC;IACjE;;;wEAGoE;IACpE,IAAI,EAAE,WAAW,CAAC,EAAE,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,SAAS,CAAC,UAAU,CAAC,EAAE,CAAC;CACxF,CAAC,CAAC;AAIH;;GAEG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;IACvC,iDAAiD;IACjD,IAAI,EAAE,UAAU;IAChB,wBAAwB;IACxB,IAAI,EAAE,cAAc;IACpB;wDACoD;IACpD,KAAK,EAAE,WAAW;IAClB,sBAAsB;IACtB,KAAK,EAAE,WAAW;CACnB,CAAC,CAAC"}

package/dist/src/lock.d.ts

@@ -13,6 +13,10 @@
  * - when it was acquired;
  * - when it expires, for a cloud backend's lease.
  *
+ * An exclusive holder may also report how far its operation has got, for
+ * another process to read while it holds the lock: a deploy taking its file
+ * sources in and deploying its records.
+ *
  * A local repository keeps each resource's locks in `locks/<resource>/`.
  */
 import { VariantType, StructType, StringType, IntegerType, DateTimeType, OptionType, NullType, ValueTypeOf } from '@elaraai/east';
@@ -128,4 +132,186 @@ export declare const LockStateType: StructType<{
     readonly expiresAt: OptionType<DateTimeType>;
 }>;
 export type LockState = ValueTypeOf<typeof LockStateType>;
+/**
+ * How far the operation holding a lock exclusively has got, as its holder
+ * reports it for another process to read while it holds the lock.
+ */
+export declare const LockProgressType: VariantType<{
+    /** A deploy: its file sources and its records */
+    readonly deployment: StructType<{
+        readonly package: StructType<{
+            readonly name: StringType;
+            readonly version: StringType;
+        }>;
+        readonly startedAt: DateTimeType;
+        readonly files: import("@elaraai/east").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: import("@elaraai/east").ArrayType<StringType>;
+                }>;
+            }>;
+            readonly bytes: IntegerType;
+            readonly total: IntegerType;
+        }>>;
+        readonly records: import("@elaraai/east").ArrayType<StructType<{
+            readonly plan: StructType<{
+                readonly record: StringType;
+                readonly action: VariantType<{
+                    readonly mint: NullType;
+                    readonly keep: StructType<{
+                        readonly deploy: import("@elaraai/east").BooleanType;
+                    }>;
+                    readonly migrate: StructType<{
+                        readonly steps: import("@elaraai/east").ArrayType<StringType>;
+                    }>;
+                    readonly reset: StructType<{
+                        readonly reason: StringType;
+                    }>;
+                    readonly drop: NullType;
+                    readonly refused: StructType<{
+                        readonly reason: StringType;
+                    }>;
+                }>;
+            }>;
+            readonly indexes: import("@elaraai/east").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;
+            }>;
+        }>>;
+    }>;
+}>;
+export type LockProgress = ValueTypeOf<typeof LockProgressType>;
+/**
+ * A resource's exclusive lock as another process reads it while it is held:
+ * what holds it, and how far that operation says it has got.
+ */
+export declare const LockStatusType: StructType<{
+    /** The lock's state: the operation, its holder, and when it was acquired */
+    readonly state: StructType<{
+        /** What operation acquired the lock */
+        readonly operation: VariantType<{
+            /** Running a dataflow */
+            readonly dataflow: NullType;
+            /** Deploying a package to the workspace */
+            readonly deployment: NullType;
+            /** Removing the workspace */
+            readonly removal: NullType;
+            /** Writing to a dataset */
+            readonly dataset_write: NullType;
+            /** Exporting a workspace */
+            readonly export: NullType;
+        }>;
+        /** Who holds the lock */
+        readonly holder: VariantType<{
+            /** A local process */
+            readonly process: StructType<{
+                /** Process ID */
+                readonly pid: IntegerType;
+                /** System boot ID (from /proc/sys/kernel/random/boot_id) */
+                readonly bootId: StringType;
+                /** Process start time in jiffies since boot */
+                readonly startTime: IntegerType;
+                /** Command that acquired the lock (for debugging) */
+                readonly command: StringType;
+            }>;
+            /** A cloud function */
+            readonly lambda: StructType<{
+                /** The invocation's request ID */
+                readonly requestId: StringType;
+                /** The function's name */
+                readonly functionName: StringType;
+            }>;
+        }>;
+        /** When the lock was acquired */
+        readonly acquiredAt: DateTimeType;
+        /** When the lock expires (for cloud TTL-based locks) */
+        readonly expiresAt: OptionType<DateTimeType>;
+    }>;
+    /** What the holder last reported of its progress; `none` until it reports */
+    readonly progress: OptionType<VariantType<{
+        /** A deploy: its file sources and its records */
+        readonly deployment: StructType<{
+            readonly package: StructType<{
+                readonly name: StringType;
+                readonly version: StringType;
+            }>;
+            readonly startedAt: DateTimeType;
+            readonly files: import("@elaraai/east").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: import("@elaraai/east").ArrayType<StringType>;
+                    }>;
+                }>;
+                readonly bytes: IntegerType;
+                readonly total: IntegerType;
+            }>>;
+            readonly records: import("@elaraai/east").ArrayType<StructType<{
+                readonly plan: StructType<{
+                    readonly record: StringType;
+                    readonly action: VariantType<{
+                        readonly mint: NullType;
+                        readonly keep: StructType<{
+                            readonly deploy: import("@elaraai/east").BooleanType;
+                        }>;
+                        readonly migrate: StructType<{
+                            readonly steps: import("@elaraai/east").ArrayType<StringType>;
+                        }>;
+                        readonly reset: StructType<{
+                            readonly reason: StringType;
+                        }>;
+                        readonly drop: NullType;
+                        readonly refused: StructType<{
+                            readonly reason: StringType;
+                        }>;
+                    }>;
+                }>;
+                readonly indexes: import("@elaraai/east").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;
+                }>;
+            }>>;
+        }>;
+    }>>;
+}>;
+export type LockStatus = ValueTypeOf<typeof LockStatusType>;
 //# sourceMappingURL=lock.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../src/lock.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,WAAW,EACX,UAAU,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,UAAU,EACV,QAAQ,EACR,WAAW,EACZ,MAAM,eAAe,CAAC;AAEvB;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC5B,yBAAyB;;IAEzB,2CAA2C;;IAE3C,6BAA6B;;IAE7B,2BAA2B;;IAE3B,4BAA4B;;EAE5B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,iBAAiB;IAC5B,iBAAiB;;IAEjB,4DAA4D;;IAE5D,+CAA+C;;IAE/C,qDAAqD;;EAErD,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B,kCAAkC;;IAElC,0BAA0B;;EAE1B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,qBAAqB;IAChC,sBAAsB;;QA5BtB,iBAAiB;;QAEjB,4DAA4D;;QAE5D,+CAA+C;;QAE/C,qDAAqD;;;IAwBrD,uBAAuB;;QAdvB,kCAAkC;;QAElC,0BAA0B;;;EAc1B,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E;;;;;GAKG;AACH,eAAO,MAAM,aAAa;IACxB,uCAAuC;;QA9DvC,yBAAyB;;QAEzB,2CAA2C;;QAE3C,6BAA6B;;QAE7B,2BAA2B;;QAE3B,4BAA4B;;;IAwD5B,yBAAyB;;QAjBzB,sBAAsB;;YA5BtB,iBAAiB;;YAEjB,4DAA4D;;YAE5D,+CAA+C;;YAE/C,qDAAqD;;;QAwBrD,uBAAuB;;YAdvB,kCAAkC;;YAElC,0BAA0B;;;;IA6B1B,iCAAiC;;IAEjC,wDAAwD;;EAExD,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,OAAO,aAAa,CAAC,CAAC"}
+{"version":3,"file":"lock.d.ts","sourceRoot":"","sources":["../../src/lock.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,WAAW,EACX,UAAU,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,UAAU,EACV,QAAQ,EACR,WAAW,EACZ,MAAM,eAAe,CAAC;AAGvB;;GAEG;AACH,eAAO,MAAM,iBAAiB;IAC5B,yBAAyB;;IAEzB,2CAA2C;;IAE3C,6BAA6B;;IAE7B,2BAA2B;;IAE3B,4BAA4B;;EAE5B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;;GAGG;AACH,eAAO,MAAM,iBAAiB;IAC5B,iBAAiB;;IAEjB,4DAA4D;;IAE5D,+CAA+C;;IAE/C,qDAAqD;;EAErD,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;GAEG;AACH,eAAO,MAAM,gBAAgB;IAC3B,kCAAkC;;IAElC,0BAA0B;;EAE1B,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;GAEG;AACH,eAAO,MAAM,qBAAqB;IAChC,sBAAsB;;QA5BtB,iBAAiB;;QAEjB,4DAA4D;;QAE5D,+CAA+C;;QAE/C,qDAAqD;;;IAwBrD,uBAAuB;;QAdvB,kCAAkC;;QAElC,0BAA0B;;;EAc1B,CAAC;AAEH,MAAM,MAAM,iBAAiB,GAAG,WAAW,CAAC,OAAO,qBAAqB,CAAC,CAAC;AAE1E;;;;;GAKG;AACH,eAAO,MAAM,aAAa;IACxB,uCAAuC;;QA9DvC,yBAAyB;;QAEzB,2CAA2C;;QAE3C,6BAA6B;;QAE7B,2BAA2B;;QAE3B,4BAA4B;;;IAwD5B,yBAAyB;;QAjBzB,sBAAsB;;YA5BtB,iBAAiB;;YAEjB,4DAA4D;;YAE5D,+CAA+C;;YAE/C,qDAAqD;;;QAwBrD,uBAAuB;;YAdvB,kCAAkC;;YAElC,0BAA0B;;;;IA6B1B,iCAAiC;;IAEjC,wDAAwD;;EAExD,CAAC;AAEH,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,OAAO,aAAa,CAAC,CAAC;AAE1D;;;GAGG;AACH,eAAO,MAAM,gBAAgB;IAC3B,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAEjD,CAAC;AAEH,MAAM,MAAM,YAAY,GAAG,WAAW,CAAC,OAAO,gBAAgB,CAAC,CAAC;AAEhE;;;GAGG;AACH,eAAO,MAAM,cAAc;IACzB,4EAA4E;;QA5B5E,uCAAuC;;YA9DvC,yBAAyB;;YAEzB,2CAA2C;;YAE3C,6BAA6B;;YAE7B,2BAA2B;;YAE3B,4BAA4B;;;QAwD5B,yBAAyB;;YAjBzB,sBAAsB;;gBA5BtB,iBAAiB;;gBAEjB,4DAA4D;;gBAE5D,+CAA+C;;gBAE/C,qDAAqD;;;YAwBrD,uBAAuB;;gBAdvB,kCAAkC;;gBAElC,0BAA0B;;;;QA6B1B,iCAAiC;;QAEjC,wDAAwD;;;IAwBxD,6EAA6E;;QAb7E,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAejD,CAAC;AAEH,MAAM,MAAM,UAAU,GAAG,WAAW,CAAC,OAAO,cAAc,CAAC,CAAC"}

package/dist/src/lock.js

@@ -13,9 +13,14 @@
  * - when it was acquired;
  * - when it expires, for a cloud backend's lease.
  *
+ * An exclusive holder may also report how far its operation has got, for
+ * another process to read while it holds the lock: a deploy taking its file
+ * sources in and deploying its records.
+ *
  * A local repository keeps each resource's locks in `locks/<resource>/`.
  */
 import { VariantType, StructType, StringType, IntegerType, DateTimeType, OptionType, NullType, } from '@elaraai/east';
+import { DeployProgressType } from './api.js';
 /**
  * Lock operation - what acquired the lock.
  */
@@ -79,4 +84,22 @@ export const LockStateType = StructType({
     /** When the lock expires (for cloud TTL-based locks) */
     expiresAt: OptionType(DateTimeType),
 });
+/**
+ * How far the operation holding a lock exclusively has got, as its holder
+ * reports it for another process to read while it holds the lock.
+ */
+export const LockProgressType = VariantType({
+    /** A deploy: its file sources and its records */
+    deployment: DeployProgressType,
+});
+/**
+ * A resource's exclusive lock as another process reads it while it is held:
+ * what holds it, and how far that operation says it has got.
+ */
+export const LockStatusType = StructType({
+    /** The lock's state: the operation, its holder, and when it was acquired */
+    state: LockStateType,
+    /** What the holder last reported of its progress; `none` until it reports */
+    progress: OptionType(LockProgressType),
+});
 //# sourceMappingURL=lock.js.map

package/dist/src/lock.js.map

@@ -1 +1 @@
-{"version":3,"file":"lock.js","sourceRoot":"","sources":["../../src/lock.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AAEH,OAAO,EACL,WAAW,EACX,UAAU,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,UAAU,EACV,QAAQ,GAET,MAAM,eAAe,CAAC;AAEvB;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,WAAW,CAAC;IAC3C,yBAAyB;IACzB,QAAQ,EAAE,QAAQ;IAClB,2CAA2C;IAC3C,UAAU,EAAE,QAAQ;IACpB,6BAA6B;IAC7B,OAAO,EAAE,QAAQ;IACjB,2BAA2B;IAC3B,aAAa,EAAE,QAAQ;IACvB,4BAA4B;IAC5B,MAAM,EAAE,QAAQ;CACjB,CAAC,CAAC;AAIH;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;IAC1C,iBAAiB;IACjB,GAAG,EAAE,WAAW;IAChB,4DAA4D;IAC5D,MAAM,EAAE,UAAU;IAClB,+CAA+C;IAC/C,SAAS,EAAE,WAAW;IACtB,qDAAqD;IACrD,OAAO,EAAE,UAAU;CACpB,CAAC,CAAC;AAIH;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;IACzC,kCAAkC;IAClC,SAAS,EAAE,UAAU;IACrB,0BAA0B;IAC1B,YAAY,EAAE,UAAU;CACzB,CAAC,CAAC;AAIH;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,WAAW,CAAC;IAC/C,sBAAsB;IACtB,OAAO,EAAE,iBAAiB;IAC1B,uBAAuB;IACvB,MAAM,EAAE,gBAAgB;CACzB,CAAC,CAAC;AAIH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;IACtC,uCAAuC;IACvC,SAAS,EAAE,iBAAiB;IAC5B,yBAAyB;IACzB,MAAM,EAAE,qBAAqB;IAC7B,iCAAiC;IACjC,UAAU,EAAE,YAAY;IACxB,wDAAwD;IACxD,SAAS,EAAE,UAAU,CAAC,YAAY,CAAC;CACpC,CAAC,CAAC"}
+{"version":3,"file":"lock.js","sourceRoot":"","sources":["../../src/lock.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EACL,WAAW,EACX,UAAU,EACV,UAAU,EACV,WAAW,EACX,YAAY,EACZ,UAAU,EACV,QAAQ,GAET,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAC;AAE9C;;GAEG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,WAAW,CAAC;IAC3C,yBAAyB;IACzB,QAAQ,EAAE,QAAQ;IAClB,2CAA2C;IAC3C,UAAU,EAAE,QAAQ;IACpB,6BAA6B;IAC7B,OAAO,EAAE,QAAQ;IACjB,2BAA2B;IAC3B,aAAa,EAAE,QAAQ;IACvB,4BAA4B;IAC5B,MAAM,EAAE,QAAQ;CACjB,CAAC,CAAC;AAIH;;;GAGG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;IAC1C,iBAAiB;IACjB,GAAG,EAAE,WAAW;IAChB,4DAA4D;IAC5D,MAAM,EAAE,UAAU;IAClB,+CAA+C;IAC/C,SAAS,EAAE,WAAW;IACtB,qDAAqD;IACrD,OAAO,EAAE,UAAU;CACpB,CAAC,CAAC;AAIH;;GAEG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,UAAU,CAAC;IACzC,kCAAkC;IAClC,SAAS,EAAE,UAAU;IACrB,0BAA0B;IAC1B,YAAY,EAAE,UAAU;CACzB,CAAC,CAAC;AAIH;;GAEG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,WAAW,CAAC;IAC/C,sBAAsB;IACtB,OAAO,EAAE,iBAAiB;IAC1B,uBAAuB;IACvB,MAAM,EAAE,gBAAgB;CACzB,CAAC,CAAC;AAIH;;;;;GAKG;AACH,MAAM,CAAC,MAAM,aAAa,GAAG,UAAU,CAAC;IACtC,uCAAuC;IACvC,SAAS,EAAE,iBAAiB;IAC5B,yBAAyB;IACzB,MAAM,EAAE,qBAAqB;IAC7B,iCAAiC;IACjC,UAAU,EAAE,YAAY;IACxB,wDAAwD;IACxD,SAAS,EAAE,UAAU,CAAC,YAAY,CAAC;CACpC,CAAC,CAAC;AAIH;;;GAGG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG,WAAW,CAAC;IAC1C,iDAAiD;IACjD,UAAU,EAAE,kBAAkB;CAC/B,CAAC,CAAC;AAIH;;;GAGG;AACH,MAAM,CAAC,MAAM,cAAc,GAAG,UAAU,CAAC;IACvC,4EAA4E;IAC5E,KAAK,EAAE,aAAa;IACpB,6EAA6E;IAC7E,QAAQ,EAAE,UAAU,CAAC,gBAAgB,CAAC;CACvC,CAAC,CAAC"}

package/dist/src/release.d.ts

@@ -15,7 +15,7 @@
  * release beside this one.
  */
 /** The release of e3 this build is. */
-export declare const E3_RELEASE = "1.0.79";
+export declare const E3_RELEASE = "1.0.81";
 /**
  * Orders two releases by semantic-version precedence.
  *

package/dist/src/release.js

@@ -15,7 +15,7 @@
  * release beside this one.
  */
 /** The release of e3 this build is. */
-export const E3_RELEASE = '1.0.79';
+export const E3_RELEASE = '1.0.81';
 /** A semantic version: its core, a pre-release, and build metadata. */
 const RELEASE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 /**

package/dist/src/transfer.d.ts

@@ -14,7 +14,7 @@
  * releases and the fix. The release decides nothing, so an older client and a
  * newer server that speak one version work together.
  */
-import { VariantType, StructType, StringType, IntegerType, NullType, DictType, type ValueTypeOf } from '@elaraai/east';
+import { VariantType, StructType, StringType, IntegerType, NullType, DictType, OptionType, type ValueTypeOf } from '@elaraai/east';
 /**
  * The dataset transfer protocol version this build speaks, and the only one.
  *
@@ -22,10 +22,10 @@ import { VariantType, StructType, StringType, IntegerType, NullType, DictType, t
  * The server plans an upload as parts — each sent to its own URL with the
  * request headers the server names, so an object store can bind a checksum to
  * a single PUT or take a multipart upload larger than one PUT allows — and a
- * commit may answer `processing` while the server verifies the bytes, for the
- * client to poll.
+ * commit may answer `processing` while the server verifies the bytes and takes
+ * them in, with how far it has got, for the client to poll.
  */
-export declare const TRANSFER_PROTOCOL_VERSION = 2;
+export declare const TRANSFER_PROTOCOL_VERSION = 3;
 /**
  * How many parts an upload of `size` bytes has when planned with `partBytes`.
  *
@@ -99,15 +99,33 @@ export type TransferPartResponse = ValueTypeOf<typeof TransferPartResponseType>;
  *
  * - `completed`: Hash verified, object stored, dataset ref updated
  * - `error`: Hash mismatch or other failure
- * - `processing`: the server is still verifying the bytes; poll
- *   `GET …/upload/<id>` until it answers `completed` or `error`
+ * - `processing`: the server is still verifying the bytes or taking them in,
+ *   with how far it has got once it has said; poll `GET …/upload/<id>` until
+ *   it answers `completed` or `error`
  */
 export declare const TransferDoneResponseType: VariantType<{
     readonly completed: NullType;
     readonly error: StructType<{
         readonly message: StringType;
     }>;
-    readonly processing: NullType;
+    readonly processing: OptionType<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: import("@elaraai/east").ArrayType<StringType>;
+            }>;
+        }>;
+        readonly bytes: IntegerType;
+        readonly total: IntegerType;
+    }>>;
 }>;
 export type TransferDoneResponse = ValueTypeOf<typeof TransferDoneResponseType>;
 //# sourceMappingURL=transfer.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../../src/transfer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAEvH;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAI3F;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,SAAS,EAAE,MAAM,GAAG,MAAM,EAC1B,IAAI,EAAE,MAAM,GACX;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAKvC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB;;;EAGpC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,WAAW,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B;;;;;;EAMrC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,WAAW,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEpF;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB;;;EAGnC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB;;;;;;EAMnC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC"}
+{"version":3,"file":"transfer.d.ts","sourceRoot":"","sources":["../../src/transfer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAE,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAGnI;;;;;;;;;GASG;AACH,eAAO,MAAM,yBAAyB,IAAI,CAAC;AAE3C;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,CAI3F;AAED;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,MAAM,GAAG,MAAM,EACrB,SAAS,EAAE,MAAM,GAAG,MAAM,EAC1B,IAAI,EAAE,MAAM,GACX;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,GAAG,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAKvC;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,yBAAyB;;;EAGpC,CAAC;AACH,MAAM,MAAM,qBAAqB,GAAG,WAAW,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAElF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,0BAA0B;;;;;;EAMrC,CAAC;AACH,MAAM,MAAM,sBAAsB,GAAG,WAAW,CAAC,OAAO,0BAA0B,CAAC,CAAC;AAEpF;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB;;;EAGnC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAEhF;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;EAMnC,CAAC;AACH,MAAM,MAAM,oBAAoB,GAAG,WAAW,CAAC,OAAO,wBAAwB,CAAC,CAAC"}

package/dist/src/transfer.js

@@ -14,7 +14,8 @@
  * releases and the fix. The release decides nothing, so an older client and a
  * newer server that speak one version work together.
  */
-import { VariantType, StructType, StringType, IntegerType, NullType, DictType } from '@elaraai/east';
+import { VariantType, StructType, StringType, IntegerType, NullType, DictType, OptionType } from '@elaraai/east';
+import { IntakeFileType } from './intake.js';
 /**
  * The dataset transfer protocol version this build speaks, and the only one.
  *
@@ -22,10 +23,10 @@ import { VariantType, StructType, StringType, IntegerType, NullType, DictType }
  * The server plans an upload as parts — each sent to its own URL with the
  * request headers the server names, so an object store can bind a checksum to
  * a single PUT or take a multipart upload larger than one PUT allows — and a
- * commit may answer `processing` while the server verifies the bytes, for the
- * client to poll.
+ * commit may answer `processing` while the server verifies the bytes and takes
+ * them in, with how far it has got, for the client to poll.
  */
-export const TRANSFER_PROTOCOL_VERSION = 2;
+export const TRANSFER_PROTOCOL_VERSION = 3;
 /**
  * How many parts an upload of `size` bytes has when planned with `partBytes`.
  *
@@ -103,14 +104,15 @@ export const TransferPartResponseType = StructType({
  *
  * - `completed`: Hash verified, object stored, dataset ref updated
  * - `error`: Hash mismatch or other failure
- * - `processing`: the server is still verifying the bytes; poll
- *   `GET …/upload/<id>` until it answers `completed` or `error`
+ * - `processing`: the server is still verifying the bytes or taking them in,
+ *   with how far it has got once it has said; poll `GET …/upload/<id>` until
+ *   it answers `completed` or `error`
  */
 export const TransferDoneResponseType = VariantType({
     completed: NullType,
     error: StructType({
         message: StringType,
     }),
-    processing: NullType,
+    processing: OptionType(IntakeFileType),
 });
 //# sourceMappingURL=transfer.js.map

package/dist/src/transfer.js.map

@@ -1 +1 @@
-{"version":3,"file":"transfer.js","sourceRoot":"","sources":["../../src/transfer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAoB,MAAM,eAAe,CAAC;AAEvH;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC;AAE3C;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAqB,EAAE,SAA0B;IACjF,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IAC/B,OAAO,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,GAAG,IAAI,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAC/B,IAAqB,EACrB,SAA0B,EAC1B,IAAY;IAEZ,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,iBAAiB,CAAC,IAAI,EAAE,SAAS,CAAC;QAAE,OAAO,IAAI,CAAC;IAClG,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IACnD,MAAM,GAAG,GAAG,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAChG,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;AACpD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;IAClD,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,WAAW;CAClB,CAAC,CAAC;AAGH;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,WAAW,CAAC;IACpD,SAAS,EAAE,QAAQ;IACnB,YAAY,EAAE,UAAU,CAAC;QACvB,EAAE,EAAE,UAAU;QACd,SAAS,EAAE,WAAW;KACvB,CAAC;CACH,CAAC,CAAC;AAGH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;IACjD,GAAG,EAAE,UAAU;IACf,OAAO,EAAE,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CAC1C,CAAC,CAAC;AAGH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,WAAW,CAAC;IAClD,SAAS,EAAE,QAAQ;IACnB,KAAK,EAAE,UAAU,CAAC;QAChB,OAAO,EAAE,UAAU;KACpB,CAAC;IACF,UAAU,EAAE,QAAQ;CACrB,CAAC,CAAC"}
+{"version":3,"file":"transfer.js","sourceRoot":"","sources":["../../src/transfer.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,QAAQ,EAAE,QAAQ,EAAE,UAAU,EAAoB,MAAM,eAAe,CAAC;AACnI,OAAO,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAE7C;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC;AAE3C;;;;;;GAMG;AACH,MAAM,UAAU,iBAAiB,CAAC,IAAqB,EAAE,SAA0B;IACjF,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;IAC3B,MAAM,IAAI,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IAC/B,OAAO,KAAK,IAAI,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,KAAK,GAAG,IAAI,GAAG,EAAE,CAAC,GAAG,IAAI,CAAC,CAAC;AAChE,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,iBAAiB,CAC/B,IAAqB,EACrB,SAA0B,EAC1B,IAAY;IAEZ,IAAI,CAAC,MAAM,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,IAAI,GAAG,CAAC,IAAI,IAAI,GAAG,iBAAiB,CAAC,IAAI,EAAE,SAAS,CAAC;QAAE,OAAO,IAAI,CAAC;IAClG,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,GAAG,CAAC,CAAC,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC;IACnD,MAAM,GAAG,GAAG,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,KAAK,GAAG,MAAM,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IAChG,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,KAAK,CAAC,EAAE,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;AACpD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,yBAAyB,GAAG,UAAU,CAAC;IAClD,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,WAAW;CAClB,CAAC,CAAC;AAGH;;;;;;;;;;;GAWG;AACH,MAAM,CAAC,MAAM,0BAA0B,GAAG,WAAW,CAAC;IACpD,SAAS,EAAE,QAAQ;IACnB,YAAY,EAAE,UAAU,CAAC;QACvB,EAAE,EAAE,UAAU;QACd,SAAS,EAAE,WAAW;KACvB,CAAC;CACH,CAAC,CAAC;AAGH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,UAAU,CAAC;IACjD,GAAG,EAAE,UAAU;IACf,OAAO,EAAE,QAAQ,CAAC,UAAU,EAAE,UAAU,CAAC;CAC1C,CAAC,CAAC;AAGH;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG,WAAW,CAAC;IAClD,SAAS,EAAE,QAAQ;IACnB,KAAK,EAAE,UAAU,CAAC;QAChB,OAAO,EAAE,UAAU;KACpB,CAAC;IACF,UAAU,EAAE,UAAU,CAAC,cAAc,CAAC;CACvC,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elaraai/e3-types",
-  "version": "1.0.80",
+  "version": "1.0.81",
   "description": "Shared type definitions for e3 (East Execution Engine)",
   "type": "module",
   "main": "dist/src/index.js",
@@ -18,7 +18,7 @@
     "directory": "libs/e3/packages/e3-types"
   },
   "peerDependencies": {
-    "@elaraai/east": "1.0.80"
+    "@elaraai/east": "1.0.81"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",

package/src/api.ts

@@ -36,6 +36,7 @@ import {
 } from '@elaraai/east';
 
 import { StructureType, TreePathType } from './structure.js';
+import { IntakeFileType } from './intake.js';
 import { RunnerType } from './runner.js';
 import { TaskBodyType, TaskInputType, TaskOutputType, TaskRoleType } from './task.js';
 import { RequeueReasonType, StageUnitType } from './dataflow.js';
@@ -367,6 +368,51 @@ export const RecordIndexPlanType = StructType({
   }),
 });
 
+/**
+ * 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 const RecordDeployStepType = VariantType({
+  waiting: NullType,
+  migrating: StructType({ name: StringType, step: IntegerType, steps: IntegerType }),
+  indexing: StructType({ index: StringType, build: IntegerType, builds: IntegerType }),
+  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 const RecordDeployStateType = StructType({
+  plan: RecordPlanType,
+  indexes: ArrayType(StringType),
+  step: RecordDeployStepType,
+});
+
+/**
+ * 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 const DeployProgressType = StructType({
+  package: StructType({ name: StringType, version: StringType }),
+  startedAt: DateTimeType,
+  files: ArrayType(IntakeFileType),
+  records: ArrayType(RecordDeployStateType),
+});
+
 /**
  * What a deploy did, or under `plan` would do.
  *
@@ -382,11 +428,12 @@ export const WorkspaceDeployResultType = StructType({
 });
 
 /**
- * A deploy job's progress: `pending` until it starts, then `deploying`.
+ * A deploy job's progress: `pending` until it starts, then `deploying`, with
+ * how far it has got once it has said.
  */
 export const WorkspaceDeployProgressType = VariantType({
   pending: NullType,
-  deploying: NullType,
+  deploying: OptionType(DeployProgressType),
 });
 
 /**
@@ -1145,6 +1192,9 @@ export type WorkspaceDeployRequest = ValueTypeOf<typeof WorkspaceDeployRequestTy
 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>;