@elaraai/e3-core 0.0.2-beta.12 → 0.0.2-beta.14

package/dist/src/trees.js

@@ -15,14 +15,10 @@
  * Low-level operations work with hashes directly (by-hash).
  * High-level operations traverse paths from a root (by-path).
  */
-import { decodeBeast2, decodeBeast2For, encodeBeast2For, StructType, } from '@elaraai/east';
+import { decodeBeast2, decodeBeast2For, encodeBeast2For, StructType, variant, } from '@elaraai/east';
 import { DataRefType, PackageObjectType, WorkspaceStateType } from '@elaraai/e3-types';
-import { objectRead, objectWrite } from './objects.js';
 import { packageRead } from './packages.js';
-import { WorkspaceNotFoundError, WorkspaceNotDeployedError, isNotFoundError, } from './errors.js';
-import { acquireWorkspaceLock } from './workspaceLock.js';
-import * as fs from 'fs/promises';
-import * as path from 'path';
+import { WorkspaceNotFoundError, WorkspaceNotDeployedError, WorkspaceLockError, } from './errors.js';
 /**
  * Build the EastType for a tree object based on its structure.
  *
@@ -50,32 +46,34 @@ function treeTypeFromStructure(structure) {
 /**
  * Read and decode a tree object from the object store.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param hash - Hash of the tree object
  * @param structure - The structure describing this tree node's shape
  * @returns The decoded tree object (field name -> DataRef)
  * @throws If object not found, structure is not a tree, or decoding fails
  */
