@orkestrel/workspace 0.0.1

package/dist/src/core/index.js

@@ -0,0 +1,946 @@
+import { arrayOf, holds, isArray, isNumber, isRecord, isString, literalOf, rawShape, stringShape } from "@orkestrel/contract";
+import { createDatabase, createMemoryDriver } from "@orkestrel/database";
+import { Emitter } from "@orkestrel/emitter";
+//#region src/core/constants.ts
+/**
+* File extensions mapped to language tags for text content.
+*
+* Unknown extensions intentionally fall back to `text` in
+* {@link import('./helpers.js').inferLanguage}.
+*/
+var EXTENSION_LANGUAGES = Object.freeze({
+	ts: "typescript",
+	tsx: "typescript",
+	js: "javascript",
+	jsx: "javascript",
+	mjs: "javascript",
+	cjs: "javascript",
+	json: "json",
+	md: "markdown",
+	html: "html",
+	htm: "html",
+	css: "css",
+	scss: "scss",
+	sass: "sass",
+	less: "less",
+	vue: "vue",
+	svelte: "svelte",
+	py: "python",
+	rb: "ruby",
+	rs: "rust",
+	go: "go",
+	java: "java",
+	kt: "kotlin",
+	swift: "swift",
+	c: "c",
+	cpp: "cpp",
+	h: "c",
+	hpp: "cpp",
+	cs: "csharp",
+	php: "php",
+	sql: "sql",
+	sh: "bash",
+	bash: "bash",
+	zsh: "bash",
+	ps1: "powershell",
+	yaml: "yaml",
+	yml: "yaml",
+	toml: "toml",
+	xml: "xml",
+	svg: "xml",
+	txt: "text"
+});
+//#endregion
+//#region src/core/errors.ts
+/** An invalid workspace edit or search operation. */
+var WorkspaceError = class extends Error {
+	code;
+	context;
+	/**
+	* Create a workspace error.
+	*
+	* @param code - The machine-readable failure code
+	* @param message - The human-readable failure message
+	* @param context - Optional values associated with the failed operation
+	*/
+	constructor(code, message, context) {
+		super(message);
+		this.name = "WorkspaceError";
+		this.code = code;
+		if (context !== void 0) this.context = context;
+	}
+};
+/**
+* Narrow a caught value to a {@link WorkspaceError}.
+*
+* @param value - The caught value
+* @returns Whether the value is a workspace error
+*
+* @example
+* ```ts
+* if (isWorkspaceError(error)) error.code
+* ```
+*/
+function isWorkspaceError(value) {
+	return value instanceof WorkspaceError;
+}
+//#endregion
+//#region src/core/helpers.ts
+/**
+* Infer a language tag from the final file extension.
+*
+* @param path - The file path
+* @returns The mapped language, or `text` when the extension is absent or unknown
+*
+* @example
+* ```ts
+* inferLanguage('src/main.ts') // 'typescript'
+* ```
+*/
+function inferLanguage(path) {
+	const dot = path.lastIndexOf(".");
+	if (dot === -1) return "text";
+	return EXTENSION_LANGUAGES[path.slice(dot + 1).toLowerCase()] ?? "text";
+}
+/**
+* Determine whether content is the text arm.
+*
+* @param content - The file content
+* @returns Whether the content carries text and a language
+*
+* @example
+* ```ts
+* isText({ text: 'hello', language: 'text' }) // true
+* ```
+*/
+function isText(content) {
+	return "text" in content;
+}
+/**
+* Determine whether content is the binary arm.
+*
+* @param content - The file content
+* @returns Whether the content carries base64 data and a MIME
+*
+* @example
+* ```ts
+* isBinary({ data: 'AAAA', mime: 'image/png' }) // true
+* ```
+*/
+function isBinary(content) {
+	return "data" in content;
+}
+/**
+* Narrow an unknown value to an immutable file record.
+*
+* @param value - The value to inspect
+* @returns Whether the value has the file shape
+*
+* @example
+* ```ts
+* isFile({ path: 'a.txt', content: { text: 'a', language: 'text' }, state: 'created', size: 1, lines: 1 })
+* ```
+*/
+function isFile(value) {
+	return holds(() => {
+		if (!isRecord(value)) return false;
+		if (!isString(value.path) || !literalOf("created", "modified")(value.state)) return false;
+		if (!isNumber(value.size) || !isNumber(value.lines)) return false;
+		if (!isRecord(value.content)) return false;
+		const text = isString(value.content.text) && isString(value.content.language);
+		const binary = isString(value.content.data) && literalOf("image/png", "image/jpeg", "image/gif", "image/webp")(value.content.mime);
+		return text || binary;
+	});
+}
+/**
+* Narrow an unknown value to a workspace snapshot.
+*
+* @param value - The value read from a persistence boundary
+* @returns Whether the value has the workspace snapshot shape
+*
+* @example
+* ```ts
+* isWorkspaceSnapshot({ id: 'work', files: [] }) // true
+* ```
+*/
+function isWorkspaceSnapshot(value) {
+	return holds(() => isRecord(value) && isString(value.id) && arrayOf(isFile)(value.files));
+}
+/**
+* Compute the byte size of file content.
+*
+* @param content - The content to measure
+* @returns UTF-8 bytes for text or decoded bytes for binary content
+*
+* @example
+* ```ts
+* computeSize({ text: 'café', language: 'text' }) // 5
+* ```
+*/
+function computeSize(content) {
+	if (isText(content)) return new TextEncoder().encode(content.text).length;
+	return decodedSize(content.data);
+}
+/**
+* Count the lines in file content.
+*
+* @param content - The content to inspect
+* @returns The text line count, or zero for empty text and binary content
+*
+* @example
+* ```ts
+* countLines({ text: 'a\nb', language: 'text' }) // 2
+* ```
+*/
+function countLines(content) {
+	if (!isText(content)) return 0;
+	if (content.text.length === 0) return 0;
+	let count = 1;
+	for (const character of content.text) if (character === "\n") count += 1;
+	return count;
+}
+/**
+* Compute the decoded byte length of a base64 string.
+*
+* @param base64 - The base64 data
+* @returns The decoded byte count
+*
+* @example
+* ```ts
+* decodedSize('AAAA') // 3
+* ```
+*/
+function decodedSize(base64) {
+	let padding = 0;
+	if (base64.endsWith("==")) padding = 2;
+	else if (base64.endsWith("=")) padding = 1;
+	return Math.floor(base64.length * 3 / 4) - padding;
+}
+/**
+* Determine whether a 1-based range is structurally valid.
+*
+* @param range - The range to inspect
+* @returns Whether both positions are positive and ordered
+*
+* @example
+* ```ts
+* isValidRange({ start: { line: 1, column: 1 }, end: { line: 1, column: 2 } }) // true
+* ```
+*/
+function isValidRange(range) {
+	if (range.start.line < 1 || range.start.column < 1) return false;
+	if (range.end.line < 1 || range.end.column < 1) return false;
+	if (range.start.line > range.end.line) return false;
+	return !(range.start.line === range.end.line && range.start.column > range.end.column);
+}
+/**
+* Clamp a position to text bounds.
+*
+* @param text - The addressed text
+* @param position - The requested position
+* @returns The clamped position
+*
+* @example
+* ```ts
+* clampPosition('ab', { line: 9, column: 9 }) // { line: 1, column: 3 }
+* ```
+*/
+function clampPosition(text, position) {
+	const lines = text.split("\n");
+	const line = Math.max(1, Math.min(position.line, lines.length));
+	const lineText = lines[line - 1] ?? "";
+	return {
+		line,
+		column: Math.max(1, Math.min(position.column, lineText.length + 1))
+	};
+}
+/**
+* Clamp both positions in a range to text bounds.
+*
+* @param text - The addressed text
+* @param range - The requested range
+* @returns The clamped range
+*
+* @example
+* ```ts
+* clampRange('ab', { start: { line: 1, column: 1 }, end: { line: 9, column: 9 } })
+* ```
+*/
+function clampRange(text, range) {
+	return {
+		start: clampPosition(text, range.start),
+		end: clampPosition(text, range.end)
+	};
+}
+/**
+* Convert a 1-based position to a zero-based string offset.
+*
+* @param text - The addressed text
+* @param position - The requested position
+* @returns The bounded string offset
+*
+* @example
+* ```ts
+* offsetAt('ab\ncd', { line: 2, column: 1 }) // 3
+* ```
+*/
+function offsetAt(text, position) {
+	const lines = text.split("\n");
+	let offset = 0;
+	for (let index = 0; index < position.line - 1 && index < lines.length; index += 1) offset += (lines[index]?.length ?? 0) + 1;
+	offset += position.column - 1;
+	return Math.min(offset, text.length);
+}
+/**
+* Slice a clamped half-open text range.
+*
+* @param text - The source text
+* @param range - The requested range
+* @returns The ranged substring
+*
+* @example
+* ```ts
+* sliceRange('hello', { start: { line: 1, column: 1 }, end: { line: 1, column: 6 } }) // 'hello'
+* ```
+*/
+function sliceRange(text, range) {
+	const clamped = clampRange(text, range);
+	return text.slice(offsetAt(text, clamped.start), offsetAt(text, clamped.end));
+}
+/**
+* Replace a clamped half-open text range.
+*
+* @param text - The source text
+* @param range - The requested range
+* @param replacement - The replacement text
+* @returns The spliced text
+*
+* @example
+* ```ts
+* spliceRange('hello', { start: { line: 1, column: 1 }, end: { line: 1, column: 6 } }, 'bye')
+* ```
+*/
+function spliceRange(text, range, replacement) {
+	const clamped = clampRange(text, range);
+	const start = offsetAt(text, clamped.start);
+	const end = offsetAt(text, clamped.end);
+	return text.slice(0, start) + replacement + text.slice(end);
+}
+/**
+* Assemble a nested range from four 1-based coordinates.
+*
+* @param fromLine - The start line
+* @param fromColumn - The start column
+* @param toLine - The end line
+* @param toColumn - The end column
+* @returns The assembled range without validation
+*
+* @example
+* ```ts
+* rangeOf(1, 1, 1, 2)
+* ```
+*/
+function rangeOf(fromLine, fromColumn, toLine, toColumn) {
+	return {
+		start: {
+			line: fromLine,
+			column: fromColumn
+		},
+		end: {
+			line: toLine,
+			column: toColumn
+		}
+	};
+}
+/**
+* Escape regular-expression metacharacters for literal matching.
+*
+* @param value - The literal text
+* @returns The escaped regular-expression source
+*
+* @example
+* ```ts
+* escapeRegExp('a.b') // 'a\\.b'
+* ```
+*/
+function escapeRegExp(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+//#endregion
+//#region src/core/workspaces/Workspace.ts
+/**
+* A mutable path-keyed editing surface over immutable files.
+*
+* Whole-file edits create text files, ranged edits operate only on existing text files, and
+* binary files remain available through construction-time hydration. Mutations emit after the
+* registry has changed.
+*
+* @example
+* ```ts
+* import { Workspace } from '@orkestrel/workspace'
+*
+* const workspace = new Workspace()
+* workspace.write('notes.txt', 'hello')
+* workspace.append('notes.txt', ' world')
+* workspace.read('notes.txt') // 'hello world'
+* ```
+*/
+var Workspace = class {
+	#id;
+	#files = /* @__PURE__ */ new Map();
+	#emitter;
+	/**
+	* Create a workspace.
+	*
+	* @param options - Optional identity, emitter configuration, and initial files
+	*/
+	constructor(options) {
+		this.#id = options?.id ?? crypto.randomUUID();
+		this.#emitter = new Emitter({
+			...options?.on === void 0 ? {} : { on: options.on },
+			...options?.error === void 0 ? {} : { error: options.error }
+		});
+		if (options?.seed) for (const file of options.seed) this.#files.set(file.path, file);
+	}
+	get id() {
+		return this.#id;
+	}
+	get emitter() {
+		return this.#emitter;
+	}
+	get count() {
+		return this.#files.size;
+	}
+	file(path) {
+		return this.#files.get(path);
+	}
+	files() {
+		return [...this.#files.values()];
+	}
+	read(path, range) {
+		if (isArray(path)) {
+			const result = {};
+			for (const one of path) {
+				const file = this.#files.get(one);
+				if (file && isText(file.content)) result[one] = file.content.text;
+			}
+			return result;
+		}
+		const file = this.#files.get(path);
+		if (!file) return void 0;
+		if (!range) return isText(file.content) ? file.content.text : void 0;
+		if (!isText(file.content)) throw new WorkspaceError("MODALITY", `Cannot read a range of a binary file: ${path}`, { path });
+		return {
+			content: sliceRange(file.content.text, range),
+			range: clampRange(file.content.text, range)
+		};
+	}
+	has(path) {
+		if (isArray(path)) return path.some((one) => this.#files.has(one));
+		return this.#files.has(path);
+	}
+	search(query, options) {
+		const pattern = this.#pattern(query, options);
+		const limit = options?.limit;
+		const matches = [];
+		for (const file of this.#files.values()) {
+			if (limit !== void 0 && matches.length >= limit) break;
+			if (!isText(file.content)) continue;
+			const lines = file.content.text.split("\n");
+			for (let index = 0; index < lines.length; index += 1) {
+				if (limit !== void 0 && matches.length >= limit) break;
+				const lineText = lines[index] ?? "";
+				pattern.lastIndex = 0;
+				let hit = pattern.exec(lineText);
+				while (hit !== null) {
+					if (limit !== void 0 && matches.length >= limit) break;
+					matches.push({
+						path: file.path,
+						line: index + 1,
+						column: hit.index + 1,
+						length: hit[0].length,
+						content: lineText
+					});
+					if (hit[0].length === 0) pattern.lastIndex += 1;
+					hit = pattern.exec(lineText);
+				}
+			}
+		}
+		return matches;
+	}
+	replace(query, replacement, options) {
+		const pattern = this.#pattern(query, options);
+		const limit = options?.limit;
+		let occurrences = 0;
+		let files = 0;
+		for (const [path, file] of this.#files) {
+			if (limit !== void 0 && occurrences >= limit) break;
+			if (!isText(file.content)) continue;
+			const remaining = limit === void 0 ? void 0 : limit - occurrences;
+			let count = 0;
+			pattern.lastIndex = 0;
+			const next = file.content.text.replace(pattern, (match) => {
+				if (remaining !== void 0 && count >= remaining) return match;
+				count += 1;
+				return replacement;
+			});
+			if (count > 0) {
+				occurrences += count;
+				files += 1;
+				this.write(path, next);
+			}
+		}
+		return {
+			occurrences,
+			files
+		};
+	}
+	write(path, content, range) {
+		if (isRecord(path)) {
+			for (const [one, text] of Object.entries(path)) this.#write(one, text);
+			return;
+		}
+		const text = content ?? "";
+		if (!range) {
+			this.#write(path, text);
+			return;
+		}
+		this.#splice(path, text, range);
+	}
+	prepend(path, content) {
+		if (isRecord(path)) {
+			for (const [one, text] of Object.entries(path)) this.#prepend(one, text);
+			return;
+		}
+		this.#prepend(path, content ?? "");
+	}
+	append(path, content) {
+		if (isRecord(path)) {
+			for (const [one, text] of Object.entries(path)) this.#append(one, text);
+			return;
+		}
+		this.#append(path, content ?? "");
+	}
+	move(from, to) {
+		if (isRecord(from)) {
+			let moved = false;
+			for (const [one, target] of Object.entries(from)) if (this.#move(one, target)) moved = true;
+			return moved;
+		}
+		return this.#move(from, to ?? "");
+	}
+	remove(path) {
+		if (isArray(path)) {
+			let removed = false;
+			for (const one of path) if (this.#remove(one)) removed = true;
+			return removed;
+		}
+		return this.#remove(path);
+	}
+	clear() {
+		this.#files.clear();
+		this.#emitter.emit("clear");
+	}
+	snapshot() {
+		return {
+			id: this.#id,
+			files: this.files()
+		};
+	}
+	destroy() {
+		this.#emitter.destroy();
+	}
+	#write(path, content) {
+		const existing = this.#files.get(path);
+		const file = createFile({
+			path,
+			content: {
+				text: content,
+				language: existing && isText(existing.content) ? existing.content.language : inferLanguage(path)
+			},
+			state: existing ? "modified" : "created"
+		});
+		this.#files.set(path, file);
+		this.#emitter.emit("write", file);
+	}
+	#splice(path, content, range) {
+		const existing = this.#files.get(path);
+		if (!existing) throw new WorkspaceError("MODALITY", `Cannot splice a range of a missing file: ${path}`, { path });
+		if (!isText(existing.content)) throw new WorkspaceError("MODALITY", `Cannot splice a range of a binary file: ${path}`, { path });
+		if (!isValidRange(range)) throw new WorkspaceError("RANGE", `Invalid range for file: ${path}`, {
+			path,
+			range
+		});
+		const file = createFile({
+			path,
+			content: {
+				text: spliceRange(existing.content.text, range, content),
+				language: existing.content.language
+			},
+			state: "modified"
+		});
+		this.#files.set(path, file);
+		this.#emitter.emit("write", file);
+	}
+	#prepend(path, content) {
+		const existing = this.#files.get(path);
+		let text = "";
+		if (existing) {
+			if (!isText(existing.content)) throw new WorkspaceError("MODALITY", `Cannot prepend text to a binary file: ${path}`, { path });
+			text = existing.content.text;
+		}
+		this.#write(path, content + text);
+	}
+	#append(path, content) {
+		const existing = this.#files.get(path);
+		let text = "";
+		if (existing) {
+			if (!isText(existing.content)) throw new WorkspaceError("MODALITY", `Cannot append text to a binary file: ${path}`, { path });
+			text = existing.content.text;
+		}
+		this.#write(path, text + content);
+	}
+	#move(from, to) {
+		if (from === to) return false;
+		const file = this.#files.get(from);
+		if (!file) return false;
+		const moved = createFile({
+			path: to,
+			content: file.content,
+			state: "modified"
+		});
+		const entries = [...this.#files];
+		this.#files.clear();
+		for (const [path, current] of entries) if (path === from) this.#files.set(to, moved);
+		else if (path !== to) this.#files.set(path, current);
+		this.#emitter.emit("move", from, to);
+		return true;
+	}
+	#remove(path) {
+		const removed = this.#files.delete(path);
+		if (removed) this.#emitter.emit("remove", path);
+		return removed;
+	}
+	#pattern(query, options) {
+		const source = options?.regex === true ? query : escapeRegExp(query);
+		const flags = options?.sensitive === false ? "gi" : "g";
+		try {
+			return new RegExp(source, flags);
+		} catch {
+			throw new WorkspaceError("PATTERN", `Invalid search pattern: ${query}`, { query });
+		}
+	}
+};
+//#endregion
+//#region src/core/workspaces/WorkspaceManager.ts
+/**
+* An insertion-ordered workspace registry with an active selection.
+*
+* A supplied store adds lenient snapshot `open` and `save` operations. Event defaults flow into
+* workspaces created through the registry, while observability remains owned by each workspace.
+*
+* @example
+* ```ts
+* import { WorkspaceManager } from '@orkestrel/workspace'
+*
+* const manager = new WorkspaceManager()
+* const workspace = manager.add({ id: 'scratch' })
+* manager.active === workspace
+* ```
+*/
+var WorkspaceManager = class {
+	#workspaces = /* @__PURE__ */ new Map();
+	#active;
+	#on;
+	#error;
+	#store;
+	/**
+	* Create a registry.
+	*
+	* @param options - Default event hooks and optional snapshot store
+	*/
+	constructor(options) {
+		this.#on = options?.on;
+		this.#error = options?.error;
+		this.#store = options?.store;
+	}
+	get count() {
+		return this.#workspaces.size;
+	}
+	get active() {
+		return this.#active === void 0 ? void 0 : this.#workspaces.get(this.#active);
+	}
+	workspace(id) {
+		return this.#workspaces.get(id);
+	}
+	workspaces() {
+		return [...this.#workspaces.values()];
+	}
+	add(options) {
+		const on = options?.on ?? this.#on;
+		const error = options?.error ?? this.#error;
+		const workspace = new Workspace({
+			...options?.id === void 0 ? {} : { id: options.id },
+			...on === void 0 ? {} : { on },
+			...error === void 0 ? {} : { error },
+			...options?.seed === void 0 ? {} : { seed: options.seed }
+		});
+		this.#workspaces.set(workspace.id, workspace);
+		if (this.#active === void 0) this.#active = workspace.id;
+		return workspace;
+	}
+	switch(id) {
+		const workspace = this.#workspaces.get(id);
+		if (workspace === void 0) return void 0;
+		this.#active = id;
+		return workspace;
+	}
+	async open(id) {
+		const existing = this.#workspaces.get(id);
+		if (existing !== void 0) {
+			this.#active = id;
+			return existing;
+		}
+		if (this.#store === void 0) return void 0;
+		const snapshot = await this.#store.get(id);
+		if (snapshot === void 0) return void 0;
+		const workspace = this.add({
+			id,
+			seed: snapshot.files
+		});
+		this.#active = workspace.id;
+		return workspace;
+	}
+	async save(id) {
+		const workspace = this.#workspaces.get(id);
+		if (this.#store === void 0 || workspace === void 0) return false;
+		await this.#store.set(workspace.snapshot());
+		return true;
+	}
+	remove(ids) {
+		if (isArray(ids)) {
+			let removed = false;
+			for (const id of ids) if (this.#drop(id)) removed = true;
+			return removed;
+		}
+		return this.#drop(ids);
+	}
+	clear() {
+		for (const workspace of this.#workspaces.values()) workspace.destroy();
+		this.#workspaces.clear();
+		this.#active = void 0;
+	}
+	#drop(id) {
+		const workspace = this.#workspaces.get(id);
+		if (workspace === void 0) return false;
+		this.#workspaces.delete(id);
+		workspace.destroy();
+		if (this.#active === id) this.#active = void 0;
+		return true;
+	}
+};
+//#endregion
+//#region src/core/workspaces/stores/DatabaseWorkspaceStore.ts
+/**
+* A workspace snapshot store over a database table.
+*
+* Snapshots occupy one opaque column and are narrowed when read back from the storage boundary.
+*
+* @example
+* ```ts
+* import { createDatabaseWorkspaceStore } from '@orkestrel/workspace'
+*
+* const store = createDatabaseWorkspaceStore()
+* ```
+*/
+var DatabaseWorkspaceStore = class {
+	#table;
+	/**
+	* Wrap a workspace snapshot table.
+	*
+	* @param table - The table keyed by workspace identifier
+	*/
+	constructor(table) {
+		this.#table = table;
+	}
+	async get(id) {
+		const row = await this.#table.get(id);
+		if (row === void 0) return void 0;
+		return isWorkspaceSnapshot(row.snapshot) ? row.snapshot : void 0;
+	}
+	async set(snapshot) {
+		await this.#table.set({
+			id: snapshot.id,
+			snapshot
+		});
+	}
+	async delete(id) {
+		await this.#table.remove(id);
+	}
+};
+//#endregion
+//#region src/core/workspaces/stores/MemoryWorkspaceStore.ts
+/**
+* A process-local workspace snapshot store.
+*
+* @example
+* ```ts
+* import { MemoryWorkspaceStore } from '@orkestrel/workspace'
+*
+* const store = new MemoryWorkspaceStore()
+* ```
+*/
+var MemoryWorkspaceStore = class {
+	#snapshots = /* @__PURE__ */ new Map();
+	get(id) {
+		return Promise.resolve(this.#snapshots.get(id));
+	}
+	set(snapshot) {
+		this.#snapshots.set(snapshot.id, snapshot);
+		return Promise.resolve();
+	}
+	delete(id) {
+		this.#snapshots.delete(id);
+		return Promise.resolve();
+	}
+};
+//#endregion
+//#region src/core/factories.ts
+/**
+* Create an immutable file with derived size and line counts.
+*
+* @param input - The file path, content, and optional state
+* @returns A frozen file record
+*
+* @example
+* ```ts
+* import { createFile, createTextContent } from '@orkestrel/workspace'
+*
+* createFile({ path: 'a.txt', content: createTextContent('hello', 'text') })
+* ```
+*/
+function createFile(input) {
+	return Object.freeze({
+		path: input.path,
+		content: input.content,
+		state: input.state ?? "created",
+		size: computeSize(input.content),
+		lines: countLines(input.content)
+	});
+}
+/**
+* Create the text arm of {@link FileContent}.
+*
+* @param text - The text body
+* @param language - The language tag
+* @returns Text file content
+*
+* @example
+* ```ts
+* import { createTextContent } from '@orkestrel/workspace'
+*
+* createTextContent('hello', 'text')
+* ```
+*/
+function createTextContent(text, language) {
+	return {
+		text,
+		language
+	};
+}
+/**
+* Create the binary arm of {@link FileContent}.
+*
+* @param data - The base64 payload
+* @param mime - The binary MIME
+* @returns Binary file content
+*
+* @example
+* ```ts
+* import { createBinaryContent } from '@orkestrel/workspace'
+*
+* createBinaryContent('AAAA', 'image/png')
+* ```
+*/
+function createBinaryContent(data, mime) {
+	return {
+		data,
+		mime
+	};
+}
+/**
+* Create a workspace.
+*
+* @param options - Optional identity, emitter configuration, and initial files
+* @returns A working workspace
+*
+* @example
+* ```ts
+* import { createWorkspace } from '@orkestrel/workspace'
+*
+* const workspace = createWorkspace()
+* workspace.write('a.txt', 'hello')
+* ```
+*/
+function createWorkspace(options) {
+	return new Workspace(options);
+}
+/**
+* Create an in-memory workspace snapshot store.
+*
+* @returns A process-local workspace store
+*
+* @example
+* ```ts
+* import { createMemoryWorkspaceStore } from '@orkestrel/workspace'
+*
+* const store = createMemoryWorkspaceStore()
+* ```
+*/
+function createMemoryWorkspaceStore() {
+	return new MemoryWorkspaceStore();
+}
+/**
+* Create a database-backed workspace snapshot store.
+*
+* @param driver - The database driver; defaults to an in-memory driver
+* @returns A workspace store backed by the supplied driver
+*
+* @example
+* ```ts
+* import { createDatabaseWorkspaceStore } from '@orkestrel/workspace'
+*
+* const store = createDatabaseWorkspaceStore()
+* ```
+*/
+function createDatabaseWorkspaceStore(driver = createMemoryDriver()) {
+	const columns = {
+		id: stringShape(),
+		snapshot: rawShape({})
+	};
+	return new DatabaseWorkspaceStore(createDatabase({
+		driver,
+		tables: { workspaces: columns }
+	}).table("workspaces"));
+}
+/**
+* Create an empty workspace registry.
+*
+* @param options - Default event hooks and optional durability
+* @returns A workspace manager
+*
+* @example
+* ```ts
+* import { createWorkspaceManager } from '@orkestrel/workspace'
+*
+* const manager = createWorkspaceManager()
+* manager.add()
+* ```
+*/
+function createWorkspaceManager(options) {
+	return new WorkspaceManager(options);
+}
+//#endregion
+export { DatabaseWorkspaceStore, EXTENSION_LANGUAGES, MemoryWorkspaceStore, Workspace, WorkspaceError, WorkspaceManager, clampPosition, clampRange, computeSize, countLines, createBinaryContent, createDatabaseWorkspaceStore, createFile, createMemoryWorkspaceStore, createTextContent, createWorkspace, createWorkspaceManager, decodedSize, escapeRegExp, inferLanguage, isBinary, isFile, isText, isValidRange, isWorkspaceError, isWorkspaceSnapshot, offsetAt, rangeOf, sliceRange, spliceRange };
+
+//# sourceMappingURL=index.js.map