@elaraai/e3-core 0.0.2-beta.3 → 0.0.2-beta.30

package/dist/src/workspaces.d.ts

@@ -3,18 +3,27 @@
  * Licensed under BSL 1.1. See LICENSE for details.
  */
 import type { WorkspaceState } from '@elaraai/e3-types';
-import { type WorkspaceLockHandle } from './workspaceLock.js';
+import type { StorageBackend, LockHandle } from './storage/interfaces.js';
+/**
+ * List workspace names.
+ *
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
+ * @returns Array of workspace names
+ */
+export declare function workspaceList(storage: StorageBackend, repo: string): Promise<string[]>;
 /**
  * Create an empty workspace.
  *
  * Creates an undeployed workspace (state file with null package info).
  * Use workspaceDeploy to deploy a package.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @throws {WorkspaceExistsError} If workspace already exists
  */
-export declare function workspaceCreate(repoPath: string, name: string): Promise<void>;
+export declare function workspaceCreate(storage: StorageBackend, repo: string, name: string): Promise<void>;
 /**
  * Options for workspace removal.
  */
@@ -24,7 +33,7 @@ export interface WorkspaceRemoveOptions {
      * for releasing the lock after the operation. If not provided, workspaceRemove
      * will acquire and release a lock internally.
      */
-    lock?: WorkspaceLockHandle;
+    lock?: LockHandle;
 }
 /**
  * Remove a workspace.
@@ -34,38 +43,34 @@ export interface WorkspaceRemoveOptions {
  * Acquires a workspace lock to prevent removing a workspace while a dataflow
  * is running. Throws WorkspaceLockError if the workspace is currently locked.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @param options - Optional settings including external lock
  * @throws {WorkspaceNotFoundError} If workspace doesn't exist
  * @throws {WorkspaceLockError} If workspace is locked by another process
  */
-export declare function workspaceRemove(repoPath: string, name: string, options?: WorkspaceRemoveOptions): Promise<void>;
-/**
- * List workspace names.
- *
- * @param repoPath - Path to .e3 repository
- * @returns Array of workspace names
- */
-export declare function workspaceList(repoPath: string): Promise<string[]>;
+export declare function workspaceRemove(storage: StorageBackend, repo: string, name: string, options?: WorkspaceRemoveOptions): Promise<void>;
 /**
  * Get the full state for a workspace.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @returns Workspace state, or null if workspace doesn't exist or is not deployed
  */
-export declare function workspaceGetState(repoPath: string, name: string): Promise<WorkspaceState | null>;
+export declare function workspaceGetState(storage: StorageBackend, repo: string, name: string): Promise<WorkspaceState | null>;
 /**
  * Get the deployed package for a workspace.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @returns Package name, version, and hash
  * @throws {WorkspaceNotFoundError} If workspace doesn't exist
  * @throws {WorkspaceNotDeployedError} If workspace exists but has no package deployed
  */
