@elaraai/e3-types 1.0.78 → 1.0.80

package/dist/src/unit-plan.d.ts

@@ -0,0 +1,130 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The unit graph of a task split into pieces, a stage at a time.
+ *
+ * A split task runs in stages: its pieces, and then, for a set, a dict or a
+ * fold, each level of the merges that assemble their outputs. Each stage's
+ * units are one of these objects, written when the stage starts and named by
+ * the task's entry in the dataflow's execution state. So resuming a stage reads
+ * this object back, and finds the units that finished in the execution cache.
+ * Each names the plan of the stage before it, and the task's `success` record
+ * names the last, so every stage the task ran is found from its record, and
+ * with them the units gc keeps beside it.
+ *
+ * It names other objects, so it carries a `kind` tag the garbage collector
+ * dispatches on.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, IntegerType, OptionType, StringType, StructType, VariantType, type ValueTypeOf } from '@elaraai/east';
+/** The kind tag every unit plan carries. */
+export declare const UNIT_PLAN_KIND = "$plan";
+/** Parts a merge level assembles into one: a group of the pieces' outputs
+ *  whose keys overlap, over one key range, or a fold's partials. */
+export declare const UnitPlanGroupType: StructType<{
+    /** The hash of the key range the group's merges run over — `{from, to}`
+     *  over the parts' key type — or `none` to merge the parts whole. */
+    readonly range: OptionType<StringType>;
+    /** The parts, in the order they fold: each unit of the level merges a run
+     *  of them, and a run of one passes through. */
+    readonly entries: ArrayType<StringType>;
+}>;
+export type UnitPlanGroupType = typeof UnitPlanGroupType;
+export type UnitPlanGroup = ValueTypeOf<typeof UnitPlanGroupType>;
+/**
+ * A stage of a split task.
+ *
+ * - `pieces`: each piece's inputs, in the task's input order — a partitioned
+ *   input's piece of it, and every other input as it is.
+ * - `merge`: one level of the merges that assemble the pieces' outputs, and
+ *   the groups it merges, in key order.
+ */
+export declare const UnitPlanStageType: VariantType<{
+    readonly pieces: ArrayType<ArrayType<StringType>>;
+    readonly merge: StructType<{
+        /** The level, from 1. */
+        readonly level: IntegerType;
+        /** The number of levels the merges take. */
+        readonly levels: IntegerType;
+        /** The groups, in key order. */
+        readonly groups: ArrayType<StructType<{
+            /** The hash of the key range the group's merges run over — `{from, to}`
+             *  over the parts' key type — or `none` to merge the parts whole. */
+            readonly range: OptionType<StringType>;
+            /** The parts, in the order they fold: each unit of the level merges a run
+             *  of them, and a run of one passes through. */
+            readonly entries: ArrayType<StringType>;
+        }>>;
+    }>;
+}>;
+export type UnitPlanStageType = typeof UnitPlanStageType;
+export type UnitPlanStage = ValueTypeOf<typeof UnitPlanStageType>;
+/**
+ * A stage of a split task's unit graph, stored as an object.
+ *
+ * @example
+ * ```ts
+ * import { none, variant } from '@elaraai/east';
+ *
+ * const plan: UnitPlan = {
+ *   kind: UNIT_PLAN_KIND,
+ *   task: '5e7a3b…',
+ *   inputs: '9c01de…',
+ *   stage: variant('pieces', [['a1b2…'], ['c3d4…']]),
+ *   previous: none,
+ *   peakBytes: none,
+ * };
+ * ```
+ */
+export declare const UnitPlanType: StructType<{
+    /** Always {@link UNIT_PLAN_KIND}. */
+    readonly kind: StringType;
+    /** The task object's hash. */
+    readonly task: StringType;
+    /** The task's inputs hash: the execution the plan belongs to. */
+    readonly inputs: StringType;
+    /** The stage. */
+    readonly stage: VariantType<{
+        readonly pieces: ArrayType<ArrayType<StringType>>;
+        readonly merge: StructType<{
+            /** The level, from 1. */
+            readonly level: IntegerType;
+            /** The number of levels the merges take. */
+            readonly levels: IntegerType;
+            /** The groups, in key order. */
+            readonly groups: ArrayType<StructType<{
+                /** The hash of the key range the group's merges run over — `{from, to}`
+                 *  over the parts' key type — or `none` to merge the parts whole. */
+                readonly range: OptionType<StringType>;
+                /** The parts, in the order they fold: each unit of the level merges a run
+                 *  of them, and a run of one passes through. */
+                readonly entries: ArrayType<StringType>;
+            }>>;
+        }>;
+    }>;
+    /** The plan of the stage before this one; `none` for the pieces. */
+    readonly previous: OptionType<StringType>;
+    /** The largest peak resident memory, in bytes, a unit of the stages before
+     *  this one reached, as their execution records hold it; `none` for the
+     *  pieces, or when no unit reported one. A task taken up at this stage
+     *  starts its own peak from it, so its record counts every stage wherever
+     *  it was taken up. */
+    readonly peakBytes: OptionType<IntegerType>;
+}>;
+export type UnitPlanType = typeof UnitPlanType;
+export type UnitPlan = ValueTypeOf<typeof UnitPlanType>;
+/** Encodes a {@link UnitPlanType} object for the object store. */
+export declare const encodeUnitPlan: (plan: UnitPlan) => Uint8Array;
+/**
+ * Decodes a unit plan.
+ *
+ * @param data - the stored bytes
+ * @returns the plan
+ * @throws {Error} When the bytes are not a unit plan, or carry another kind
+ *   tag.
+ */
+export declare function decodeUnitPlan(data: Uint8Array): UnitPlan;
+//# sourceMappingURL=unit-plan.d.ts.map

