@aigne/afs 1.4.0 → 1.11.0-beta

package/lib/dts/afs.d.ts

@@ -1,42 +0,0 @@
-import { Emitter } from "strict-event-emitter";
-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;
-        path: string;
-        description?: string;
-        module: AFSModule;
-    }[]>;
-    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: AFSExecOptions): Promise<AFSExecResult>;
-    private buildSimpleListView;
-    private buildTreeView;
-    private buildMetadataSuffix;
-    private physicalPath?;
-    initializePhysicalPath(): Promise<string>;
-    cleanupPhysicalPath(): Promise<void>;
-}

package/lib/dts/error.d.ts

@@ -1,13 +0,0 @@
-/**
- * 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/dts/index.d.ts

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

package/lib/dts/type.d.ts

@@ -1,242 +0,0 @@
-import type { Emitter } from "strict-event-emitter";
-import { type ZodType, z } from "zod";
-/**
- * Access mode for AFS modules and root.
- * - "readonly": Only read operations are allowed (list, read, search)
- * - "readwrite": All operations are allowed
- */
-export type AFSAccessMode = "readonly" | "readwrite";
-/**
- * Zod schema for access mode validation.
- * Can be reused across modules that support access mode configuration.
- */
-export declare const accessModeSchema: z.ZodOptional<z.ZodEnum<["readonly", "readwrite"]>>;
-export interface AFSOperationOptions {
-    context?: any;
-}
-export interface AFSListOptions extends AFSOperationOptions {
-    filter?: {
-        agentId?: string;
-        userId?: string;
-        sessionId?: string;
-        before?: string;
-        after?: string;
-    };
-    maxDepth?: number;
-    limit?: number;
-    orderBy?: [string, "asc" | "desc"][];
-    maxChildren?: number;
-    onOverflow?: "truncate";
-    /**
-     * Whether to disable .gitignore files when listing files.
-     * @default false
-     */
-    disableGitignore?: boolean;
-    /**
-     * Glob pattern to filter entries by path.
-     * Examples: "*.ts", "**\/*.js", "src/**\/*.{ts,tsx}"
-     */
-    pattern?: string;
-}
-export interface AFSListResult {
-    data: AFSEntry[];
-    message?: string;
-}
-export interface AFSSearchOptions extends AFSOperationOptions {
-    limit?: number;
-    caseSensitive?: boolean;
-}
-export interface AFSSearchResult {
-    data: AFSEntry[];
-    message?: string;
-}
-export interface AFSReadOptions extends AFSOperationOptions {
-    filter?: AFSListOptions["filter"];
-}
-export interface AFSReadResult {
-    data?: AFSEntry;
-    message?: string;
-}
-export interface AFSDeleteOptions extends AFSOperationOptions {
-    recursive?: boolean;
-}
-export interface AFSDeleteResult {
-    message?: string;
-}
-export interface AFSRenameOptions extends AFSOperationOptions {
-    overwrite?: boolean;
-}
-export interface AFSRenameResult {
-    message?: string;
-}
-export interface AFSWriteOptions extends AFSOperationOptions {
-    append?: boolean;
-}
-export interface AFSWriteResult {
-    data: AFSEntry;
-    message?: string;
-    context?: any;
-}
-export interface AFSWriteEntryPayload extends Omit<AFSEntry, "id" | "path"> {
-}
-export interface AFSExecOptions extends AFSOperationOptions {
-}
-export interface AFSExecResult {
-    data: Record<string, any>;
-}
-export interface AFSModule {
-    readonly name: string;
-    readonly description?: string;
-    /**
-     * Access mode for this module.
-     * - "readonly": Only read operations are allowed
-     * - "readwrite": All operations are allowed
-     * Default behavior is implementation-specific.
-     */
-    readonly accessMode?: AFSAccessMode;
-    /**
-     * Enable automatic agent skill scanning for this module.
-     * When set to true, the system will scan this module for agent skills.
-     * @default false
-     */
-    readonly agentSkills?: boolean;
-    onMount?(root: AFSRoot): void;
-    symlinkToPhysical?(path: string): Promise<void>;
-    list?(path: string, options?: AFSListOptions): Promise<AFSListResult>;
-    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?: AFSSearchOptions): Promise<AFSSearchResult>;
-    exec?(path: string, args: Record<string, any>, options: AFSExecOptions): Promise<AFSExecResult>;
-}
-/**
- * Parameters for loading a module from configuration.
- */
-export interface AFSModuleLoadParams {
-    /** Path to the configuration file */
-    filepath: string;
-    /** Parsed configuration object */
-    parsed?: object;
-}
-/**
- * Interface for module classes that support schema validation and loading from configuration.
- * This describes the static part of a module class.
- *
- * @example
- * ```typescript
- * class MyModule implements AFSModule {
- *   static schema() { return mySchema; }
- *   static async load(params: AFSModuleLoadParams) { ... }
- *   // ...
- * }
- *
- * // Type check
- * const _check: AFSModuleClass<MyModule, MyModuleOptions> = MyModule;
- * ```
- */
-export interface AFSModuleClass<T extends AFSModule = AFSModule, O extends object = object> {
-    /** Returns the Zod schema for validating module configuration */
-    schema(): ZodType<O>;
-    /** Loads a module instance from configuration file path and parsed config */
-    load(params: AFSModuleLoadParams): Promise<T>;
-    /** Constructor */
-    new (options: O): T;
-}
-export type AFSRootEvents = {
-    agentSucceed: [
-        {
-            agentId?: string;
-            userId?: string;
-            sessionId?: string;
-            input: object;
-            output: object;
-            messages?: object[];
-        }
-    ];
-    historyCreated: [{
-        entry: AFSEntry;
-    }, options: AFSOperationOptions];
-};
-export interface AFSRootListOptions extends AFSListOptions, AFSContextPreset {
-    preset?: string;
-}
-export interface AFSRootListResult extends Omit<AFSListResult, "data"> {
-    data: any;
-}
-export interface AFSRootSearchOptions extends AFSSearchOptions, AFSContextPreset {
-    preset?: string;
-}
-export interface AFSRootSearchResult extends Omit<AFSSearchResult, "data"> {
-    data: any;
-}
-export interface AFSRoot extends Emitter<AFSRootEvents>, AFSModule {
-    list(path: string, options?: AFSRootListOptions): Promise<AFSRootListResult>;
-    search(path: string, query: string, options: AFSRootSearchOptions): Promise<AFSRootSearchResult>;
-    initializePhysicalPath(): Promise<string>;
-    cleanupPhysicalPath(): Promise<void>;
-}
-export interface AFSEntryMetadata extends Record<string, any> {
-    execute?: {
-        name: string;
-        description?: string;
-        inputSchema?: Record<string, any>;
-        outputSchema?: Record<string, any>;
-    };
-    childrenCount?: number;
-    childrenTruncated?: boolean;
-    gitignored?: boolean;
-}
-export interface AFSEntry<T = any> {
-    id: string;
-    createdAt?: Date;
-    updatedAt?: Date;
-    path: string;
-    agentId?: string | null;
-    userId?: string | null;
-    sessionId?: string | null;
-    summary?: string | null;
-    description?: string | null;
-    metadata?: AFSEntryMetadata | null;
-    linkTo?: string | null;
-    content?: T;
-}
-export declare const afsEntrySchema: ZodType<AFSEntry>;
-export interface AFSContextPreset {
-    /**
-     * The view template for presenting the search results.
-     */
-    view?: string;
-    select?: AFSContextPresetOptionAgent<{
-        path: string;
-        query?: string;
-    }, {
-        data: string[];
-    }>;
-    per?: AFSContextPresetOptionAgent<{
-        data: AFSEntry;
-    }, {
-        data: unknown;
-    }>;
-    dedupe?: AFSContextPresetOptionAgent<{
-        data: unknown[];
-    }, {
-        data: unknown;
-    }>;
-    format?: "default" | "simple-list" | "tree" | AFSContextPresetOptionAgent<{
-        data: unknown;
-    }, {
-        data: unknown;
-    }>;
-}
-export interface AFSContextPresetOptionAgent<I = any, O = any> {
-    invoke(input: I, options?: any): Promise<O>;
-}
-export interface AFSContext {
-    search?: {
-        presets?: Record<string, AFSContextPreset>;
-    };
-    list?: {
-        presets?: Record<string, AFSContextPreset>;
-    };
-}

