@elaraai/e3-core 0.0.1-beta.0

package/LICENSE.md

@@ -0,0 +1,50 @@
+# Business Source License 1.1
+
+Copyright (c) 2025 Elara AI Pty Ltd
+
+## License
+
+**Licensor:** Elara AI Pty Ltd
+
+**Licensed Work:** @elaraai/e3-core
+
+**Change Date:** Four years from the date of each release
+
+**Change License:** AGPL-3.0
+
+## Terms
+
+The Licensed Work is provided under the terms of the Business Source License 1.1 as detailed below.
+
+### Grant of Rights
+
+The Licensor grants you the right to copy, modify, create derivative works, redistribute, and make non-production use of the Licensed Work.
+
+### Production Use Limitation
+
+**"Production Use"** means any use by or on behalf of a for-profit entity, other than for evaluation, testing, or development purposes.
+
+Production Use requires a separate commercial license from the Licensor.
+
+### Change Date
+
+On the Change Date (four years after each release), the Licensed Work will be made available under the Change License (AGPL-3.0).
+
+### No Warranty
+
+THE LICENSED WORK IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND. THE LICENSOR DISCLAIMS ALL WARRANTIES, EXPRESS OR IMPLIED, INCLUDING WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+
+## Commercial Licensing
+
+To obtain a commercial license for Production Use, contact:
+
+**Email:** support@elara.ai
+**Website:** https://elaraai.com
+
+## Governing Law
+
+This license is governed by the laws of New South Wales, Australia.
+
+---
+
+*Elara AI Pty Ltd*

package/README.md