package/dist/src/unit-plan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-plan.d.ts","sourceRoot":"","sources":["../../src/unit-plan.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAoC,KAAK,WAAW,EAAE,MAAM,eAAe,CAAC;AAE5J,4CAA4C;AAC5C,eAAO,MAAM,cAAc,UAAU,CAAC;AAEtC;oEACoE;AACpE,eAAO,MAAM,iBAAiB;IAC5B;yEACqE;;IAErE;oDACgD;;EAEhD,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AACzD,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB;;;QAG1B,yBAAyB;;QAEzB,4CAA4C;;QAE5C,gCAAgC;;YAzBlC;iFACqE;;YAErE;4DACgD;;;;EAwBhD,CAAC;AACH,MAAM,MAAM,iBAAiB,GAAG,OAAO,iBAAiB,CAAC;AACzD,MAAM,MAAM,aAAa,GAAG,WAAW,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAElE;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,YAAY;IACvB,qCAAqC;;IAErC,8BAA8B;;IAE9B,iEAAiE;;IAEjE,iBAAiB;;;;YAnCf,yBAAyB;;YAEzB,4CAA4C;;YAE5C,gCAAgC;;gBAzBlC;qFACqE;;gBAErE;gEACgD;;;;;IAsDhD,oEAAoE;;IAEpE;;;;2BAIuB;;EAEvB,CAAC;AACH,MAAM,MAAM,YAAY,GAAG,OAAO,YAAY,CAAC;AAC/C,MAAM,MAAM,QAAQ,GAAG,WAAW,CAAC,OAAO,YAAY,CAAC,CAAC;AAExD,kEAAkE;AAClE,eAAO,MAAM,cAAc,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,UAA0C,CAAC;AAI5F;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE,UAAU,GAAG,QAAQ,CAMzD"}

package/dist/src/unit-plan.js

