@elaraai/e3-core

Core library for e3 repository operations, similar to libgit2 for git.

Installation

npm install @elaraai/e3-core

Overview

Pure business logic with no UI dependencies. Use this to build custom tools, integrations, or alternative interfaces on top of e3.

API

Repository

import { repoInit, repoFind, repoGet } from '@elaraai/e3-core';

await repoInit('/path/to/project');
const repoPath = repoFind();  // Searches cwd and parents

Packages

import { packageImport, packageList, packageResolve } from '@elaraai/e3-core';

await packageImport(repoPath, zipPath);
const packages = await packageList(repoPath);
const pkg = await packageResolve(repoPath, '[email protected]');

Workspaces

import { workspaceCreate, workspaceList, workspaceDeploy, workspaceStatus, LocalTaskRunner } from '@elaraai/e3-core';

await workspaceCreate(repoPath, 'dev');
await workspaceDeploy(repoPath, 'dev', '[email protected]');
// The runner says whether an execution recorded running can still finish
const status = await workspaceStatus(storage, new LocalTaskRunner(repoPath), repoPath, 'dev');

A workspace's bundle is the workspace as it is, in one stream of beast2: its package, every dataset's ref, the executions its tasks' outputs come from, and every object those reach. Another repository, in any store, makes the workspace from it under a name no workspace there has.

import { workspaceBundleExport, workspaceBundleImport } from '@elaraai/e3-core';

// Written to a WHATWG stream, and made from one, or from chunks
await workspaceBundleExport(storage, repoPath, 'dev', writable);
await workspaceBundleImport(otherStorage, otherRepo, 'dev', readable);

Datasets

import { workspaceGetDataset, workspaceSetDataset } from '@elaraai/e3-core';

const value = await workspaceGetDataset(storage, repoPath, 'dev', ['inputs', 'config']);
await workspaceSetDataset(storage, repoPath, 'dev', ['inputs', 'config'], newValue);

Dataflow Execution

import { dataflowExecute, dataflowStart } from '@elaraai/e3-core';

// Blocking execution
const result = await dataflowExecute(storage, repoPath, 'dev', { force: true });

// Non-blocking execution
const handle = await dataflowStart(storage, repoPath, 'dev');

The local runner's processes

Every process a local runner starts is started under the runner's settings: task and unit runners, function calls, intake units, and environment installs.

import { LocalTaskRunner, resolveBudget } from '@elaraai/e3-core';

const runner = new LocalTaskRunner(repoPath, resolveBudget(), {
  // In place of this process's own environment: e3 still puts its bins ahead
  // of PATH and sets its own variables, and a call's extraEnv comes after
  env: { PATH: '/usr/local/bin:/usr/bin:/bin', HOME: '/home/tasks' },
  // Another user and group (POSIX), which e3 needs root to start them as
  uid: 1500,
  gid: 1500,
});

• env replaces this process's environment for every process. An install runs with it as it is, so it names the home and caches the installs write.
• uid and gid are POSIX alone, and refused on Windows. e3 must run as root, or hold CAP_SETUID, CAP_SETGID, CAP_CHOWN, CAP_KILL and CAP_DAC_OVERRIDE.
  • e3 gives the user each directory it makes for a process to write in: an execution's or a call's scratch directory, the segment directory of an input its runner asks for, an intake's, and an environment's build directory.
  • What a process only reads stays e3's: a staged input is a link to an object, which never changes hands.
  • What e3 keeps of what the user wrote is e3's own: an output is stored as a copy, never linked, and a built environment is taken back before any runner reads it.
  • The repository's directories must let the user pass through to its scratch directory and its environments.
• No install runs a lifecycle script. A project's own packages arrive built: npm pack runs prepack when the package is exported.

Claude Code plugin

The East ecosystem also ships a Claude Code plugin — East language skills, example search, and preemptive diagnostics for East code — installed separately from the elaraai marketplace:

# Inside Claude Code
/plugin marketplace add elaraai/east-workspace
/plugin install east@elaraai

# From a terminal
claude plugin marketplace add elaraai/east-workspace
claude plugin install east@elaraai

License

BSL 1.1. See LICENSE.md.

Ecosystem

• East: Statically typed, expression-based language with serializable IR. Run portable logic across TypeScript, Python, C, and other runtimes.

  • @elaraai/east: Core language SDK with type system, expressions, and reference JS compiler

• East Node: Node.js platform functions for I/O, databases, and system operations.

  • @elaraai/east-node-std: Console, FileSystem, Fetch, Crypto, Time, Path, Random
  • @elaraai/east-node-io: SQLite, PostgreSQL, MySQL, MongoDB, Redis, S3, FTP, SFTP, XLSX, XML, compression
  • @elaraai/east-node-cli: CLI for running East IR programs in Node.js

• East C: C11 native runtime for executing East IR. Distributed via npm (launcher + per-platform optional dependencies) and as tarballs on each GitHub Release.

  • @elaraai/east-c-cli: npm launcher — installs the matching native binary as an optional dependency
  • east-c: Core runtime — type system, IR interpreter, builtins, serialization (Beast2, JSON, CSV, East text)
  • east-c-std: Console, FileSystem, Fetch, Crypto, Time, Path, Random
  • east-c-cli: CLI for running East IR programs natively

• East Python: Python runtime, standard platform, I/O, and data-science platform functions. Published to PyPI.

  • east-py: Core Python runtime — type system, IR compiler, 212+ builtins, Cython-accelerated hot paths
  • east-py-std: Console, FileSystem, Fetch, Crypto, Time, Path, Random
  • east-py-io: SQLite, PostgreSQL, MySQL, MongoDB, Redis, S3, FTP, SFTP, XLSX, XML, compression
  • east-py-cli: CLI for running East IR programs in Python
  • east-py-datascience (PyPI) + @elaraai/east-py-datascience (npm): Optimization (MADS, Optuna, ALNS, GoogleOR), ML (XGBoost, LightGBM, NGBoost, PyTorch, Lightning, GP), Bayesian inference (PyMC), explainability (SHAP), conformal prediction (MAPIE)

• East UI: Typed UI component definitions and React renderer, plus VS Code preview.

  • @elaraai/east-ui: 50+ typed UI components for layouts, forms, charts, tables, dialogs
  • @elaraai/east-ui-components: React renderer with Chakra UI v3 styling
  • @elaraai/e3-ui: e3 + UI bridge — Data bindings, e3.ui() task, manifest
  • @elaraai/e3-ui-components: React Query hooks and preview components for the e3 API

• e3 — East Execution Engine: Durable execution engine for running East pipelines at scale. Git-like content-addressable storage, automatic memoization, reactive dataflow, real-time monitoring.

  • @elaraai/e3: SDK for authoring e3 packages with typed tasks and pipelines
  • @elaraai/e3-core: Object store, dataflow orchestrator, execution state
  • @elaraai/e3-types: Shared type definitions for e3 packages
  • @elaraai/e3-cli: e3 repo, e3 package, e3 workspace, e3 dataflow run, e3 watch, e3 task logs commands
  • @elaraai/e3-api-client: HTTP client for remote e3 repositories
  • @elaraai/e3-api-server: REST API server for e3 repositories
  • @elaraai/e3-api-tests: Shared API compliance test suites

Links

• East Language
• East Python Runtime
• Elara AI
• Issues
• [email protected]

About Elara

East is developed by Elara AI Pty Ltd, 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.

Developed by Elara AI Pty Ltd