@@ -0,0 +1,76 @@
+# @elaraai/e3-core
+
+Core library for e3 repository operations, similar to libgit2 for git.
+
+## Installation
+
+```bash
+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
+
+```typescript
+import { initRepository, findRepository, getRepository } from '@elaraai/e3-core';
+
+initRepository('/path/to/project');
+const repoPath = findRepository();  // Searches cwd and parents
+```
+
+### Objects
+
+```typescript
+import { storeObject, loadObject, computeTaskId } from '@elaraai/e3-core';
+
+const hash = await storeObject(repoPath, data, '.beast2');
+const data = await loadObject(repoPath, hash, '.beast2');
+const taskId = computeTaskId(irHash, argsHashes);
+```
+
+### Commits
+
+```typescript
+import { createNewTaskCommit, createTaskDoneCommit, loadCommit } from '@elaraai/e3-core';
+
+const commitHash = await createNewTaskCommit(repoPath, taskId, irHash, argsHashes, 'node', null);
+const commit = await loadCommit(repoPath, commitHash);
+```
+
+### Tasks
+
+```typescript
+import { updateTaskState, getTaskState, listTasks } from '@elaraai/e3-core';
+
+await updateTaskState(repoPath, taskId, commitHash);
+const commit = await getTaskState(repoPath, taskId);
+const tasks = await listTasks(repoPath);
+```
+
+### Refs
+
+```typescript
+import { setTaskRef, deleteTaskRef, listTaskRefs, resolveToTaskId } from '@elaraai/e3-core';
+
+await setTaskRef(repoPath, 'my-task', taskId);
+const taskId = await resolveToTaskId(repoPath, 'my-task');
+```
+
+## 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
+
+BSL 1.1. See [LICENSE.md](./LICENSE.md).

package/dist/src/dataflow.d.ts

@@ -0,0 +1,96 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Result of executing a single task in the dataflow.
+ */
+export interface TaskExecutionResult {
+    /** Task name */
+    name: string;
+    /** Whether the task was cached */
+    cached: boolean;
+    /** Final state */
+    state: 'success' | 'failed' | 'error' | 'skipped';
+    /** Error message if state is 'error' */
+    error?: string;
+    /** Exit code if state is 'failed' */
+    exitCode?: number;
+    /** Duration in milliseconds */
+    duration: number;
+}
+/**
+ * Result of a dataflow execution.
+ */
+export interface DataflowResult {
+    /** Overall success - true if all tasks completed successfully */
+    success: boolean;
+    /** Number of tasks executed (not from cache) */
+    executed: number;
+    /** Number of tasks served from cache */
+    cached: number;
+    /** Number of tasks that failed */
+    failed: number;
+    /** Number of tasks skipped due to upstream failure */
+    skipped: number;
+    /** Per-task results */
+    tasks: TaskExecutionResult[];
+    /** Total duration in milliseconds */
+    duration: number;
+}
+/**
+ * Options for dataflow execution.
+ */
+export interface DataflowOptions {
+    /** Maximum concurrent task executions (default: 4) */
+    concurrency?: number;
+    /** Force re-execution even if cached (default: false) */
+    force?: boolean;
+    /** Filter to run only specific task(s) by exact name */
+    filter?: string;
+    /** Callback when a task starts */
+    onTaskStart?: (name: string) => void;
+    /** Callback when a task completes */
+    onTaskComplete?: (result: TaskExecutionResult) => void;
+    /** Callback for task stdout */
+    onStdout?: (taskName: string, data: string) => void;
+    /** Callback for task stderr */
+    onStderr?: (taskName: string, data: string) => void;
+}
+/**
+ * Execute all tasks in a workspace according to the dependency graph.
+ *
+ * Tasks are executed in parallel where dependencies allow, respecting
+ * the concurrency limit. On failure, no new tasks are launched but
+ * running tasks are allowed to complete.
+ *
+ * @param repoPath - Path to .e3 repository
+ * @param ws - Workspace name
+ * @param options - Execution options
+ * @returns Result of the dataflow execution
+ * @throws {WorkspaceNotFoundError} If workspace doesn't exist
+ * @throws {WorkspaceNotDeployedError} If workspace has no package deployed
+ * @throws {TaskNotFoundError} If filter specifies a task that doesn't exist
+ * @throws {DataflowError} If execution fails for other reasons
+ */
+export declare function dataflowExecute(repoPath: string, ws: string, options?: DataflowOptions): Promise<DataflowResult>;
+/**
+ * Get the dependency graph for a workspace (for visualization/debugging).
+ *
+ * @param repoPath - Path to .e3 repository
+ * @param ws - Workspace name
+ * @returns Graph information
+ * @throws {WorkspaceNotFoundError} If workspace doesn't exist
+ * @throws {WorkspaceNotDeployedError} If workspace has no package deployed
+ * @throws {DataflowError} If graph building fails for other reasons
+ */
+export declare function dataflowGetGraph(repoPath: string, ws: string): Promise<{
+    tasks: Array<{
+        name: string;
+        hash: string;
+        inputs: string[];
+        output: string;
+        dependsOn: string[];
+    }>;
+}>;
+//# sourceMappingURL=dataflow.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"dataflow.d.ts","sourceRoot":"","sources":["../../src/dataflow.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAsEH;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,gBAAgB;IAChB,IAAI,EAAE,MAAM,CAAC;IACb,kCAAkC;IAClC,MAAM,EAAE,OAAO,CAAC;IAChB,kBAAkB;IAClB,KAAK,EAAE,SAAS,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAC;IAClD,wCAAwC;IACxC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,qCAAqC;IACrC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,+BAA+B;IAC/B,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,iEAAiE;IACjE,OAAO,EAAE,OAAO,CAAC;IACjB,gDAAgD;IAChD,QAAQ,EAAE,MAAM,CAAC;IACjB,wCAAwC;IACxC,MAAM,EAAE,MAAM,CAAC;IACf,kCAAkC;IAClC,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,OAAO,EAAE,MAAM,CAAC;IAChB,uBAAuB;IACvB,KAAK,EAAE,mBAAmB,EAAE,CAAC;IAC7B,qCAAqC;IACrC,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,sDAAsD;IACtD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,yDAAyD;IACzD,KAAK,CAAC,EAAE,OAAO,CAAC;IAChB,wDAAwD;IACxD,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,kCAAkC;IAClC,WAAW,CAAC,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACrC,qCAAqC;IACrC,cAAc,CAAC,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,IAAI,CAAC;IACvD,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;IACpD,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,IAAI,CAAC;CACrD;AAqHD;;;;;;;;;;;;;;;GAeG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,EACV,OAAO,GAAE,eAAoB,GAC5B,OAAO,CAAC,cAAc,CAAC,CA2RzB;AAED;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,EAChB,EAAE,EAAE,MAAM,GACT,OAAO,CAAC;IACT,KAAK,EAAE,KAAK,CAAC;QACX,IAAI,EAAE,MAAM,CAAC;QACb,IAAI,EAAE,MAAM,CAAC;QACb,MAAM,EAAE,MAAM,EAAE,CAAC;QACjB,MAAM,EAAE,MAAM,CAAC;QACf,SAAS,EAAE,MAAM,EAAE,CAAC;KACrB,CAAC,CAAC;CACJ,CAAC,CA0CD"}

package/dist/src/dataflow.js

@@ -0,0 +1,433 @@
+/**
+ * Copyright (c) 2025 Elara AI Pty Ltd
+ * Dual-licensed under AGPL-3.0 and commercial license. See LICENSE for details.
+ */
+/**
+ * Dataflow execution for e3 workspaces.
+ *
+ * Executes tasks in a workspace based on their dependency graph. Tasks are
+ * executed in parallel where possible, respecting a concurrency limit.
+ *
+ * The execution model is event-driven with a work queue:
+ * 1. Build dependency graph from tasks (input paths -> task -> output path)
+ * 2. Compute reverse dependencies (which tasks depend on each output)
+ * 3. Initialize ready queue with tasks whose inputs are all assigned
+ * 4. Execute tasks from ready queue, respecting concurrency limit
+ * 5. On task completion, update workspace and check dependents for readiness
+ * 6. On failure, stop launching new tasks but wait for running ones
+ */
+import { decodeBeast2For } from '@elaraai/east';
+import { PackageObjectType, TaskObjectType, WorkspaceStateType, pathToString, } from '@elaraai/e3-types';
+import { objectRead } from './objects.js';
+import { taskExecute, executionGetOutput, inputsHash, } from './executions.js';
+import { workspaceGetDatasetHash, workspaceSetDatasetByHash, } from './trees.js';
+import { E3Error, WorkspaceNotFoundError, WorkspaceNotDeployedError, TaskNotFoundError, DataflowError, isNotFoundError, } from './errors.js';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+// =============================================================================
+// Workspace State Reader
+// =============================================================================
+/**
+ * Read workspace state from file.
+ * @throws {WorkspaceNotFoundError} If workspace doesn't exist
+ * @throws {WorkspaceNotDeployedError} If workspace has no package deployed
+ */
+async function readWorkspaceState(repoPath, ws) {
+    const stateFile = path.join(repoPath, 'workspaces', `${ws}.beast2`);
+    let data;
+    try {
+        data = await fs.readFile(stateFile);
+    }
+    catch (err) {
+        if (isNotFoundError(err)) {
+            throw new WorkspaceNotFoundError(ws);
+        }
+        throw err;
+    }
+    if (data.length === 0) {
+        throw new WorkspaceNotDeployedError(ws);
+    }
+    const decoder = decodeBeast2For(WorkspaceStateType);
+    return decoder(data);
+}
+// =============================================================================
+// Dependency Graph Building
+// =============================================================================
+/**
+ * Build the dependency graph for a workspace.
+ *
+ * Returns:
+ * - taskNodes: Map of task name -> TaskNode
+ * - outputToTask: Map of output path string -> task name
+ * - taskDependents: Map of task name -> set of dependent task names
+ */
+async function buildDependencyGraph(repoPath, ws) {
+    // Read workspace state to get package hash
+    const state = await readWorkspaceState(repoPath, ws);
+    // Read package object to get tasks map
+    const pkgData = await objectRead(repoPath, state.packageHash);
+    const pkgDecoder = decodeBeast2For(PackageObjectType);
+    const pkgObject = pkgDecoder(Buffer.from(pkgData));
+    const taskNodes = new Map();
+    const outputToTask = new Map(); // output path -> task name
+    // First pass: load all tasks and build output->task map
+    const taskDecoder = decodeBeast2For(TaskObjectType);
+    for (const [taskName, taskHash] of pkgObject.tasks) {
+        const taskData = await objectRead(repoPath, taskHash);
+        const task = taskDecoder(Buffer.from(taskData));
+        const outputPathStr = pathToString(task.output);
+        outputToTask.set(outputPathStr, taskName);
+        taskNodes.set(taskName, {
+            name: taskName,
+            hash: taskHash,
+            task,
+            inputPaths: task.inputs,
+            outputPath: task.output,
+            unresolvedCount: 0, // Will be computed below
+        });
+    }
+    // Build reverse dependency map: task -> tasks that depend on it
+    const taskDependents = new Map();
+    for (const taskName of taskNodes.keys()) {
+        taskDependents.set(taskName, new Set());
+    }
+    // Second pass: compute dependencies and unresolved counts
+    for (const [taskName, node] of taskNodes) {
+        for (const inputPath of node.inputPaths) {
+            const inputPathStr = pathToString(inputPath);
+            const producerTask = outputToTask.get(inputPathStr);
+            if (producerTask) {
+                // This input comes from another task's output.
+                // The task cannot run until the producer task completes,
+                // regardless of whether the output is currently assigned
+                // (it might be stale from a previous run).
+                taskDependents.get(producerTask).add(taskName);
+                node.unresolvedCount++;
+            }
+            // If not produced by a task, it's an external input - check if assigned
+            else {
+                const { refType } = await workspaceGetDatasetHash(repoPath, ws, inputPath);
+                if (refType === 'unassigned') {
+                    // External input that is unassigned - this task can never run
+                    node.unresolvedCount++;
+                }
+            }
+        }
+    }
+    return { taskNodes, outputToTask, taskDependents };
+}
+// =============================================================================
+// Dataflow Execution
+// =============================================================================
+/**
+ * Execute all tasks in a workspace according to the dependency graph.
+ *
+ * Tasks are executed in parallel where dependencies allow, respecting
+ * the concurrency limit. On failure, no new tasks are launched but
+ * running tasks are allowed to complete.
+ *
+ * @param repoPath - Path to .e3 repository
+ * @param ws - Workspace name
+ * @param options - Execution options
+ * @returns Result of the dataflow execution
+ * @throws {WorkspaceNotFoundError} If workspace doesn't exist
+ * @throws {WorkspaceNotDeployedError} If workspace has no package deployed
+ * @throws {TaskNotFoundError} If filter specifies a task that doesn't exist
+ * @throws {DataflowError} If execution fails for other reasons
+ */
+export async function dataflowExecute(repoPath, ws, options = {}) {
+    const startTime = Date.now();
+    const concurrency = options.concurrency ?? 4;
+    let taskNodes;
+    let taskDependents;
+    try {
+        // Build dependency graph
+        const graph = await buildDependencyGraph(repoPath, ws);
+        taskNodes = graph.taskNodes;
+        taskDependents = graph.taskDependents;
+    }
+    catch (err) {
+        // Re-throw E3Errors as-is
+        if (err instanceof E3Error)
+            throw err;
+        // Wrap unexpected errors
+        throw new DataflowError(`Failed to build dependency graph: ${err instanceof Error ? err.message : err}`);
+    }
+    // Apply filter if specified
+    const filteredTaskNames = options.filter
+        ? new Set([options.filter])
+        : null;
+    // Validate filter
+    if (filteredTaskNames && options.filter && !taskNodes.has(options.filter)) {
+        throw new TaskNotFoundError(options.filter);
+    }
+    // Track execution state
+    const results = [];
+    let executed = 0;
+    let cached = 0;
+    let failed = 0;
+    let skipped = 0;
+    let hasFailure = false;
+    // Ready queue: tasks with all dependencies resolved
+    const readyQueue = [];
+    const completed = new Set();
+    const inProgress = new Set();
+    // Initialize ready queue with tasks that have no unresolved dependencies
+    // and pass the filter (if any)
+    for (const [taskName, node] of taskNodes) {
+        if (node.unresolvedCount === 0) {
+            if (!filteredTaskNames || filteredTaskNames.has(taskName)) {
+                readyQueue.push(taskName);
+            }
+        }
+    }
+    // Check if the task has a valid cached execution for current inputs
+    // Returns the output hash if cached, null if re-execution is needed
+    async function getCachedOutput(taskName) {
+        const node = taskNodes.get(taskName);
+        // Gather current input hashes
+        const currentInputHashes = [];
+        for (const inputPath of node.inputPaths) {
+            const { refType, hash } = await workspaceGetDatasetHash(repoPath, ws, inputPath);
+            if (refType !== 'value' || hash === null) {
+                // Input not assigned, can't be cached
+                return null;
+            }
+            currentInputHashes.push(hash);
+        }
+        // Check if there's a cached execution for these inputs
+        const inHash = inputsHash(currentInputHashes);
+        const cachedOutputHash = await executionGetOutput(repoPath, node.hash, inHash);
+        if (cachedOutputHash === null) {
+            // No cached execution for current inputs
+            return null;
+        }
+        // Also verify the workspace output matches the cached output
+        // (in case the workspace was modified outside of execution)
+        const { refType, hash: wsOutputHash } = await workspaceGetDatasetHash(repoPath, ws, node.outputPath);
+        if (refType !== 'value' || wsOutputHash !== cachedOutputHash) {
+            // Workspace output doesn't match cached output, need to re-execute
+            // (or update workspace with cached value)
+            return null;
+        }
+        return cachedOutputHash;
+    }
+    // Execute a single task
+    async function executeTask(taskName) {
+        const node = taskNodes.get(taskName);
+        const taskStartTime = Date.now();
+        options.onTaskStart?.(taskName);
+        // Gather input hashes
+        const inputHashes = [];
+        for (const inputPath of node.inputPaths) {
+            const { refType, hash } = await workspaceGetDatasetHash(repoPath, ws, inputPath);
+            if (refType !== 'value' || hash === null) {
+                // Input not available - should not happen if dependency tracking is correct
+                return {
+                    name: taskName,
+                    cached: false,
+                    state: 'error',
+                    error: `Input at ${pathToString(inputPath)} is not assigned (refType: ${refType})`,
+                    duration: Date.now() - taskStartTime,
+                };
+            }
+            inputHashes.push(hash);
+        }
+        // Execute the task
+        const execOptions = {
+            force: options.force,
+            onStdout: options.onStdout ? (data) => options.onStdout(taskName, data) : undefined,
+            onStderr: options.onStderr ? (data) => options.onStderr(taskName, data) : undefined,
+        };
+        const result = await taskExecute(repoPath, node.hash, inputHashes, execOptions);
+        // Build task result
+        const taskResult = {
+            name: taskName,
+            cached: result.cached,
+            state: result.state,
+            duration: Date.now() - taskStartTime,
+        };
+        if (result.state === 'error') {
+            taskResult.error = result.error ?? undefined;
+        }
+        else if (result.state === 'failed') {
+            taskResult.exitCode = result.exitCode ?? undefined;
+            taskResult.error = result.error ?? undefined;
+        }
+        // On success, update the workspace with the output
+        if (result.state === 'success' && result.outputHash) {
+            await workspaceSetDatasetByHash(repoPath, ws, node.outputPath, result.outputHash);
+        }
+        return taskResult;
+    }
+    // Process dependents when a task completes
+    function notifyDependents(taskName) {
+        const dependents = taskDependents.get(taskName) ?? new Set();
+        for (const depName of dependents) {
+            if (completed.has(depName) || inProgress.has(depName))
+                continue;
+            // Skip dependents not in the filter
+            if (filteredTaskNames && !filteredTaskNames.has(depName))
+                continue;
+            const depNode = taskNodes.get(depName);
+            depNode.unresolvedCount--;
+            if (depNode.unresolvedCount === 0 && !readyQueue.includes(depName)) {
+                readyQueue.push(depName);
+            }
+        }
+    }
+    // Mark dependents as skipped when a task fails
+    function skipDependents(taskName) {
+        const dependents = taskDependents.get(taskName) ?? new Set();
+        for (const depName of dependents) {
+            if (completed.has(depName) || inProgress.has(depName))
+                continue;
+            // Skip dependents not in the filter
+            if (filteredTaskNames && !filteredTaskNames.has(depName))
+                continue;
+            // Recursively skip
+            completed.add(depName);
+            skipped++;
+            results.push({
+                name: depName,
+                cached: false,
+                state: 'skipped',
+                duration: 0,
+            });
+            options.onTaskComplete?.({
+                name: depName,
+                cached: false,
+                state: 'skipped',
+                duration: 0,
+            });
+            skipDependents(depName);
+        }
+    }
+    // Main execution loop using a work-stealing approach
+    const runningPromises = new Map();
+    async function processQueue() {
+        while (true) {
+            // Check if we're done
+            if (readyQueue.length === 0 && runningPromises.size === 0) {
+                break;
+            }
+            // Launch tasks up to concurrency limit if no failure
+            while (!hasFailure && readyQueue.length > 0 && runningPromises.size < concurrency) {
+                const taskName = readyQueue.shift();
+                if (completed.has(taskName) || inProgress.has(taskName))
+                    continue;
+                // Check if there's a valid cached execution for current inputs
+                const cachedOutputHash = await getCachedOutput(taskName);
+                if (cachedOutputHash !== null && !options.force) {
+                    // Valid cached execution exists for current inputs
+                    completed.add(taskName);
+                    cached++;
+                    const result = {
+                        name: taskName,
+                        cached: true,
+                        state: 'success',
+                        duration: 0,
+                    };
+                    results.push(result);
+                    options.onTaskComplete?.(result);
+                    notifyDependents(taskName);
+                    continue;
+                }
+                inProgress.add(taskName);
+                const promise = (async () => {
+                    try {
+                        const result = await executeTask(taskName);
+                        inProgress.delete(taskName);
+                        completed.add(taskName);
+                        results.push(result);
+                        options.onTaskComplete?.(result);
+                        if (result.state === 'success') {
+                            if (result.cached) {
+                                cached++;
+                            }
+                            else {
+                                executed++;
+                            }
+                            notifyDependents(taskName);
+                        }
+                        else {
+                            failed++;
+                            hasFailure = true;
+                            skipDependents(taskName);
+                        }
+                    }
+                    finally {
+                        runningPromises.delete(taskName);
+                    }
+                })();
+                runningPromises.set(taskName, promise);
+            }
+            // Wait for at least one task to complete if we can't launch more
+            if (runningPromises.size > 0) {
+                await Promise.race(runningPromises.values());
+            }
+            else if (readyQueue.length === 0) {
+                // No running tasks and no ready tasks - we might have unresolvable dependencies
+                break;
+            }
+        }
+    }
+    await processQueue();
+    // Wait for any remaining tasks
+    if (runningPromises.size > 0) {
+        await Promise.all(runningPromises.values());
+    }
+    return {
+        success: !hasFailure,
+        executed,
+        cached,
+        failed,
+        skipped,
+        tasks: results,
+        duration: Date.now() - startTime,
+    };
+}
+/**
+ * Get the dependency graph for a workspace (for visualization/debugging).
+ *
+ * @param repoPath - Path to .e3 repository
+ * @param ws - Workspace name
+ * @returns Graph information
+ * @throws {WorkspaceNotFoundError} If workspace doesn't exist
+ * @throws {WorkspaceNotDeployedError} If workspace has no package deployed
+ * @throws {DataflowError} If graph building fails for other reasons
+ */
+export async function dataflowGetGraph(repoPath, ws) {
+    let taskNodes;
+    let outputToTask;
+    try {
+        const graph = await buildDependencyGraph(repoPath, ws);
+        taskNodes = graph.taskNodes;
+        outputToTask = graph.outputToTask;
+    }
+    catch (err) {
+        if (err instanceof E3Error)
+            throw err;
+        throw new DataflowError(`Failed to build dependency graph: ${err instanceof Error ? err.message : err}`);
+    }
+    const tasks = [];
+    for (const [taskName, node] of taskNodes) {
+        const dependsOn = [];
+        for (const inputPath of node.inputPaths) {
+            const inputPathStr = pathToString(inputPath);
+            const producerTask = outputToTask.get(inputPathStr);
+            if (producerTask) {
+                dependsOn.push(producerTask);
+            }
+        }
+        tasks.push({
+            name: taskName,
+            hash: node.hash,
+            inputs: node.inputPaths.map(pathToString),
+            output: pathToString(node.outputPath),
+            dependsOn,
+        });
+    }
+    return { tasks };
+}
+//# sourceMappingURL=dataflow.js.map