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

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,25 @@ 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
+ * @returns The new root hash after updating the tree
  * @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 +596,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 +613,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,10 +630,125 @@ 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(),
     });
+    return newRootHash;
+}
+/**
+ * Check if a structure represents a task (has function_ir and output).
+ */
+function isTaskStructure(structure) {
+    if (structure.type !== 'struct')
+        return false;
+    const fields = structure.value;
+    return fields.has('function_ir') && fields.has('output');
+}
+/**
+ * Get the output type from a task structure (from structure, not value).
+ */
+function getTaskOutputTypeFromStructure(structure) {
+    if (structure.type !== 'struct')
+        return undefined;
+    const outputStructure = structure.value.get('output');
+    if (outputStructure?.type === 'value') {
+        return outputStructure.value;
+    }
+    return undefined;
+}
+/**
+ * Get the full tree structure at a path within a workspace.
+ *
+ * Recursively walks the tree and returns a hierarchical structure
+ * suitable for display. Tasks are shown as leaves with their output type.
+ *
+ * @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(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(storage, repo, rootHash, rootStructure, 0, maxDepth, includeTypes);
+    }
+    // Traverse to the path first
+    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('.');
+        throw new Error(`Path '${pathStr}' points to a dataset, not a tree`);
+    }
+    // Must be a tree ref
+    if (ref.type !== 'tree') {
+        const pathStr = treePath.map(s => s.value).join('.');
+        throw new Error(`Path '${pathStr}' has ref type '${ref.type}', expected 'tree'`);
+    }
+    return walkTree(storage, repo, ref.value, structure, 0, maxDepth, includeTypes);
+}
+/**
+ * Recursively walk a tree and build TreeNode array.
+ */
+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(storage, repo, treeHash, structure);
+    const nodes = [];
+    for (const [fieldName, childRef] of Object.entries(treeObject)) {
+        const childStructure = structure.value.get(fieldName);
+        if (!childStructure) {
+            continue; // Skip unknown fields
+        }
+        if (childStructure.type === 'value') {
+            // This is a dataset (leaf node)
+            // The type is directly in the structure - no need to read the value
+            const node = {
+                name: fieldName,
+                kind: 'dataset',
+                datasetType: includeTypes ? childStructure.value : undefined,
+            };
+            nodes.push(node);
+        }
+        else if (childStructure.type === 'struct') {
+            // Check if this is a task subtree - show as leaf with output type
+            if (isTaskStructure(childStructure) && childRef.type === 'tree') {
+                const node = {
+                    name: fieldName,
+                    kind: 'dataset',
+                    datasetType: includeTypes ? getTaskOutputTypeFromStructure(childStructure) : undefined,
+                };
+                nodes.push(node);
+                continue;
+            }
+            // Regular subtree
+            let children = [];
+            // Recurse if we haven't hit max depth
+            if (maxDepth === undefined || currentDepth < maxDepth) {
+                if (childRef.type === 'tree') {
+                    children = await walkTree(storage, repo, childRef.value, childStructure, currentDepth + 1, maxDepth, includeTypes);
+                }
+            }
+            const node = {
+                name: fieldName,
+                kind: 'tree',
+                children,
+            };
+            nodes.push(node);
+        }
+    }
+    // Sort alphabetically for consistent output
+    nodes.sort((a, b) => a.name.localeCompare(b.name));
+    return nodes;
 }
 //# sourceMappingURL=trees.js.map