@aigne/afs 1.3.0 → 1.4.0-beta.10

package/CHANGELOG.md

@@ -1,5 +1,111 @@
 # Changelog
 
+## [1.4.0-beta.10](https://github.com/AIGNE-io/aigne-framework/compare/afs-v1.4.0-beta.9...afs-v1.4.0-beta.10) (2026-01-16)
+
+
+### Features
+
+* **afs:** improve list behavior to always include current path ([cb91f80](https://github.com/AIGNE-io/aigne-framework/commit/cb91f80c6ea3aa6e93dde26b6feeea8689fceb48))
+
+## [1.4.0-beta.9](https://github.com/AIGNE-io/aigne-framework/compare/afs-v1.4.0-beta.8...afs-v1.4.0-beta.9) (2026-01-14)
+
+
+### Features
+
+* **afs:** add module access control and schema validation support ([#904](https://github.com/AIGNE-io/aigne-framework/issues/904)) ([d0b279a](https://github.com/AIGNE-io/aigne-framework/commit/d0b279aac07ebe2bcc1fd4148498fc3f6bbcd561))
+
+
+### Bug Fixes
+
+* improve test coverage tracking and reporting ([#903](https://github.com/AIGNE-io/aigne-framework/issues/903)) ([031144e](https://github.com/AIGNE-io/aigne-framework/commit/031144e74f29e882cffe52ffda8f7a18c76ace7f))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/platform-helpers bumped to 0.6.7-beta.2
+
+## [1.4.0-beta.8](https://github.com/AIGNE-io/aigne-framework/compare/afs-v1.4.0-beta.7...afs-v1.4.0-beta.8) (2026-01-12)
+
+
+### Bug Fixes
+
+* **afs:** show gitignored files with marker instead of filtering ([c2bdea1](https://github.com/AIGNE-io/aigne-framework/commit/c2bdea155f47c9420f2fe810cdfed79ef70ef899))
+
+## [1.4.0-beta.7](https://github.com/AIGNE-io/aigne-framework/compare/afs-v1.4.0-beta.6...afs-v1.4.0-beta.7) (2026-01-08)
+
+
+### Features
+
+* **afs,bash:** add physical path mapping for AFS modules in bash execution ([#881](https://github.com/AIGNE-io/aigne-framework/issues/881)) ([50dbda2](https://github.com/AIGNE-io/aigne-framework/commit/50dbda224bd666d951494d2449779830d8db57fc))
+
+
+### Bug Fixes
+
+* bump version ([696560f](https://github.com/AIGNE-io/aigne-framework/commit/696560fa2673eddcb4d00ac0523fbbbde7273cb3))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @aigne/platform-helpers bumped to 0.6.7-beta.1
+
+## [1.4.0-beta.6](https://github.com/AIGNE-io/aigne-framework/compare/afs-v1.4.0-beta.5...afs-v1.4.0-beta.6) (2026-01-06)
+
+
+### Bug Fixes
+
+* **afs:** throw errors instead of logging in AFS module operations ([#874](https://github.com/AIGNE-io/aigne-framework/issues/874)) ([f0cc1c4](https://github.com/AIGNE-io/aigne-framework/commit/f0cc1c4056f8b95b631d595892bb12eb75da4b9f))
+
+## [1.4.0-beta.5](https://github.com/AIGNE-io/aigne-framework/compare/afs-v1.4.0-beta.4...afs-v1.4.0-beta.5) (2025-12-31)
+
+
+### Features
+
+* add session compact support for AIAgent ([#863](https://github.com/AIGNE-io/aigne-framework/issues/863)) ([9010918](https://github.com/AIGNE-io/aigne-framework/commit/9010918cd3f18b02b5c60ddc9ed5c34b568d0b28))
+
+## [1.4.0-beta.4](https://github.com/AIGNE-io/aigne-framework/compare/afs-v1.4.0-beta.3...afs-v1.4.0-beta.4) (2025-12-26)
+
+
+### Features
+
+* **core:** add session history support ([#858](https://github.com/AIGNE-io/aigne-framework/issues/858)) ([28a070e](https://github.com/AIGNE-io/aigne-framework/commit/28a070ed33b821d1fd344b899706d817ca992b9f))
+
+## [1.4.0-beta.3](https://github.com/AIGNE-io/aigne-framework/compare/afs-v1.4.0-beta.2...afs-v1.4.0-beta.3) (2025-12-24)
+
+
+### Features
+
+* add Agent Skill support ([#787](https://github.com/AIGNE-io/aigne-framework/issues/787)) ([f04fbe7](https://github.com/AIGNE-io/aigne-framework/commit/f04fbe76ec24cf3c59c74adf92d87b0c3784a8f7))
+
+## [1.4.0-beta.2](https://github.com/AIGNE-io/aigne-framework/compare/afs-v1.4.0-beta.1...afs-v1.4.0-beta.2) (2025-12-19)
+
+
+### Bug Fixes
+
+* **afs:** use simple-list instead of tree as default type ([#839](https://github.com/AIGNE-io/aigne-framework/issues/839)) ([65a9a40](https://github.com/AIGNE-io/aigne-framework/commit/65a9a4054b3bdad6f7e40357299ef3dc48f7c3e4))
+
+## [1.4.0-beta.1](https://github.com/AIGNE-io/aigne-framework/compare/afs-v1.4.0-beta...afs-v1.4.0-beta.1) (2025-12-17)
+
+
+### Bug Fixes
+
+* bump version ([70d217c](https://github.com/AIGNE-io/aigne-framework/commit/70d217c8360dd0dda7f5f17011c4e92ec836e801))
+
+## [1.4.0-beta](https://github.com/AIGNE-io/aigne-framework/compare/afs-v1.3.0...afs-v1.4.0-beta) (2025-12-17)
+
+
+### Features
+
+* **afs:** support expand context into prompt template by call `$afs.xxx` ([#830](https://github.com/AIGNE-io/aigne-framework/issues/830)) ([5616acd](https://github.com/AIGNE-io/aigne-framework/commit/5616acd6ea257c91aa0b766608f45c5ce17f0345))
+
+
+### Bug Fixes
+
+* **afs:** read method should not throw not found error ([#835](https://github.com/AIGNE-io/aigne-framework/issues/835)) ([ebfdfc1](https://github.com/AIGNE-io/aigne-framework/commit/ebfdfc1cdba23efd23ac2ad4621e3f046990fd8b))
+
 ## [1.3.0](https://github.com/AIGNE-io/aigne-framework/compare/afs-v1.3.0-beta.3...afs-v1.3.0) (2025-12-12)
 
 ## [1.3.0-beta.3](https://github.com/AIGNE-io/aigne-framework/compare/afs-v1.3.0-beta.2...afs-v1.3.0-beta.3) (2025-12-11)

package/lib/cjs/afs.d.ts

@@ -1,12 +1,19 @@
 import { Emitter } from "strict-event-emitter";
-import type { AFSDeleteOptions, AFSEntry, AFSListOptions, AFSModule, AFSRenameOptions, AFSRoot, AFSRootEvents, AFSSearchOptions, AFSWriteEntryPayload, AFSWriteOptions } from "./type.js";
+import { type AFSContext, type AFSDeleteOptions, type AFSDeleteResult, type AFSExecOptions, type AFSExecResult, type AFSModule, type AFSReadOptions, type AFSReadResult, type AFSRenameOptions, type AFSRenameResult, type AFSRoot, type AFSRootEvents, type AFSRootListOptions, type AFSRootListResult, type AFSRootSearchOptions, type AFSRootSearchResult, type AFSWriteEntryPayload, type AFSWriteOptions, type AFSWriteResult } from "./type.js";
 export interface AFSOptions {
     modules?: AFSModule[];
+    context?: AFSContext;
 }
 export declare class AFS extends Emitter<AFSRootEvents> implements AFSRoot {
+    options: AFSOptions;
     name: string;
     constructor(options?: AFSOptions);
     private modules;
+    /**
+     * Check if write operations are allowed for the given module.
+     * Throws AFSReadonlyError if not allowed.
+     */
+    private checkWritePermission;
     mount(module: AFSModule): this;
     listModules(): Promise<{
         name: string;
@@ -14,32 +21,22 @@ export declare class AFS extends Emitter<AFSRootEvents> implements AFSRoot {
         description?: string;
         module: AFSModule;
     }[]>;
-    list(path: string, options?: AFSListOptions): Promise<{
-        list: AFSEntry[];
-        message?: string;
-    }>;
-    read(path: string): Promise<{
-        result?: AFSEntry;
-        message?: string;
-    }>;
-    write(path: string, content: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<{
-        result: AFSEntry;
-        message?: string;
-    }>;
-    delete(path: string, options?: AFSDeleteOptions): Promise<{
-        message?: string;
-    }>;
-    rename(oldPath: string, newPath: string, options?: AFSRenameOptions): Promise<{
-        message?: string;
-    }>;
-    search(path: string, query: string, options?: AFSSearchOptions): Promise<{
-        list: AFSEntry[];
-        message?: string;
-    }>;
+    list(path: string, options?: AFSRootListOptions): Promise<AFSRootListResult>;
+    private _list;
+    read(path: string, _options?: AFSReadOptions): Promise<AFSReadResult>;
+    write(path: string, content: AFSWriteEntryPayload, options?: AFSWriteOptions): Promise<AFSWriteResult>;
+    delete(path: string, options?: AFSDeleteOptions): Promise<AFSDeleteResult>;
+    rename(oldPath: string, newPath: string, options?: AFSRenameOptions): Promise<AFSRenameResult>;
+    search(path: string, query: string, options?: AFSRootSearchOptions): Promise<AFSRootSearchResult>;
+    private processWithPreset;
+    private _select;
+    private _search;
     private findModules;
-    exec(path: string, args: Record<string, any>, options: {
-        context: any;
-    }): Promise<{
-        result: Record<string, any>;
-    }>;
+    exec(path: string, args: Record<string, any>, options: AFSExecOptions): Promise<AFSExecResult>;
+    private buildSimpleListView;
+    private buildTreeView;
+    private buildMetadataSuffix;
+    private physicalPath?;
+    initializePhysicalPath(): Promise<string>;
+    cleanupPhysicalPath(): Promise<void>;
 }

package/lib/cjs/afs.js

@@ -1,25 +1,42 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AFS = void 0;
+const index_js_1 = require("@aigne/platform-helpers/nodejs/index.js");
+const uuid_1 = require("@aigne/uuid");
 const strict_event_emitter_1 = require("strict-event-emitter");
 const ufo_1 = require("ufo");
+const zod_1 = require("zod");
+const error_js_1 = require("./error.js");
+const type_js_1 = require("./type.js");
 const DEFAULT_MAX_DEPTH = 1;
 const MODULES_ROOT_DIR = "/modules";
 class AFS extends strict_event_emitter_1.Emitter {
+    options;
     name = "AFSRoot";
-    constructor(options) {
+    constructor(options = {}) {
         super();
+        this.options = options;
         for (const module of options?.modules ?? []) {
             this.mount(module);
         }
     }
     modules = new Map();
+    /**
+     * Check if write operations are allowed for the given module.
+     * Throws AFSReadonlyError if not allowed.
+     */
+    checkWritePermission(module, operation, path) {
+        // Module-level readonly (undefined means readonly by default)
+        if (module.accessMode !== "readwrite") {
+            throw new error_js_1.AFSReadonlyError(`Module '${module.name}' is readonly, cannot perform ${operation} to ${path}`);
+        }
+    }
     mount(module) {
-        let path = (0, ufo_1.joinURL)("/", module.name);
-        if (!/^\/[^/]+$/.test(path)) {
-            throw new Error(`Invalid mount path: ${path}. Must start with '/' and contain no other '/'`);
+        // Validate module name (should not contain '/')
+        if (module.name.includes("/")) {
+            throw new Error(`Invalid module name: ${module.name}. Module name must not contain '/'`);
         }
-        path = (0, ufo_1.joinURL)(MODULES_ROOT_DIR, path);
+        const path = (0, ufo_1.joinURL)(MODULES_ROOT_DIR, module.name);
         if (this.modules.has(path)) {
             throw new Error(`Module already mounted at path: ${path}`);
         }
@@ -35,74 +52,101 @@ class AFS extends strict_event_emitter_1.Emitter {
             module,
         }));
     }
-    async list(path, options) {
-        const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
-        if (!(maxDepth >= 0))
-            throw new Error(`Invalid maxDepth: ${maxDepth}`);
+    async list(path, options = {}) {
+        let preset;
+        if (options.preset) {
+            preset = this.options?.context?.list?.presets?.[options.preset];
+            if (!preset)
+                throw new Error(`Preset not found: ${options.preset}`);
+        }
+        return await this.processWithPreset(path, undefined, preset, {
+            ...options,
+            defaultSelect: () => this._list(path, options),
+        });
+    }
+    async _list(path, options = {}) {
         const results = [];
-        const messages = [];
+        // Special case: listing root "/" should return /modules directory
+        if (path === "/" && this.modules.size > 0) {
+            const maxDepth = options?.maxDepth ?? DEFAULT_MAX_DEPTH;
+            // Always include /modules directory first
+            results.push({
+                id: "modules",
+                path: MODULES_ROOT_DIR,
+                summary: "All mounted modules",
+            });
+            if (maxDepth === 1) {
+                // Only show /modules directory
+                return { data: results };
+            }
+            // For maxDepth > 1, also get children of /modules with reduced depth
+            const childrenResult = await this._list(MODULES_ROOT_DIR, {
+                ...options,
+                maxDepth: maxDepth - 1,
+            });
+            results.push(...childrenResult.data);
+            return { data: results };
+        }
         const matches = this.findModules(path, options);
         for (const matched of matches) {
-            const moduleEntry = {
-                id: matched.module.name,
-                path: matched.remainedModulePath,
-                summary: matched.module.description,
-            };
             if (matched.maxDepth === 0) {
+                // When maxDepth is 0, show the module entry
+                const moduleEntry = {
+                    id: matched.module.name,
+                    path: matched.modulePath,
+                    summary: matched.module.description,
+                };
                 results.push(moduleEntry);
                 continue;
             }
             if (!matched.module.list)
                 continue;
             try {
-                const { list, message } = await matched.module.list(matched.subpath, {
+                const { data } = await matched.module.list(matched.subpath, {
                     ...options,
                     maxDepth: matched.maxDepth,
                 });
-                if (list.length) {
-                    results.push(...list.map((entry) => ({
-                        ...entry,
-                        path: (0, ufo_1.joinURL)(matched.modulePath, entry.path),
-                    })));
-                }
-                else {
-                    results.push(moduleEntry);
-                }
-                if (message)
-                    messages.push(message);
+                const children = data.map((entry) => ({
+                    ...entry,
+                    path: (0, ufo_1.joinURL)(matched.modulePath, entry.path),
+                }));
+                // Always include all nodes (including the current path itself)
+                // This ensures consistent behavior across all listing scenarios
+                results.push(...children);
             }
             catch (error) {
-                console.error(`Error listing from module at ${matched.modulePath}`, error);
+                throw new Error(`Error listing from module at ${matched.modulePath}: ${error.message}`);
             }
         }
-        return { list: results, message: messages.join("; ").trim() || undefined };
+        return { data: results };
     }
-    async read(path) {
+    async read(path, _options) {
         const modules = this.findModules(path, { exactMatch: true });
         for (const { module, modulePath, subpath } of modules) {
             const res = await module.read?.(subpath);
-            if (res?.result) {
+            if (res?.data) {
                 return {
                     ...res,
-                    result: {
-                        ...res.result,
-                        path: (0, ufo_1.joinURL)(modulePath, res.result.path),
+                    data: {
+                        ...res.data,
+                        path: (0, ufo_1.joinURL)(modulePath, res.data.path),
                     },
                 };
             }
         }
-        return { result: undefined, message: "File not found" };
+        return { data: undefined, message: "File not found" };
     }
     async write(path, content, options) {
         const module = this.findModules(path, { exactMatch: true })[0];
         if (!module?.module.write)
             throw new Error(`No module found for path: ${path}`);
+        this.checkWritePermission(module.module, "write", path);
         const res = await module.module.write(module.subpath, content, options);
         return {
             ...res,
-            result: {
-                ...res.result,
-                path: (0, ufo_1.joinURL)(module.modulePath, res.result.path),
+            data: {
+                ...res.data,
+                path: (0, ufo_1.joinURL)(module.modulePath, res.data.path),
             },
         };
     }
@@ -110,6 +154,7 @@ class AFS extends strict_event_emitter_1.Emitter {
         const module = this.findModules(path, { exactMatch: true })[0];
         if (!module?.module.delete)
             throw new Error(`No module found for path: ${path}`);
+        this.checkWritePermission(module.module, "delete", path);
         return await module.module.delete(module.subpath, options);
     }
     async rename(oldPath, newPath, options) {
@@ -122,17 +167,64 @@ class AFS extends strict_event_emitter_1.Emitter {
         if (!oldModule.module.rename) {
             throw new Error(`Module does not support rename operation: ${oldModule.modulePath}`);
         }
+        this.checkWritePermission(oldModule.module, "rename", oldPath);
         return await oldModule.module.rename(oldModule.subpath, newModule.subpath, options);
     }
-    async search(path, query, options) {
+    async search(path, query, options = {}) {
+        let preset;
+        if (options.preset) {
+            preset = this.options?.context?.search?.presets?.[options.preset];
+            if (!preset)
+                throw new Error(`Preset not found: ${options.preset}`);
+        }
+        return await this.processWithPreset(path, query, preset, {
+            ...options,
+            defaultSelect: () => this._search(path, query, options),
+        });
+    }
+    async processWithPreset(path, query, preset, options) {
+        const select = options.select || preset?.select;
+        const per = options.per || preset?.per;
+        const dedupe = options.dedupe || preset?.dedupe;
+        const format = options.format || preset?.format;
+        const entries = select
+            ? (await this._select(path, query, select, options)).data
+            : (await options.defaultSelect()).data;
+        const mapped = per
+            ? await Promise.all(entries.map((data) => per.invoke({ data }, options).then((res) => res.data)))
+            : entries;
+        const deduped = dedupe
+            ? await dedupe.invoke({ data: mapped }, options).then((res) => res.data)
+            : mapped;
+        let formatted = deduped;
+        if (format === "simple-list" || format === "tree") {
+            const valid = zod_1.z.array(type_js_1.afsEntrySchema).safeParse(deduped);
+            if (!valid.data)
+                throw new Error("Tree format requires entries to be AFSEntry objects");
+            if (format === "tree")
+                formatted = this.buildTreeView(valid.data);
+            else if (format === "simple-list")
+                formatted = this.buildSimpleListView(valid.data);
+        }
+        else if (typeof format === "object" && typeof format.invoke === "function") {
+            formatted = await format.invoke({ data: deduped }, options).then((res) => res.data);
+        }
+        return { data: formatted };
+    }
+    async _select(path, query, select, options) {
+        const { data } = await select.invoke({ path, query }, options);
+        const results = (await Promise.all(data.map((p) => this.read(p).then((res) => res.data)))).filter((i) => !!i);
+        return { data: results };
+    }
+    async _search(path, query, options) {
         const results = [];
         const messages = [];
         for (const { module, modulePath, subpath } of this.findModules(path)) {
             if (!module.search)
                 continue;
             try {
-                const { list, message } = await module.search(subpath, query, options);
-                results.push(...list.map((entry) => ({
+                const { data, message } = await module.search(subpath, query, options);
+                results.push(...data.map((entry) => ({
                     ...entry,
                     path: (0, ufo_1.joinURL)(modulePath, entry.path),
                 })));
@@ -140,10 +232,10 @@ class AFS extends strict_event_emitter_1.Emitter {
                     messages.push(message);
             }
             catch (error) {
-                console.error(`Error searching in module at ${modulePath}`, error);
+                throw new Error(`Error searching in module at ${modulePath}: ${error.message}`);
             }
         }
-        return { list: results, message: messages.join("; ") };
+        return { data: results, message: messages.join("; ") };
     }
     findModules(path, options) {
         const maxDepth = Math.max(options?.maxDepth ?? DEFAULT_MAX_DEPTH, 1);
@@ -179,5 +271,80 @@ class AFS extends strict_event_emitter_1.Emitter {
             throw new Error(`No module found for path: ${path}`);
         return await module.module.exec(module.subpath, args, options);
     }
+    buildSimpleListView(entries) {
+        return entries.map((entry) => `${entry.path}${this.buildMetadataSuffix(entry)}`);
+    }
+    buildTreeView(entries) {
+        const tree = {};
+        const entryMap = new Map();
+        for (const entry of entries) {
+            entryMap.set(entry.path, entry);
+            const parts = entry.path.split("/").filter(Boolean);
+            let current = tree;
+            for (const part of parts) {
+                if (!current[part]) {
+                    current[part] = {};
+                }
+                current = current[part];
+            }
+        }
+        const renderTree = (node, prefix = "", currentPath = "") => {
+            let result = "";
+            const keys = Object.keys(node);
+            keys.forEach((key, index) => {
+                const isLast = index === keys.length - 1;
+                const fullPath = currentPath ? `${currentPath}/${key}` : `/${key}`;
+                const entry = entryMap.get(fullPath);
+                result += `${prefix}${isLast ? "└── " : "├── "}${key}${entry ? this.buildMetadataSuffix(entry) : ""}`;
+                result += `\n`;
+                result += renderTree(node[key], `${prefix}${isLast ? "    " : "│   "}`, fullPath);
+            });
+            return result;
+        };
+        return renderTree(tree);
+    }
+    buildMetadataSuffix(entry) {
+        // Build metadata suffix
+        const metadataParts = [];
+        // Children count
+        const childrenCount = entry?.metadata?.childrenCount;
+        if (typeof childrenCount === "number") {
+            metadataParts.push(`${childrenCount} items`);
+        }
+        // Children truncated
+        if (entry?.metadata?.childrenTruncated) {
+            metadataParts.push("truncated");
+        }
+        // Gitignored
+        if (entry?.metadata?.gitignored) {
+            metadataParts.push("gitignored");
+        }
+        // Executable
+        if (entry?.metadata?.execute) {
+            metadataParts.push("executable");
+        }
+        const metadataSuffix = metadataParts.length > 0 ? ` [${metadataParts.join(", ")}]` : "";
+        return metadataSuffix;
+    }
+    physicalPath;
+    async initializePhysicalPath() {
+        this.physicalPath ??= (async () => {
+            const rootDir = index_js_1.nodejs.path.join(index_js_1.nodejs.os.tmpdir(), (0, uuid_1.v7)());
+            await index_js_1.nodejs.fs.mkdir(rootDir, { recursive: true });
+            for (const [modulePath, module] of this.modules) {
+                const physicalModulePath = index_js_1.nodejs.path.join(rootDir, modulePath);
+                await index_js_1.nodejs.fs.mkdir(index_js_1.nodejs.path.dirname(physicalModulePath), { recursive: true });
+                await module.symlinkToPhysical?.(physicalModulePath);
+            }
+            return rootDir;
+        })();
+        return this.physicalPath;
+    }
+    async cleanupPhysicalPath() {
+        if (this.physicalPath) {
+            await index_js_1.nodejs.fs.rm(await this.physicalPath, { recursive: true, force: true });
+            this.physicalPath = undefined;
+        }
+    }
 }
 exports.AFS = AFS;

package/lib/cjs/error.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Base error class for all AFS errors.
+ */
+export declare class AFSError extends Error {
+    readonly code: string;
+    constructor(message: string, code: string);
+}
+/**
+ * Error thrown when attempting write operations on a readonly AFS or module.
+ */
+export declare class AFSReadonlyError extends AFSError {
+    constructor(message: string);
+}

package/lib/cjs/error.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AFSReadonlyError = exports.AFSError = void 0;
+/**
+ * Base error class for all AFS errors.
+ */
+class AFSError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.name = "AFSError";
+        this.code = code;
+    }
+}
+exports.AFSError = AFSError;
+/**
+ * Error thrown when attempting write operations on a readonly AFS or module.
+ */
+class AFSReadonlyError extends AFSError {
+    constructor(message) {
+        super(message, "AFS_READONLY");
+        this.name = "AFSReadonlyError";
+    }
+}
+exports.AFSReadonlyError = AFSReadonlyError;

package/lib/cjs/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./afs.js";
+export * from "./error.js";
 export * from "./type.js";

package/lib/cjs/index.js

@@ -15,4 +15,5 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./afs.js"), exports);
+__exportStar(require("./error.js"), exports);
 __exportStar(require("./type.js"), exports);