-export declare function workspaceGetPackage(repoPath: string, name: string): Promise<{
+export declare function workspaceGetPackage(storage: StorageBackend, repo: string, name: string): Promise<{
     name: string;
     version: string;
     hash: string;
@@ -73,23 +78,25 @@ export declare function workspaceGetPackage(repoPath: string, name: string): Pro
 /**
  * Get the root tree hash for a workspace.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @returns Root tree object hash
  * @throws {WorkspaceNotFoundError} If workspace doesn't exist
  * @throws {WorkspaceNotDeployedError} If workspace exists but has no package deployed
  */
-export declare function workspaceGetRoot(repoPath: string, name: string): Promise<string>;
+export declare function workspaceGetRoot(storage: StorageBackend, repo: string, name: string): Promise<string>;
 /**
  * Atomically update the root tree hash for a workspace.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @param hash - New root tree object hash
  * @throws {WorkspaceNotFoundError} If workspace doesn't exist
  * @throws {WorkspaceNotDeployedError} If workspace exists but has no package deployed
  */
-export declare function workspaceSetRoot(repoPath: string, name: string, hash: string): Promise<void>;
+export declare function workspaceSetRoot(storage: StorageBackend, repo: string, name: string, hash: string): Promise<void>;
 /**
  * Options for workspace deployment.
  */
@@ -99,7 +106,7 @@ export interface WorkspaceDeployOptions {
      * for releasing the lock after the operation. If not provided, workspaceDeploy
      * will acquire and release a lock internally.
      */
-    lock?: WorkspaceLockHandle;
+    lock?: LockHandle;
 }
 /**
  * Deploy a package to a workspace.
@@ -111,14 +118,15 @@ export interface WorkspaceDeployOptions {
  * or concurrent deploys. Throws WorkspaceLockError if the workspace is
  * currently locked by another process.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @param pkgName - Package name
  * @param pkgVersion - Package version
  * @param options - Optional settings including external lock
  * @throws {WorkspaceLockError} If workspace is locked by another process
  */
-export declare function workspaceDeploy(repoPath: string, name: string, pkgName: string, pkgVersion: string, options?: WorkspaceDeployOptions): Promise<void>;
+export declare function workspaceDeploy(storage: StorageBackend, repo: string, name: string, pkgName: string, pkgVersion: string, options?: WorkspaceDeployOptions): Promise<void>;
 /**
  * Result of exporting a workspace
  */
@@ -137,7 +145,8 @@ export interface WorkspaceExportResult {
  * 4. Collect all referenced objects
  * 5. Write to .zip
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @param zipPath - Path to write the .zip file
  * @param outputName - Package name (default: deployed package name)
@@ -146,5 +155,5 @@ export interface WorkspaceExportResult {
  * @throws {WorkspaceNotFoundError} If workspace doesn't exist
  * @throws {WorkspaceNotDeployedError} If workspace exists but has no package deployed
  */
-export declare function workspaceExport(repoPath: string, name: string, zipPath: string, outputName?: string, version?: string): Promise<WorkspaceExportResult>;
+export declare function workspaceExport(storage: StorageBackend, repo: string, name: string, zipPath: string, outputName?: string, version?: string): Promise<WorkspaceExportResult>;
 //# sourceMappingURL=workspaces.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"workspaces.d.ts","sourceRoot":"","sources":["../../src/workspaces.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAoBH,OAAO,KAAK,EAAiB,cAAc,EAAE,MAAM,mBAAmB,CAAC;AASvE,OAAO,EAAwB,KAAK,mBAAmB,EAAE,MAAM,oBAAoB,CAAC;AA6EpF;;;;;;;;;GASG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAqBf;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,IAAI,CAAC,EAAE,mBAAmB,CAAC;CAC5B;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,IAAI,CAAC,CAoBf;AAED;;;;;GAKG;AACH,wBAAsB,aAAa,CACjC,QAAQ,EAAE,MAAM,GACf,OAAO,CAAC,MAAM,EAAE,CAAC,CAgBnB;AAED;;;;;;GAMG;AACH,wBAAsB,iBAAiB,CACrC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAMhC;AAED;;;;;;;;GAQG;AACH,wBAAsB,mBAAmB,CACvC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAO1D;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,CAAC,CAGjB;AAED;;;;;;;;GAQG;AACH,wBAAsB,gBAAgB,CACpC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAUf;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,IAAI,CAAC,EAAE,mBAAmB,CAAC;CAC5B;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,IAAI,CAAC,CA0Bf;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAOD;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,eAAe,CACnC,QAAQ,EAAE,MAAM,EAChB,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,qBAAqB,CAAC,CAqGhC"}
+{"version":3,"file":"workspaces.d.ts","sourceRoot":"","sources":["../../src/workspaces.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAmBH,OAAO,KAAK,EAAiB,cAAc,EAAc,MAAM,mBAAmB,CAAC;AAQnF,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAE1E;;;;;;GAMG;AACH,wBAAsB,aAAa,CAAC,OAAO,EAAE,cAAc,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,EAAE,CAAC,CAE5F;AA0DD;;;;;;;;;;GAUG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CASf;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,IAAI,CAAC,CA4Bf;AAED;;;;;;;GAOG;AACH,wBAAsB,iBAAiB,CACrC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,cAAc,GAAG,IAAI,CAAC,CAMhC;AAED;;;;;;;;;GASG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,OAAO,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CAO1D;AAED;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,MAAM,CAAC,CAGjB;AAED;;;;;;;;;GASG;AACH,wBAAsB,gBAAgB,CACpC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,GACX,OAAO,CAAC,IAAI,CAAC,CAUf;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC;;;;OAIG;IACH,IAAI,CAAC,EAAE,UAAU,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,sBAA2B,GACnC,OAAO,CAAC,IAAI,CAAC,CAqCf;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,WAAW,EAAE,MAAM,CAAC;IACpB,WAAW,EAAE,MAAM,CAAC;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,OAAO,EAAE,MAAM,CAAC;CACjB;AAOD;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAsB,eAAe,CACnC,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,MAAM,EACZ,OAAO,EAAE,MAAM,EACf,UAAU,CAAC,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE,MAAM,GACf,OAAO,CAAC,qBAAqB,CAAC,CAoLhC"}

package/dist/src/workspaces.js

@@ -13,37 +13,30 @@
  * State is stored in workspaces/<name>.beast2 as a single atomic file.
  * No state file means the workspace does not exist.
  */
-import * as fs from 'fs/promises';
 import { createWriteStream } from 'fs';
-import * as path from 'path';
+import * as fs from 'fs/promises';
 import yazl from 'yazl';
-import { decodeBeast2For, encodeBeast2For } from '@elaraai/east';
-import { PackageObjectType, WorkspaceStateType } from '@elaraai/e3-types';
-import { objectRead, objectWrite } from './objects.js';
+import { decodeBeast2For, encodeBeast2For, variant } from '@elaraai/east';
+import { PackageObjectType, WorkspaceStateType, TaskObjectType, DataflowRunType } from '@elaraai/e3-types';
 import { packageResolve, packageRead } from './packages.js';
-import { WorkspaceNotFoundError, WorkspaceNotDeployedError, WorkspaceExistsError, isNotFoundError, } from './errors.js';
-import { acquireWorkspaceLock } from './workspaceLock.js';
+import { WorkspaceNotFoundError, WorkspaceNotDeployedError, WorkspaceExistsError, WorkspaceLockError, } from './errors.js';
 /**
- * Get the path to a workspace's state file.
+ * List workspace names.
+ *
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
+ * @returns Array of workspace names
  */
-function statePath(repoPath, name) {
-    return path.join(repoPath, 'workspaces', `${name}.beast2`);
+export async function workspaceList(storage, repo) {
+    return storage.refs.workspaceList(repo);
 }
 /**
- * Atomically write workspace state.
+ * Write workspace state via storage backend.
  */
-async function writeState(repoPath, name, state) {
-    const wsDir = path.join(repoPath, 'workspaces');
-    const stateFile = statePath(repoPath, name);
-    // Ensure workspaces directory exists
-    await fs.mkdir(wsDir, { recursive: true });
+async function writeState(storage, repo, name, state) {
     const encoder = encodeBeast2For(WorkspaceStateType);
     const data = encoder(state);
-    // Write atomically: write to temp file, then rename
-    const randomSuffix = Math.random().toString(36).slice(2, 10);
-    const tempPath = path.join(wsDir, `.${name}.${Date.now()}.${randomSuffix}.tmp`);
-    await fs.writeFile(tempPath, data);
-    await fs.rename(tempPath, stateFile);
+    await storage.refs.workspaceWrite(repo, name, data);
 }
 /**
  * Read workspace state.
@@ -51,31 +44,25 @@ async function writeState(repoPath, name, state) {
  * Returns { exists: true, deployed: false } if workspace exists but not deployed.
  * Returns { exists: true, deployed: true, state } if workspace is deployed.
  */
-async function readState(repoPath, name) {
-    const stateFile = statePath(repoPath, name);
-    try {
-        const data = await fs.readFile(stateFile);
-        // Empty file means workspace exists but is not deployed
-        if (data.length === 0) {
-            return { exists: true, deployed: false };
-        }
-        const decoder = decodeBeast2For(WorkspaceStateType);
-        return { exists: true, deployed: true, state: decoder(data) };
+async function readState(storage, repo, name) {
+    const data = await storage.refs.workspaceRead(repo, name);
+    if (data === null) {
+        return { exists: false };
     }
-    catch (err) {
-        if (isNotFoundError(err)) {
-            return { exists: false };
-        }
-        throw err;
+    // Empty file means workspace exists but is not deployed
+    if (data.length === 0) {
+        return { exists: true, deployed: false };
     }
+    const decoder = decodeBeast2For(WorkspaceStateType);
+    return { exists: true, deployed: true, state: decoder(Buffer.from(data)) };
 }
 /**
  * Read workspace state, throwing if workspace doesn't exist or is not deployed.
  * @throws {WorkspaceNotFoundError} If workspace doesn't exist
  * @throws {WorkspaceNotDeployedError} If workspace exists but has no package deployed
  */
-async function readStateOrThrow(repoPath, name) {
-    const result = await readState(repoPath, name);
+async function readStateOrThrow(storage, repo, name) {
+    const result = await readState(storage, repo, name);
     if (!result.exists) {
         throw new WorkspaceNotFoundError(name);
     }
@@ -90,30 +77,19 @@ async function readStateOrThrow(repoPath, name) {
  * Creates an undeployed workspace (state file with null package info).
  * Use workspaceDeploy to deploy a package.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @throws {WorkspaceExistsError} If workspace already exists
  */
-export async function workspaceCreate(repoPath, name) {
-    const stateFile = statePath(repoPath, name);
+export async function workspaceCreate(storage, repo, name) {
     // Check if workspace already exists
-    try {
-        await fs.access(stateFile);
+    const existing = await storage.refs.workspaceRead(repo, name);
+    if (existing !== null) {
         throw new WorkspaceExistsError(name);
     }
-    catch (err) {
-        if (err instanceof WorkspaceExistsError)
-            throw err;
-        if (!isNotFoundError(err)) {
-            throw err;
-        }
-    }
-    // Create workspaces directory if needed
-    const wsDir = path.join(repoPath, 'workspaces');
-    await fs.mkdir(wsDir, { recursive: true });
-    // Create empty file to mark workspace as existing but not deployed
-    // We use an empty file rather than a state file since there's no valid state yet
-    await fs.writeFile(stateFile, '');
+    // Create empty state to mark workspace as existing but not deployed
+    await storage.refs.workspaceWrite(repo, name, new Uint8Array(0));
 }
 /**
  * Remove a workspace.
@@ -123,27 +99,34 @@ export async function workspaceCreate(repoPath, name) {
  * Acquires a workspace lock to prevent removing a workspace while a dataflow
  * is running. Throws WorkspaceLockError if the workspace is currently locked.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @param options - Optional settings including external lock
  * @throws {WorkspaceNotFoundError} If workspace doesn't exist
  * @throws {WorkspaceLockError} If workspace is locked by another process
  */
-export async function workspaceRemove(repoPath, name, options = {}) {
+export async function workspaceRemove(storage, repo, name, options = {}) {
     // Acquire lock if not provided externally
     const externalLock = options.lock;
-    const lock = externalLock ?? await acquireWorkspaceLock(repoPath, name);
-    try {
-        const stateFile = statePath(repoPath, name);
-        try {
-            await fs.unlink(stateFile);
+    let lock = externalLock ?? null;
+    if (!lock) {
+        lock = await storage.locks.acquire(repo, name, variant('removal', null));
+        if (!lock) {
+            const state = await storage.locks.getState(repo, name);
+            throw new WorkspaceLockError(name, state ? {
+                acquiredAt: state.acquiredAt.toISOString(),
+                operation: state.operation.type,
+            } : undefined);
         }
-        catch (err) {
-            if (isNotFoundError(err)) {
-                throw new WorkspaceNotFoundError(name);
-            }
-            throw err;
+    }
+    try {
+        // Check if workspace exists
+        const existing = await storage.refs.workspaceRead(repo, name);
+        if (existing === null) {
+            throw new WorkspaceNotFoundError(name);
         }
+        await storage.refs.workspaceRemove(repo, name);
     }
     finally {
         // Only release the lock if we acquired it internally
@@ -152,37 +135,16 @@ export async function workspaceRemove(repoPath, name, options = {}) {
         }
     }
 }
-/**
- * List workspace names.
- *
- * @param repoPath - Path to .e3 repository
- * @returns Array of workspace names
- */
-export async function workspaceList(repoPath) {
-    const workspacesDir = path.join(repoPath, 'workspaces');
-    const names = [];
-    try {
-        const entries = await fs.readdir(workspacesDir);
-        for (const entry of entries) {
-            if (entry.endsWith('.beast2')) {
-                names.push(entry.slice(0, -7)); // Remove .beast2 extension
-            }
-        }
-    }
-    catch {
-        // workspaces directory doesn't exist
-    }
-    return names;
-}
 /**
  * Get the full state for a workspace.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @returns Workspace state, or null if workspace doesn't exist or is not deployed
  */
-export async function workspaceGetState(repoPath, name) {
-    const result = await readState(repoPath, name);
+export async function workspaceGetState(storage, repo, name) {
+    const result = await readState(storage, repo, name);
     if (!result.exists || !result.deployed) {
         return null;
     }
@@ -191,14 +153,15 @@ export async function workspaceGetState(repoPath, name) {
 /**
  * Get the deployed package for a workspace.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @returns Package name, version, and hash
  * @throws {WorkspaceNotFoundError} If workspace doesn't exist
  * @throws {WorkspaceNotDeployedError} If workspace exists but has no package deployed
  */
-export async function workspaceGetPackage(repoPath, name) {
-    const state = await readStateOrThrow(repoPath, name);
+export async function workspaceGetPackage(storage, repo, name) {
+    const state = await readStateOrThrow(storage, repo, name);
     return {
         name: state.packageName,
         version: state.packageVersion,
@@ -208,33 +171,35 @@ export async function workspaceGetPackage(repoPath, name) {
 /**
  * Get the root tree hash for a workspace.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @returns Root tree object hash
  * @throws {WorkspaceNotFoundError} If workspace doesn't exist
  * @throws {WorkspaceNotDeployedError} If workspace exists but has no package deployed
  */
-export async function workspaceGetRoot(repoPath, name) {
-    const state = await readStateOrThrow(repoPath, name);
+export async function workspaceGetRoot(storage, repo, name) {
+    const state = await readStateOrThrow(storage, repo, name);
     return state.rootHash;
 }
 /**
  * Atomically update the root tree hash for a workspace.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @param hash - New root tree object hash
  * @throws {WorkspaceNotFoundError} If workspace doesn't exist
  * @throws {WorkspaceNotDeployedError} If workspace exists but has no package deployed
  */
-export async function workspaceSetRoot(repoPath, name, hash) {
-    const state = await readStateOrThrow(repoPath, name);
+export async function workspaceSetRoot(storage, repo, name, hash) {
+    const state = await readStateOrThrow(storage, repo, name);
     const newState = {
         ...state,
         rootHash: hash,
         rootUpdatedAt: new Date(),
     };
-    await writeState(repoPath, name, newState);
+    await writeState(storage, repo, name, newState);
 }
 /**
  * Deploy a package to a workspace.
@@ -246,21 +211,32 @@ export async function workspaceSetRoot(repoPath, name, hash) {
  * or concurrent deploys. Throws WorkspaceLockError if the workspace is
  * currently locked by another process.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @param pkgName - Package name
  * @param pkgVersion - Package version
  * @param options - Optional settings including external lock
  * @throws {WorkspaceLockError} If workspace is locked by another process
  */
-export async function workspaceDeploy(repoPath, name, pkgName, pkgVersion, options = {}) {
+export async function workspaceDeploy(storage, repo, name, pkgName, pkgVersion, options = {}) {
     // Acquire lock if not provided externally
     const externalLock = options.lock;
-    const lock = externalLock ?? await acquireWorkspaceLock(repoPath, name);
+    let lock = externalLock ?? null;
+    if (!lock) {
+        lock = await storage.locks.acquire(repo, name, variant('deployment', null));
+        if (!lock) {
+            const state = await storage.locks.getState(repo, name);
+            throw new WorkspaceLockError(name, state ? {
+                acquiredAt: state.acquiredAt.toISOString(),
+                operation: state.operation.type,
+            } : undefined);
+        }
+    }
     try {
         // Resolve package hash and read package object
-        const packageHash = await packageResolve(repoPath, pkgName, pkgVersion);
-        const pkg = await packageRead(repoPath, pkgName, pkgVersion);
+        const packageHash = await packageResolve(storage, repo, pkgName, pkgVersion);
+        const pkg = await packageRead(storage, repo, pkgName, pkgVersion);
         const now = new Date();
         const state = {
             packageName: pkgName,
@@ -269,8 +245,9 @@ export async function workspaceDeploy(repoPath, name, pkgName, pkgVersion, optio
             deployedAt: now,
             rootHash: pkg.data.value,
             rootUpdatedAt: now,
+            currentRunId: variant('none', null),
         };
-        await writeState(repoPath, name, state);
+        await writeState(storage, repo, name, state);
     }
     finally {
         // Only release the lock if we acquired it internally
@@ -292,7 +269,8 @@ const DETERMINISTIC_MTIME = new Date(0);
  * 4. Collect all referenced objects
  * 5. Write to .zip
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Workspace name
  * @param zipPath - Path to write the .zip file
  * @param outputName - Package name (default: deployed package name)
@@ -301,12 +279,12 @@ const DETERMINISTIC_MTIME = new Date(0);
  * @throws {WorkspaceNotFoundError} If workspace doesn't exist
  * @throws {WorkspaceNotDeployedError} If workspace exists but has no package deployed
  */
-export async function workspaceExport(repoPath, name, zipPath, outputName, version) {
+export async function workspaceExport(storage, repo, name, zipPath, outputName, version) {
     const partialPath = `${zipPath}.partial`;
     // Get workspace state
-    const state = await readStateOrThrow(repoPath, name);
+    const state = await readStateOrThrow(storage, repo, name);
     // Read the deployed package object using the stored hash
-    const deployedPkgData = await objectRead(repoPath, state.packageHash);
+    const deployedPkgData = await storage.objects.read(repo, state.packageHash);
     const decoder = decodeBeast2For(PackageObjectType);
     const deployedPkgObject = decoder(Buffer.from(deployedPkgData));
     // Determine output name and version
@@ -323,7 +301,7 @@ export async function workspaceExport(repoPath, name, zipPath, outputName, versi
     // Encode and store the new package object
     const encoder = encodeBeast2For(PackageObjectType);
     const pkgData = encoder(newPkgObject);
-    const packageHash = await objectWrite(repoPath, pkgData);
+    const packageHash = await storage.objects.write(repo, pkgData);
     // Create zip file
     const zipfile = new yazl.ZipFile();
     // Track which objects we've added to avoid duplicates
@@ -333,7 +311,7 @@ export async function workspaceExport(repoPath, name, zipPath, outputName, versi
         if (addedObjects.has(hash))
             return;
         addedObjects.add(hash);
-        const data = await objectRead(repoPath, hash);
+        const data = await storage.objects.read(repo, hash);
         const objPath = `objects/${hash.slice(0, 2)}/${hash.slice(2)}.beast2`;
         zipfile.addBuffer(Buffer.from(data), objPath, { mtime: DETERMINISTIC_MTIME });
     };
@@ -348,7 +326,7 @@ export async function workspaceExport(repoPath, name, zipPath, outputName, versi
                 continue;
             try {
                 await addObject(potentialHash);
-                const childData = await objectRead(repoPath, potentialHash);
+                const childData = await storage.objects.read(repo, potentialHash);
                 await collectTreeChildren(childData);
             }
             catch {
@@ -358,17 +336,90 @@ export async function workspaceExport(repoPath, name, zipPath, outputName, versi
     };
     // Add the package object
     await addObject(packageHash);
-    // Collect all task objects
+    // Collect all task objects and their commandIr references
+    const taskDecoder = decodeBeast2For(TaskObjectType);
     for (const taskHash of newPkgObject.tasks.values()) {
         await addObject(taskHash);
+        // Task objects contain commandIr hashes that must also be exported
+        const taskData = await storage.objects.read(repo, taskHash);
+        const taskObject = taskDecoder(Buffer.from(taskData));
+        // The commandIr is a hash reference to an IR object
+        await addObject(taskObject.commandIr);
+        // Recursively collect any objects referenced by the IR
+        const irData = await storage.objects.read(repo, taskObject.commandIr);
+        await collectTreeChildren(irData);
     }
     // Collect the root tree and all its children
     await addObject(state.rootHash);
-    const rootTreeData = await objectRead(repoPath, state.rootHash);
+    const rootTreeData = await storage.objects.read(repo, state.rootHash);
     await collectTreeChildren(rootTreeData);
     // Write the package ref
     const refPath = `packages/${finalName}/${finalVersion}`;
     zipfile.addBuffer(Buffer.from(packageHash + '\n'), refPath, { mtime: DETERMINISTIC_MTIME });
+    // Include executions and logs if currentRunId exists
+    if (state.currentRunId.type === 'some') {
+        const currentRunId = state.currentRunId.value;
+        const dataflowRun = await storage.refs.dataflowRunGet(repo, name, currentRunId);
+        if (dataflowRun) {
+            // Write the dataflow run record
+            const runEncoder = encodeBeast2For(DataflowRunType);
+            const dataflowPath = `dataflows/${name}/${currentRunId}.beast2`;
+            zipfile.addBuffer(Buffer.from(runEncoder(dataflowRun)), dataflowPath, { mtime: DETERMINISTIC_MTIME });
+            // Include execution files for each task
+            for (const [taskName, execRecord] of dataflowRun.taskExecutions) {
+                const taskHash = newPkgObject.tasks.get(taskName);
+                if (!taskHash)
+                    continue;
+                // Get the task to find its inputs
+                const taskData = await storage.objects.read(repo, taskHash);
+                const task = taskDecoder(Buffer.from(taskData));
+                // Compute inputsHash
+                const inputHashes = [];
+                for (const inputPath of task.inputs) {
+                    try {
+                        // Read input hash from the workspace at export time
+                        // These should match what was used during execution
+                        const { workspaceGetDatasetHash } = await import('./trees.js');
+                        const { hash } = await workspaceGetDatasetHash(storage, repo, name, inputPath);
+                        if (hash)
+                            inputHashes.push(hash);
+                    }
+                    catch {
+                        // Skip if input not available
+                    }
+                }
+                if (inputHashes.length !== task.inputs.length)
+                    continue;
+                const { inputsHash } = await import('./executions.js');
+                const inHash = inputsHash(inputHashes);
+                // Read and add execution status
+                const execStatus = await storage.refs.executionGet(repo, taskHash, inHash, execRecord.executionId);
+                if (execStatus) {
+                    const statusEncoder = await import('@elaraai/e3-types').then(m => encodeBeast2For(m.ExecutionStatusType));
+                    const statusPath = `executions/${taskHash}/${inHash}/${execRecord.executionId}/status.beast2`;
+                    zipfile.addBuffer(Buffer.from(statusEncoder(execStatus)), statusPath, { mtime: DETERMINISTIC_MTIME });
+                    // Add output file if success
+                    if (execStatus.type === 'success') {
+                        const outputPath = `executions/${taskHash}/${inHash}/${execRecord.executionId}/output`;
+                        zipfile.addBuffer(Buffer.from(execStatus.value.outputHash + '\n'), outputPath, { mtime: DETERMINISTIC_MTIME });
+                    }
+                }
+                // Read and add logs (stdout/stderr)
+                for (const stream of ['stdout', 'stderr']) {
+                    try {
+                        const logChunk = await storage.logs.read(repo, taskHash, inHash, execRecord.executionId, stream, { limit: 100 * 1024 * 1024 });
+                        if (logChunk.data && logChunk.data.length > 0) {
+                            const logPath = `executions/${taskHash}/${inHash}/${execRecord.executionId}/${stream}.txt`;
+                            zipfile.addBuffer(Buffer.from(logChunk.data), logPath, { mtime: DETERMINISTIC_MTIME });
+                        }
+                    }
+                    catch {
+                        // Skip if log not available
+                    }
+                }
+            }
+        }
+    }
     // Finalize and write zip to disk
     await new Promise((resolve, reject) => {
         const writeStream = createWriteStream(partialPath);