@aigne/afs-workspace 1.11.0-beta.7

package/dist/index.cjs

@@ -0,0 +1,579 @@
+Object.defineProperty(exports, '__esModule', { value: true });
+const require_config = require('./config.cjs');
+const require_decorate = require('./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.cjs');
+let node_path = require("node:path");
+let _aigne_afs = require("@aigne/afs");
+let _aigne_afs_provider = require("@aigne/afs/provider");
+let _aigne_afs_provider_registry = require("@aigne/afs-provider-registry");
+let ufo = require("ufo");
+
+//#region src/index.ts
+var AFSWorkspace = class extends _aigne_afs_provider.AFSBaseProvider {
+	name;
+	description;
+	accessMode;
+	workspacePath;
+	registry;
+	innerAFS;
+	mountStatuses = [];
+	initialized = false;
+	initPromise;
+	constructor(options) {
+		super();
+		this.workspacePath = (0, node_path.resolve)(options.workspacePath);
+		this.registry = options.registry;
+		this.name = options.name ?? "workspace";
+		this.description = options.description ?? `Workspace: ${this.workspacePath}`;
+		this.accessMode = options.accessMode ?? "readwrite";
+		this.innerAFS = new _aigne_afs.AFS();
+		this.innerAFS.name = `${this.name}-inner`;
+	}
+	/** Get resolved workspace path */
+	getWorkspacePath() {
+		return this.workspacePath;
+	}
+	/**
+	* Resolve relative paths in local-scheme URIs against the workspace directory.
+	* For example, `sqlite://./sqlite/test.db` becomes `sqlite:///absolute/workspace/path/sqlite/test.db`.
+	* Non-local schemes and absolute paths are returned unchanged.
+	*/
+	resolveURI(uri) {
+		const LOCAL_SCHEMES = [
+			"fs",
+			"sqlite",
+			"json",
+			"toml",
+			"git"
+		];
+		let parsed;
+		try {
+			parsed = (0, _aigne_afs_provider_registry.parseURI)(uri);
+		} catch {
+			return uri;
+		}
+		if (!LOCAL_SCHEMES.includes(parsed.scheme)) return uri;
+		if (parsed.path.startsWith("/")) return uri;
+		const absolutePath = (0, node_path.resolve)(this.workspacePath, parsed.path);
+		const queryIndex = uri.indexOf("?");
+		const query = queryIndex >= 0 ? uri.slice(queryIndex) : "";
+		return `${parsed.scheme}://${absolutePath}${query}`;
+	}
+	/** Initialize workspace: load config, mount sub-providers */
+	async initialize() {
+		if (this.initialized) return;
+		if (this.initPromise) return this.initPromise;
+		this.initPromise = this._doInitialize();
+		await this.initPromise;
+	}
+	async _doInitialize() {
+		const config = await require_config.loadConfig(this.workspacePath);
+		await this.mountSubProviders(config);
+		this.initialized = true;
+	}
+	async ensureInitialized() {
+		if (!this.initialized) await this.initialize();
+	}
+	/** Mount sub-providers from workspace config using tolerant-parallel-mount */
+	async mountSubProviders(config) {
+		if (config.mounts.length === 0) return;
+		const validMounts = [];
+		for (const mount of config.mounts) {
+			if ((0, _aigne_afs_provider_registry.parseURI)(mount.uri).scheme === "workspace") {
+				this.mountStatuses.push({
+					path: mount.path,
+					uri: mount.uri,
+					status: "failed",
+					error: "Nested workspace is not supported"
+				});
+				continue;
+			}
+			validMounts.push(mount);
+		}
+		const results = await Promise.allSettled(validMounts.map(async (mount) => {
+			const effectiveMount = {
+				...mount,
+				uri: this.resolveURI(mount.uri)
+			};
+			if (this.accessMode === "readonly") effectiveMount.access_mode = "readonly";
+			return {
+				mount,
+				provider: await this.registry.createProvider(effectiveMount)
+			};
+		}));
+		let successCount = 0;
+		for (let i = 0; i < results.length; i++) {
+			const result = results[i];
+			const mount = validMounts[i];
+			if (result.status === "fulfilled") {
+				const { provider } = result.value;
+				try {
+					await this.innerAFS.mount(provider, mount.path);
+					this.mountStatuses.push({
+						path: mount.path,
+						uri: mount.uri,
+						status: "ok"
+					});
+					successCount++;
+				} catch (err) {
+					this.mountStatuses.push({
+						path: mount.path,
+						uri: mount.uri,
+						status: "failed",
+						error: err instanceof Error ? err.message : String(err)
+					});
+				}
+			} else {
+				const reason = result.reason;
+				this.mountStatuses.push({
+					path: mount.path,
+					uri: mount.uri,
+					status: "failed",
+					error: reason instanceof Error ? reason.message : String(reason)
+				});
+			}
+		}
+		if (successCount === 0 && validMounts.length > 0) throw new Error(`Workspace '${this.name}': all ${validMounts.length} sub-mounts failed to load`);
+	}
+	async statRoot(_ctx) {
+		await this.ensureInitialized();
+		return { data: {
+			id: "/",
+			path: "/",
+			meta: {
+				kind: "workspace",
+				kinds: ["workspace", "afs:node"],
+				childrenCount: this.mountStatuses.filter((s) => s.status === "ok").length
+			}
+		} };
+	}
+	async readRoot(_ctx) {
+		await this.ensureInitialized();
+		const okMounts = this.mountStatuses.filter((s) => s.status === "ok").length;
+		return {
+			id: "/",
+			path: "/",
+			content: {
+				type: "workspace",
+				name: this.name,
+				description: this.description,
+				mountCount: okMounts
+			},
+			meta: {
+				kind: "workspace",
+				kinds: ["workspace", "afs:node"],
+				childrenCount: okMounts
+			}
+		};
+	}
+	async listRoot(_ctx) {
+		await this.ensureInitialized();
+		const result = await this.innerAFS.list("/");
+		for (const entry of result.data) if (entry.meta && !entry.meta.kind) entry.meta.kind = "afs:directory";
+		return result;
+	}
+	async readRootMeta(_ctx) {
+		await this.ensureInitialized();
+		const okMounts = this.mountStatuses.filter((s) => s.status === "ok").length;
+		return {
+			id: "/.meta",
+			path: "/.meta",
+			content: {
+				type: "workspace",
+				storagePath: this.workspacePath,
+				mountCount: this.mountStatuses.length,
+				mounts: this.mountStatuses.map((s) => ({
+					path: s.path,
+					uri: s.uri,
+					status: s.status
+				}))
+			},
+			meta: {
+				kind: "workspace",
+				childrenCount: okMounts
+			}
+		};
+	}
+	async readCapabilities(_ctx) {
+		await this.ensureInitialized();
+		return {
+			id: "/.meta/.capabilities",
+			path: "/.meta/.capabilities",
+			content: {
+				schemaVersion: 1,
+				provider: this.name,
+				description: this.description ?? `Workspace: ${this.workspacePath}`,
+				tools: [],
+				actions: [],
+				operations: this.getOperationsDeclaration()
+			},
+			meta: { kind: "afs:capabilities" }
+		};
+	}
+	async explainRoot(_ctx) {
+		await this.ensureInitialized();
+		const lines = [];
+		lines.push(`# Workspace: ${this.name}`);
+		lines.push("");
+		if (this.description) {
+			lines.push(this.description);
+			lines.push("");
+		}
+		lines.push("## Mounts");
+		lines.push("");
+		if (this.mountStatuses.length === 0) lines.push("No mounts configured.");
+		else for (const s of this.mountStatuses) {
+			const statusIcon = s.status === "ok" ? "[ok]" : "[FAILED]";
+			lines.push(`- ${statusIcon} \`${s.path}\` -> \`${s.uri}\``);
+			if (s.error) lines.push(`  Error: ${s.error}`);
+		}
+		lines.push("");
+		lines.push("## Configuration");
+		lines.push("");
+		lines.push(`- **Storage Path**: ${this.workspacePath}`);
+		lines.push(`- **Config File**: ${require_config.getConfigPath(this.workspacePath)}`);
+		lines.push(`- **Access Mode**: ${this.accessMode}`);
+		lines.push(`- **Total Mounts**: ${this.mountStatuses.length}`);
+		lines.push(`- **Active Mounts**: ${this.mountStatuses.filter((s) => s.status === "ok").length}`);
+		return {
+			format: "markdown",
+			content: lines.join("\n")
+		};
+	}
+	async searchRoot(ctx, query) {
+		await this.ensureInitialized();
+		const options = ctx.options;
+		const result = await this.innerAFS.search("/", query, options);
+		if (options?.limit && result.data.length > options.limit) result.data = result.data.slice(0, options.limit);
+		return result;
+	}
+	async listRootActions(_ctx) {
+		return { data: [{
+			id: "/.actions/add",
+			path: "/.actions/add",
+			summary: "Add a new mount to the workspace",
+			meta: {
+				kind: "afs:executable",
+				kinds: ["afs:executable", "afs:node"],
+				name: "add",
+				description: "Add a new sub-provider mount to this workspace",
+				inputSchema: {
+					type: "object",
+					properties: {
+						path: {
+							type: "string",
+							description: "Mount path (must start with /)"
+						},
+						uri: {
+							type: "string",
+							description: "Provider URI (e.g. fs:///path, sqlite:///db)"
+						},
+						description: {
+							type: "string",
+							description: "Optional mount description"
+						},
+						access_mode: {
+							type: "string",
+							description: "readonly or readwrite"
+						},
+						options: {
+							type: "object",
+							description: "Provider-specific options"
+						}
+					},
+					required: ["path", "uri"]
+				}
+			}
+		}, {
+			id: "/.actions/remove",
+			path: "/.actions/remove",
+			summary: "Remove a mount from the workspace",
+			meta: {
+				kind: "afs:executable",
+				kinds: ["afs:executable", "afs:node"],
+				name: "remove",
+				description: "Remove a sub-provider mount from this workspace",
+				inputSchema: {
+					type: "object",
+					properties: {
+						path: {
+							type: "string",
+							description: "Mount path to remove"
+						},
+						keepData: {
+							type: "boolean",
+							description: "Keep local data (default: false)"
+						}
+					},
+					required: ["path"]
+				}
+			}
+		}] };
+	}
+	async handleAdd(_ctx, args) {
+		await this.ensureInitialized();
+		const path = args.path;
+		const uri = args.uri;
+		if (!path) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "Missing required parameter: path"
+			}
+		};
+		if (!uri) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "Missing required parameter: uri"
+			}
+		};
+		if (!path.startsWith("/")) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "Path must start with /"
+			}
+		};
+		try {
+			if ((0, _aigne_afs_provider_registry.parseURI)(uri).scheme === "workspace") return {
+				success: false,
+				error: {
+					code: "UNSUPPORTED",
+					message: "Nested workspace is not supported"
+				}
+			};
+		} catch (err) {
+			return {
+				success: false,
+				error: {
+					code: "INVALID_URI",
+					message: err instanceof Error ? err.message : String(err)
+				}
+			};
+		}
+		const mountConfig = {
+			path,
+			uri: this.resolveURI(uri),
+			description: args.description,
+			access_mode: this.accessMode === "readonly" ? "readonly" : args.access_mode,
+			options: args.options,
+			autoInit: true
+		};
+		try {
+			const provider = await this.registry.createProvider(mountConfig);
+			await this.innerAFS.mount(provider, path);
+			this.mountStatuses.push({
+				path,
+				uri,
+				status: "ok"
+			});
+			const { addMountToConfig } = await Promise.resolve().then(() => require("./config.cjs"));
+			await addMountToConfig(this.workspacePath, {
+				path,
+				uri,
+				description: mountConfig.description,
+				access_mode: mountConfig.access_mode,
+				options: mountConfig.options
+			});
+			return {
+				success: true,
+				data: {
+					path,
+					uri,
+					message: `Mount '${path}' added successfully`
+				}
+			};
+		} catch (err) {
+			return {
+				success: false,
+				error: {
+					code: "ADD_FAILED",
+					message: err instanceof Error ? err.message : String(err)
+				}
+			};
+		}
+	}
+	async handleRemove(_ctx, args) {
+		await this.ensureInitialized();
+		const path = args.path;
+		const keepData = args.keepData === true;
+		if (!path) return {
+			success: false,
+			error: {
+				code: "VALIDATION_ERROR",
+				message: "Missing required parameter: path"
+			}
+		};
+		const mountIndex = this.mountStatuses.findIndex((s) => s.path === path);
+		if (mountIndex === -1) return {
+			success: false,
+			error: {
+				code: "NOT_FOUND",
+				message: `Mount '${path}' not found in workspace`
+			}
+		};
+		try {
+			this.innerAFS.unmount(path);
+			const { removeMountFromConfig } = await Promise.resolve().then(() => require("./config.cjs"));
+			const { removed } = await removeMountFromConfig(this.workspacePath, path);
+			this.mountStatuses.splice(mountIndex, 1);
+			if (!keepData && removed) await this.deleteLocalData(removed.uri);
+			return {
+				success: true,
+				data: {
+					path,
+					message: `Mount '${path}' removed successfully`
+				}
+			};
+		} catch (err) {
+			return {
+				success: false,
+				error: {
+					code: "REMOVE_FAILED",
+					message: err instanceof Error ? err.message : String(err)
+				}
+			};
+		}
+	}
+	/** Delete local data for a URI. Only deletes for local providers. */
+	async deleteLocalData(uri) {
+		try {
+			const parsed = (0, _aigne_afs_provider_registry.parseURI)(uri);
+			if (![
+				"fs",
+				"json",
+				"toml",
+				"sqlite",
+				"git"
+			].includes(parsed.scheme)) return;
+			const localPath = (0, node_path.resolve)(this.workspacePath, parsed.path);
+			if (!localPath.startsWith(this.workspacePath)) return;
+			const { rm } = await import("node:fs/promises");
+			const { existsSync } = await import("node:fs");
+			if (existsSync(localPath)) await rm(localPath, {
+				recursive: true,
+				force: true
+			});
+		} catch {}
+	}
+	/** Check if a path falls under any active mount */
+	isPathUnderMount(path) {
+		return this.mountStatuses.some((s) => s.status === "ok" && (path === s.path || path.startsWith((0, ufo.joinURL)(s.path, "/"))));
+	}
+	/** Ensure a path is under an active mount, or throw AFSNotFoundError */
+	ensurePathUnderMount(path) {
+		if (!this.isPathUnderMount(path)) throw new _aigne_afs.AFSNotFoundError(path);
+	}
+	/** Re-throw errors from innerAFS delegation. AFS errors pass through; others are wrapped preserving the message */
+	rethrowAsNotFound(path, err) {
+		if (err instanceof _aigne_afs.AFSError) throw err;
+		throw new _aigne_afs.AFSError(`Error at ${path}: ${err instanceof Error ? err.message : String(err)}`, "AFS_INTERNAL_ERROR");
+	}
+	async statDelegate(ctx) {
+		await this.ensureInitialized();
+		const fullPath = (0, ufo.joinURL)("/", ctx.params.path);
+		this.ensurePathUnderMount(fullPath);
+		try {
+			const result = await this.innerAFS.stat(fullPath);
+			if (result.data) result.data.path = fullPath;
+			return result;
+		} catch (err) {
+			this.rethrowAsNotFound(fullPath, err);
+		}
+	}
+	async listDelegate(ctx) {
+		await this.ensureInitialized();
+		const fullPath = (0, ufo.joinURL)("/", ctx.params.path);
+		this.ensurePathUnderMount(fullPath);
+		try {
+			return await this.innerAFS.list(fullPath, ctx.options);
+		} catch (err) {
+			this.rethrowAsNotFound(fullPath, err);
+		}
+	}
+	async readDelegate(ctx) {
+		await this.ensureInitialized();
+		const fullPath = (0, ufo.joinURL)("/", ctx.params.path);
+		this.ensurePathUnderMount(fullPath);
+		try {
+			const result = await this.innerAFS.read(fullPath, ctx.options);
+			if (!result.data) throw new _aigne_afs.AFSNotFoundError(fullPath);
+			return result.data;
+		} catch (err) {
+			this.rethrowAsNotFound(fullPath, err);
+		}
+	}
+	async writeDelegate(ctx, content) {
+		await this.ensureInitialized();
+		const fullPath = (0, ufo.joinURL)("/", ctx.params.path);
+		this.ensurePathUnderMount(fullPath);
+		try {
+			return await this.innerAFS.write(fullPath, content, ctx.options);
+		} catch (err) {
+			this.rethrowAsNotFound(fullPath, err);
+		}
+	}
+	async deleteDelegate(ctx) {
+		await this.ensureInitialized();
+		const fullPath = (0, ufo.joinURL)("/", ctx.params.path);
+		this.ensurePathUnderMount(fullPath);
+		try {
+			return await this.innerAFS.delete(fullPath, ctx.options);
+		} catch (err) {
+			this.rethrowAsNotFound(fullPath, err);
+		}
+	}
+	async execDelegate(ctx, args) {
+		await this.ensureInitialized();
+		const fullPath = (0, ufo.joinURL)("/", ctx.params.path);
+		this.ensurePathUnderMount(fullPath);
+		try {
+			return await this.innerAFS.exec(fullPath, args, ctx.options ?? {});
+		} catch (err) {
+			this.rethrowAsNotFound(fullPath, err);
+		}
+	}
+	async searchDelegate(ctx, query, options) {
+		await this.ensureInitialized();
+		const fullPath = (0, ufo.joinURL)("/", ctx.params.path);
+		this.ensurePathUnderMount(fullPath);
+		try {
+			return await this.innerAFS.search(fullPath, query, options);
+		} catch (err) {
+			this.rethrowAsNotFound(fullPath, err);
+		}
+	}
+	async explainDelegate(ctx) {
+		await this.ensureInitialized();
+		const fullPath = (0, ufo.joinURL)("/", ctx.params.path);
+		this.ensurePathUnderMount(fullPath);
+		try {
+			return await this.innerAFS.explain(fullPath, ctx.options);
+		} catch (err) {
+			this.rethrowAsNotFound(fullPath, err);
+		}
+	}
+};
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/")], AFSWorkspace.prototype, "statRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/")], AFSWorkspace.prototype, "readRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/")], AFSWorkspace.prototype, "listRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/")], AFSWorkspace.prototype, "readRootMeta", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/.meta/.capabilities")], AFSWorkspace.prototype, "readCapabilities", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/")], AFSWorkspace.prototype, "explainRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Search)("/")], AFSWorkspace.prototype, "searchRoot", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Actions)("/")], AFSWorkspace.prototype, "listRootActions", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/", "add")], AFSWorkspace.prototype, "handleAdd", null);
+require_decorate.__decorate([_aigne_afs_provider.Actions.Exec("/", "remove")], AFSWorkspace.prototype, "handleRemove", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/:path+")], AFSWorkspace.prototype, "statDelegate", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/:path+", { handleDepth: true })], AFSWorkspace.prototype, "listDelegate", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/:path+")], AFSWorkspace.prototype, "readDelegate", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Write)("/:path+")], AFSWorkspace.prototype, "writeDelegate", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Delete)("/:path+")], AFSWorkspace.prototype, "deleteDelegate", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Exec)("/:path+")], AFSWorkspace.prototype, "execDelegate", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Search)("/:path+")], AFSWorkspace.prototype, "searchDelegate", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Explain)("/:path+")], AFSWorkspace.prototype, "explainDelegate", null);
+var src_default = AFSWorkspace;
+
+//#endregion
+exports.AFSWorkspace = AFSWorkspace;
+exports.default = src_default;