@@ -0,0 +1,107 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * The unit graph of a task split into pieces, a stage at a time.
+ *
+ * A split task runs in stages: its pieces, and then, for a set, a dict or a
+ * fold, each level of the merges that assemble their outputs. Each stage's
+ * units are one of these objects, written when the stage starts and named by
+ * the task's entry in the dataflow's execution state. So resuming a stage reads
+ * this object back, and finds the units that finished in the execution cache.
+ * Each names the plan of the stage before it, and the task's `success` record
+ * names the last, so every stage the task ran is found from its record, and
+ * with them the units gc keeps beside it.
+ *
+ * It names other objects, so it carries a `kind` tag the garbage collector
+ * dispatches on.
+ *
+ * @packageDocumentation
+ */
+import { ArrayType, IntegerType, OptionType, StringType, StructType, VariantType, decodeBeast2For, encodeBeast2For } from '@elaraai/east';
+/** The kind tag every unit plan carries. */
+export const UNIT_PLAN_KIND = '$plan';
+/** Parts a merge level assembles into one: a group of the pieces' outputs
+ *  whose keys overlap, over one key range, or a fold's partials. */
+export const UnitPlanGroupType = StructType({
+    /** The hash of the key range the group's merges run over — `{from, to}`
+     *  over the parts' key type — or `none` to merge the parts whole. */
+    range: OptionType(StringType),
+    /** The parts, in the order they fold: each unit of the level merges a run
+     *  of them, and a run of one passes through. */
+    entries: ArrayType(StringType),
+});
+/**
+ * A stage of a split task.
+ *
+ * - `pieces`: each piece's inputs, in the task's input order — a partitioned
+ *   input's piece of it, and every other input as it is.
+ * - `merge`: one level of the merges that assemble the pieces' outputs, and
+ *   the groups it merges, in key order.
+ */
+export const UnitPlanStageType = VariantType({
+    pieces: ArrayType(ArrayType(StringType)),
+    merge: StructType({
+        /** The level, from 1. */
+        level: IntegerType,
+        /** The number of levels the merges take. */
+        levels: IntegerType,
+        /** The groups, in key order. */
+        groups: ArrayType(UnitPlanGroupType),
+    }),
+});
+/**
+ * A stage of a split task's unit graph, stored as an object.
+ *
+ * @example
+ * ```ts
+ * import { none, variant } from '@elaraai/east';
+ *
+ * const plan: UnitPlan = {
+ *   kind: UNIT_PLAN_KIND,
+ *   task: '5e7a3b…',
+ *   inputs: '9c01de…',
+ *   stage: variant('pieces', [['a1b2…'], ['c3d4…']]),
+ *   previous: none,
+ *   peakBytes: none,
+ * };
+ * ```
+ */
+export const UnitPlanType = StructType({
+    /** Always {@link UNIT_PLAN_KIND}. */
+    kind: StringType,
+    /** The task object's hash. */
+    task: StringType,
+    /** The task's inputs hash: the execution the plan belongs to. */
+    inputs: StringType,
+    /** The stage. */
+    stage: UnitPlanStageType,
+    /** The plan of the stage before this one; `none` for the pieces. */
+    previous: OptionType(StringType),
+    /** The largest peak resident memory, in bytes, a unit of the stages before
+     *  this one reached, as their execution records hold it; `none` for the
+     *  pieces, or when no unit reported one. A task taken up at this stage
+     *  starts its own peak from it, so its record counts every stage wherever
+     *  it was taken up. */
+    peakBytes: OptionType(IntegerType),
+});
+/** Encodes a {@link UnitPlanType} object for the object store. */
+export const encodeUnitPlan = encodeBeast2For(UnitPlanType);
+const decodeUnitPlanValue = decodeBeast2For(UnitPlanType);
+/**
+ * Decodes a unit plan.
+ *
+ * @param data - the stored bytes
+ * @returns the plan
+ * @throws {Error} When the bytes are not a unit plan, or carry another kind
+ *   tag.
+ */
+export function decodeUnitPlan(data) {
+    const plan = decodeUnitPlanValue(data);
+    if (plan.kind !== UNIT_PLAN_KIND) {
+        throw new Error(`the object is not a unit plan: its kind is '${plan.kind}', not '${UNIT_PLAN_KIND}'`);
+    }
+    return plan;
+}
+//# sourceMappingURL=unit-plan.js.map