-export async function treeRead(repoPath, hash, structure) {
+export async function treeRead(storage, repo, hash, structure) {
     const treeType = treeTypeFromStructure(structure);
-    const data = await objectRead(repoPath, hash);
+    const data = await storage.objects.read(repo, hash);
     const decoder = decodeBeast2For(treeType);
     return decoder(Buffer.from(data));
 }
 /**
  * Encode and write a tree object to the object store.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param fields - Object mapping field names to DataRefs
  * @param structure - The structure describing this tree node's shape
  * @returns Hash of the written tree object
  * @throws If structure is not a tree or encoding fails
  */
-export async function treeWrite(repoPath, fields, structure) {
+export async function treeWrite(storage, repo, fields, structure) {
     const treeType = treeTypeFromStructure(structure);
     const encoder = encodeBeast2For(treeType);
     const data = encoder(fields);
-    return objectWrite(repoPath, data);
+    return storage.objects.write(repo, data);
 }
 /**
  * Read and decode a dataset value from the object store.
@@ -83,43 +81,46 @@ export async function treeWrite(repoPath, fields, structure) {
  * The .beast2 format includes type information in the header, so values
  * can be decoded without knowing the schema in advance.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param hash - Hash of the dataset value
  * @returns The decoded value and its type
  * @throws If object not found or not a valid beast2 object
  */
-export async function datasetRead(repoPath, hash) {
-    const data = await objectRead(repoPath, hash);
+export async function datasetRead(storage, repo, hash) {
+    const data = await storage.objects.read(repo, hash);
     const result = decodeBeast2(Buffer.from(data));
     return { type: result.type, value: result.value };
 }
 /**
  * Encode and write a dataset value to the object store.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param value - The value to encode
  * @param type - The East type for encoding (EastType or EastTypeValue)
  * @returns Hash of the written dataset value
  */
-export async function datasetWrite(repoPath, value, type) {
+export async function datasetWrite(storage, repo, value, type) {
     // encodeBeast2For accepts both EastType and EastTypeValue, but TypeScript
     // overloads don't support union types directly. Cast to EastTypeValue since
     // that's the more general case and the runtime handles both.
     const encoder = encodeBeast2For(type);
     const data = encoder(value);
-    return objectWrite(repoPath, data);
+    return storage.objects.write(repo, data);
 }
 /**
  * Traverse a tree from root to a path, co-walking structure and data.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param rootHash - Hash of the root tree object
  * @param rootStructure - Structure of the root tree
  * @param path - Path to traverse
  * @returns The structure and DataRef at the path location
  * @throws If path is invalid or traversal fails
  */
-async function traverse(repoPath, rootHash, rootStructure, path) {
+async function traverse(storage, repo, rootHash, rootStructure, path) {
     let currentStructure = rootStructure;
     let currentHash = rootHash;
     for (let i = 0; i < path.length; i++) {
@@ -134,7 +135,7 @@ async function traverse(repoPath, rootHash, rootStructure, path) {
             throw new Error(`Cannot descend into non-struct at path '${pathSoFar}'`);
         }
         // Read the current tree object
-        const treeObject = await treeRead(repoPath, currentHash, currentStructure);
+        const treeObject = await treeRead(storage, repo, currentHash, currentStructure);
         // Look up the child ref
         const childRef = treeObject[fieldName];
         if (!childRef) {
@@ -168,16 +169,17 @@ async function traverse(repoPath, rootHash, rootStructure, path) {
 /**
  * List field names at a tree path within a package's data tree.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Package name
  * @param version - Package version
  * @param path - Path to the tree node
  * @returns Array of field names at the path
  * @throws If package not found, path invalid, or path points to a dataset
  */
-export async function packageListTree(repoPath, name, version, path) {
+export async function packageListTree(storage, repo, name, version, path) {
     // Read the package to get root structure and hash
-    const pkg = await packageRead(repoPath, name, version);
+    const pkg = await packageRead(storage, repo, name, version);
     const rootStructure = pkg.data.structure;
     const rootHash = pkg.data.value;
     if (path.length === 0) {
@@ -185,11 +187,11 @@ export async function packageListTree(repoPath, name, version, path) {
         if (rootStructure.type !== 'struct') {
             throw new Error('Root is not a tree');
         }
-        const treeObject = await treeRead(repoPath, rootHash, rootStructure);
+        const treeObject = await treeRead(storage, repo, rootHash, rootStructure);
         return Object.keys(treeObject);
     }
     // Traverse to the path
-    const { structure, ref } = await traverse(repoPath, rootHash, rootStructure, path);
+    const { structure, ref } = await traverse(storage, repo, rootHash, rootStructure, path);
     // Must be a tree structure
     if (structure.type !== 'struct') {
         const pathStr = path.map(s => s.value).join('.');
@@ -201,29 +203,30 @@ export async function packageListTree(repoPath, name, version, path) {
         throw new Error(`Path '${pathStr}' has ref type '${ref.type}', expected 'tree'`);
     }
     // Read the tree and return field names
-    const treeObject = await treeRead(repoPath, ref.value, structure);
+    const treeObject = await treeRead(storage, repo, ref.value, structure);
     return Object.keys(treeObject);
 }
 /**
  * Read and decode a dataset value at a path within a package's data tree.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param name - Package name
  * @param version - Package version
  * @param path - Path to the dataset
  * @returns The decoded dataset value
  * @throws If package not found, path invalid, or path points to a tree
  */
-export async function packageGetDataset(repoPath, name, version, path) {
+export async function packageGetDataset(storage, repo, name, version, path) {
     // Read the package to get root structure and hash
-    const pkg = await packageRead(repoPath, name, version);
+    const pkg = await packageRead(storage, repo, name, version);
     const rootStructure = pkg.data.structure;
     const rootHash = pkg.data.value;
     if (path.length === 0) {
         throw new Error('Cannot get dataset at root path - root is always a tree');
     }
     // Traverse to the path
-    const { structure, ref } = await traverse(repoPath, rootHash, rootStructure, path);
+    const { structure, ref } = await traverse(storage, repo, rootHash, rootStructure, path);
     // Must be a value structure
     if (structure.type !== 'value') {
         const pathStr = path.map(s => s.value).join('.');
@@ -241,7 +244,7 @@ export async function packageGetDataset(repoPath, name, version, path) {
         throw new Error(`Path '${pathStr}' structure says value but ref is tree`);
     }
     // Read and return the dataset value
-    const result = await datasetRead(repoPath, ref.value);
+    const result = await datasetRead(storage, repo, ref.value);
     return result.value;
 }
 /**
@@ -253,7 +256,8 @@ export async function packageGetDataset(repoPath, name, version, path) {
  * Acquires an exclusive lock on the workspace for the duration of the write
  * to prevent concurrent modifications.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param ws - Workspace name
  * @param treePath - Path to the dataset
  * @param value - The new value to write
@@ -262,15 +266,25 @@ export async function packageGetDataset(repoPath, name, version, path) {
  * @throws {WorkspaceLockError} If workspace is locked by another process
  * @throws If workspace not deployed, path invalid, or path points to a tree
  */
-export async function workspaceSetDataset(repoPath, ws, treePath, value, type, options = {}) {
+export async function workspaceSetDataset(storage, repo, ws, treePath, value, type, options = {}) {
     if (treePath.length === 0) {
         throw new Error('Cannot set dataset at root path - root is always a tree');
     }
     // Acquire lock if not provided externally
     const externalLock = options.lock;
-    const lock = externalLock ?? await acquireWorkspaceLock(repoPath, ws);
+    let lock = externalLock ?? null;
+    if (!lock) {
+        lock = await storage.locks.acquire(repo, ws, variant('dataset_write', null));
+        if (!lock) {
+            const state = await storage.locks.getState(repo, ws);
+            throw new WorkspaceLockError(ws, state ? {
+                acquiredAt: state.acquiredAt.toISOString(),
+                operation: state.operation.type,
+            } : undefined);
+        }
+    }
     try {
-        await workspaceSetDatasetUnlocked(repoPath, ws, treePath, value, type);
+        await workspaceSetDatasetUnlocked(storage, repo, ws, treePath, value, type);
     }
     finally {
         // Only release the lock if we acquired it internally
@@ -283,10 +297,10 @@ export async function workspaceSetDataset(repoPath, ws, treePath, value, type, o
  * Internal: Update a dataset without acquiring a lock.
  * Caller must hold the workspace lock.
  */
-async function workspaceSetDatasetUnlocked(repoPath, ws, treePath, value, type) {
-    const state = await readWorkspaceState(repoPath, ws);
+async function workspaceSetDatasetUnlocked(storage, repo, ws, treePath, value, type) {
+    const state = await readWorkspaceState(storage, repo, ws);
     // Read the deployed package object to get the structure
-    const pkgData = await objectRead(repoPath, state.packageHash);
+    const pkgData = await storage.objects.read(repo, state.packageHash);
     const decoder = decodeBeast2For(PackageObjectType);
     const pkgObject = decoder(Buffer.from(pkgData));
     const rootStructure = pkgObject.data.structure;
@@ -315,7 +329,7 @@ async function workspaceSetDatasetUnlocked(repoPath, ws, treePath, value, type)
         throw new Error(`Path '${pathStr}' points to a tree, not a dataset`);
     }
     // Write the new dataset value
-    const newValueHash = await datasetWrite(repoPath, value, type);
+    const newValueHash = await datasetWrite(storage, repo, value, type);
     // Now rebuild the tree path from leaf to root (structural sharing)
     // We need to read each tree along the path, modify it, and write a new version
     // Collect all tree hashes and structures along the path
@@ -326,7 +340,7 @@ async function workspaceSetDatasetUnlocked(repoPath, ws, treePath, value, type)
     for (let i = 0; i < treePath.length - 1; i++) {
         treeInfos.push({ hash: currentHash, structure: currentStructure });
         const segment = treePath[i];
-        const treeObject = await treeRead(repoPath, currentHash, currentStructure);
+        const treeObject = await treeRead(storage, repo, currentHash, currentStructure);
         const childRef = treeObject[segment.value];
         if (!childRef || childRef.type !== 'tree') {
             throw new Error(`Expected tree ref at path segment ${i}`);
@@ -343,14 +357,14 @@ async function workspaceSetDatasetUnlocked(repoPath, ws, treePath, value, type)
         const { hash, structure } = treeInfos[i];
         const fieldName = treePath[i].value;
         // Read the current tree
-        const treeObject = await treeRead(repoPath, hash, structure);
+        const treeObject = await treeRead(storage, repo, hash, structure);
         // Create modified tree with the new ref
         const newTreeObject = {
             ...treeObject,
             [fieldName]: newRef,
         };
         // Write the new tree
-        const newTreeHash = await treeWrite(repoPath, newTreeObject, structure);
+        const newTreeHash = await treeWrite(storage, repo, newTreeObject, structure);
         // This becomes the new ref for the parent
         newRef = { type: 'tree', value: newTreeHash };
     }
@@ -361,7 +375,7 @@ async function workspaceSetDatasetUnlocked(repoPath, ws, treePath, value, type)
     }
     const newRootHash = newRef.value;
     // Update workspace state atomically
-    await writeWorkspaceState(repoPath, ws, {
+    await writeWorkspaceState(storage, repo, ws, {
         ...state,
         rootHash: newRootHash,
         rootUpdatedAt: new Date(),
@@ -373,51 +387,35 @@ async function workspaceSetDatasetUnlocked(repoPath, ws, treePath, value, type)
 /**
  * Write workspace state to file atomically.
  */
-async function writeWorkspaceState(repoPath, ws, state) {
-    const wsDir = path.join(repoPath, 'workspaces');
-    const stateFile = path.join(wsDir, `${ws}.beast2`);
-    // Ensure workspaces directory exists
-    await fs.mkdir(wsDir, { recursive: true });
+async function writeWorkspaceState(storage, repo, ws, 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, `.${ws}.${Date.now()}.${randomSuffix}.tmp`);
-    await fs.writeFile(tempPath, data);
-    await fs.rename(tempPath, stateFile);
+    await storage.refs.workspaceWrite(repo, ws, data);
 }
 /**
  * Read workspace state from file.
  * @throws {WorkspaceNotFoundError} If workspace doesn't exist
  * @throws {WorkspaceNotDeployedError} If workspace exists but not deployed
  */
-async function readWorkspaceState(repoPath, ws) {
-    const stateFile = path.join(repoPath, 'workspaces', `${ws}.beast2`);
-    try {
-        const data = await fs.readFile(stateFile);
-        if (data.length === 0) {
-            throw new WorkspaceNotDeployedError(ws);
-        }
-        const decoder = decodeBeast2For(WorkspaceStateType);
-        return decoder(data);
-    }
-    catch (err) {
-        if (err instanceof WorkspaceNotDeployedError)
-            throw err;
-        if (isNotFoundError(err)) {
-            throw new WorkspaceNotFoundError(ws);
-        }
-        throw err;
+async function readWorkspaceState(storage, repo, ws) {
+    const data = await storage.refs.workspaceRead(repo, ws);
+    if (data === null) {
+        throw new WorkspaceNotFoundError(ws);
+    }
+    if (data.length === 0) {
+        throw new WorkspaceNotDeployedError(ws);
     }
+    const decoder = decodeBeast2For(WorkspaceStateType);
+    return decoder(data);
 }
 /**
  * Get root structure and hash for a workspace.
  * Reads the deployed package object to get the structure.
  */
-async function getWorkspaceRootInfo(repoPath, ws) {
-    const state = await readWorkspaceState(repoPath, ws);
+async function getWorkspaceRootInfo(storage, repo, ws) {
+    const state = await readWorkspaceState(storage, repo, ws);
     // Read the deployed package object using the stored hash
-    const pkgData = await objectRead(repoPath, state.packageHash);
+    const pkgData = await storage.objects.read(repo, state.packageHash);
     const decoder = decodeBeast2For(PackageObjectType);
     const pkgObject = decoder(Buffer.from(pkgData));
     return {
@@ -431,24 +429,25 @@ async function getWorkspaceRootInfo(repoPath, ws) {
 /**
  * List field names at a tree path within a workspace's data tree.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param ws - Workspace name
  * @param path - Path to the tree node
  * @returns Array of field names at the path
  * @throws If workspace not deployed, path invalid, or path points to a dataset
  */
-export async function workspaceListTree(repoPath, ws, treePath) {
-    const { rootHash, rootStructure } = await getWorkspaceRootInfo(repoPath, ws);
+export async function workspaceListTree(storage, repo, ws, treePath) {
+    const { rootHash, rootStructure } = await getWorkspaceRootInfo(storage, repo, ws);
     if (treePath.length === 0) {
         // Empty path - list root tree fields
         if (rootStructure.type !== 'struct') {
             throw new Error('Root is not a tree');
         }
-        const treeObject = await treeRead(repoPath, rootHash, rootStructure);
+        const treeObject = await treeRead(storage, repo, rootHash, rootStructure);
         return Object.keys(treeObject);
     }
     // Traverse to the path
-    const { structure, ref } = await traverse(repoPath, rootHash, rootStructure, treePath);
+    const { structure, ref } = await traverse(storage, repo, rootHash, rootStructure, treePath);
     // Must be a tree structure
     if (structure.type !== 'struct') {
         const pathStr = treePath.map(s => s.value).join('.');
@@ -460,25 +459,26 @@ export async function workspaceListTree(repoPath, ws, treePath) {
         throw new Error(`Path '${pathStr}' has ref type '${ref.type}', expected 'tree'`);
     }
     // Read the tree and return field names
-    const treeObject = await treeRead(repoPath, ref.value, structure);
+    const treeObject = await treeRead(storage, repo, ref.value, structure);
     return Object.keys(treeObject);
 }
 /**
  * Read and decode a dataset value at a path within a workspace's data tree.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param ws - Workspace name
  * @param path - Path to the dataset
  * @returns The decoded dataset value
  * @throws If workspace not deployed, path invalid, or path points to a tree
  */
-export async function workspaceGetDataset(repoPath, ws, treePath) {
-    const { rootHash, rootStructure } = await getWorkspaceRootInfo(repoPath, ws);
+export async function workspaceGetDataset(storage, repo, ws, treePath) {
+    const { rootHash, rootStructure } = await getWorkspaceRootInfo(storage, repo, ws);
     if (treePath.length === 0) {
         throw new Error('Cannot get dataset at root path - root is always a tree');
     }
     // Traverse to the path
-    const { structure, ref } = await traverse(repoPath, rootHash, rootStructure, treePath);
+    const { structure, ref } = await traverse(storage, repo, rootHash, rootStructure, treePath);
     // Must be a value structure
     if (structure.type !== 'value') {
         const pathStr = treePath.map(s => s.value).join('.');
@@ -496,7 +496,7 @@ export async function workspaceGetDataset(repoPath, ws, treePath) {
         throw new Error(`Path '${pathStr}' structure says value but ref is tree`);
     }
     // Read and return the dataset value
-    const result = await datasetRead(repoPath, ref.value);
+    const result = await datasetRead(storage, repo, ref.value);
     return result.value;
 }
 /**
@@ -505,19 +505,20 @@ export async function workspaceGetDataset(repoPath, ws, treePath) {
  * Unlike workspaceGetDataset which decodes the value, this returns the raw
  * hash reference. Useful for dataflow execution which operates on hashes.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param ws - Workspace name
  * @param treePath - Path to the dataset
  * @returns Object with ref type and hash (null for unassigned/null refs)
  * @throws If workspace not deployed, path invalid, or path points to a tree
  */
-export async function workspaceGetDatasetHash(repoPath, ws, treePath) {
-    const { rootHash, rootStructure } = await getWorkspaceRootInfo(repoPath, ws);
+export async function workspaceGetDatasetHash(storage, repo, ws, treePath) {
+    const { rootHash, rootStructure } = await getWorkspaceRootInfo(storage, repo, ws);
     if (treePath.length === 0) {
         throw new Error('Cannot get dataset at root path - root is always a tree');
     }
     // Traverse to the path
-    const { structure, ref } = await traverse(repoPath, rootHash, rootStructure, treePath);
+    const { structure, ref } = await traverse(storage, repo, rootHash, rootStructure, treePath);
     // Must be a value structure
     if (structure.type !== 'value') {
         const pathStr = treePath.map(s => s.value).join('.');
@@ -540,23 +541,24 @@ export async function workspaceGetDatasetHash(repoPath, ws, treePath) {
  * directly. Useful for dataflow execution which already has the output hash.
  *
  * IMPORTANT: This function does NOT acquire a workspace lock. The caller must
- * hold an exclusive lock on the workspace (via acquireWorkspaceLock) before
- * calling this function. This is typically used by dataflowExecute which
- * holds the lock for the entire execution.
+ * hold an exclusive lock on the workspace before calling this function. This
+ * is typically used by dataflowExecute which holds the lock for the entire
+ * execution.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param ws - Workspace name
  * @param treePath - Path to the dataset
  * @param valueHash - Hash of the dataset value already in the object store
  * @throws If workspace not deployed, path invalid, or path points to a tree
  */
-export async function workspaceSetDatasetByHash(repoPath, ws, treePath, valueHash) {
+export async function workspaceSetDatasetByHash(storage, repo, ws, treePath, valueHash) {
     if (treePath.length === 0) {
         throw new Error('Cannot set dataset at root path - root is always a tree');
     }
-    const state = await readWorkspaceState(repoPath, ws);
+    const state = await readWorkspaceState(storage, repo, ws);
     // Read the deployed package object to get the structure
-    const pkgData = await objectRead(repoPath, state.packageHash);
+    const pkgData = await storage.objects.read(repo, state.packageHash);
     const decoder = decodeBeast2For(PackageObjectType);
     const pkgObject = decoder(Buffer.from(pkgData));
     const rootStructure = pkgObject.data.structure;
@@ -593,7 +595,7 @@ export async function workspaceSetDatasetByHash(repoPath, ws, treePath, valueHas
     for (let i = 0; i < treePath.length - 1; i++) {
         treeInfos.push({ hash: currentHash, structure: currentStructure });
         const segment = treePath[i];
-        const treeObject = await treeRead(repoPath, currentHash, currentStructure);
+        const treeObject = await treeRead(storage, repo, currentHash, currentStructure);
         const childRef = treeObject[segment.value];
         if (!childRef || childRef.type !== 'tree') {
             throw new Error(`Expected tree ref at path segment ${i}`);
@@ -610,14 +612,14 @@ export async function workspaceSetDatasetByHash(repoPath, ws, treePath, valueHas
         const { hash, structure } = treeInfos[i];
         const fieldName = treePath[i].value;
         // Read the current tree
-        const treeObject = await treeRead(repoPath, hash, structure);
+        const treeObject = await treeRead(storage, repo, hash, structure);
         // Create modified tree with the new ref
         const newTreeObject = {
             ...treeObject,
             [fieldName]: newRef,
         };
         // Write the new tree
-        const newTreeHash = await treeWrite(repoPath, newTreeObject, structure);
+        const newTreeHash = await treeWrite(storage, repo, newTreeObject, structure);
         // This becomes the new ref for the parent
         newRef = { type: 'tree', value: newTreeHash };
     }
@@ -627,7 +629,7 @@ export async function workspaceSetDatasetByHash(repoPath, ws, treePath, valueHas
     }
     const newRootHash = newRef.value;
     // Update workspace state atomically
-    await writeWorkspaceState(repoPath, ws, {
+    await writeWorkspaceState(storage, repo, ws, {
         ...state,
         rootHash: newRootHash,
         rootUpdatedAt: new Date(),
@@ -660,25 +662,26 @@ function getTaskOutputTypeFromStructure(structure) {
  * Recursively walks the tree and returns a hierarchical structure
  * suitable for display. Tasks are shown as leaves with their output type.
  *
- * @param repoPath - Path to .e3 repository
+ * @param storage - Storage backend
+ * @param repo - Repository identifier
  * @param ws - Workspace name
  * @param treePath - Path to start from (empty for root)
  * @param options - Optional settings for depth limit and type inclusion
  * @returns Array of tree nodes at the path
  * @throws If workspace not deployed or path invalid
  */
-export async function workspaceGetTree(repoPath, ws, treePath, options = {}) {
-    const { rootHash, rootStructure } = await getWorkspaceRootInfo(repoPath, ws);
+export async function workspaceGetTree(storage, repo, ws, treePath, options = {}) {
+    const { rootHash, rootStructure } = await getWorkspaceRootInfo(storage, repo, ws);
     const { maxDepth, includeTypes } = options;
     // If path is empty, start from root
     if (treePath.length === 0) {
         if (rootStructure.type !== 'struct') {
             throw new Error('Root is not a tree');
         }
-        return walkTree(repoPath, rootHash, rootStructure, 0, maxDepth, includeTypes);
+        return walkTree(storage, repo, rootHash, rootStructure, 0, maxDepth, includeTypes);
     }
     // Traverse to the path first
-    const { structure, ref } = await traverse(repoPath, rootHash, rootStructure, treePath);
+    const { structure, ref } = await traverse(storage, repo, rootHash, rootStructure, treePath);
     // Must be a tree structure
     if (structure.type !== 'struct') {
         const pathStr = treePath.map(s => s.value).join('.');
@@ -689,16 +692,16 @@ export async function workspaceGetTree(repoPath, ws, treePath, options = {}) {
         const pathStr = treePath.map(s => s.value).join('.');
         throw new Error(`Path '${pathStr}' has ref type '${ref.type}', expected 'tree'`);
     }
-    return walkTree(repoPath, ref.value, structure, 0, maxDepth, includeTypes);
+    return walkTree(storage, repo, ref.value, structure, 0, maxDepth, includeTypes);
 }
 /**
  * Recursively walk a tree and build TreeNode array.
  */
-async function walkTree(repoPath, treeHash, structure, currentDepth, maxDepth, includeTypes) {
+async function walkTree(storage, repo, treeHash, structure, currentDepth, maxDepth, includeTypes) {
     if (structure.type !== 'struct') {
         throw new Error('Expected struct structure for tree walk');
     }
-    const treeObject = await treeRead(repoPath, treeHash, structure);
+    const treeObject = await treeRead(storage, repo, treeHash, structure);
     const nodes = [];
     for (const [fieldName, childRef] of Object.entries(treeObject)) {
         const childStructure = structure.value.get(fieldName);
@@ -731,7 +734,7 @@ async function walkTree(repoPath, treeHash, structure, currentDepth, maxDepth, i
             // Recurse if we haven't hit max depth
             if (maxDepth === undefined || currentDepth < maxDepth) {
                 if (childRef.type === 'tree') {
-                    children = await walkTree(repoPath, childRef.value, childStructure, currentDepth + 1, maxDepth, includeTypes);
+                    children = await walkTree(storage, repo, childRef.value, childStructure, currentDepth + 1, maxDepth, includeTypes);
                 }
             }
             const node = {