@aigne/afs-toml 1.11.0-beta.6

package/LICENSE.md

@@ -0,0 +1,26 @@
+# Proprietary License
+
+Copyright (c) 2024-2025 ArcBlock, Inc. All Rights Reserved.
+
+This software and associated documentation files (the "Software") are proprietary
+and confidential. Unauthorized copying, modification, distribution, or use of
+this Software, via any medium, is strictly prohibited.
+
+The Software is provided for internal use only within ArcBlock, Inc. and its
+authorized affiliates.
+
+## No License Granted
+
+No license, express or implied, is granted to any party for any purpose.
+All rights are reserved by ArcBlock, Inc.
+
+## Public Artifact Distribution
+
+Portions of this Software may be released publicly under separate open-source
+licenses (such as MIT License) through designated public repositories. Such
+public releases are governed by their respective licenses and do not affect
+the proprietary nature of this repository.
+
+## Contact
+
+For licensing inquiries, contact: legal@arcblock.io

package/dist/_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.cjs

@@ -0,0 +1,11 @@
+
+//#region \0@oxc-project+runtime@0.108.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+exports.__decorate = __decorate;

package/dist/_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.mjs

@@ -0,0 +1,10 @@
+//#region \0@oxc-project+runtime@0.108.0/helpers/decorate.js
+function __decorate(decorators, target, key, desc) {
+	var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+	if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+	else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+	return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+//#endregion
+export { __decorate };

package/dist/index.cjs

@@ -0,0 +1,499 @@
+const require_decorate = require('./_virtual/_@oxc-project_runtime@0.108.0/helpers/decorate.cjs');
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let _aigne_afs = require("@aigne/afs");
+let _aigne_afs_provider = require("@aigne/afs/provider");
+let _aigne_afs_utils_zod = require("@aigne/afs/utils/zod");
+let smol_toml = require("smol-toml");
+let ufo = require("ufo");
+let zod = require("zod");
+
+//#region src/index.ts
+const LIST_MAX_LIMIT = 1e3;
+/** Hidden key for storing AFS metadata (mirrors FS provider's .afs directory) */
+const AFS_KEY = ".afs";
+/** Subkey for storing metadata (mirrors FS provider's meta.yaml file) */
+const META_KEY = "meta";
+/** Subkey for storing child node metadata (mirrors FS provider's .nodes directory) */
+const NODES_KEY = ".nodes";
+const afsTOMLOptionsSchema = (0, _aigne_afs_utils_zod.camelize)(zod.z.object({
+	name: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string()),
+	tomlPath: zod.z.string().describe("The path to the TOML file to mount"),
+	description: (0, _aigne_afs_utils_zod.optionalize)(zod.z.string().describe("A description of the TOML module")),
+	accessMode: (0, _aigne_afs_utils_zod.optionalize)(zod.z.enum(["readonly", "readwrite"]).describe("Access mode for this module"))
+}));
+/**
+* AFS module for mounting TOML files as virtual file systems.
+*
+* TOML tables are treated as directories, and properties as files.
+* Supports nested structures and path-based access to data values.
+*/
+var AFSTOML = class AFSTOML extends _aigne_afs_provider.AFSBaseProvider {
+	static schema() {
+		return afsTOMLOptionsSchema;
+	}
+	static async load({ filepath, parsed }) {
+		return new AFSTOML({
+			...await AFSTOML.schema().parseAsync(parsed),
+			cwd: (0, node_path.dirname)(filepath)
+		});
+	}
+	name;
+	description;
+	accessMode;
+	tomlData = null;
+	fileStats = {};
+	resolvedTomlPath;
+	constructor(options) {
+		super();
+		this.options = options;
+		(0, _aigne_afs_utils_zod.zodParse)(afsTOMLOptionsSchema, options);
+		let tomlPath;
+		tomlPath = options.tomlPath.replaceAll("${CWD}", process.cwd());
+		if (tomlPath.startsWith("~/")) tomlPath = (0, node_path.join)(process.env.HOME || "", tomlPath.slice(2));
+		if (!(0, node_path.isAbsolute)(tomlPath)) tomlPath = (0, node_path.join)(options.cwd || process.cwd(), tomlPath);
+		let name = (0, node_path.basename)(tomlPath);
+		if (name.endsWith(".toml")) name = name.slice(0, -5);
+		this.name = options.name || name || "toml";
+		this.description = options.description;
+		this.accessMode = options.accessMode ?? "readwrite";
+		this.resolvedTomlPath = tomlPath;
+	}
+	/**
+	* Read metadata for a TOML node via /.meta or /path/.meta
+	* Returns stored metadata merged with computed type information
+	* Note: Meta is read-only. To write metadata, use write() with payload.metadata.
+	*/
+	async readMetaHandler(ctx) {
+		await this.ensureLoaded();
+		const nodePath = (0, ufo.joinURL)("/", ctx.params.path ?? "");
+		const segments = this.getPathSegments(nodePath);
+		const value = this.getValueAtPath(this.tomlData, segments);
+		if (value === void 0) throw new _aigne_afs.AFSNotFoundError(nodePath);
+		const isDir = this.isDirectoryValue(value);
+		const children = isDir ? this.getChildren(value) : [];
+		let type;
+		if (Array.isArray(value)) type = "array";
+		else if (value === null) type = "null";
+		else if (value instanceof Date) type = "datetime";
+		else if (typeof value === "object") type = "table";
+		else type = typeof value;
+		const storedMeta = this.loadMeta(nodePath) || {};
+		const computedMeta = {
+			type,
+			path: nodePath
+		};
+		if (isDir) {
+			computedMeta.childrenCount = children.length;
+			if (Array.isArray(value)) computedMeta.length = value.length;
+			else computedMeta.keys = Object.keys(value).filter((k) => !this.isMetaKey(k));
+		} else computedMeta.value = value;
+		if (this.fileStats.birthtime) computedMeta.created = this.fileStats.birthtime;
+		if (this.fileStats.mtime) computedMeta.modified = this.fileStats.mtime;
+		return this.buildEntry((0, ufo.joinURL)(nodePath, ".meta"), {
+			metadata: storedMeta,
+			content: computedMeta,
+			createdAt: this.fileStats.birthtime,
+			updatedAt: this.fileStats.mtime
+		});
+	}
+	async listHandler(ctx) {
+		await this.ensureLoaded();
+		const normalizedPath = ctx.params.path ? `/${ctx.params.path}` : "/";
+		const options = ctx.options;
+		const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);
+		const maxChildren = typeof options?.maxChildren === "number" ? options.maxChildren : Number.MAX_SAFE_INTEGER;
+		const maxDepth = options?.maxDepth ?? 1;
+		const segments = this.getPathSegments(normalizedPath);
+		const value = this.getValueAtPath(this.tomlData, segments);
+		if (value === void 0) throw new _aigne_afs.AFSNotFoundError(normalizedPath);
+		const entries = [];
+		const queue = [{
+			path: normalizedPath,
+			value,
+			depth: 0
+		}];
+		while (queue.length > 0) {
+			const item = queue.shift();
+			if (!item) break;
+			const { path: itemPath, value: itemValue, depth } = item;
+			const entry = this.valueToAFSEntry(itemPath, itemValue);
+			entries.push(entry);
+			if (entries.length >= limit) break;
+			if (this.isDirectoryValue(itemValue) && depth < maxDepth) {
+				const children = this.getChildren(itemValue);
+				const childrenToProcess = children.length > maxChildren ? children.slice(0, maxChildren) : children;
+				for (const child of childrenToProcess) {
+					const childPath = itemPath === "/" ? `/${child.key}` : `${itemPath}/${child.key}`;
+					queue.push({
+						path: childPath,
+						value: child.value,
+						depth: depth + 1
+					});
+				}
+			}
+		}
+		return { data: entries };
+	}
+	async readHandler(ctx) {
+		await this.ensureLoaded();
+		const normalizedPath = ctx.params.path ? `/${ctx.params.path}` : "/";
+		const segments = this.getPathSegments(normalizedPath);
+		const value = this.getValueAtPath(this.tomlData, segments);
+		if (value === void 0) throw new _aigne_afs.AFSNotFoundError(normalizedPath);
+		return this.valueToAFSEntry(normalizedPath, value);
+	}
+	/**
+	* Write handler - supports writing content and/or metadata
+	*
+	* | payload | behavior |
+	* |---------|----------|
+	* | { content } | write content only |
+	* | { metadata } | write metadata only (to .afs storage) |
+	* | { content, metadata } | write both |
+	*/
+	async writeHandler(ctx, payload) {
+		await this.ensureLoaded();
+		const normalizedPath = ctx.params.path ? `/${ctx.params.path}` : "/";
+		const segments = this.getPathSegments(normalizedPath);
+		if (payload.content !== void 0) this.setValueAtPath(this.tomlData, segments, payload.content);
+		if (payload.metadata !== void 0 && typeof payload.metadata === "object") {
+			const finalMeta = {
+				...this.loadMeta(normalizedPath) || {},
+				...payload.metadata
+			};
+			this.saveMeta(normalizedPath, finalMeta);
+		}
+		await this.saveToFile();
+		const newValue = this.getValueAtPath(this.tomlData, segments);
+		const isDir = this.isDirectoryValue(newValue);
+		const children = isDir ? this.getChildren(newValue) : [];
+		const storedMeta = this.loadMeta(normalizedPath) || {};
+		return { data: {
+			id: normalizedPath,
+			path: normalizedPath,
+			content: payload.content !== void 0 ? payload.content : newValue,
+			summary: payload.summary,
+			createdAt: this.fileStats.birthtime,
+			updatedAt: this.fileStats.mtime,
+			metadata: {
+				...storedMeta,
+				childrenCount: isDir ? children.length : void 0
+			},
+			userId: payload.userId,
+			sessionId: payload.sessionId,
+			linkTo: payload.linkTo
+		} };
+	}
+	async deleteHandler(ctx) {
+		await this.ensureLoaded();
+		const normalizedPath = ctx.params.path ? `/${ctx.params.path}` : "/";
+		const options = ctx.options;
+		const segments = this.getPathSegments(normalizedPath);
+		const value = this.getValueAtPath(this.tomlData, segments);
+		if (value === void 0) throw new _aigne_afs.AFSNotFoundError(normalizedPath);
+		if (this.isDirectoryValue(value) && this.getChildren(value).length > 0 && !options?.recursive) throw new Error(`Cannot delete directory '${normalizedPath}' without recursive option. Set recursive: true to delete directories.`);
+		this.deleteValueAtPath(this.tomlData, segments);
+		await this.saveToFile();
+		return { message: `Successfully deleted: ${normalizedPath}` };
+	}
+	async renameHandler(ctx, newPath) {
+		await this.ensureLoaded();
+		const normalizedOldPath = ctx.params.path ? `/${ctx.params.path}` : "/";
+		const normalizedNewPath = this.normalizePath(newPath);
+		const options = ctx.options;
+		const oldSegments = this.getPathSegments(normalizedOldPath);
+		const newSegments = this.getPathSegments(normalizedNewPath);
+		const oldValue = this.getValueAtPath(this.tomlData, oldSegments);
+		if (oldValue === void 0) throw new _aigne_afs.AFSNotFoundError(normalizedOldPath);
+		if (this.getValueAtPath(this.tomlData, newSegments) !== void 0 && !options?.overwrite) throw new Error(`Destination '${normalizedNewPath}' already exists. Set overwrite: true to replace it.`);
+		this.setValueAtPath(this.tomlData, newSegments, oldValue);
+		this.deleteValueAtPath(this.tomlData, oldSegments);
+		await this.saveToFile();
+		return { message: `Successfully renamed '${normalizedOldPath}' to '${normalizedNewPath}'` };
+	}
+	async searchHandler(ctx, query, options) {
+		await this.ensureLoaded();
+		const normalizedPath = ctx.params.path ? `/${ctx.params.path}` : "/";
+		const limit = Math.min(options?.limit || LIST_MAX_LIMIT, LIST_MAX_LIMIT);
+		const caseSensitive = options?.caseSensitive ?? false;
+		const segments = this.getPathSegments(normalizedPath);
+		const rootValue = this.getValueAtPath(this.tomlData, segments);
+		if (rootValue === void 0) throw new _aigne_afs.AFSNotFoundError(normalizedPath);
+		const entries = [];
+		const searchQuery = caseSensitive ? query : query.toLowerCase();
+		const searchInValue = (valuePath, value) => {
+			if (entries.length >= limit) return;
+			let matched = false;
+			if (!this.isDirectoryValue(value)) {
+				const valueStr = typeof value === "string" ? value : JSON.stringify(value);
+				if ((caseSensitive ? valueStr : valueStr.toLowerCase()).includes(searchQuery)) matched = true;
+			}
+			if (matched) entries.push(this.valueToAFSEntry(valuePath, value));
+			if (this.isDirectoryValue(value)) {
+				const children = this.getChildren(value);
+				for (const child of children) {
+					if (entries.length >= limit) break;
+					searchInValue(valuePath === "/" ? `/${child.key}` : `${valuePath}/${child.key}`, child.value);
+				}
+			}
+		};
+		searchInValue(normalizedPath, rootValue);
+		return {
+			data: entries,
+			message: entries.length >= limit ? `Results truncated to limit ${limit}` : void 0
+		};
+	}
+	async statHandler(ctx) {
+		await this.ensureLoaded();
+		const normalizedPath = ctx.params.path ? `/${ctx.params.path}` : "/";
+		const segments = this.getPathSegments(normalizedPath);
+		const value = this.getValueAtPath(this.tomlData, segments);
+		if (value === void 0) throw new _aigne_afs.AFSNotFoundError(normalizedPath);
+		const isDir = this.isDirectoryValue(value);
+		const children = isDir ? this.getChildren(value) : [];
+		const meta = this.loadMeta(normalizedPath);
+		return { data: {
+			path: normalizedPath,
+			childrenCount: isDir ? children.length : void 0,
+			created: this.fileStats.birthtime,
+			modified: this.fileStats.mtime,
+			meta: meta ?? void 0
+		} };
+	}
+	/**
+	* Check if a key is a hidden meta key that should be filtered from listings
+	*/
+	isMetaKey(key) {
+		return key === AFS_KEY;
+	}
+	/**
+	* Load metadata for a node.
+	*
+	* Storage location depends on node type (mirrors FS provider's .afs structure):
+	* - Objects: `.afs.meta` key within the object itself
+	* - Primitives: parent's `.afs[".nodes"][key].meta`
+	*/
+	loadMeta(nodePath) {
+		const segments = this.getPathSegments(nodePath);
+		const value = this.getValueAtPath(this.tomlData, segments);
+		if (value === void 0) return null;
+		if (this.isDirectoryValue(value) && !Array.isArray(value)) {
+			const afs$1 = value[AFS_KEY];
+			if (afs$1 && typeof afs$1 === "object" && !Array.isArray(afs$1)) {
+				const meta$1 = afs$1[META_KEY];
+				if (meta$1 && typeof meta$1 === "object" && !Array.isArray(meta$1)) return meta$1;
+			}
+			return null;
+		}
+		if (segments.length === 0) return null;
+		const parentSegments = segments.slice(0, -1);
+		const nodeKey = segments[segments.length - 1];
+		const parentValue = this.getValueAtPath(this.tomlData, parentSegments);
+		if (!parentValue || Array.isArray(parentValue) || typeof parentValue !== "object") return null;
+		const afs = parentValue[AFS_KEY];
+		if (!afs || typeof afs !== "object" || Array.isArray(afs)) return null;
+		const nodes = afs[NODES_KEY];
+		if (!nodes || typeof nodes !== "object" || Array.isArray(nodes)) return null;
+		const nodeEntry = nodes[nodeKey];
+		if (!nodeEntry || typeof nodeEntry !== "object" || Array.isArray(nodeEntry)) return null;
+		const meta = nodeEntry[META_KEY];
+		if (!meta || typeof meta !== "object" || Array.isArray(meta)) return null;
+		return meta;
+	}
+	/**
+	* Save metadata for a node.
+	*
+	* Storage location depends on node type (mirrors FS provider's .afs structure):
+	* - Objects: `.afs.meta` key within the object itself
+	* - Primitives: parent's `.afs[".nodes"][key].meta`
+	*/
+	saveMeta(nodePath, meta) {
+		const segments = this.getPathSegments(nodePath);
+		const value = this.getValueAtPath(this.tomlData, segments);
+		if (value === void 0) throw new _aigne_afs.AFSNotFoundError(nodePath);
+		if (this.isDirectoryValue(value) && !Array.isArray(value)) {
+			const obj = value;
+			if (!obj[AFS_KEY]) obj[AFS_KEY] = {};
+			obj[AFS_KEY][META_KEY] = meta;
+			return;
+		}
+		if (segments.length === 0) throw new Error("Cannot save meta for root when root is not an object");
+		const parentSegments = segments.slice(0, -1);
+		const nodeKey = segments[segments.length - 1];
+		const parentValue = this.getValueAtPath(this.tomlData, parentSegments);
+		if (!parentValue || typeof parentValue !== "object") throw new Error(`Parent path is not an object`);
+		if (Array.isArray(parentValue)) throw new Error(`Cannot save meta for array elements`);
+		const parentObj = parentValue;
+		if (!parentObj[AFS_KEY]) parentObj[AFS_KEY] = {};
+		const afs = parentObj[AFS_KEY];
+		if (!afs[NODES_KEY]) afs[NODES_KEY] = {};
+		const nodes = afs[NODES_KEY];
+		if (!nodes[nodeKey]) nodes[nodeKey] = {};
+		nodes[nodeKey][META_KEY] = meta;
+	}
+	/**
+	* Load TOML data from file. Called lazily on first access.
+	*/
+	async ensureLoaded() {
+		if (this.tomlData !== null) return;
+		try {
+			const stats = await (0, node_fs_promises.stat)(this.resolvedTomlPath);
+			this.fileStats = {
+				birthtime: stats.birthtime,
+				mtime: stats.mtime
+			};
+			this.tomlData = (0, smol_toml.parse)(await (0, node_fs_promises.readFile)(this.resolvedTomlPath, "utf8"));
+		} catch (error) {
+			if (error.code === "ENOENT") this.tomlData = {};
+			else throw error;
+		}
+	}
+	/**
+	* Save TOML data back to file. Only called in readwrite mode.
+	*/
+	async saveToFile() {
+		const content = (0, smol_toml.stringify)(this.tomlData);
+		await (0, node_fs_promises.writeFile)(this.resolvedTomlPath, content, "utf8");
+		const stats = await (0, node_fs_promises.stat)(this.resolvedTomlPath);
+		this.fileStats = {
+			birthtime: this.fileStats.birthtime || stats.birthtime,
+			mtime: stats.mtime
+		};
+	}
+	/**
+	* Get path segments from normalized path
+	*/
+	getPathSegments(path) {
+		const normalized = this.normalizePath(path);
+		if (normalized === "/") return [];
+		return normalized.slice(1).split("/");
+	}
+	/**
+	* Navigate to a value in the TOML structure using path segments
+	*/
+	getValueAtPath(data, segments) {
+		let current = data;
+		for (const segment of segments) {
+			if (current == null) return void 0;
+			if (Array.isArray(current)) {
+				const index = Number.parseInt(segment, 10);
+				if (Number.isNaN(index) || index < 0 || index >= current.length) return;
+				current = current[index];
+			} else if (typeof current === "object") current = current[segment];
+			else return;
+		}
+		return current;
+	}
+	/**
+	* Set a value in the TOML structure at the given path
+	*/
+	setValueAtPath(data, segments, value) {
+		if (segments.length === 0) throw new Error("Cannot set value at root path");
+		let current = data;
+		for (let i = 0; i < segments.length - 1; i++) {
+			const segment = segments[i];
+			const nextSegment = segments[i + 1];
+			if (Array.isArray(current)) {
+				const index = Number.parseInt(segment, 10);
+				if (Number.isNaN(index) || index < 0) throw new Error(`Invalid array index: ${segment}`);
+				while (current.length <= index) current.push(null);
+				if (current[index] == null) current[index] = !Number.isNaN(Number.parseInt(nextSegment, 10)) ? [] : {};
+				current = current[index];
+			} else if (typeof current === "object" && current !== null) {
+				const obj = current;
+				if (obj[segment] == null) obj[segment] = !Number.isNaN(Number.parseInt(nextSegment, 10)) ? [] : {};
+				current = obj[segment];
+			} else throw new Error(`Cannot set property on non-object at ${segments.slice(0, i + 1).join("/")}`);
+		}
+		const lastSegment = segments[segments.length - 1];
+		if (Array.isArray(current)) {
+			const index = Number.parseInt(lastSegment, 10);
+			if (Number.isNaN(index) || index < 0) throw new Error(`Invalid array index: ${lastSegment}`);
+			current[index] = value;
+		} else if (typeof current === "object" && current !== null) current[lastSegment] = value;
+		else throw new Error("Cannot set property on non-object");
+	}
+	/**
+	* Delete a value from the TOML structure at the given path
+	*/
+	deleteValueAtPath(data, segments) {
+		if (segments.length === 0) throw new Error("Cannot delete root path");
+		let current = data;
+		for (let i = 0; i < segments.length - 1; i++) {
+			const segment = segments[i];
+			if (Array.isArray(current)) {
+				const index = Number.parseInt(segment, 10);
+				if (Number.isNaN(index) || index < 0 || index >= current.length) return false;
+				current = current[index];
+			} else if (typeof current === "object" && current !== null) {
+				const obj = current;
+				if (!(segment in obj)) return false;
+				current = obj[segment];
+			} else return false;
+		}
+		const lastSegment = segments[segments.length - 1];
+		if (Array.isArray(current)) {
+			const index = Number.parseInt(lastSegment, 10);
+			if (Number.isNaN(index) || index < 0 || index >= current.length) return false;
+			current.splice(index, 1);
+			return true;
+		}
+		if (typeof current === "object" && current !== null) {
+			const obj = current;
+			if (!(lastSegment in obj)) return false;
+			delete obj[lastSegment];
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Check if a value is a "directory" (object or array with children)
+	*/
+	isDirectoryValue(value) {
+		if (Array.isArray(value)) return true;
+		if (typeof value === "object" && value !== null) {
+			if (value instanceof Date) return false;
+			return true;
+		}
+		return false;
+	}
+	/**
+	* Get children of a directory value (filters out .afs meta key)
+	*/
+	getChildren(value) {
+		if (Array.isArray(value)) return value.map((item, index) => ({
+			key: String(index),
+			value: item
+		}));
+		if (typeof value === "object" && value !== null && !(value instanceof Date)) return Object.entries(value).filter(([key]) => !this.isMetaKey(key)).map(([key, val]) => ({
+			key,
+			value: val
+		}));
+		return [];
+	}
+	/**
+	* Convert a TOML value to an AFSEntry
+	*/
+	valueToAFSEntry(path, value) {
+		const isDir = this.isDirectoryValue(value);
+		const children = isDir ? this.getChildren(value) : [];
+		return this.buildEntry(path, {
+			content: isDir ? void 0 : value,
+			metadata: { childrenCount: isDir ? children.length : void 0 },
+			createdAt: this.fileStats.birthtime,
+			updatedAt: this.fileStats.mtime
+		});
+	}
+};
+require_decorate.__decorate([(0, _aigne_afs_provider.Meta)("/:path*")], AFSTOML.prototype, "readMetaHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.List)("/:path*", { handleDepth: true })], AFSTOML.prototype, "listHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Read)("/:path*")], AFSTOML.prototype, "readHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Write)("/:path*")], AFSTOML.prototype, "writeHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Delete)("/:path*")], AFSTOML.prototype, "deleteHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Rename)("/:path*")], AFSTOML.prototype, "renameHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Search)("/:path*")], AFSTOML.prototype, "searchHandler", null);
+require_decorate.__decorate([(0, _aigne_afs_provider.Stat)("/:path*")], AFSTOML.prototype, "statHandler", null);
+
+//#endregion
+exports.AFSTOML = AFSTOML;