@drej/core 0.2.0 → 0.4.0

package/dist/index.mjs

@@ -0,0 +1,603 @@
+import { ExecClient, SSEEventType, SnapshotState } from "@drej/opensandbox";
+//#region src/ledger.ts
+/** Status of a sandbox session derived from its ledger events. */
+let SandboxStatus = /* @__PURE__ */ function(SandboxStatus) {
+	SandboxStatus["Running"] = "running";
+	SandboxStatus["Completed"] = "completed";
+	return SandboxStatus;
+}({});
+/** Events emitted during execution and stored in the ledger. */
+let LedgerEvent = /* @__PURE__ */ function(LedgerEvent) {
+	/** Emitted when a sandbox is created and reaches Running state. */
+	LedgerEvent["SandboxCreated"] = "sandbox_created";
+	/** Emitted at the start of each exec() or execCode() call. */
+	LedgerEvent["ExecStart"] = "exec_start";
+	/** Streaming output chunk from exec() or execCode(). */
+	LedgerEvent["ExecEvent"] = "exec_event";
+	/** Emitted when an exec() or execCode() call completes. */
+	LedgerEvent["ExecComplete"] = "exec_complete";
+	/** Emitted when checkpoint() captures a snapshot. */
+	LedgerEvent["CheckpointCreated"] = "checkpoint_created";
+	/** Emitted when a sandbox is closed. */
+	LedgerEvent["SandboxClosed"] = "sandbox_closed";
+	/** Emitted once when a workflow run starts, before any steps execute. */
+	LedgerEvent["RunStarted"] = "run_started";
+	/** Emitted at the beginning of each step. */
+	LedgerEvent["StepStart"] = "step_start";
+	/** Emitted when a step finishes successfully. */
+	LedgerEvent["StepComplete"] = "step_complete";
+	/** Emitted when a step throws an unrecoverable error. */
+	LedgerEvent["StepFailed"] = "step_failed";
+	/** Emitted when a step's rollback handler completes during saga compensation. */
+	LedgerEvent["StepRolledBack"] = "step_rolled_back";
+	/** Emitted after all steps finish without error. */
+	LedgerEvent["WorkflowComplete"] = "workflow_complete";
+	/** Emitted after rollback completes following a step failure. */
+	LedgerEvent["WorkflowFailed"] = "workflow_failed";
+	/** Durable resumption point written after each successful step. */
+	LedgerEvent["Checkpoint"] = "checkpoint";
+	/** Emitted when a sandbox snapshot is captured mid-run. */
+	LedgerEvent["Snapshot"] = "snapshot";
+	return LedgerEvent;
+}({});
+//#endregion
+//#region src/logger.ts
+let LogLevel = /* @__PURE__ */ function(LogLevel) {
+	LogLevel[LogLevel["Debug"] = 0] = "Debug";
+	LogLevel[LogLevel["Info"] = 1] = "Info";
+	LogLevel[LogLevel["Warn"] = 2] = "Warn";
+	LogLevel[LogLevel["Error"] = 3] = "Error";
+	LogLevel[LogLevel["Silent"] = 4] = "Silent";
+	return LogLevel;
+}({});
+var ConsoleLogger = class {
+	minLevel;
+	constructor(minLevel = 1) {
+		this.minLevel = minLevel;
+	}
+	log(level, prefix, msg, meta) {
+		if (level < this.minLevel) return;
+		const out = meta ? `${prefix} ${msg} ${JSON.stringify(meta)}` : `${prefix} ${msg}`;
+		if (level >= 3) console.error(out);
+		else console.log(out);
+	}
+	debug(msg, meta) {
+		this.log(0, "[DEBUG]", msg, meta);
+	}
+	info(msg, meta) {
+		this.log(1, "[INFO]", msg, meta);
+	}
+	warn(msg, meta) {
+		this.log(2, "[WARN]", msg, meta);
+	}
+	error(msg, meta) {
+		this.log(3, "[ERROR]", msg, meta);
+	}
+};
+const noopLogger = {
+	debug: () => {},
+	info: () => {},
+	warn: () => {},
+	error: () => {}
+};
+//#endregion
+//#region src/errors.ts
+/** Base class for all drej workflow runtime errors. */
+var WorkflowError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "WorkflowError";
+	}
+};
+/** Thrown when a sandbox fails to create, boot, or reach `Running` state. */
+var SandboxError = class extends WorkflowError {
+	sandboxId;
+	constructor(message, sandboxId) {
+		super(message);
+		this.sandboxId = sandboxId;
+		this.name = "SandboxError";
+	}
+};
+/**
+* Thrown when execd inside a sandbox never becomes ready within the retry window.
+* The sandbox is `Running` from the control plane's perspective, but the exec
+* daemon is not accepting connections.
+*/
+var ExecConnectionError = class extends WorkflowError {
+	sandboxId;
+	constructor(sandboxId) {
+		super(`execd not ready for sandbox ${sandboxId}`);
+		this.sandboxId = sandboxId;
+		this.name = "ExecConnectionError";
+	}
+};
+/**
+* Thrown when an `exec()` step exits with a non-zero exit code and the
+* `strict` option is enabled. Carries the exit code and original command.
+*/
+var CommandError = class extends WorkflowError {
+	exitCode;
+	command;
+	sandboxId;
+	constructor(exitCode, command, sandboxId) {
+		super(`Command exited with code ${exitCode}: ${command}`);
+		this.exitCode = exitCode;
+		this.command = command;
+		this.sandboxId = sandboxId;
+		this.name = "CommandError";
+	}
+};
+/**
+* Thrown when a step exceeds its `timeoutMs` limit (either set per-step or
+* via `RunOptions.stepTimeoutMs`). The workflow will roll back after this error.
+*/
+var StepTimeoutError = class extends WorkflowError {
+	stepId;
+	timeoutMs;
+	constructor(stepId, timeoutMs) {
+		super(`Step "${stepId}" timed out after ${timeoutMs}ms`);
+		this.stepId = stepId;
+		this.timeoutMs = timeoutMs;
+		this.name = "StepTimeoutError";
+	}
+};
+//#endregion
+//#region src/exec-handle.ts
+/**
+* Returned by `Sandbox.exec()` and `Sandbox.execCode()`.
+*
+* Implements `PromiseLike<ExecResult>` so `await sb.exec(...)` works naturally.
+* Also exposes `pipe()`, `stdout()`, and `result()` for streaming output.
+*
+* @example
+* ```ts
+* // simple await
+* const { exitCode } = await sb.exec("npm test");
+*
+* // stream to stdout
+* await sb.exec("npm run build").pipe(process.stdout);
+*
+* // async generator
+* for await (const chunk of sb.exec("npm test").stdout()) process.stdout.write(chunk);
+* ```
+*/
+var ExecHandle = class {
+	_promise;
+	_chunks = [];
+	_wakeup = null;
+	_done = false;
+	_err;
+	_hasErr = false;
+	constructor(driver) {
+		if (driver.type === "replay") {
+			if (driver.result.stdout) this._chunks.push(driver.result.stdout);
+			this._done = true;
+			this._promise = Promise.resolve(driver.result);
+		} else {
+			this._promise = this._drain(driver.gen, driver.onDone);
+			this._promise.catch(() => {});
+		}
+	}
+	async _drain(gen, onDone) {
+		const stderr = [];
+		let exitCode = 0;
+		try {
+			for await (const ev of gen) {
+				if (ev.type === SSEEventType.Stdout && ev.text) {
+					this._chunks.push(ev.text);
+					this._notify();
+				}
+				if (ev.type === SSEEventType.Stderr && ev.text) stderr.push(ev.text);
+				if (ev.type === SSEEventType.Error && ev.error?.evalue !== void 0) {
+					const code = Number(ev.error.evalue);
+					if (!isNaN(code)) exitCode = code;
+				}
+			}
+		} catch (err) {
+			this._err = err;
+			this._hasErr = true;
+			throw err;
+		} finally {
+			this._done = true;
+			this._notify();
+		}
+		const result = {
+			stdout: this._chunks.join(""),
+			stderr: stderr.join(""),
+			exitCode
+		};
+		await onDone(result);
+		return result;
+	}
+	_notify() {
+		const fn = this._wakeup;
+		this._wakeup = null;
+		fn?.();
+	}
+	then(onfulfilled, onrejected) {
+		return this._promise.then(onfulfilled, onrejected);
+	}
+	/** Resolve the full result: `{ stdout, stderr, exitCode }`. */
+	result() {
+		return this._promise;
+	}
+	/** Async generator yielding stdout chunks as they arrive. */
+	async *stdout() {
+		let pos = 0;
+		while (true) {
+			while (pos < this._chunks.length) yield this._chunks[pos++];
+			if (this._done) break;
+			await new Promise((r) => {
+				this._wakeup = r;
+			});
+		}
+		while (pos < this._chunks.length) yield this._chunks[pos++];
+		if (this._hasErr) throw this._err;
+	}
+	/** Pipe stdout to any writable with a `write(chunk: string)` method. */
+	async pipe(writable) {
+		for await (const chunk of this.stdout()) writable.write(chunk);
+	}
+};
+//#endregion
+//#region src/sandbox.ts
+/**
+* Resolve an ExecClient for a sandbox. Calls getEndpoint once (each call
+* returns a different ephemeral proxy port) then polls listContexts until
+* execd is ready to accept connections.
+*/
+async function resolveExecClient(control, sandboxId, useServerProxy, retries = 15, delayMs = 1e3) {
+	const ep = await control.getEndpoint(sandboxId, 44772, useServerProxy);
+	const client = new ExecClient({
+		baseUrl: ep.endpoint.startsWith("http") ? ep.endpoint : `http://${ep.endpoint}`,
+		accessToken: ep.headers?.["X-EXECD-ACCESS-TOKEN"] ?? ""
+	});
+	for (let attempt = 0; attempt <= retries; attempt++) try {
+		await client.listContexts();
+		return client;
+	} catch {
+		if (attempt === retries) throw new ExecConnectionError(sandboxId);
+		await new Promise((r) => setTimeout(r, delayMs));
+	}
+	throw new Error("unreachable");
+}
+/**
+* A live sandbox container. Returned by `DrejClient.sandbox()` and `DrejClient.resume()`.
+*
+* Call `exec()` to run commands, `checkpoint()` to snapshot state, and `close()`
+* when done. Multiple sandboxes can be held simultaneously — just assign to
+* different variables.
+*
+* @example
+* ```ts
+* const sb = await client.sandbox({ image: "node:22", resources: { cpu: "500m", memory: "256Mi" } });
+* await sb.exec("npm ci");
+* await sb.checkpoint();
+* await sb.exec("npm test").pipe(process.stdout);
+* await sb.close();
+* ```
+*/
+var Sandbox = class {
+	/** OpenSandbox container ID — also the unique ledger key for this session. */
+	sandboxId;
+	/** User-provided name (or auto-generated). */
+	name;
+	_deps;
+	/** Cached exec results for replay mode (populated by DrejClient.resume()). */
+	_replayCache;
+	_execClient = null;
+	_seq = 0;
+	_closed = false;
+	constructor(sandboxId, name, deps, replayCache = /* @__PURE__ */ new Map()) {
+		this.sandboxId = sandboxId;
+		this.name = name;
+		this._deps = deps;
+		this._replayCache = replayCache;
+	}
+	async _getExecClient() {
+		if (!this._execClient) this._execClient = await resolveExecClient(this._deps.control, this.sandboxId, this._deps.useServerProxy);
+		return this._execClient;
+	}
+	async _emit(event, stepIndex, payload) {
+		await this._deps.adapter.append({
+			ts: Date.now(),
+			name: this.name,
+			sandboxId: this.sandboxId,
+			stepIndex,
+			event,
+			payload
+		});
+	}
+	/**
+	* Execute a shell command inside the sandbox.
+	*
+	* Returns an `ExecHandle` — await it for the result, call `.pipe()` to stream
+	* stdout, or use `.stdout()` as an async generator. Every call is logged to
+	* the ledger; replayed execs in a resumed sandbox return cached output
+	* instantly without re-running.
+	*
+	* @example
+	* ```ts
+	* const { exitCode } = await sb.exec("npm test");
+	* await sb.exec("npm run build").pipe(process.stdout);
+	* ```
+	*/
+	exec(cmd, opts = {}) {
+		const seq = ++this._seq;
+		if (this._replayCache.has(seq)) return new ExecHandle({
+			type: "replay",
+			result: this._replayCache.get(seq)
+		});
+		const self = this;
+		async function* stream() {
+			const execClient = await self._getExecClient();
+			await self._emit("exec_start", seq, {
+				cmd,
+				seq
+			});
+			self._deps.hooks?.onExecStart?.(self.sandboxId, seq, cmd);
+			const sh = opts.shell ?? self._deps.shell ?? "/bin/sh";
+			const command = `echo ${Buffer.from(cmd).toString("base64")} | base64 -d | ${sh}`;
+			for await (const ev of execClient.executeCommand({
+				command,
+				cwd: opts.cwd,
+				envs: opts.env,
+				timeout: opts.timeoutMs
+			})) {
+				await self._emit("exec_event", seq, {
+					seq,
+					...ev
+				});
+				yield ev;
+			}
+		}
+		return new ExecHandle({
+			type: "stream",
+			gen: stream(),
+			onDone: async (result) => {
+				await self._emit("exec_complete", seq, {
+					exitCode: result.exitCode,
+					seq
+				});
+				self._deps.hooks?.onExecComplete?.(self.sandboxId, seq, result);
+				if (opts.strict !== false && result.exitCode !== 0) throw new CommandError(result.exitCode, cmd, self.sandboxId);
+			}
+		});
+	}
+	/**
+	* Create a code execution context for use with `execCode()`.
+	*
+	* The code interpreter requires a context for every `execCode()` call. Call
+	* this once per session (or once per isolated scope), then pass the returned
+	* object as `opts.context` to `execCode()`. Variables defined in one call
+	* are visible to subsequent calls sharing the same context.
+	*
+	* @example
+	* ```ts
+	* const ctx = await sb.createCodeContext(CodeLanguage.Python);
+	* await sb.execCode('x = 42', { context: ctx });
+	* await sb.execCode('print(x)', { context: ctx }); // prints 42
+	* ```
+	*/
+	async createCodeContext(language) {
+		return (await this._getExecClient()).createContext(language);
+	}
+	/**
+	* Execute code via the sandbox's code interpreter (Python, JS, etc.).
+	*
+	* Uses the execd `/code` endpoint for stateful, Jupyter-style execution.
+	* Contexts persist across calls — use `opts.context` to target a specific one.
+	* Create a context first with `sb.createCodeContext(language)`.
+	*/
+	execCode(code, opts = {}) {
+		const seq = ++this._seq;
+		if (this._replayCache.has(seq)) return new ExecHandle({
+			type: "replay",
+			result: this._replayCache.get(seq)
+		});
+		const self = this;
+		async function* stream() {
+			const execClient = await self._getExecClient();
+			await self._emit("exec_start", seq, {
+				code,
+				seq
+			});
+			for await (const ev of execClient.executeCode({
+				code,
+				context: opts.context
+			})) {
+				await self._emit("exec_event", seq, {
+					seq,
+					...ev
+				});
+				yield ev;
+			}
+		}
+		return new ExecHandle({
+			type: "stream",
+			gen: stream(),
+			onDone: async (result) => {
+				await self._emit("exec_complete", seq, {
+					exitCode: result.exitCode,
+					seq
+				});
+			}
+		});
+	}
+	/** Write a file into the sandbox. */
+	async writeFile(path, content) {
+		await (await this._getExecClient()).uploadFile(path, content);
+	}
+	/** Read a file from the sandbox as a UTF-8 string. */
+	async readFile(path) {
+		const reader = (await (await this._getExecClient()).downloadFile(path)).getReader();
+		const chunks = [];
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			if (value) chunks.push(value);
+		}
+		const total = chunks.reduce((n, c) => n + c.length, 0);
+		const merged = new Uint8Array(total);
+		let offset = 0;
+		for (const chunk of chunks) {
+			merged.set(chunk, offset);
+			offset += chunk.length;
+		}
+		return new TextDecoder().decode(merged);
+	}
+	/** Delete a file from the sandbox. */
+	async deleteFile(path) {
+		await (await this._getExecClient()).deleteFile(path);
+	}
+	/** Move or rename a file inside the sandbox. */
+	async moveFile(from, to) {
+		await (await this._getExecClient()).moveFile(from, to);
+	}
+	/** List files in a directory inside the sandbox. */
+	async listDirectory(path, opts = {}) {
+		return (await this._getExecClient()).listDirectory(path, opts.depth);
+	}
+	/** Search for files matching a glob pattern inside the sandbox. */
+	async searchFiles(pattern, path = "/") {
+		return (await this._getExecClient()).searchFiles(pattern, path);
+	}
+	/** Create a directory (and parents) inside the sandbox. */
+	async createDirectory(path) {
+		await (await this._getExecClient()).createDirectory(path);
+	}
+	/** Delete a directory inside the sandbox. */
+	async deleteDirectory(path) {
+		await (await this._getExecClient()).deleteDirectory(path);
+	}
+	/** Return metadata for a file or directory (size, type, mode, timestamps). */
+	async getFileInfo(path) {
+		return (await this._getExecClient()).getFileInfo(path);
+	}
+	/**
+	* Replace substrings in one or more files inside the sandbox.
+	*
+	* More efficient than `readFile` → string replace → `writeFile` for targeted edits.
+	*
+	* @example
+	* ```ts
+	* await sb.replaceInFiles([{ path: "/app/config.json", old: "localhost", new: "0.0.0.0" }]);
+	* ```
+	*/
+	async replaceInFiles(replacements) {
+		await (await this._getExecClient()).replaceInFiles(replacements);
+	}
+	/**
+	* Copy a file from this sandbox into another sandbox.
+	*
+	* Reads the file as a UTF-8 string and writes it to the same path on the target.
+	* Use this to move results between a fork and its origin, or between parallel sandboxes.
+	*
+	* @example
+	* ```ts
+	* await sb.transfer("/app/output.json", fork);
+	* ```
+	*/
+	async transfer(path, target) {
+		const content = await this.readFile(path);
+		await target.writeFile(path, content);
+	}
+	/**
+	* Return a proxied URL and auth headers for a port inside the sandbox.
+	*
+	* Use this to send HTTP requests to a server running inside the sandbox.
+	*
+	* @example
+	* ```ts
+	* await sb.exec("node server.js &");
+	* const { url, headers } = await sb.proxy(3000);
+	* const res = await fetch(`${url}/health`, { headers });
+	* ```
+	*/
+	async proxy(port) {
+		const ep = await this._deps.control.getEndpoint(this.sandboxId, port, this._deps.useServerProxy);
+		return {
+			url: ep.endpoint.startsWith("http") ? ep.endpoint : `http://${ep.endpoint}`,
+			headers: ep.headers ?? {}
+		};
+	}
+	/** Return current CPU and memory usage for this sandbox. */
+	async metrics() {
+		return (await this._getExecClient()).getMetrics();
+	}
+	/** Return all checkpoints for this sandbox in creation order. */
+	listCheckpoints() {
+		return this._deps.adapter.listCheckpoints(this.name, this.sandboxId);
+	}
+	/**
+	* Snapshot the current sandbox and return a new independent `Sandbox` from that state.
+	*
+	* The original sandbox keeps running. Both operate on separate containers restored
+	* from the same snapshot. Equivalent to `checkpoint()` followed by `resume()` on a
+	* clone, but without closing the original.
+	*
+	* @example
+	* ```ts
+	* await sb.exec("npm ci");
+	* const fork = await sb.fork("after-install");
+	*
+	* await sb.exec("npm test");         // runs on original
+	* await fork.exec("npm run build");  // runs on fork
+	* ```
+	*/
+	async fork(tag) {
+		if (!this._deps.fork) throw new SandboxError("fork() is not supported on this sandbox", this.sandboxId);
+		const snap = await this._deps.control.createSnapshot(this.sandboxId);
+		await this._waitForSnapshot(snap.id);
+		await this._emit("checkpoint_created", -1, {
+			snapshotId: snap.id,
+			name: tag
+		});
+		this._deps.hooks?.onCheckpoint?.(this.sandboxId, snap.id, tag);
+		return this._deps.fork(snap.id, tag);
+	}
+	/**
+	* Capture a snapshot of the sandbox's current filesystem state.
+	*
+	* Writes a `checkpoint_created` event to the ledger with the snapshot ID.
+	* Use `DrejClient.resume(sandboxId)` to restore from the latest checkpoint.
+	*/
+	async checkpoint(name) {
+		const snap = await this._deps.control.createSnapshot(this.sandboxId);
+		await this._waitForSnapshot(snap.id);
+		await this._emit("checkpoint_created", -1, {
+			snapshotId: snap.id,
+			name
+		});
+		this._deps.hooks?.onCheckpoint?.(this.sandboxId, snap.id, name);
+	}
+	async _waitForSnapshot(snapshotId, timeoutMs = 12e4) {
+		const deadline = Date.now() + timeoutMs;
+		while (Date.now() < deadline) {
+			const snap = await this._deps.control.getSnapshot(snapshotId);
+			if (snap.state === SnapshotState.Ready) return;
+			if (snap.state === SnapshotState.Failed) throw new SandboxError(`Snapshot ${snapshotId} failed`, this.sandboxId);
+			await new Promise((r) => setTimeout(r, 2e3));
+		}
+		throw new SandboxError(`Snapshot ${snapshotId} did not become ready within ${timeoutMs}ms`, this.sandboxId);
+	}
+	/**
+	* Delete the sandbox container and release its resources.
+	*
+	* Always call `close()` when done — even on error — to avoid leaking containers.
+	* Idempotent: subsequent calls are no-ops.
+	*/
+	async close() {
+		if (this._closed) return;
+		this._closed = true;
+		try {
+			await this._deps.control.deleteSandbox(this.sandboxId);
+		} finally {
+			await this._emit("sandbox_closed", -1);
+			this._deps.hooks?.onSandboxClosed?.(this.sandboxId);
+			this._deps.onClose?.();
+		}
+	}
+};
+//#endregion
+export { CommandError, ConsoleLogger, ExecConnectionError, ExecHandle, LedgerEvent, LogLevel, Sandbox, SandboxError, SandboxStatus, StepTimeoutError, WorkflowError, noopLogger, resolveExecClient };

