@elaraai/e3-types 0.0.1-beta.0

package/LICENSE.md

@@ -0,0 +1,31 @@
+Copyright (c) 2025 Elara AI Pty Ltd
+
+# Dual License
+
+This software is available under two licenses. You may choose which license applies to your use:
+
+## Option 1: AGPL-3.0 (Open Source)
+
+You may use, modify, and distribute this software under the terms of the GNU Affero General Public License v3.0.
+
+This requires that if you use this software in a network service, you must make your complete source code available under AGPL-3.0.
+
+Full text: https://www.gnu.org/licenses/agpl-3.0.html
+
+## Option 2: Commercial License
+
+If you wish to use this software without the source code disclosure requirements of AGPL-3.0, you must obtain a commercial license from Elara AI Pty Ltd.
+
+Contact: support@elara.ai
+
+## Contributions
+
+Contributions are welcome. By submitting a pull request, you agree to license your contribution under both AGPL-3.0 and our commercial license terms.
+
+## Governing Law
+
+This license is governed by the laws of New South Wales, Australia.
+
+---
+
+*Elara AI Pty Ltd*

package/README.md

@@ -0,0 +1,33 @@
+# @elaraai/e3-types
+
+Shared type definitions for e3 (East Execution Engine).
+
+## Installation
+
+```bash
+npm install @elaraai/e3-types
+```
+
+## Types
+
+- **Repository** - Repository configuration and paths
+- **Commit** - Task commit types (new, done, error)
+- **Task** - Task definition and state
+- **Package** - Package manifest and metadata
+- **Dataset** - Dataset schemas and paths
+- **Dataflow** - Dataflow definitions
+- **Runner** - Runner configuration
+
+## Related Repos
+
+- **[east](https://github.com/elaraai/east)** - East language core
+- **[east-node](https://github.com/elaraai/east-node)** - Node.js runtime and platform functions
+- **[east-py](https://github.com/elaraai/east-py)** - Python runtime and data science
+
+## About Elara
+
+e3 is developed by [Elara AI](https://elaraai.com/), an AI-powered platform that creates economic digital twins of businesses. e3 powers the execution layer of Elara solutions, enabling durable and efficient execution of East programs across multiple runtimes.
+
+## License
+
+Dual AGPL-3.0 / Commercial. See [LICENSE.md](./LICENSE.md).

package/dist/src/dataset.d.ts

@@ -0,0 +1,109 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Dataset reference and tree types for e3's persistent data structures.
+ *
+ * e3 stores data as persistent trees with structural sharing (like git trees).
+ * Each node is either a leaf (value) or a branch (tree of refs).
+ */
+import { VariantType, StringType, NullType, ValueTypeOf, StructType, EastType } from '@elaraai/east';
+/**
+ * Reference to data in the object store.
+ *
+ * DataRef is the fundamental building block of e3's data trees.
+ * Each ref points to either a value or another tree node.
+ *
+ * @remarks
+ * - `unassigned`: Placeholder for pending task outputs
+ * - `null`: Inline null value (optimization)
+ * - `value`: Hash of a typed value blob in objects/
+ * - `tree`: Hash of a tree object in objects/
+ *
+ * @example
+ * ```ts
+ * // Pending output
+ * const pending: DataRef = variant('unassigned', null);
+ *
+ * // Value reference
+ * const ref: DataRef = variant('value', 'abc123...');
+ *
+ * // Tree reference
+ * const treeRef: DataRef = variant('tree', 'def456...');
+ * ```
+ */
+export declare const DataRefType: VariantType<{
+    /** Unassigned value (e.g., pending task output) */
+    unassigned: NullType;
+    /** Inline null value (optimization for NullType) */
+    null: NullType;
+    /** Hash of a beast2 value blob in objects/ */
+    value: StringType;
+    /** Hash of a tree object in objects/ */
+    tree: StringType;
+}>;
+export type DataRefType = typeof DataRefType;
+export type DataRef = ValueTypeOf<typeof DataRefType>;
+/**
+ * Singleton DataRef representing an unassigned value.
+ *
+ * Used for dataset fields that have not yet been computed (e.g., pending task outputs).
+ *
+ * @example
+ * ```ts
+ * const tree = {
+ *   computed: variant('value', 'abc123...'),
+ *   pending: unassignedRef,
+ * };
+ * ```
+ */
+export declare const unassignedRef: DataRef;
+/**
+ * Singleton DataRef representing an inline null value.
+ *
+ * Optimization for datasets with NullType fields - avoids storing a separate object.
+ */
+export declare const nullRef: DataRef;
+/**
+ * Computes the DataTreeType for a given EastType.
+ *
+ * A DataTreeType is a StructType where each field is replaced with a DataRefType,
+ * enabling structural sharing in e3's persistent data trees.
+ *
+ * @typeParam T - The source EastType (must be a StructType for MVP)
+ *
+ * @remarks
+ * Currently only StructType is supported. Future versions may support
+ * ArrayType, DictType, VariantType, and RecursiveType.
+ *
+ * @example
+ * ```ts
+ * const PersonType = StructType({ name: StringType, age: IntegerType });
+ * type PersonTree = DataTreeType<typeof PersonType>;
+ * // Equivalent to: StructType<{ name: DataRefType, age: DataRefType }>
+ * ```
+ */
+export type DataTreeType<T extends EastType> = T extends StructType<infer Fields> ? StructType<{
+    [K in keyof Fields]: DataRefType;
+}> : never;
+/**
+ * Creates a DataTreeType from an EastType at runtime.
+ *
+ * Transforms a StructType into a new StructType where each field
+ * is replaced with DataRefType.
+ *
+ * @param type - The source EastType (must be a StructType)
+ * @returns A new StructType with DataRefType fields
+ *
+ * @throws {Error} When the input type is not a StructType
+ *
+ * @example
+ * ```ts
+ * const PersonType = StructType({ name: StringType, age: IntegerType });
+ * const PersonTreeType = DataTreeType(PersonType);
+ * // PersonTreeType.fields = { name: DataRefType, age: DataRefType }
+ * ```
+ */
+export declare function DataTreeType<T extends EastType>(type: T): DataTreeType<T>;
+//# sourceMappingURL=dataset.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataset.d.ts","sourceRoot":"","sources":["../../src/dataset.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAE,WAAW,EAAW,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AAE9G;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,WAAW;IACtB,mDAAmD;;IAEnD,oDAAoD;;IAEpD,8CAA8C;;IAE9C,wCAAwC;;EAExC,CAAC;AACH,MAAM,MAAM,WAAW,GAAG,OAAO,WAAW,CAAC;AAE7C,MAAM,MAAM,OAAO,GAAG,WAAW,CAAC,OAAO,WAAW,CAAC,CAAC;AAEtD;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,aAAa,EAAE,OAAqC,CAAC;AAElE;;;;GAIG;AACH,eAAO,MAAM,OAAO,EAAE,OAA+B,CAAC;AAEtD;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,MAAM,YAAY,CAAC,CAAC,SAAS,QAAQ,IACzC,CAAC,SAAS,UAAU,CAAC,MAAM,MAAM,CAAC,GAAG,UAAU,CAAC;KAAG,CAAC,IAAI,MAAM,MAAM,GAAG,WAAW;CAAE,CAAC,GACrF,KAAK,CAAC;AAER;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,YAAY,CAAC,CAAC,SAAS,QAAQ,EAAE,IAAI,EAAE,CAAC,GAAG,YAAY,CAAC,CAAC,CAAC,CAUzE"}

package/dist/src/dataset.js

@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Dataset reference and tree types for e3's persistent data structures.
+ *
+ * e3 stores data as persistent trees with structural sharing (like git trees).
+ * Each node is either a leaf (value) or a branch (tree of refs).
+ */
+import { VariantType, StringType, NullType, variant, StructType } from '@elaraai/east';
+/**
+ * Reference to data in the object store.
+ *
+ * DataRef is the fundamental building block of e3's data trees.
+ * Each ref points to either a value or another tree node.
+ *
+ * @remarks
+ * - `unassigned`: Placeholder for pending task outputs
+ * - `null`: Inline null value (optimization)
+ * - `value`: Hash of a typed value blob in objects/
+ * - `tree`: Hash of a tree object in objects/
+ *
+ * @example
+ * ```ts
+ * // Pending output
+ * const pending: DataRef = variant('unassigned', null);
+ *
+ * // Value reference
+ * const ref: DataRef = variant('value', 'abc123...');
+ *
+ * // Tree reference
+ * const treeRef: DataRef = variant('tree', 'def456...');
+ * ```
+ */
+export const DataRefType = VariantType({
+    /** Unassigned value (e.g., pending task output) */
+    unassigned: NullType,
+    /** Inline null value (optimization for NullType) */
+    null: NullType,
+    /** Hash of a beast2 value blob in objects/ */
+    value: StringType,
+    /** Hash of a tree object in objects/ */
+    tree: StringType,
+});
+/**
+ * Singleton DataRef representing an unassigned value.
+ *
+ * Used for dataset fields that have not yet been computed (e.g., pending task outputs).
+ *
+ * @example
+ * ```ts
+ * const tree = {
+ *   computed: variant('value', 'abc123...'),
+ *   pending: unassignedRef,
+ * };
+ * ```
+ */
+export const unassignedRef = variant('unassigned', null);
+/**
+ * Singleton DataRef representing an inline null value.
+ *
+ * Optimization for datasets with NullType fields - avoids storing a separate object.
+ */
+export const nullRef = variant('null', null);
+/**
+ * Creates a DataTreeType from an EastType at runtime.
+ *
+ * Transforms a StructType into a new StructType where each field
+ * is replaced with DataRefType.
+ *
+ * @param type - The source EastType (must be a StructType)
+ * @returns A new StructType with DataRefType fields
+ *
+ * @throws {Error} When the input type is not a StructType
+ *
+ * @example
+ * ```ts
+ * const PersonType = StructType({ name: StringType, age: IntegerType });
+ * const PersonTreeType = DataTreeType(PersonType);
+ * // PersonTreeType.fields = { name: DataRefType, age: DataRefType }
+ * ```
+ */
+export function DataTreeType(type) {
+    if (type.type === "Struct") {
+        const fields = {};
+        for (const key of Object.keys(type.fields)) {
+            fields[key] = DataRefType;
+        }
+        return StructType(fields);
+    }
+    else {
+        throw new Error(`DataTreeType not implemented for type .${type.type}`);
+    }
+}
+//# sourceMappingURL=dataset.js.map

package/dist/src/dataset.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"dataset.js","sourceRoot":"","sources":["../../src/dataset.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AAEH,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,QAAQ,EAAe,OAAO,EAAE,UAAU,EAAY,MAAM,eAAe,CAAC;AAE9G;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,MAAM,CAAC,MAAM,WAAW,GAAG,WAAW,CAAC;IACrC,mDAAmD;IACnD,UAAU,EAAE,QAAQ;IACpB,oDAAoD;IACpD,IAAI,EAAE,QAAQ;IACd,8CAA8C;IAC9C,KAAK,EAAE,UAAU;IACjB,wCAAwC;IACxC,IAAI,EAAE,UAAU;CACjB,CAAC,CAAC;AAKH;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,aAAa,GAAY,OAAO,CAAC,YAAY,EAAE,IAAI,CAAC,CAAC;AAElE;;;;GAIG;AACH,MAAM,CAAC,MAAM,OAAO,GAAY,OAAO,CAAC,MAAM,EAAE,IAAI,CAAC,CAAC;AAyBtD;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,UAAU,YAAY,CAAqB,IAAO;IACtD,IAAI,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE,CAAC;QAC3B,MAAM,MAAM,GAAgC,EAAE,CAAC;QAC/C,KAAK,MAAM,GAAG,IAAI,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,EAAE,CAAC;YAC3C,MAAM,CAAC,GAAG,CAAC,GAAG,WAAW,CAAC;QAC5B,CAAC;QACD,OAAO,UAAU,CAAC,MAAM,CAAoB,CAAC;IAC/C,CAAC;SAAM,CAAC;QACN,MAAM,IAAI,KAAK,CAAC,0CAA0C,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC;IACzE,CAAC;AACH,CAAC"}

package/dist/src/execution.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Execution status type definitions.
+ *
+ * An execution represents a single run of a task with specific inputs.
+ * Executions are stored at: executions/<taskHash>/<inputsHash>/
+ *
+ * The status file tracks:
+ * - For running: process identification for crash detection
+ * - For success: output hash and timing
+ * - For failed: exit code and timing
+ * - For error: internal error message and timing
+ */
+import { VariantType, StructType, ArrayType, StringType, IntegerType, DateTimeType, ValueTypeOf } from '@elaraai/east';
+/**
+ * Execution status stored in executions/<taskHash>/<inputsHash>/status.beast2
+ *
+ * A variant type representing the four possible states of an execution:
+ *
+ * - `running`: Task has been launched but not yet completed
+ * - `success`: Task ran and returned exit code 0
+ * - `failed`: Task ran and returned non-zero exit code
+ * - `error`: e3 execution engine had an internal error (runner not found, output missing, etc.)
+ *
+ * The `running` state includes process identification fields (pid, pidStartTime, bootId)
+ * to enable detection of crashed executions. See design/e3-execution.md for details.
+ */
+export declare const ExecutionStatusType: VariantType<{
+    /** Task has been launched but not yet completed */
+    running: StructType<{
+        /** Input dataset hashes */
+        inputHashes: ArrayType<StringType>;
+        /** When execution started */
+        startedAt: DateTimeType;
+        /** Process ID of the runner */
+        pid: IntegerType;
+        /** Process start time in jiffies since boot (from /proc/<pid>/stat field 22) */
+        pidStartTime: IntegerType;
+        /** System boot ID (from /proc/sys/kernel/random/boot_id) */
+        bootId: StringType;
+    }>;
+    /** Task ran and returned exit code 0 */
+    success: StructType<{
+        /** Input dataset hashes */
+        inputHashes: ArrayType<StringType>;
+        /** Hash of the output dataset */
+        outputHash: StringType;
+        /** When execution started */
+        startedAt: DateTimeType;
+        /** When execution completed */
+        completedAt: DateTimeType;
+    }>;
+    /** Task ran and returned non-zero exit code */
+    failed: StructType<{
+        /** Input dataset hashes */
+        inputHashes: ArrayType<StringType>;
+        /** When execution started */
+        startedAt: DateTimeType;
+        /** When execution completed */
+        completedAt: DateTimeType;
+        /** Process exit code */
+        exitCode: IntegerType;
+    }>;
+    /** e3 execution engine had an internal error */
+    error: StructType<{
+        /** Input dataset hashes */
+        inputHashes: ArrayType<StringType>;
+        /** When execution started */
+        startedAt: DateTimeType;
+        /** When execution completed */
+        completedAt: DateTimeType;
+        /** Error message describing what went wrong */
+        message: StringType;
+    }>;
+}>;
+export type ExecutionStatus = ValueTypeOf<typeof ExecutionStatusType>;
+//# sourceMappingURL=execution.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"execution.d.ts","sourceRoot":"","sources":["../../src/execution.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,WAAW,EACX,UAAU,EACV,SAAS,EACT,UAAU,EACV,WAAW,EACX,YAAY,EACZ,WAAW,EACZ,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB;IAC9B,mDAAmD;;QAEjD,2BAA2B;;QAE3B,6BAA6B;;QAE7B,+BAA+B;;QAE/B,gFAAgF;;QAEhF,4DAA4D;;;IAG9D,wCAAwC;;QAEtC,2BAA2B;;QAE3B,iCAAiC;;QAEjC,6BAA6B;;QAE7B,+BAA+B;;;IAGjC,+CAA+C;;QAE7C,2BAA2B;;QAE3B,6BAA6B;;QAE7B,+BAA+B;;QAE/B,wBAAwB;;;IAG1B,gDAAgD;;QAE9C,2BAA2B;;QAE3B,6BAA6B;;QAE7B,+BAA+B;;QAE/B,+CAA+C;;;EAGjD,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,WAAW,CAAC,OAAO,mBAAmB,CAAC,CAAC"}

package/dist/src/execution.js

@@ -0,0 +1,79 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Execution status type definitions.
+ *
+ * An execution represents a single run of a task with specific inputs.
+ * Executions are stored at: executions/<taskHash>/<inputsHash>/
+ *
+ * The status file tracks:
+ * - For running: process identification for crash detection
+ * - For success: output hash and timing
+ * - For failed: exit code and timing
+ * - For error: internal error message and timing
+ */
+import { VariantType, StructType, ArrayType, StringType, IntegerType, DateTimeType, } from '@elaraai/east';
+/**
+ * Execution status stored in executions/<taskHash>/<inputsHash>/status.beast2
+ *
+ * A variant type representing the four possible states of an execution:
+ *
+ * - `running`: Task has been launched but not yet completed
+ * - `success`: Task ran and returned exit code 0
+ * - `failed`: Task ran and returned non-zero exit code
+ * - `error`: e3 execution engine had an internal error (runner not found, output missing, etc.)
+ *
+ * The `running` state includes process identification fields (pid, pidStartTime, bootId)
+ * to enable detection of crashed executions. See design/e3-execution.md for details.
+ */
+export const ExecutionStatusType = VariantType({
+    /** Task has been launched but not yet completed */
+    running: StructType({
+        /** Input dataset hashes */
+        inputHashes: ArrayType(StringType),
+        /** When execution started */
+        startedAt: DateTimeType,
+        /** Process ID of the runner */
+        pid: IntegerType,
+        /** Process start time in jiffies since boot (from /proc/<pid>/stat field 22) */
+        pidStartTime: IntegerType,
+        /** System boot ID (from /proc/sys/kernel/random/boot_id) */
+        bootId: StringType,
+    }),
+    /** Task ran and returned exit code 0 */
+    success: StructType({
+        /** Input dataset hashes */
+        inputHashes: ArrayType(StringType),
+        /** Hash of the output dataset */
+        outputHash: StringType,
+        /** When execution started */
+        startedAt: DateTimeType,
+        /** When execution completed */
+        completedAt: DateTimeType,
+    }),
+    /** Task ran and returned non-zero exit code */
+    failed: StructType({
+        /** Input dataset hashes */
+        inputHashes: ArrayType(StringType),
+        /** When execution started */
+        startedAt: DateTimeType,
+        /** When execution completed */
+        completedAt: DateTimeType,
+        /** Process exit code */
+        exitCode: IntegerType,
+    }),
+    /** e3 execution engine had an internal error */
+    error: StructType({
+        /** Input dataset hashes */
+        inputHashes: ArrayType(StringType),
+        /** When execution started */
+        startedAt: DateTimeType,
+        /** When execution completed */
+        completedAt: DateTimeType,
+        /** Error message describing what went wrong */
+        message: StringType,
+    }),
+});
+//# sourceMappingURL=execution.js.map

package/dist/src/execution.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"execution.js","sourceRoot":"","sources":["../../src/execution.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;GAWG;AAEH,OAAO,EACL,WAAW,EACX,UAAU,EACV,SAAS,EACT,UAAU,EACV,WAAW,EACX,YAAY,GAEb,MAAM,eAAe,CAAC;AAEvB;;;;;;;;;;;;GAYG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,WAAW,CAAC;IAC7C,mDAAmD;IACnD,OAAO,EAAE,UAAU,CAAC;QAClB,2BAA2B;QAC3B,WAAW,EAAE,SAAS,CAAC,UAAU,CAAC;QAClC,6BAA6B;QAC7B,SAAS,EAAE,YAAY;QACvB,+BAA+B;QAC/B,GAAG,EAAE,WAAW;QAChB,gFAAgF;QAChF,YAAY,EAAE,WAAW;QACzB,4DAA4D;QAC5D,MAAM,EAAE,UAAU;KACnB,CAAC;IACF,wCAAwC;IACxC,OAAO,EAAE,UAAU,CAAC;QAClB,2BAA2B;QAC3B,WAAW,EAAE,SAAS,CAAC,UAAU,CAAC;QAClC,iCAAiC;QACjC,UAAU,EAAE,UAAU;QACtB,6BAA6B;QAC7B,SAAS,EAAE,YAAY;QACvB,+BAA+B;QAC/B,WAAW,EAAE,YAAY;KAC1B,CAAC;IACF,+CAA+C;IAC/C,MAAM,EAAE,UAAU,CAAC;QACjB,2BAA2B;QAC3B,WAAW,EAAE,SAAS,CAAC,UAAU,CAAC;QAClC,6BAA6B;QAC7B,SAAS,EAAE,YAAY;QACvB,+BAA+B;QAC/B,WAAW,EAAE,YAAY;QACzB,wBAAwB;QACxB,QAAQ,EAAE,WAAW;KACtB,CAAC;IACF,gDAAgD;IAChD,KAAK,EAAE,UAAU,CAAC;QAChB,2BAA2B;QAC3B,WAAW,EAAE,SAAS,CAAC,UAAU,CAAC;QAClC,6BAA6B;QAC7B,SAAS,EAAE,YAAY;QACvB,+BAA+B;QAC/B,WAAW,EAAE,YAAY;QACzB,+CAA+C;QAC/C,OAAO,EAAE,UAAU;KACpB,CAAC;CACH,CAAC,CAAC"}

package/dist/src/index.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * e3-types: Shared type definitions for e3 (East Execution Engine)
+ *
+ * This package defines the East types used for serializing e3 objects:
+ * - Data references and tree structures
+ * - Task definitions (command IR, input/output paths)
+ * - Package objects
+ * - Data structure and paths
+ * - Workspace state
+ * - Execution status
+ *
+ * Terminology:
+ * - **Dataset**: A location holding a value (leaf node)
+ * - **Tree**: A location containing other locations (branch node)
+ * - **Structure**: The shape of the data tree
+ * - **Task**: A computation with command IR and input/output paths
+ * - **Path**: An address in the data tree
+ */
+export { DataRefType, type DataRef, unassignedRef, nullRef, DataTreeType, } from './dataset.js';
+export { TaskObjectType, type TaskObject, } from './task.js';
+export { StructureType, type Structure, PathSegmentType, type PathSegment, TreePathType, type TreePath, type ParsePathResult, treePath, pathToString, parsePath, DatasetSchemaType, type DatasetSchema, } from './structure.js';
+export { PackageDataType, type PackageData, PackageObjectType, type PackageObject, PackageDatasetsType, type PackageDatasets, } from './package.js';
+export { WorkspaceStateType, type WorkspaceState, } from './workspace.js';
+export { ExecutionStatusType, type ExecutionStatus, } from './execution.js';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAGH,OAAO,EACL,WAAW,EACX,KAAK,OAAO,EACZ,aAAa,EACb,OAAO,EACP,YAAY,GACb,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,cAAc,EACd,KAAK,UAAU,GAChB,MAAM,WAAW,CAAC;AAGnB,OAAO,EACL,aAAa,EACb,KAAK,SAAS,EACd,eAAe,EACf,KAAK,WAAW,EAChB,YAAY,EACZ,KAAK,QAAQ,EACb,KAAK,eAAe,EACpB,QAAQ,EACR,YAAY,EACZ,SAAS,EAET,iBAAiB,EACjB,KAAK,aAAa,GACnB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,eAAe,EACf,KAAK,WAAW,EAChB,iBAAiB,EACjB,KAAK,aAAa,EAElB,mBAAmB,EACnB,KAAK,eAAe,GACrB,MAAM,cAAc,CAAC;AAGtB,OAAO,EACL,kBAAkB,EAClB,KAAK,cAAc,GACpB,MAAM,gBAAgB,CAAC;AAGxB,OAAO,EACL,mBAAmB,EACnB,KAAK,eAAe,GACrB,MAAM,gBAAgB,CAAC"}

package/dist/src/index.js

@@ -0,0 +1,39 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * e3-types: Shared type definitions for e3 (East Execution Engine)
+ *
+ * This package defines the East types used for serializing e3 objects:
+ * - Data references and tree structures
+ * - Task definitions (command IR, input/output paths)
+ * - Package objects
+ * - Data structure and paths
+ * - Workspace state
+ * - Execution status
+ *
+ * Terminology:
+ * - **Dataset**: A location holding a value (leaf node)
+ * - **Tree**: A location containing other locations (branch node)
+ * - **Structure**: The shape of the data tree
+ * - **Task**: A computation with command IR and input/output paths
+ * - **Path**: An address in the data tree
+ */
+// Data references and trees
+export { DataRefType, unassignedRef, nullRef, DataTreeType, } from './dataset.js';
+// Task definitions
+export { TaskObjectType, } from './task.js';
+// Data structure and paths
+export { StructureType, PathSegmentType, TreePathType, treePath, pathToString, parsePath, 
+// Backwards compatibility
+DatasetSchemaType, } from './structure.js';
+// Package objects
+export { PackageDataType, PackageObjectType, 
+// Backwards compatibility
+PackageDatasetsType, } from './package.js';
+// Workspace state
+export { WorkspaceStateType, } from './workspace.js';
+// Execution status
+export { ExecutionStatusType, } from './execution.js';
+//# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AAEH,4BAA4B;AAC5B,OAAO,EACL,WAAW,EAEX,aAAa,EACb,OAAO,EACP,YAAY,GACb,MAAM,cAAc,CAAC;AAEtB,mBAAmB;AACnB,OAAO,EACL,cAAc,GAEf,MAAM,WAAW,CAAC;AAEnB,2BAA2B;AAC3B,OAAO,EACL,aAAa,EAEb,eAAe,EAEf,YAAY,EAGZ,QAAQ,EACR,YAAY,EACZ,SAAS;AACT,0BAA0B;AAC1B,iBAAiB,GAElB,MAAM,gBAAgB,CAAC;AAExB,kBAAkB;AAClB,OAAO,EACL,eAAe,EAEf,iBAAiB;AAEjB,0BAA0B;AAC1B,mBAAmB,GAEpB,MAAM,cAAc,CAAC;AAEtB,kBAAkB;AAClB,OAAO,EACL,kBAAkB,GAEnB,MAAM,gBAAgB,CAAC;AAExB,mBAAmB;AACnB,OAAO,EACL,mBAAmB,GAEpB,MAAM,gBAAgB,CAAC"}