package/dist/index.d.cts

@@ -0,0 +1,104 @@
+import { WorkspaceConfig } from "./config.cjs";
+import * as _aigne_afs0 from "@aigne/afs";
+import { AFSAccessMode, AFSDeleteResult, AFSEntry, AFSExplainResult, AFSListResult, AFSSearchOptions, AFSSearchResult, AFSStatResult, AFSWriteEntryPayload, AFSWriteResult } from "@aigne/afs";
+import { AFSBaseProvider, RouteContext } from "@aigne/afs/provider";
+import { ProviderRegistry } from "@aigne/afs-provider-registry";
+
+//#region src/index.d.ts
+interface AFSWorkspaceOptions {
+  /** Absolute or relative path to the workspace directory */
+  workspacePath: string;
+  /** Provider name (used as mount name) */
+  name?: string;
+  /** Human-readable description */
+  description?: string;
+  /** Access mode for the workspace. When readonly, all sub-providers are forced readonly. */
+  accessMode?: AFSAccessMode;
+  /** Provider registry for creating sub-providers (injected to break circular dependency) */
+  registry: ProviderRegistry;
+}
+declare class AFSWorkspace extends AFSBaseProvider {
+  readonly name: string;
+  readonly description?: string;
+  readonly accessMode: AFSAccessMode;
+  private readonly workspacePath;
+  private readonly registry;
+  private innerAFS;
+  private mountStatuses;
+  private initialized;
+  private initPromise;
+  constructor(options: AFSWorkspaceOptions);
+  /** Get resolved workspace path */
+  getWorkspacePath(): string;
+  /**
+   * Resolve relative paths in local-scheme URIs against the workspace directory.
+   * For example, `sqlite://./sqlite/test.db` becomes `sqlite:///absolute/workspace/path/sqlite/test.db`.
+   * Non-local schemes and absolute paths are returned unchanged.
+   */
+  private resolveURI;
+  /** Initialize workspace: load config, mount sub-providers */
+  private initialize;
+  private _doInitialize;
+  private ensureInitialized;
+  /** Mount sub-providers from workspace config using tolerant-parallel-mount */
+  private mountSubProviders;
+  statRoot(_ctx: RouteContext): Promise<AFSStatResult>;
+  readRoot(_ctx: RouteContext): Promise<AFSEntry>;
+  listRoot(_ctx: RouteContext): Promise<AFSListResult>;
+  readRootMeta(_ctx: RouteContext): Promise<AFSEntry>;
+  readCapabilities(_ctx: RouteContext): Promise<AFSEntry>;
+  explainRoot(_ctx: RouteContext): Promise<AFSExplainResult>;
+  searchRoot(ctx: RouteContext, query: string): Promise<AFSSearchResult>;
+  listRootActions(_ctx: RouteContext): Promise<AFSListResult>;
+  handleAdd(_ctx: RouteContext, args: Record<string, unknown>): Promise<{
+    success: boolean;
+    data?: Record<string, unknown>;
+    error?: {
+      code: string;
+      message: string;
+    };
+  }>;
+  handleRemove(_ctx: RouteContext, args: Record<string, unknown>): Promise<{
+    success: boolean;
+    data?: Record<string, unknown>;
+    error?: {
+      code: string;
+      message: string;
+    };
+  }>;
+  /** Delete local data for a URI. Only deletes for local providers. */
+  private deleteLocalData;
+  /** Check if a path falls under any active mount */
+  private isPathUnderMount;
+  /** Ensure a path is under an active mount, or throw AFSNotFoundError */
+  private ensurePathUnderMount;
+  /** Re-throw errors from innerAFS delegation. AFS errors pass through; others are wrapped preserving the message */
+  private rethrowAsNotFound;
+  statDelegate(ctx: RouteContext<{
+    path: string;
+  }>): Promise<AFSStatResult>;
+  listDelegate(ctx: RouteContext<{
+    path: string;
+  }>): Promise<AFSListResult>;
+  readDelegate(ctx: RouteContext<{
+    path: string;
+  }>): Promise<AFSEntry | undefined>;
+  writeDelegate(ctx: RouteContext<{
+    path: string;
+  }>, content: AFSWriteEntryPayload): Promise<AFSWriteResult>;
+  deleteDelegate(ctx: RouteContext<{
+    path: string;
+  }>): Promise<AFSDeleteResult>;
+  execDelegate(ctx: RouteContext<{
+    path: string;
+  }>, args: Record<string, unknown>): Promise<_aigne_afs0.AFSExecResult>;
+  searchDelegate(ctx: RouteContext<{
+    path: string;
+  }>, query: string, options?: AFSSearchOptions): Promise<AFSSearchResult>;
+  explainDelegate(ctx: RouteContext<{
+    path: string;
+  }>): Promise<AFSExplainResult>;
+}
+//#endregion
+export { AFSWorkspace, AFSWorkspace as default, AFSWorkspaceOptions, type WorkspaceConfig };
+//# sourceMappingURL=index.d.cts.map