package/package.json

@@ -1,20 +1,33 @@
 {
   "name": "@drej/core",
-  "version": "0.2.0",
-  "main": "./src/index.ts",
-  "types": "./dist/index.d.ts",
+  "version": "0.4.0",
   "files": [
     "dist"
   ],
-  "publishConfig": { "access": "public" },
+  "type": "module",
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "types": "./dist/index.d.mts"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
   "scripts": {
-    "build:types": "tsc --project tsconfig.build.json"
+    "build": "tsdown",
+    "test": "vitest run",
+    "test:watch": "vitest"
   },
   "dependencies": {
     "@drej/opensandbox": "workspace:*"
   },
   "devDependencies": {
-    "bun-types": "latest",
-    "typescript": "latest"
+    "bun-types": "1.3.14",
+    "tsdown": "0.22.3",
+    "typescript": "6.0.3",
+    "vitest": "4.1.9"
   }
 }

package/dist/errors.d.ts

@@ -1,31 +0,0 @@
-/** Base class for all drej workflow runtime errors. */
-export declare class WorkflowError extends Error {
-    constructor(message: string);
-}
-/** Thrown when a sandbox fails to create, boot, or reach `Running` state. */
-export declare class SandboxError extends WorkflowError {
-    /** The sandbox ID, if one was assigned before the failure. */
-    readonly sandboxId?: string | undefined;
-    constructor(message: string, 
-    /** The sandbox ID, if one was assigned before the failure. */
-    sandboxId?: string | undefined);
-}
-/**
- * Thrown when execd inside a sandbox never becomes ready within the retry window.
- * The sandbox is `Running` from the control plane's perspective, but the exec
- * daemon is not accepting connections.
- */
-export declare class ExecConnectionError extends WorkflowError {
-    readonly sandboxId: string;
-    constructor(sandboxId: string);
-}
-/**
- * Thrown when an `exec()` step exits with a non-zero exit code and the
- * `strict` option is enabled. Carries the exit code and original command.
- */
-export declare class CommandError extends WorkflowError {
-    readonly exitCode: number;
-    readonly command: string;
-    readonly sandboxId: string;
-    constructor(exitCode: number, command: string, sandboxId: string);
-}

package/dist/index.d.ts

@@ -1,10 +0,0 @@
-export { LedgerEvent } from "./ledger";
-export type { LedgerEntry, IStorageAdapter } from "./ledger";
-export { LogLevel, ConsoleLogger, noopLogger } from "./logger";
-export type { ILogger } from "./logger";
-export { Workflow, WorkflowStatus } from "./workflow";
-export type { WorkflowRunContext, WorkflowStep, WorkflowCheckpoint, WorkflowDeps, WorkflowHooks, } from "./workflow";
-export { buildStep, resolveExecClient, shouldSnapshot, waitForSnapshot } from "./steps";
-export type { StepDef, Predicate, WorkflowState, SnapshotConfig } from "./steps";
-export { validateWorkflow } from "./validate";
-export { WorkflowError, SandboxError, ExecConnectionError, CommandError } from "./errors";