package/dist/src/unit-plan.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-plan.js","sourceRoot":"","sources":["../../src/unit-plan.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,UAAU,EAAE,UAAU,EAAE,UAAU,EAAE,WAAW,EAAE,eAAe,EAAE,eAAe,EAAoB,MAAM,eAAe,CAAC;AAE5J,4CAA4C;AAC5C,MAAM,CAAC,MAAM,cAAc,GAAG,OAAO,CAAC;AAEtC;oEACoE;AACpE,MAAM,CAAC,MAAM,iBAAiB,GAAG,UAAU,CAAC;IAC1C;yEACqE;IACrE,KAAK,EAAE,UAAU,CAAC,UAAU,CAAC;IAC7B;oDACgD;IAChD,OAAO,EAAE,SAAS,CAAC,UAAU,CAAC;CAC/B,CAAC,CAAC;AAIH;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,WAAW,CAAC;IAC3C,MAAM,EAAE,SAAS,CAAC,SAAS,CAAC,UAAU,CAAC,CAAC;IACxC,KAAK,EAAE,UAAU,CAAC;QAChB,yBAAyB;QACzB,KAAK,EAAE,WAAW;QAClB,4CAA4C;QAC5C,MAAM,EAAE,WAAW;QACnB,gCAAgC;QAChC,MAAM,EAAE,SAAS,CAAC,iBAAiB,CAAC;KACrC,CAAC;CACH,CAAC,CAAC;AAIH;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,CAAC,MAAM,YAAY,GAAG,UAAU,CAAC;IACrC,qCAAqC;IACrC,IAAI,EAAE,UAAU;IAChB,8BAA8B;IAC9B,IAAI,EAAE,UAAU;IAChB,iEAAiE;IACjE,MAAM,EAAE,UAAU;IAClB,iBAAiB;IACjB,KAAK,EAAE,iBAAiB;IACxB,oEAAoE;IACpE,QAAQ,EAAE,UAAU,CAAC,UAAU,CAAC;IAChC;;;;2BAIuB;IACvB,SAAS,EAAE,UAAU,CAAC,WAAW,CAAC;CACnC,CAAC,CAAC;AAIH,kEAAkE;AAClE,MAAM,CAAC,MAAM,cAAc,GAAmC,eAAe,CAAC,YAAY,CAAC,CAAC;AAE5F,MAAM,mBAAmB,GAAG,eAAe,CAAC,YAAY,CAAC,CAAC;AAE1D;;;;;;;GAOG;AACH,MAAM,UAAU,cAAc,CAAC,IAAgB;IAC7C,MAAM,IAAI,GAAG,mBAAmB,CAAC,IAAI,CAAC,CAAC;IACvC,IAAI,IAAI,CAAC,IAAI,KAAK,cAAc,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CAAC,+CAA+C,IAAI,CAAC,IAAI,WAAW,cAAc,GAAG,CAAC,CAAC;IACxG,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/src/unit-plan.spec.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+export {};
+//# sourceMappingURL=unit-plan.spec.d.ts.map

package/dist/src/unit-plan.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-plan.spec.d.ts","sourceRoot":"","sources":["../../src/unit-plan.spec.ts"],"names":[],"mappings":"AAAA;;;GAGG"}

package/dist/src/unit-plan.spec.js

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+import { describe, it } from 'node:test';
+import assert from 'node:assert/strict';
+import { encodeBeast2For, equalFor, none, some, variant } from '@elaraai/east';
+import { UNIT_PLAN_KIND, UnitPlanType, decodeUnitPlan, encodeUnitPlan } from './unit-plan.js';
+describe('unit plans', () => {
+    it('round-trips each stage', () => {
+        const plans = [
+            { kind: UNIT_PLAN_KIND, task: 'a1', inputs: 'b2', stage: variant('pieces', [['c3', 'd4'], ['e5', 'd4']]), previous: none, peakBytes: none },
+            {
+                kind: UNIT_PLAN_KIND, task: 'a1', inputs: 'b2',
+                stage: variant('merge', { level: 1n, levels: 2n, groups: [{ range: some('f6'), entries: ['g7', 'h8'] }, { range: none, entries: ['i9'] }] }),
+                previous: some('j0'),
+                peakBytes: some(52428800n),
+            },
+        ];
+        for (const plan of plans) {
+            assert.ok(equalFor(UnitPlanType)(decodeUnitPlan(encodeUnitPlan(plan)), plan));
+        }
+    });
+    it('refuses an object of another kind', () => {
+        const other = encodeBeast2For(UnitPlanType)({ kind: 'task', task: 'a1', inputs: 'b2', stage: variant('pieces', []), previous: none, peakBytes: none });
+        assert.throws(() => decodeUnitPlan(other), { message: "the object is not a unit plan: its kind is 'task', not '$plan'" });
+    });
+});
+//# sourceMappingURL=unit-plan.spec.js.map