package/dist/index.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.cts","names":[],"sources":["../src/index.ts"],"mappings":";;;;;;;UAwCiB,mBAAA;;EAEf,aAAA;;EAEA,IAAA;EAJkC;EAMlC,WAAA;EAI0B;EAF1B,UAAA,GAAa,aAAA;EAJb;EAMA,QAAA,EAAU,gBAAA;AAAA;AAAA,cAYC,YAAA,SAAqB,eAAA;EAAA,SACd,IAAA;EAAA,SACA,WAAA;EAAA,SACA,UAAA,EAAY,aAAA;EAAA,iBAEb,aAAA;EAAA,iBACA,QAAA;EAAA,QACT,QAAA;EAAA,QACA,aAAA;EAAA,QACA,WAAA;EAAA,QACA,WAAA;cAEI,OAAA,EAAS,mBAAA;EA6Ie;EAjIpC,gBAAA,CAAA;EAkJ4C;;;;;EAAA,QAzIpC,UAAA;EA2KwC;EAAA,QA1JlC,UAAA;EAAA,QAQA,aAAA;EAAA,QAMA,iBAAA;EAoK8B;EAAA,QA7J9B,iBAAA;EAkFR,QAAA,CAAS,IAAA,EAAM,YAAA,GAAe,OAAA,CAAQ,aAAA;EAiBtC,QAAA,CAAS,IAAA,EAAM,YAAA,GAAe,OAAA,CAAQ,QAAA;EAqBtC,QAAA,CAAS,IAAA,EAAM,YAAA,GAAe,OAAA,CAAQ,aAAA;EAatC,YAAA,CAAa,IAAA,EAAM,YAAA,GAAe,OAAA,CAAQ,QAAA;EAwB1C,gBAAA,CAAiB,IAAA,EAAM,YAAA,GAAe,OAAA,CAAQ,QAAA;EAmB9C,WAAA,CAAY,IAAA,EAAM,YAAA,GAAe,OAAA,CAAQ,gBAAA;EAqCzC,UAAA,CAAW,GAAA,EAAK,YAAA,EAAc,KAAA,WAAgB,OAAA,CAAQ,eAAA;EActD,eAAA,CAAgB,IAAA,EAAM,YAAA,GAAe,OAAA,CAAQ,aAAA;EAoD7C,SAAA,CACJ,IAAA,EAAM,YAAA,EACN,IAAA,EAAM,MAAA,oBACL,OAAA;IACD,OAAA;IACA,IAAA,GAAO,MAAA;IACP,KAAA;MAAU,IAAA;MAAc,OAAA;IAAA;EAAA;EA8FpB,YAAA,CACJ,IAAA,EAAM,YAAA,EACN,IAAA,EAAM,MAAA,oBACL,OAAA;IACD,OAAA;IACA,IAAA,GAAO,MAAA;IACP,KAAA;MAAU,IAAA;MAAc,OAAA;IAAA;EAAA;EAuI+B;EAAA,QAnF3C,eAAA;EAqGH;EAAA,QAxEH,gBAAA;EAyEL;EAAA,QAlEK,oBAAA;EA8E2D;EAAA,QAvE3D,iBAAA;EAWF,YAAA,CAAa,GAAA,EAAK,YAAA;IAAe,IAAA;EAAA,KAAkB,OAAA,CAAQ,aAAA;EAiB3D,YAAA,CAAa,GAAA,EAAK,YAAA;IAAe,IAAA;EAAA,KAAkB,OAAA,CAAQ,aAAA;EAY3D,YAAA,CAAa,GAAA,EAAK,YAAA;IAAe,IAAA;EAAA,KAAkB,OAAA,CAAQ,QAAA;EAgB3D,aAAA,CACJ,GAAA,EAAK,YAAA;IAAe,IAAA;EAAA,IACpB,OAAA,EAAS,oBAAA,GACR,OAAA,CAAQ,cAAA;EAYL,cAAA,CAAe,GAAA,EAAK,YAAA;IAAe,IAAA;EAAA,KAAkB,OAAA,CAAQ,eAAA;EAY7D,YAAA,CAAa,GAAA,EAAK,YAAA;IAAe,IAAA;EAAA,IAAiB,IAAA,EAAM,MAAA,oBAAuB,OAAA,CAAjB,WAAA,CAAiB,aAAA;EAY/E,cAAA,CACJ,GAAA,EAAK,YAAA;IAAe,IAAA;EAAA,IACpB,KAAA,UACA,OAAA,GAAU,gBAAA,GACT,OAAA,CAAQ,eAAA;EAYL,eAAA,CAAgB,GAAA,EAAK,YAAA;IAAe,IAAA;EAAA,KAAkB,OAAA,CAAQ,gBAAA;AAAA"}