@elaraai/e3-types 0.0.1-alpha.2

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,62 @@
+# @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
+
+
+## License
+
+Dual AGPL-3.0 / Commercial. See [LICENSE.md](./LICENSE.md).
+
+### Ecosystem
+
+- **[East Node](https://github.com/elaraai/east-node)**: Node.js platform functions for I/O, databases, and system operations. Connect East programs to filesystems, SQL/NoSQL databases, cloud storage, and network services.
+  - [@elaraai/east-node-std](https://www.npmjs.com/package/@elaraai/east-node-std): Filesystem, console, HTTP fetch, crypto, random distributions, timestamps
+  - [@elaraai/east-node-io](https://www.npmjs.com/package/@elaraai/east-node-io): SQLite, PostgreSQL, MySQL, MongoDB, S3, FTP, SFTP
+  - [@elaraai/east-node-cli](https://www.npmjs.com/package/@elaraai/east-node-cli): CLI for running East IR programs in Node.js
+
+- **[East Python](https://github.com/elaraai/east-py)**: Python runtime and platform functions for data science and machine learning. Execute East programs with access to optimization solvers, gradient boosting, neural networks, and model explainability.
+  - [@elaraai/east-py-datascience](https://www.npmjs.com/package/@elaraai/east-py-datascience): TypeScript types for optimization, gradient boosting, neural networks, explainability
+
+- **[East UI](https://github.com/elaraai/east-ui)**: East types and expressions for building dashboards and interactive layouts. Define UIs as data structures that render consistently across React, web, and other environments.
+  - [@elaraai/east-ui](https://www.npmjs.com/package/@elaraai/east-ui): 50+ typed UI components for layouts, forms, charts, tables, dialogs
+  - [@elaraai/east-ui-components](https://www.npmjs.com/package/@elaraai/east-ui-components): React renderer with Chakra UI styling
+
+- **[e3 - East Execution Engine](https://github.com/elaraai/e3)**: Durable execution engine for running East pipelines at scale. Features Git-like content-addressable storage, automatic memoization, task queuing, and real-time monitoring.
+  - [@elaraai/e3](https://www.npmjs.com/package/@elaraai/e3): SDK for authoring e3 packages with typed tasks and pipelines
+  - [@elaraai/e3-core](https://www.npmjs.com/package/@elaraai/e3-core): Git-like object store, task queue, result caching
+  - [@elaraai/e3-types](https://www.npmjs.com/package/@elaraai/e3-types): Shared type definitions for e3 packages
+  - [@elaraai/e3-cli](https://www.npmjs.com/package/@elaraai/e3-cli): `e3 init`, `e3 run`, `e3 logs` commands for managing and monitoring tasks
+  - [@elaraai/e3-api-client](https://www.npmjs.com/package/@elaraai/e3-api-client): HTTP client for remote e3 servers
+  - [@elaraai/e3-api-server](https://www.npmjs.com/package/@elaraai/e3-api-server): REST API server for e3 repositories
+
+## Links
+
+- [East Language](https://github.com/elaraai/east)
+- [East Python Runtime](https://github.com/elaraai/east-py)
+- [Elara AI](https://elaraai.com/)
+- [Issues](https://github.com/elaraai/e3/issues)
+- support@elara.ai
+
+## About Elara
+
+East is developed by [Elara AI Pty Ltd](https://elaraai.com/), an AI-powered platform that creates economic digital twins of businesses that optimize performance. Elara combines business objectives, decisions and data to help organizations make data-driven decisions across operations, purchasing, sales and customer engagement, and project and investment planning. East powers the computational layer of Elara solutions, enabling the expression of complex business logic and data in a simple, type-safe and portable language.
+
+---
+
+*Developed by [Elara AI Pty Ltd](https://elaraai.com/)*

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, type ParseDatasetPathResult, type ParsePackageRefResult, treePath, pathToString, parsePath, parseDatasetPath, parsePackageRef, urlPathToTreePath, 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,KAAK,sBAAsB,EAC3B,KAAK,qBAAqB,EAC1B,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,eAAe,EACf,iBAAiB,EAEjB,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, parseDatasetPath, parsePackageRef, urlPathToTreePath, 
+// 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,EAKZ,QAAQ,EACR,YAAY,EACZ,SAAS,EACT,gBAAgB,EAChB,eAAe,EACf,iBAAiB;AACjB,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"}