package/dist/src/unit-plan.spec.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"unit-plan.spec.js","sourceRoot":"","sources":["../../src/unit-plan.spec.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,MAAM,MAAM,oBAAoB,CAAC;AACxC,OAAO,EAAE,eAAe,EAAE,QAAQ,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,MAAM,eAAe,CAAC;AAC/E,OAAO,EAAE,cAAc,EAAE,YAAY,EAAE,cAAc,EAAE,cAAc,EAAiB,MAAM,gBAAgB,CAAC;AAE7G,QAAQ,CAAC,YAAY,EAAE,GAAG,EAAE;IAC1B,EAAE,CAAC,wBAAwB,EAAE,GAAG,EAAE;QAChC,MAAM,KAAK,GAAe;YACxB,EAAE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,CAAC,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE;YAC3I;gBACE,IAAI,EAAE,cAAc,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI;gBAC9C,KAAK,EAAE,OAAO,CAAC,OAAO,EAAE,EAAE,KAAK,EAAE,EAAE,EAAE,MAAM,EAAE,EAAE,EAAE,MAAM,EAAE,CAAC,EAAE,KAAK,EAAE,IAAI,CAAC,IAAI,CAAC,EAAE,OAAO,EAAE,CAAC,IAAI,EAAE,IAAI,CAAC,EAAE,EAAE,EAAE,KAAK,EAAE,IAAI,EAAE,OAAO,EAAE,CAAC,IAAI,CAAC,EAAE,CAAC,EAAE,CAAC;gBAC5I,QAAQ,EAAE,IAAI,CAAC,IAAI,CAAC;gBACpB,SAAS,EAAE,IAAI,CAAC,SAAW,CAAC;aAC7B;SACF,CAAC;QACF,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;YACzB,MAAM,CAAC,EAAE,CAAC,QAAQ,CAAC,YAAY,CAAC,CAAC,cAAc,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC;QAChF,CAAC;IACH,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,mCAAmC,EAAE,GAAG,EAAE;QAC3C,MAAM,KAAK,GAAG,eAAe,CAAC,YAAY,CAAC,CAAC,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,KAAK,EAAE,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;QACvJ,MAAM,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,cAAc,CAAC,KAAK,CAAC,EAAE,EAAE,OAAO,EAAE,gEAAgE,EAAE,CAAC,CAAC;IAC5H,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/src/workspace.d.ts

@@ -5,21 +5,15 @@
 /**
  * Workspace state type definitions.
  *
- * A workspace is a mutable working copy of a package. The state tracks:
- * - Which package was deployed (immutable reference via hash)
- * - When the deployment occurred
- * - Current root data tree hash
- * - When the root was last updated
+ * A workspace is a mutable working copy of a package. Its record is `none`
+ * from its creation until a package is deployed to it, and then its state:
+ * which package was deployed, when, and the latest dataflow run.
  *
- * State file location: workspaces/<name>/state.beast2
- * No state file = workspace exists but not yet deployed.
+ * A local repository keeps the record at `workspaces/<name>.beast2`.
  */
 import { StructType, StringType, DateTimeType, OptionType, ValueTypeOf } from '@elaraai/east';
 /**
- * Workspace state stored in workspaces/<name>/state.beast2
- *
- * Contains both deployment info and current data root in a single
- * atomic unit to ensure consistency.
+ * A deployed workspace's state.
  *
  * Future audit trail support:
  * When we implement full audit trail, this state will move to the object
@@ -44,4 +38,21 @@ export declare const WorkspaceStateType: StructType<{
     readonly currentRunId: OptionType<StringType>;
 }>;
 export type WorkspaceState = ValueTypeOf<typeof WorkspaceStateType>;
+/**
+ * A workspace's record: `none` until a package is deployed to it, and then
+ * its state.
+ */
+export declare const WorkspaceRecordType: OptionType<StructType<{
+    /** Name of the deployed package */
+    readonly packageName: StringType;
+    /** Version of the deployed package */
+    readonly packageVersion: StringType;
+    /** Hash of the package object at deploy time (immutable reference) */
+    readonly packageHash: StringType;
+    /** UTC datetime when the package was deployed */
+    readonly deployedAt: DateTimeType;
+    /** Run ID of the latest completed dataflow run (null if never run) */
+    readonly currentRunId: OptionType<StringType>;
+}>>;
+export type WorkspaceRecord = ValueTypeOf<typeof WorkspaceRecordType>;
 //# sourceMappingURL=workspace.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/workspace.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE9F;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,kBAAkB;IAC7B,mCAAmC;;IAEnC,sCAAsC;;IAEtC,sEAAsE;;IAEtE,iDAAiD;;IAEjD,sEAAsE;;EAEtE,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC"}
+{"version":3,"file":"workspace.d.ts","sourceRoot":"","sources":["../../src/workspace.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAE,WAAW,EAAE,MAAM,eAAe,CAAC;AAE9F;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,kBAAkB;IAC7B,mCAAmC;;IAEnC,sCAAsC;;IAEtC,sEAAsE;;IAEtE,iDAAiD;;IAEjD,sEAAsE;;EAEtE,CAAC;AAEH,MAAM,MAAM,cAAc,GAAG,WAAW,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAEpE;;;GAGG;AACH,eAAO,MAAM,mBAAmB;IAlB9B,mCAAmC;;IAEnC,sCAAsC;;IAEtC,sEAAsE;;IAEtE,iDAAiD;;IAEjD,sEAAsE;;GAUP,CAAC;AAElE,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/src/workspace.js

@@ -5,21 +5,15 @@
 /**
  * Workspace state type definitions.
  *
- * A workspace is a mutable working copy of a package. The state tracks:
- * - Which package was deployed (immutable reference via hash)
- * - When the deployment occurred
- * - Current root data tree hash
- * - When the root was last updated
+ * A workspace is a mutable working copy of a package. Its record is `none`
+ * from its creation until a package is deployed to it, and then its state:
+ * which package was deployed, when, and the latest dataflow run.
  *
- * State file location: workspaces/<name>/state.beast2
- * No state file = workspace exists but not yet deployed.
+ * A local repository keeps the record at `workspaces/<name>.beast2`.
  */
 import { StructType, StringType, DateTimeType, OptionType } from '@elaraai/east';
 /**
- * Workspace state stored in workspaces/<name>/state.beast2
- *
- * Contains both deployment info and current data root in a single
- * atomic unit to ensure consistency.
+ * A deployed workspace's state.
  *
  * Future audit trail support:
  * When we implement full audit trail, this state will move to the object
@@ -43,4 +37,9 @@ export const WorkspaceStateType = StructType({
     /** Run ID of the latest completed dataflow run (null if never run) */
     currentRunId: OptionType(StringType),
 });
+/**
+ * A workspace's record: `none` until a package is deployed to it, and then
+ * its state.
+ */
+export const WorkspaceRecordType = OptionType(WorkspaceStateType);
 //# sourceMappingURL=workspace.js.map

package/dist/src/workspace.js.map

@@ -1 +1 @@
-{"version":3,"file":"workspace.js","sourceRoot":"","sources":["../../src/workspace.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAe,MAAM,eAAe,CAAC;AAE9F;;;;;;;;;;;;;;;GAeG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;IAC3C,mCAAmC;IACnC,WAAW,EAAE,UAAU;IACvB,sCAAsC;IACtC,cAAc,EAAE,UAAU;IAC1B,sEAAsE;IACtE,WAAW,EAAE,UAAU;IACvB,iDAAiD;IACjD,UAAU,EAAE,YAAY;IACxB,sEAAsE;IACtE,YAAY,EAAE,UAAU,CAAC,UAAU,CAAC;CACrC,CAAC,CAAC"}
+{"version":3,"file":"workspace.js","sourceRoot":"","sources":["../../src/workspace.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;GAQG;AAEH,OAAO,EAAE,UAAU,EAAE,UAAU,EAAE,YAAY,EAAE,UAAU,EAAe,MAAM,eAAe,CAAC;AAE9F;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,UAAU,CAAC;IAC3C,mCAAmC;IACnC,WAAW,EAAE,UAAU;IACvB,sCAAsC;IACtC,cAAc,EAAE,UAAU;IAC1B,sEAAsE;IACtE,WAAW,EAAE,UAAU;IACvB,iDAAiD;IACjD,UAAU,EAAE,YAAY;IACxB,sEAAsE;IACtE,YAAY,EAAE,UAAU,CAAC,UAAU,CAAC;CACrC,CAAC,CAAC;AAIH;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,UAAU,CAAC,kBAAkB,CAAC,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@elaraai/e3-types",
-  "version": "1.0.78",
+  "version": "1.0.80",
   "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.78"
+    "@elaraai/east": "1.0.80"
   },
   "devDependencies": {
     "@types/node": "^22.0.0",
@@ -31,6 +31,6 @@
     "build": "tsc",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
-    "test": "npm run build && node --enable-source-maps --test-reporter=spec --test 'dist/src/**/*.spec.js'"
+    "test": "npm run build && node --enable-source-maps --test-reporter=spec --test-timeout=480000 --test 'dist/src/**/*.spec.js'"
   }
 }