agents 0.7.7 → 0.7.8

package/dist/experimental/workspace.js

@@ -1,1265 +0,0 @@
-import { channel } from "node:diagnostics_channel";
-import { Shell, defineCommand } from "@cloudflare/shell";
-//#region src/experimental/workspace.ts
-let _Symbol$dispose;
-const DEFAULT_INLINE_THRESHOLD = 15e5;
-const TEXT_ENCODER = new TextEncoder();
-const TEXT_DECODER = new TextDecoder();
-const MAX_SYMLINK_DEPTH = 40;
-const DEFAULT_BASH_LIMITS = {
-	maxCommandCount: 5e3,
-	maxLoopIterations: 2e3,
-	maxCallDepth: 50
-};
-const VALID_NAMESPACE = /^[a-zA-Z][a-zA-Z0-9_]*$/;
-const LIKE_ESCAPE = "\\";
-const MAX_STREAM_SIZE = 100 * 1024 * 1024;
-const MAX_DIFF_LINES = 1e4;
-const MAX_PATH_LENGTH = 4096;
-const MAX_SYMLINK_TARGET_LENGTH = 4096;
-const MAX_MKDIR_DEPTH = 100;
-const SESS_STATE_BEGIN = "__BASHSESSION_STATE_BEGIN__";
-const SESS_STATE_END = "__BASHSESSION_STATE_END__";
-const SESS_CWD_PREFIX = "__SESS_CWD__=";
-const workspaceRegistry = /* @__PURE__ */ new WeakMap();
-const wsChannel = channel("agents:workspace");
-var Workspace = class {
-	/**
-	* @param host - Any object with a `sql` tagged-template method (typically your Agent: `this`).
-	* @param options - Optional configuration (namespace, R2 bucket, thresholds, etc.).
-	*
-	* ```ts
-	* class MyAgent extends Agent<Env> {
-	*   workspace = new Workspace(this, {
-	*     r2: this.env.WORKSPACE_FILES,
-	*     // r2Prefix defaults to this.name (the Durable Object ID)
-	*   });
-	* }
-	* ```
-	*/
-	constructor(host, options) {
-		this.initialized = false;
-		this.sqlCache = /* @__PURE__ */ new Map();
-		const ns = options?.namespace ?? "default";
-		if (!VALID_NAMESPACE.test(ns)) throw new Error(`Invalid workspace namespace "${ns}": must start with a letter and contain only alphanumeric characters or underscores`);
-		const registered = workspaceRegistry.get(host) ?? /* @__PURE__ */ new Set();
-		if (registered.has(ns)) throw new Error(`Workspace namespace "${ns}" is already registered on this agent`);
-		registered.add(ns);
-		workspaceRegistry.set(host, registered);
-		this.host = host;
-		this.namespace = ns;
-		this.tableName = `cf_workspace_${ns}`;
-		this.indexName = `cf_workspace_${ns}_parent`;
-		this.r2 = options?.r2 ?? null;
-		this.r2Prefix = options?.r2Prefix;
-		this.threshold = options?.inlineThreshold ?? DEFAULT_INLINE_THRESHOLD;
-		this.bashLimits = {
-			...DEFAULT_BASH_LIMITS,
-			...options?.bashLimits
-		};
-		this.commands = options?.commands ?? [];
-		this.env = options?.env ?? {};
-		this.network = options?.network;
-		this.onChange = options?.onChange;
-	}
-	emit(type, path, entryType) {
-		if (this.onChange) this.onChange({
-			type,
-			path,
-			entryType
-		});
-	}
-	_observe(type, payload) {
-		wsChannel.publish({
-			type,
-			name: this.host.name,
-			payload: {
-				...payload,
-				namespace: this.namespace
-			},
-			timestamp: Date.now()
-		});
-	}
-	sql(strings, ...values) {
-		let tsa = this.sqlCache.get(strings);
-		if (!tsa) {
-			const replaced = strings.map((s) => s.replace(/__TABLE__/g, this.tableName).replace(/__INDEX__/g, this.indexName));
-			tsa = Object.assign(replaced, { raw: replaced });
-			this.sqlCache.set(strings, tsa);
-		}
-		return this.host.sql(tsa, ...values);
-	}
-	ensureInit() {
-		if (this.initialized) return;
-		this.initialized = true;
-		this.sql`
-      CREATE TABLE IF NOT EXISTS __TABLE__ (
-        path            TEXT PRIMARY KEY,
-        parent_path     TEXT NOT NULL,
-        name            TEXT NOT NULL,
-        type            TEXT NOT NULL CHECK(type IN ('file','directory','symlink')),
-        mime_type       TEXT NOT NULL DEFAULT 'text/plain',
-        size            INTEGER NOT NULL DEFAULT 0,
-        storage_backend TEXT NOT NULL DEFAULT 'inline' CHECK(storage_backend IN ('inline','r2')),
-        r2_key          TEXT,
-        target          TEXT,
-        content_encoding TEXT NOT NULL DEFAULT 'utf8',
-        content         TEXT,
-        created_at      INTEGER NOT NULL DEFAULT (unixepoch()),
-        modified_at     INTEGER NOT NULL DEFAULT (unixepoch())
-      )
-    `;
-		this.sql`
-      CREATE INDEX IF NOT EXISTS __INDEX__
-        ON __TABLE__(parent_path)
-    `;
-		if ((this.sql`
-        SELECT COUNT(*) AS cnt FROM __TABLE__ WHERE path = '/'
-      `[0]?.cnt ?? 0) === 0) {
-			const now = Math.floor(Date.now() / 1e3);
-			this.sql`
-        INSERT INTO __TABLE__
-          (path, parent_path, name, type, size, created_at, modified_at)
-        VALUES ('/', '', '', 'directory', 0, ${now}, ${now})
-      `;
-		}
-	}
-	getR2() {
-		return this.r2;
-	}
-	resolveR2Prefix() {
-		if (this.r2Prefix !== void 0) return this.r2Prefix;
-		const name = this.host.name;
-		if (!name) throw new Error("[Workspace] R2 is configured but no r2Prefix was provided and host.name is not available. Either pass r2Prefix in WorkspaceOptions or ensure the host exposes a name property.");
-		return name;
-	}
-	r2Key(filePath) {
-		return `${this.resolveR2Prefix()}/${this.namespace}${filePath}`;
-	}
-	resolveSymlink(path, depth = 0) {
-		if (depth > MAX_SYMLINK_DEPTH) throw new Error(`ELOOP: too many levels of symbolic links: ${path}`);
-		const r = this.sql`
-      SELECT type, target FROM __TABLE__ WHERE path = ${path}
-    `[0];
-		if (!r || r.type !== "symlink" || !r.target) return path;
-		const resolved = r.target.startsWith("/") ? normalizePath(r.target) : normalizePath(getParent(path) + "/" + r.target);
-		return this.resolveSymlink(resolved, depth + 1);
-	}
-	symlink(target, linkPath) {
-		this.ensureInit();
-		if (!target || target.trim().length === 0) throw new Error("EINVAL: symlink target must not be empty");
-		if (target.length > MAX_SYMLINK_TARGET_LENGTH) throw new Error(`ENAMETOOLONG: symlink target exceeds ${MAX_SYMLINK_TARGET_LENGTH} characters`);
-		const normalized = normalizePath(linkPath);
-		if (normalized === "/") throw new Error("EPERM: cannot create symlink at root");
-		const parentPath = getParent(normalized);
-		const name = getBasename(normalized);
-		const now = Math.floor(Date.now() / 1e3);
-		this.ensureParentDir(parentPath);
-		if (this.sql`
-      SELECT type FROM __TABLE__ WHERE path = ${normalized}
-    `[0]) throw new Error(`EEXIST: path already exists: ${linkPath}`);
-		this.sql`
-      INSERT INTO __TABLE__
-        (path, parent_path, name, type, target, size, created_at, modified_at)
-      VALUES
-        (${normalized}, ${parentPath}, ${name}, 'symlink', ${target}, 0, ${now}, ${now})
-    `;
-		this.emit("create", normalized, "symlink");
-	}
-	readlink(path) {
-		this.ensureInit();
-		const normalized = normalizePath(path);
-		const r = this.sql`
-      SELECT type, target FROM __TABLE__ WHERE path = ${normalized}
-    `[0];
-		if (!r) throw new Error(`ENOENT: no such file or directory: ${path}`);
-		if (r.type !== "symlink" || !r.target) throw new Error(`EINVAL: not a symlink: ${path}`);
-		return r.target;
-	}
-	lstat(path) {
-		this.ensureInit();
-		const normalized = normalizePath(path);
-		const r = this.sql`
-      SELECT path, name, type, mime_type, size, created_at, modified_at, target
-      FROM __TABLE__ WHERE path = ${normalized}
-    `[0];
-		if (!r) return null;
-		return toFileInfo(r);
-	}
-	stat(path) {
-		this.ensureInit();
-		const normalized = normalizePath(path);
-		const resolved = this.resolveSymlink(normalized);
-		const r = this.sql`
-      SELECT path, name, type, mime_type, size, created_at, modified_at, target
-      FROM __TABLE__ WHERE path = ${resolved}
-    `[0];
-		if (!r) return null;
-		return toFileInfo(r);
-	}
-	async readFile(path) {
-		this.ensureInit();
-		const normalized = normalizePath(path);
-		const resolved = this.resolveSymlink(normalized);
-		const r = this.sql`
-      SELECT type, storage_backend, r2_key, content, content_encoding
-      FROM __TABLE__ WHERE path = ${resolved}
-    `[0];
-		if (!r) return null;
-		if (r.type !== "file") throw new Error(`EISDIR: ${path} is a directory`);
-		this._observe("workspace:read", {
-			path: resolved,
-			storage: r.storage_backend
-		});
-		if (r.storage_backend === "r2" && r.r2_key) {
-			const r2 = this.getR2();
-			if (!r2) throw new Error(`File ${path} is stored in R2 but no R2 bucket was provided`);
-			const obj = await r2.get(r.r2_key);
-			if (!obj) return "";
-			return await obj.text();
-		}
-		if (r.content_encoding === "base64" && r.content) {
-			const bytes = base64ToBytes(r.content);
-			return TEXT_DECODER.decode(bytes);
-		}
-		return r.content ?? "";
-	}
-	async readFileBytes(path) {
-		this.ensureInit();
-		const normalized = normalizePath(path);
-		const resolved = this.resolveSymlink(normalized);
-		const r = this.sql`
-      SELECT type, storage_backend, r2_key, content, content_encoding
-      FROM __TABLE__ WHERE path = ${resolved}
-    `[0];
-		if (!r) return null;
-		if (r.type !== "file") throw new Error(`EISDIR: ${path} is a directory`);
-		this._observe("workspace:read", {
-			path: resolved,
-			storage: r.storage_backend
-		});
-		if (r.storage_backend === "r2" && r.r2_key) {
-			const r2 = this.getR2();
-			if (!r2) throw new Error(`File ${path} is stored in R2 but no R2 bucket was provided`);
-			const obj = await r2.get(r.r2_key);
-			if (!obj) return new Uint8Array(0);
-			return new Uint8Array(await obj.arrayBuffer());
-		}
-		if (r.content_encoding === "base64" && r.content) return base64ToBytes(r.content);
-		return TEXT_ENCODER.encode(r.content ?? "");
-	}
-	async writeFileBytes(path, data, mimeType = "application/octet-stream") {
-		this.ensureInit();
-		const normalized = this.resolveSymlink(normalizePath(path));
-		if (normalized === "/") throw new Error("EISDIR: cannot write to root directory");
-		const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
-		const size = bytes.byteLength;
-		const parentPath = getParent(normalized);
-		const name = getBasename(normalized);
-		const now = Math.floor(Date.now() / 1e3);
-		this.ensureParentDir(parentPath);
-		const existing = this.sql`
-      SELECT storage_backend, r2_key FROM __TABLE__ WHERE path = ${normalized}
-    `[0];
-		const r2 = this.getR2();
-		if (size >= this.threshold && r2) {
-			const key = this.r2Key(normalized);
-			if (existing?.storage_backend === "r2" && existing.r2_key !== key) await r2.delete(existing.r2_key);
-			await r2.put(key, bytes, { httpMetadata: { contentType: mimeType } });
-			try {
-				this.sql`
-          INSERT INTO __TABLE__
-            (path, parent_path, name, type, mime_type, size,
-             storage_backend, r2_key, content_encoding, content, created_at, modified_at)
-          VALUES
-            (${normalized}, ${parentPath}, ${name}, 'file', ${mimeType}, ${size},
-             'r2', ${key}, 'base64', NULL, ${now}, ${now})
-          ON CONFLICT(path) DO UPDATE SET
-            mime_type         = excluded.mime_type,
-            size              = excluded.size,
-            storage_backend   = 'r2',
-            r2_key            = excluded.r2_key,
-            content_encoding  = 'base64',
-            content           = NULL,
-            modified_at       = excluded.modified_at
-        `;
-			} catch (sqlErr) {
-				try {
-					await r2.delete(key);
-				} catch {
-					console.error(`[Workspace] Failed to clean up orphaned R2 object ${key} after SQL error`);
-				}
-				throw sqlErr;
-			}
-			this.emit(existing ? "update" : "create", normalized, "file");
-			this._observe("workspace:write", {
-				path: normalized,
-				size,
-				storage: "r2",
-				update: !!existing
-			});
-		} else {
-			if (size >= this.threshold && !r2) console.warn(`[Workspace] File ${path} is ${size} bytes but no R2 bucket was provided. Storing inline.`);
-			if (existing?.storage_backend === "r2" && existing.r2_key && r2) await r2.delete(existing.r2_key);
-			const b64 = bytesToBase64(bytes);
-			this.sql`
-        INSERT INTO __TABLE__
-          (path, parent_path, name, type, mime_type, size,
-           storage_backend, r2_key, content_encoding, content, created_at, modified_at)
-        VALUES
-          (${normalized}, ${parentPath}, ${name}, 'file', ${mimeType}, ${size},
-           'inline', NULL, 'base64', ${b64}, ${now}, ${now})
-        ON CONFLICT(path) DO UPDATE SET
-          mime_type         = excluded.mime_type,
-          size              = excluded.size,
-          storage_backend   = 'inline',
-          r2_key            = NULL,
-          content_encoding  = 'base64',
-          content           = excluded.content,
-          modified_at       = excluded.modified_at
-      `;
-			this.emit(existing ? "update" : "create", normalized, "file");
-			this._observe("workspace:write", {
-				path: normalized,
-				size,
-				storage: "inline",
-				update: !!existing
-			});
-		}
-	}
-	async writeFile(path, content, mimeType = "text/plain") {
-		this.ensureInit();
-		const normalized = this.resolveSymlink(normalizePath(path));
-		if (normalized === "/") throw new Error("EISDIR: cannot write to root directory");
-		const parentPath = getParent(normalized);
-		const name = getBasename(normalized);
-		const bytes = TEXT_ENCODER.encode(content);
-		const size = bytes.byteLength;
-		const now = Math.floor(Date.now() / 1e3);
-		this.ensureParentDir(parentPath);
-		const existing = this.sql`
-      SELECT storage_backend, r2_key FROM __TABLE__ WHERE path = ${normalized}
-    `[0];
-		const r2 = this.getR2();
-		if (size >= this.threshold && r2) {
-			const key = this.r2Key(normalized);
-			if (existing?.storage_backend === "r2" && existing.r2_key !== key) await r2.delete(existing.r2_key);
-			await r2.put(key, bytes, { httpMetadata: { contentType: mimeType } });
-			try {
-				this.sql`
-          INSERT INTO __TABLE__
-            (path, parent_path, name, type, mime_type, size,
-             storage_backend, r2_key, content_encoding, content, created_at, modified_at)
-          VALUES
-            (${normalized}, ${parentPath}, ${name}, 'file', ${mimeType}, ${size},
-             'r2', ${key}, 'utf8', NULL, ${now}, ${now})
-          ON CONFLICT(path) DO UPDATE SET
-            mime_type         = excluded.mime_type,
-            size              = excluded.size,
-            storage_backend   = 'r2',
-            r2_key            = excluded.r2_key,
-            content_encoding  = 'utf8',
-            content           = NULL,
-            modified_at       = excluded.modified_at
-        `;
-			} catch (sqlErr) {
-				try {
-					await r2.delete(key);
-				} catch {
-					console.error(`[Workspace] Failed to clean up orphaned R2 object ${key} after SQL error`);
-				}
-				throw sqlErr;
-			}
-			this.emit(existing ? "update" : "create", normalized, "file");
-			this._observe("workspace:write", {
-				path: normalized,
-				size,
-				storage: "r2",
-				update: !!existing
-			});
-		} else {
-			if (size >= this.threshold && !r2) console.warn(`[Workspace] File ${path} is ${size} bytes but no R2 bucket was provided. Storing inline — this may hit SQLite row limits for very large files.`);
-			if (existing?.storage_backend === "r2" && existing.r2_key && r2) await r2.delete(existing.r2_key);
-			this.sql`
-        INSERT INTO __TABLE__
-          (path, parent_path, name, type, mime_type, size,
-           storage_backend, r2_key, content_encoding, content, created_at, modified_at)
-        VALUES
-          (${normalized}, ${parentPath}, ${name}, 'file', ${mimeType}, ${size},
-           'inline', NULL, 'utf8', ${content}, ${now}, ${now})
-        ON CONFLICT(path) DO UPDATE SET
-          mime_type         = excluded.mime_type,
-          size              = excluded.size,
-          storage_backend   = 'inline',
-          r2_key            = NULL,
-          content_encoding  = 'utf8',
-          content           = excluded.content,
-          modified_at       = excluded.modified_at
-      `;
-			this.emit(existing ? "update" : "create", normalized, "file");
-			this._observe("workspace:write", {
-				path: normalized,
-				size,
-				storage: "inline",
-				update: !!existing
-			});
-		}
-	}
-	async readFileStream(path) {
-		this.ensureInit();
-		const normalized = normalizePath(path);
-		const resolved = this.resolveSymlink(normalized);
-		const r = this.sql`
-      SELECT type, storage_backend, r2_key, content, content_encoding
-      FROM __TABLE__ WHERE path = ${resolved}
-    `[0];
-		if (!r) return null;
-		if (r.type !== "file") throw new Error(`EISDIR: ${path} is a directory`);
-		this._observe("workspace:read", {
-			path: resolved,
-			storage: r.storage_backend
-		});
-		if (r.storage_backend === "r2" && r.r2_key) {
-			const r2 = this.getR2();
-			if (!r2) throw new Error(`File ${path} is stored in R2 but no R2 bucket was provided`);
-			const obj = await r2.get(r.r2_key);
-			if (!obj) return new ReadableStream({ start(c) {
-				c.close();
-			} });
-			return obj.body;
-		}
-		const bytes = r.content_encoding === "base64" && r.content ? base64ToBytes(r.content) : TEXT_ENCODER.encode(r.content ?? "");
-		return new ReadableStream({ start(controller) {
-			controller.enqueue(bytes);
-			controller.close();
-		} });
-	}
-	async writeFileStream(path, stream, mimeType = "application/octet-stream") {
-		const reader = stream.getReader();
-		const chunks = [];
-		let totalSize = 0;
-		for (;;) {
-			const { done, value } = await reader.read();
-			if (done) break;
-			totalSize += value.byteLength;
-			if (totalSize > MAX_STREAM_SIZE) {
-				reader.cancel();
-				throw new Error(`EFBIG: stream exceeds maximum size of ${MAX_STREAM_SIZE} bytes`);
-			}
-			chunks.push(value);
-		}
-		const buffer = new Uint8Array(totalSize);
-		let offset = 0;
-		for (const chunk of chunks) {
-			buffer.set(chunk, offset);
-			offset += chunk.byteLength;
-		}
-		await this.writeFileBytes(path, buffer, mimeType);
-	}
-	async appendFile(path, content, mimeType = "text/plain") {
-		this.ensureInit();
-		const normalized = this.resolveSymlink(normalizePath(path));
-		const row = this.sql`
-      SELECT type, storage_backend, content_encoding
-      FROM __TABLE__ WHERE path = ${normalized}
-    `[0];
-		if (!row) {
-			await this.writeFile(path, content, mimeType);
-			return;
-		}
-		if (row.type !== "file") throw new Error(`EISDIR: ${path} is a directory`);
-		if (row.storage_backend === "inline" && row.content_encoding === "utf8") {
-			const appendSize = TEXT_ENCODER.encode(content).byteLength;
-			const now = Math.floor(Date.now() / 1e3);
-			this.sql`
-        UPDATE __TABLE__ SET
-          content = content || ${content},
-          size = size + ${appendSize},
-          modified_at = ${now}
-        WHERE path = ${normalized}
-      `;
-			this.emit("update", normalized, "file");
-			return;
-		}
-		const existing = await this.readFile(path);
-		await this.writeFile(path, (existing ?? "") + content, mimeType);
-	}
-	async deleteFile(path) {
-		this.ensureInit();
-		const normalized = normalizePath(path);
-		const rows = this.sql`
-      SELECT type, storage_backend, r2_key FROM __TABLE__ WHERE path = ${normalized}
-    `;
-		if (!rows[0]) return false;
-		if (rows[0].type === "directory") throw new Error(`EISDIR: ${path} is a directory — use rm() instead`);
-		if (rows[0].storage_backend === "r2" && rows[0].r2_key) {
-			const r2 = this.getR2();
-			if (r2) await r2.delete(rows[0].r2_key);
-		}
-		this.sql`DELETE FROM __TABLE__ WHERE path = ${normalized}`;
-		this.emit("delete", normalized, rows[0].type);
-		this._observe("workspace:delete", { path: normalized });
-		return true;
-	}
-	fileExists(path) {
-		this.ensureInit();
-		const resolved = this.resolveSymlink(normalizePath(path));
-		const rows = this.sql`
-      SELECT type FROM __TABLE__ WHERE path = ${resolved}
-    `;
-		return rows.length > 0 && rows[0].type === "file";
-	}
-	exists(path) {
-		this.ensureInit();
-		const normalized = normalizePath(path);
-		return (this.sql`
-      SELECT COUNT(*) AS cnt FROM __TABLE__ WHERE path = ${normalized}
-    `[0]?.cnt ?? 0) > 0;
-	}
-	readDir(dir = "/", opts) {
-		this.ensureInit();
-		const normalized = normalizePath(dir);
-		const limit = opts?.limit ?? 1e3;
-		const offset = opts?.offset ?? 0;
-		return this.sql`
-      SELECT path, name, type, mime_type, size, created_at, modified_at
-      FROM __TABLE__
-      WHERE parent_path = ${normalized}
-      ORDER BY type ASC, name ASC
-      LIMIT ${limit} OFFSET ${offset}
-    `.map(toFileInfo);
-	}
-	glob(pattern) {
-		this.ensureInit();
-		const normalized = normalizePath(pattern);
-		const likePattern = escapeLike(getGlobPrefix(normalized)) + "%";
-		const regex = globToRegex(normalized);
-		return this.sql`
-      SELECT path, name, type, mime_type, size, created_at, modified_at, target
-      FROM __TABLE__
-      WHERE path LIKE ${likePattern} ESCAPE ${LIKE_ESCAPE}
-      ORDER BY path
-    `.filter((r) => regex.test(r.path)).map(toFileInfo);
-	}
-	mkdir(path, opts, _depth = 0) {
-		this.ensureInit();
-		if (_depth > MAX_MKDIR_DEPTH) throw new Error(`ELOOP: mkdir recursion too deep (max ${MAX_MKDIR_DEPTH} levels)`);
-		const normalized = normalizePath(path);
-		if (normalized === "/") return;
-		const existing = this.sql`
-      SELECT type FROM __TABLE__ WHERE path = ${normalized}
-    `;
-		if (existing.length > 0) {
-			if (existing[0].type === "directory" && opts?.recursive) return;
-			throw new Error(existing[0].type === "directory" ? `EEXIST: directory already exists: ${path}` : `EEXIST: path exists as a file: ${path}`);
-		}
-		const parentPath = getParent(normalized);
-		const parentRows = this.sql`
-      SELECT type FROM __TABLE__ WHERE path = ${parentPath}
-    `;
-		if (!parentRows[0]) if (opts?.recursive) this.mkdir(parentPath, { recursive: true }, _depth + 1);
-		else throw new Error(`ENOENT: parent directory not found: ${parentPath}`);
-		else if (parentRows[0].type !== "directory") throw new Error(`ENOTDIR: parent is not a directory: ${parentPath}`);
-		const name = getBasename(normalized);
-		const now = Math.floor(Date.now() / 1e3);
-		this.sql`
-      INSERT INTO __TABLE__
-        (path, parent_path, name, type, size, created_at, modified_at)
-      VALUES (${normalized}, ${parentPath}, ${name}, 'directory', 0, ${now}, ${now})
-    `;
-		this.emit("create", normalized, "directory");
-		this._observe("workspace:mkdir", {
-			path: normalized,
-			recursive: !!opts?.recursive
-		});
-	}
-	async rm(path, opts) {
-		this.ensureInit();
-		const normalized = normalizePath(path);
-		if (normalized === "/") throw new Error("EPERM: cannot remove root directory");
-		const rows = this.sql`
-      SELECT type FROM __TABLE__ WHERE path = ${normalized}
-    `;
-		if (!rows[0]) {
-			if (opts?.force) return;
-			throw new Error(`ENOENT: no such file or directory: ${path}`);
-		}
-		if (rows[0].type === "directory") {
-			if ((this.sql`
-        SELECT COUNT(*) AS cnt FROM __TABLE__ WHERE parent_path = ${normalized}
-      `[0]?.cnt ?? 0) > 0) {
-				if (!opts?.recursive) throw new Error(`ENOTEMPTY: directory not empty: ${path}`);
-				await this.deleteDescendants(normalized);
-			}
-		} else {
-			const fileRow = this.sql`
-        SELECT storage_backend, r2_key FROM __TABLE__ WHERE path = ${normalized}
-      `[0];
-			if (fileRow?.storage_backend === "r2" && fileRow.r2_key) {
-				const r2 = this.getR2();
-				if (r2) await r2.delete(fileRow.r2_key);
-			}
-		}
-		this.sql`DELETE FROM __TABLE__ WHERE path = ${normalized}`;
-		this.emit("delete", normalized, rows[0].type);
-		this._observe("workspace:rm", {
-			path: normalized,
-			recursive: !!opts?.recursive
-		});
-	}
-	async cp(src, dest, opts) {
-		this.ensureInit();
-		const srcNorm = normalizePath(src);
-		const destNorm = normalizePath(dest);
-		const srcStat = this.lstat(srcNorm);
-		if (!srcStat) throw new Error(`ENOENT: no such file or directory: ${src}`);
-		if (srcStat.type === "symlink") {
-			const target = this.readlink(srcNorm);
-			this.symlink(target, destNorm);
-			return;
-		}
-		if (srcStat.type === "directory") {
-			if (!opts?.recursive) throw new Error(`EISDIR: cannot copy directory without recursive: ${src}`);
-			this.mkdir(destNorm, { recursive: true });
-			for (const child of this.readDir(srcNorm)) await this.cp(child.path, `${destNorm}/${child.name}`, opts);
-			return;
-		}
-		const bytes = await this.readFileBytes(srcNorm);
-		if (bytes) await this.writeFileBytes(destNorm, bytes, srcStat.mimeType);
-		else await this.writeFile(destNorm, "", srcStat.mimeType);
-		this._observe("workspace:cp", {
-			src: srcNorm,
-			dest: destNorm,
-			recursive: !!opts?.recursive
-		});
-	}
-	async mv(src, dest, opts) {
-		this.ensureInit();
-		const srcNorm = normalizePath(src);
-		const destNorm = normalizePath(dest);
-		const srcStat = this.lstat(srcNorm);
-		if (!srcStat) throw new Error(`ENOENT: no such file or directory: ${src}`);
-		if (srcStat.type === "directory") {
-			if (!(opts?.recursive ?? true)) throw new Error(`EISDIR: cannot move directory without recursive: ${src}`);
-			await this.cp(src, dest, { recursive: true });
-			await this.rm(src, {
-				recursive: true,
-				force: true
-			});
-			return;
-		}
-		const destParent = getParent(destNorm);
-		const destName = getBasename(destNorm);
-		this.ensureParentDir(destParent);
-		const existingDest = this.sql`
-      SELECT type FROM __TABLE__ WHERE path = ${destNorm}
-    `[0];
-		if (existingDest) {
-			if (existingDest.type === "directory") throw new Error(`EISDIR: cannot overwrite directory: ${dest}`);
-			await this.deleteFile(destNorm);
-		}
-		if (srcStat.type === "file") {
-			const row = this.sql`
-        SELECT storage_backend, r2_key FROM __TABLE__ WHERE path = ${srcNorm}
-      `[0];
-			if (row?.storage_backend === "r2" && row.r2_key) {
-				const r2 = this.getR2();
-				if (r2) {
-					const newKey = this.r2Key(destNorm);
-					const obj = await r2.get(row.r2_key);
-					if (obj) await r2.put(newKey, await obj.arrayBuffer(), { httpMetadata: obj.httpMetadata });
-					await r2.delete(row.r2_key);
-					const now = Math.floor(Date.now() / 1e3);
-					this.sql`
-            UPDATE __TABLE__ SET
-              path = ${destNorm},
-              parent_path = ${destParent},
-              name = ${destName},
-              r2_key = ${newKey},
-              modified_at = ${now}
-            WHERE path = ${srcNorm}
-          `;
-					this.emit("delete", srcNorm, "file");
-					this.emit("create", destNorm, "file");
-					this._observe("workspace:mv", {
-						src: srcNorm,
-						dest: destNorm
-					});
-					return;
-				}
-			}
-		}
-		const now = Math.floor(Date.now() / 1e3);
-		this.sql`
-      UPDATE __TABLE__ SET
-        path = ${destNorm},
-        parent_path = ${destParent},
-        name = ${destName},
-        modified_at = ${now}
-      WHERE path = ${srcNorm}
-    `;
-		this.emit("delete", srcNorm, srcStat.type);
-		this.emit("create", destNorm, srcStat.type);
-		this._observe("workspace:mv", {
-			src: srcNorm,
-			dest: destNorm
-		});
-	}
-	async diff(pathA, pathB) {
-		const contentA = await this.readFile(pathA);
-		if (contentA === null) throw new Error(`ENOENT: no such file: ${pathA}`);
-		const contentB = await this.readFile(pathB);
-		if (contentB === null) throw new Error(`ENOENT: no such file: ${pathB}`);
-		const linesA = contentA.split("\n").length;
-		const linesB = contentB.split("\n").length;
-		if (linesA > MAX_DIFF_LINES || linesB > MAX_DIFF_LINES) throw new Error(`EFBIG: files too large for diff (max ${MAX_DIFF_LINES} lines)`);
-		return unifiedDiff(contentA, contentB, normalizePath(pathA), normalizePath(pathB));
-	}
-	async diffContent(path, newContent) {
-		const existing = await this.readFile(path);
-		if (existing === null) throw new Error(`ENOENT: no such file: ${path}`);
-		const linesA = existing.split("\n").length;
-		const linesB = newContent.split("\n").length;
-		if (linesA > MAX_DIFF_LINES || linesB > MAX_DIFF_LINES) throw new Error(`EFBIG: content too large for diff (max ${MAX_DIFF_LINES} lines)`);
-		const normalized = normalizePath(path);
-		return unifiedDiff(existing, newContent, normalized, normalized);
-	}
-	_resolveBashConfig(options) {
-		const commands = options?.commands ? [...this.commands, ...options.commands] : this.commands.length > 0 ? this.commands : void 0;
-		const hasWsEnv = Object.keys(this.env).length > 0;
-		return {
-			commands,
-			env: options?.env && hasWsEnv ? {
-				...this.env,
-				...options.env
-			} : options?.env ?? (hasWsEnv ? this.env : void 0),
-			network: options?.network ?? this.network
-		};
-	}
-	async bash(command, options) {
-		this.ensureInit();
-		const { commands, env, network } = this._resolveBashConfig(options);
-		const bashInstance = new Shell({
-			fs: new WorkspaceFileSystem(this),
-			cwd: options?.cwd ?? "/",
-			executionLimits: this.bashLimits,
-			customCommands: commands,
-			env,
-			network
-		});
-		const t0 = Date.now();
-		const result = await bashInstance.exec(command);
-		this._observe("workspace:bash", {
-			command,
-			exitCode: result.exitCode,
-			durationMs: Date.now() - t0
-		});
-		return {
-			stdout: result.stdout,
-			stderr: result.stderr,
-			exitCode: result.exitCode
-		};
-	}
-	createBashSession(options) {
-		this.ensureInit();
-		const { commands, env, network } = this._resolveBashConfig(options);
-		return new BashSession({
-			ws: this,
-			fs: new WorkspaceFileSystem(this),
-			bashLimits: this.bashLimits,
-			commands,
-			env: env ? { ...env } : {},
-			network,
-			cwd: options?.cwd ?? "/",
-			observe: this._observe.bind(this)
-		});
-	}
-	getWorkspaceInfo() {
-		this.ensureInit();
-		const rows = this.sql`
-      SELECT
-        SUM(CASE WHEN type = 'file'                               THEN 1 ELSE 0 END) AS files,
-        SUM(CASE WHEN type = 'directory'                          THEN 1 ELSE 0 END) AS dirs,
-        COALESCE(SUM(CASE WHEN type = 'file' THEN size ELSE 0 END), 0)               AS total,
-        SUM(CASE WHEN type = 'file' AND storage_backend = 'r2'   THEN 1 ELSE 0 END) AS r2files
-      FROM __TABLE__
-    `;
-		return {
-			fileCount: rows[0]?.files ?? 0,
-			directoryCount: rows[0]?.dirs ?? 0,
-			totalBytes: rows[0]?.total ?? 0,
-			r2FileCount: rows[0]?.r2files ?? 0
-		};
-	}
-	/** @internal */
-	_getAllPaths() {
-		this.ensureInit();
-		return this.sql`
-      SELECT path FROM __TABLE__ ORDER BY path
-    `.map((r) => r.path);
-	}
-	/** @internal */
-	_updateModifiedAt(path, mtime) {
-		this.ensureInit();
-		const normalized = normalizePath(path);
-		const ts = Math.floor(mtime.getTime() / 1e3);
-		this.sql`
-      UPDATE __TABLE__ SET modified_at = ${ts} WHERE path = ${normalized}
-    `;
-	}
-	ensureParentDir(dirPath) {
-		if (!dirPath || dirPath === "/") return;
-		const rows = this.sql`
-      SELECT type FROM __TABLE__ WHERE path = ${dirPath}
-    `;
-		if (rows[0]) {
-			if (rows[0].type !== "directory") throw new Error(`ENOTDIR: ${dirPath} is not a directory`);
-			return;
-		}
-		const missing = [dirPath];
-		let current = getParent(dirPath);
-		while (current && current !== "/") {
-			const r = this.sql`
-        SELECT type FROM __TABLE__ WHERE path = ${current}
-      `;
-			if (r[0]) {
-				if (r[0].type !== "directory") throw new Error(`ENOTDIR: ${current} is not a directory`);
-				break;
-			}
-			missing.push(current);
-			current = getParent(current);
-		}
-		const now = Math.floor(Date.now() / 1e3);
-		for (let i = missing.length - 1; i >= 0; i--) {
-			const p = missing[i];
-			const parentPath = getParent(p);
-			const name = getBasename(p);
-			this.sql`
-        INSERT INTO __TABLE__
-          (path, parent_path, name, type, size, created_at, modified_at)
-        VALUES (${p}, ${parentPath}, ${name}, 'directory', 0, ${now}, ${now})
-      `;
-			this.emit("create", p, "directory");
-		}
-	}
-	async deleteDescendants(dirPath) {
-		const pattern = escapeLike(dirPath) + "/%";
-		const r2Rows = this.sql`
-      SELECT r2_key FROM __TABLE__
-      WHERE path LIKE ${pattern} ESCAPE ${LIKE_ESCAPE}
-        AND storage_backend = 'r2'
-        AND r2_key IS NOT NULL
-    `;
-		if (r2Rows.length > 0) {
-			const r2 = this.getR2();
-			if (r2) {
-				const keys = r2Rows.map((r) => r.r2_key);
-				await r2.delete(keys);
-			}
-		}
-		this.sql`DELETE FROM __TABLE__ WHERE path LIKE ${pattern} ESCAPE ${LIKE_ESCAPE}`;
-	}
-};
-_Symbol$dispose = Symbol.dispose;
-var BashSession = class {
-	/** @internal — use workspace.createBashSession() instead */
-	constructor(init) {
-		this._closed = false;
-		this._ws = init.ws;
-		this._fs = init.fs;
-		this._bashLimits = init.bashLimits;
-		this._customCommands = init.commands;
-		this._networkConfig = init.network;
-		this._observe = init.observe;
-		this._currentCwd = init.cwd;
-		this._currentEnv = init.env;
-	}
-	async exec(command) {
-		if (this._closed) throw new Error("BashSession is closed");
-		const bash = new Shell({
-			fs: this._fs,
-			cwd: this._currentCwd,
-			env: Object.keys(this._currentEnv).length > 0 ? this._currentEnv : void 0,
-			executionLimits: this._bashLimits,
-			customCommands: this._customCommands,
-			network: this._networkConfig
-		});
-		const wrapped = `${command}\n__sess_rc=$?\necho "${SESS_STATE_BEGIN}"\necho "${SESS_CWD_PREFIX}$(pwd)"\nenv\necho "${SESS_STATE_END}"\nexit $__sess_rc`;
-		const t0 = Date.now();
-		const result = await bash.exec(wrapped);
-		let stdout = result.stdout;
-		const beginIdx = stdout.lastIndexOf(SESS_STATE_BEGIN);
-		const endIdx = stdout.lastIndexOf(SESS_STATE_END);
-		if (beginIdx >= 0 && endIdx > beginIdx) {
-			const lines = stdout.slice(beginIdx + 27 + 1, endIdx).split("\n");
-			const newEnv = {};
-			for (const line of lines) if (line.startsWith(SESS_CWD_PREFIX)) {
-				const cwd = line.slice(13).trim();
-				if (cwd) this._currentCwd = cwd;
-			} else if (line.includes("=")) {
-				const eqIdx = line.indexOf("=");
-				const key = line.slice(0, eqIdx);
-				const value = line.slice(eqIdx + 1);
-				if (key && key !== "__sess_rc") newEnv[key] = value;
-			}
-			if (Object.keys(newEnv).length > 0) this._currentEnv = newEnv;
-			let cutStart = beginIdx;
-			if (cutStart > 0 && stdout[cutStart - 1] === "\n") cutStart--;
-			stdout = stdout.slice(0, cutStart);
-		}
-		this._observe("workspace:bash", {
-			command,
-			exitCode: result.exitCode,
-			durationMs: Date.now() - t0,
-			session: true
-		});
-		return {
-			stdout,
-			stderr: result.stderr,
-			exitCode: result.exitCode
-		};
-	}
-	get cwd() {
-		return this._currentCwd;
-	}
-	get env() {
-		return { ...this._currentEnv };
-	}
-	get isClosed() {
-		return this._closed;
-	}
-	close() {
-		this._closed = true;
-	}
-	[_Symbol$dispose]() {
-		this.close();
-	}
-};
-function fileContentToString(content) {
-	return typeof content === "string" ? content : TEXT_DECODER.decode(content);
-}
-var WorkspaceFileSystem = class {
-	constructor(ws) {
-		this.ws = ws;
-	}
-	async readFile(path, _options) {
-		const content = await this.ws.readFile(path);
-		if (content === null) throw Object.assign(/* @__PURE__ */ new Error(`ENOENT: ${path}`), { code: "ENOENT" });
-		return content;
-	}
-	async readFileBuffer(path) {
-		const bytes = await this.ws.readFileBytes(path);
-		if (bytes === null) throw Object.assign(/* @__PURE__ */ new Error(`ENOENT: ${path}`), { code: "ENOENT" });
-		return bytes;
-	}
-	async writeFile(path, content, _options) {
-		if (typeof content === "string") await this.ws.writeFile(path, content);
-		else await this.ws.writeFileBytes(path, content);
-	}
-	async appendFile(path, content, _options) {
-		await this.ws.appendFile(path, fileContentToString(content));
-	}
-	async exists(path) {
-		return this.ws.stat(path) !== null;
-	}
-	async stat(path) {
-		const s = this.ws.stat(path);
-		if (!s) throw Object.assign(/* @__PURE__ */ new Error(`ENOENT: ${path}`), { code: "ENOENT" });
-		return {
-			isFile: s.type === "file",
-			isDirectory: s.type === "directory",
-			isSymbolicLink: false,
-			mode: s.type === "directory" ? 493 : 420,
-			size: s.size,
-			mtime: new Date(s.updatedAt)
-		};
-	}
-	async lstat(path) {
-		const s = this.ws.lstat(path);
-		if (!s) throw Object.assign(/* @__PURE__ */ new Error(`ENOENT: ${path}`), { code: "ENOENT" });
-		return {
-			isFile: s.type === "file",
-			isDirectory: s.type === "directory",
-			isSymbolicLink: s.type === "symlink",
-			mode: s.type === "directory" ? 493 : 420,
-			size: s.size,
-			mtime: new Date(s.updatedAt)
-		};
-	}
-	async mkdir(path, options) {
-		this.ws.mkdir(path, options);
-	}
-	async readdir(path) {
-		return this.ws.readDir(path).map((e) => e.name);
-	}
-	async readdirWithFileTypes(path) {
-		return this.ws.readDir(path).map((e) => ({
-			name: e.name,
-			isFile: e.type === "file",
-			isDirectory: e.type === "directory",
-			isSymbolicLink: e.type === "symlink"
-		}));
-	}
-	async rm(path, options) {
-		await this.ws.rm(path, options);
-	}
-	async cp(src, dest, options) {
-		await this.ws.cp(src, dest, options);
-	}
-	async mv(src, dest) {
-		await this.ws.mv(src, dest);
-	}
-	resolvePath(base, path) {
-		const parts = (path.startsWith("/") ? path : `${base}/${path}`).split("/").filter(Boolean);
-		const resolved = [];
-		for (const part of parts) if (part === "..") resolved.pop();
-		else if (part !== ".") resolved.push(part);
-		return "/" + resolved.join("/");
-	}
-	getAllPaths() {
-		return this.ws._getAllPaths();
-	}
-	async chmod(_path, _mode) {}
-	async symlink(target, linkPath) {
-		this.ws.symlink(target, linkPath);
-	}
-	async link(_existingPath, _newPath) {
-		throw new Error("ENOSYS: hard links not supported in workspace filesystem");
-	}
-	async readlink(path) {
-		return this.ws.readlink(path);
-	}
-	async realpath(path) {
-		const normalized = normalizePath(path);
-		const s = this.ws.lstat(normalized);
-		if (!s) throw Object.assign(/* @__PURE__ */ new Error(`ENOENT: ${path}`), { code: "ENOENT" });
-		if (s.type === "symlink") {
-			const target = this.ws.readlink(normalized);
-			const resolved = target.startsWith("/") ? normalizePath(target) : normalizePath(getParent(normalized) + "/" + target);
-			return this.realpath(resolved);
-		}
-		return normalized;
-	}
-	async utimes(_path, _atime, mtime) {
-		this.ws._updateModifiedAt(_path, mtime);
-	}
-};
-function bytesToBase64(bytes) {
-	const CHUNK = 8192;
-	let binary = "";
-	for (let i = 0; i < bytes.byteLength; i += CHUNK) binary += String.fromCharCode(...bytes.subarray(i, Math.min(i + CHUNK, bytes.byteLength)));
-	return btoa(binary);
-}
-function base64ToBytes(b64) {
-	const binary = atob(b64);
-	const bytes = new Uint8Array(binary.length);
-	for (let i = 0; i < binary.length; i++) bytes[i] = binary.charCodeAt(i);
-	return bytes;
-}
-function escapeLike(s) {
-	return s.replace(/[\\%_]/g, (ch) => "\\" + ch);
-}
-function normalizePath(path) {
-	if (!path.startsWith("/")) path = "/" + path;
-	const parts = path.split("/");
-	const resolved = [];
-	for (const part of parts) {
-		if (part === "" || part === ".") continue;
-		if (part === "..") resolved.pop();
-		else resolved.push(part);
-	}
-	const result = "/" + resolved.join("/");
-	if (result.length > MAX_PATH_LENGTH) throw new Error(`ENAMETOOLONG: path exceeds ${MAX_PATH_LENGTH} characters`);
-	return result;
-}
-function getParent(path) {
-	const normalized = normalizePath(path);
-	if (normalized === "/") return "";
-	const lastSlash = normalized.lastIndexOf("/");
-	return lastSlash === 0 ? "/" : normalized.slice(0, lastSlash);
-}
-function getBasename(path) {
-	const normalized = normalizePath(path);
-	if (normalized === "/") return "";
-	return normalized.slice(normalized.lastIndexOf("/") + 1);
-}
-function toFileInfo(r) {
-	const info = {
-		path: r.path,
-		name: r.name,
-		type: r.type,
-		mimeType: r.mime_type,
-		size: r.size,
-		createdAt: r.created_at * 1e3,
-		updatedAt: r.modified_at * 1e3
-	};
-	if (r.target) info.target = r.target;
-	return info;
-}
-function getGlobPrefix(pattern) {
-	const first = pattern.search(/[*?[{]/);
-	if (first === -1) return pattern;
-	const before = pattern.slice(0, first);
-	const lastSlash = before.lastIndexOf("/");
-	return lastSlash >= 0 ? before.slice(0, lastSlash + 1) : "/";
-}
-function globToRegex(pattern) {
-	let i = 0;
-	let re = "^";
-	while (i < pattern.length) {
-		const ch = pattern[i];
-		if (ch === "*") if (pattern[i + 1] === "*") {
-			i += 2;
-			if (pattern[i] === "/") {
-				re += "(?:.+/)?";
-				i++;
-			} else re += ".*";
-		} else {
-			re += "[^/]*";
-			i++;
-		}
-		else if (ch === "?") {
-			re += "[^/]";
-			i++;
-		} else if (ch === "[") {
-			const close = pattern.indexOf("]", i + 1);
-			if (close === -1) {
-				re += "\\[";
-				i++;
-			} else {
-				re += pattern.slice(i, close + 1);
-				i = close + 1;
-			}
-		} else if (ch === "{") {
-			const close = pattern.indexOf("}", i + 1);
-			if (close === -1) {
-				re += "\\{";
-				i++;
-			} else {
-				const inner = pattern.slice(i + 1, close).split(",").join("|");
-				re += `(?:${inner})`;
-				i = close + 1;
-			}
-		} else {
-			re += ch.replace(/[.+^$|\\()]/g, "\\$&");
-			i++;
-		}
-	}
-	re += "$";
-	return new RegExp(re);
-}
-function unifiedDiff(a, b, labelA, labelB, contextLines = 3) {
-	if (a === b) return "";
-	const linesA = a.split("\n");
-	const linesB = b.split("\n");
-	return formatUnified(myersDiff(linesA, linesB), linesA, linesB, labelA, labelB, contextLines);
-}
-function myersDiff(a, b) {
-	const n = a.length;
-	const m = b.length;
-	const max = n + m;
-	const vSize = 2 * max + 1;
-	const v = new Int32Array(vSize);
-	v.fill(-1);
-	const offset = max;
-	v[offset + 1] = 0;
-	const trace = [];
-	outer: for (let d = 0; d <= max; d++) {
-		trace.push(v.slice());
-		for (let k = -d; k <= d; k += 2) {
-			let x;
-			if (k === -d || k !== d && v[offset + k - 1] < v[offset + k + 1]) x = v[offset + k + 1];
-			else x = v[offset + k - 1] + 1;
-			let y = x - k;
-			while (x < n && y < m && a[x] === b[y]) {
-				x++;
-				y++;
-			}
-			v[offset + k] = x;
-			if (x >= n && y >= m) break outer;
-		}
-	}
-	const edits = [];
-	let x = n;
-	let y = m;
-	for (let d = trace.length - 1; d >= 0; d--) {
-		const vPrev = trace[d];
-		const k = x - y;
-		let prevK;
-		if (k === -d || k !== d && vPrev[offset + k - 1] < vPrev[offset + k + 1]) prevK = k + 1;
-		else prevK = k - 1;
-		const prevX = vPrev[offset + prevK];
-		const prevY = prevX - prevK;
-		while (x > prevX && y > prevY) {
-			x--;
-			y--;
-			edits.push({
-				type: "keep",
-				lineA: x,
-				lineB: y
-			});
-		}
-		if (d > 0) if (x === prevX) {
-			edits.push({
-				type: "insert",
-				lineA: x,
-				lineB: y - 1
-			});
-			y--;
-		} else {
-			edits.push({
-				type: "delete",
-				lineA: x - 1,
-				lineB: y
-			});
-			x--;
-		}
-	}
-	edits.reverse();
-	return edits;
-}
-function formatUnified(edits, linesA, linesB, labelA, labelB, ctx) {
-	const out = [];
-	out.push(`--- ${labelA}`);
-	out.push(`+++ ${labelB}`);
-	const changes = [];
-	for (let i = 0; i < edits.length; i++) if (edits[i].type !== "keep") changes.push(i);
-	if (changes.length === 0) return "";
-	let i = 0;
-	while (i < changes.length) {
-		let start = Math.max(0, changes[i] - ctx);
-		let end = Math.min(edits.length - 1, changes[i] + ctx);
-		let j = i + 1;
-		while (j < changes.length && changes[j] - ctx <= end + 1) {
-			end = Math.min(edits.length - 1, changes[j] + ctx);
-			j++;
-		}
-		let startA = edits[start].lineA;
-		let startB = edits[start].lineB;
-		let countA = 0;
-		let countB = 0;
-		const hunkLines = [];
-		for (let idx = start; idx <= end; idx++) {
-			const e = edits[idx];
-			if (e.type === "keep") {
-				hunkLines.push(` ${linesA[e.lineA]}`);
-				countA++;
-				countB++;
-			} else if (e.type === "delete") {
-				hunkLines.push(`-${linesA[e.lineA]}`);
-				countA++;
-			} else {
-				hunkLines.push(`+${linesB[e.lineB]}`);
-				countB++;
-			}
-		}
-		out.push(`@@ -${startA + 1},${countA} +${startB + 1},${countB} @@`);
-		out.push(...hunkLines);
-		i = j;
-	}
-	return out.join("\n");
-}
-//#endregion
-export { BashSession, Workspace, defineCommand };
-
-//# sourceMappingURL=workspace.js.map