package/lib/esm/afs.d.ts

@@ -1,42 +0,0 @@
-import { Emitter } from "strict-event-emitter";
-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;
-        path: string;
-        description?: string;
-        module: AFSModule;
-    }[]>;
-    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: AFSExecOptions): Promise<AFSExecResult>;
-    private buildSimpleListView;
-    private buildTreeView;
-    private buildMetadataSuffix;
-    private physicalPath?;
-    initializePhysicalPath(): Promise<string>;
-    cleanupPhysicalPath(): Promise<void>;
-}

package/lib/esm/afs.js

@@ -1,346 +0,0 @@
-import { nodejs } from "@aigne/platform-helpers/nodejs/index.js";
-import { v7 } from "@aigne/uuid";
-import { Emitter } from "strict-event-emitter";
-import { joinURL } from "ufo";
-import { z } from "zod";
-import { AFSReadonlyError } from "./error.js";
-import { afsEntrySchema, } from "./type.js";
-const DEFAULT_MAX_DEPTH = 1;
-const MODULES_ROOT_DIR = "/modules";
-export class AFS extends Emitter {
-    options;
-    name = "AFSRoot";
-    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 AFSReadonlyError(`Module '${module.name}' is readonly, cannot perform ${operation} to ${path}`);
-        }
-    }
-    mount(module) {
-        // Validate module name (should not contain '/')
-        if (module.name.includes("/")) {
-            throw new Error(`Invalid module name: ${module.name}. Module name must not contain '/'`);
-        }
-        const path = joinURL(MODULES_ROOT_DIR, module.name);
-        if (this.modules.has(path)) {
-            throw new Error(`Module already mounted at path: ${path}`);
-        }
-        this.modules.set(path, module);
-        module.onMount?.(this);
-        return this;
-    }
-    async listModules() {
-        return Array.from(this.modules.entries()).map(([path, module]) => ({
-            path,
-            name: module.name,
-            description: module.description,
-            module,
-        }));
-    }
-    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 = [];
-        // 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) {
-            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 { data } = await matched.module.list(matched.subpath, {
-                    ...options,
-                    maxDepth: matched.maxDepth,
-                });
-                const children = data.map((entry) => ({
-                    ...entry,
-                    path: 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) {
-                throw new Error(`Error listing from module at ${matched.modulePath}: ${error.message}`);
-            }
-        }
-        return { data: results };
-    }
-    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?.data) {
-                return {
-                    ...res,
-                    data: {
-                        ...res.data,
-                        path: joinURL(modulePath, res.data.path),
-                    },
-                };
-            }
-        }
-        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,
-            data: {
-                ...res.data,
-                path: joinURL(module.modulePath, res.data.path),
-            },
-        };
-    }
-    async delete(path, options) {
-        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) {
-        const oldModule = this.findModules(oldPath, { exactMatch: true })[0];
-        const newModule = this.findModules(newPath, { exactMatch: true })[0];
-        // Both paths must be in the same module
-        if (!oldModule || !newModule || oldModule.modulePath !== newModule.modulePath) {
-            throw new Error(`Cannot rename across different modules. Both paths must be in the same module.`);
-        }
-        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 = {}) {
-        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 = z.array(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 { data, message } = await module.search(subpath, query, options);
-                results.push(...data.map((entry) => ({
-                    ...entry,
-                    path: joinURL(modulePath, entry.path),
-                })));
-                if (message)
-                    messages.push(message);
-            }
-            catch (error) {
-                throw new Error(`Error searching in module at ${modulePath}: ${error.message}`);
-            }
-        }
-        return { data: results, message: messages.join("; ") };
-    }
-    findModules(path, options) {
-        const maxDepth = Math.max(options?.maxDepth ?? DEFAULT_MAX_DEPTH, 1);
-        const matched = [];
-        for (const [modulePath, module] of this.modules) {
-            const pathSegments = path.split("/").filter(Boolean);
-            const modulePathSegments = modulePath.split("/").filter(Boolean);
-            let newMaxDepth;
-            let subpath;
-            let remainedModulePath;
-            if (!options?.exactMatch && modulePath.startsWith(path)) {
-                newMaxDepth = Math.max(0, maxDepth - (modulePathSegments.length - pathSegments.length));
-                subpath = "/";
-                remainedModulePath = joinURL("/", ...modulePathSegments.slice(pathSegments.length).slice(0, maxDepth));
-            }
-            else if (path.startsWith(modulePath)) {
-                newMaxDepth = maxDepth;
-                subpath = joinURL("/", ...pathSegments.slice(modulePathSegments.length));
-                remainedModulePath = "/";
-            }
-            else {
-                continue;
-            }
-            if (newMaxDepth < 0)
-                continue;
-            matched.push({ module, modulePath, maxDepth: newMaxDepth, subpath, remainedModulePath });
-        }
-        return matched;
-    }
-    async exec(path, args, options) {
-        const module = this.findModules(path)[0];
-        if (!module?.module.exec)
-            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 = nodejs.path.join(nodejs.os.tmpdir(), v7());
-            await nodejs.fs.mkdir(rootDir, { recursive: true });
-            for (const [modulePath, module] of this.modules) {
-                const physicalModulePath = nodejs.path.join(rootDir, modulePath);
-                await nodejs.fs.mkdir(nodejs.path.dirname(physicalModulePath), { recursive: true });
-                await module.symlinkToPhysical?.(physicalModulePath);
-            }
-            return rootDir;
-        })();
-        return this.physicalPath;
-    }
-    async cleanupPhysicalPath() {
-        if (this.physicalPath) {
-            await nodejs.fs.rm(await this.physicalPath, { recursive: true, force: true });
-            this.physicalPath = undefined;
-        }
-    }
-}