ac-storage 0.14.1 → 0.15.0

package/dist/bundle.cjs

@@ -2,8 +2,8 @@
 
 var fs = require('node:fs');
 var fs$1 = require('node:fs/promises');
-var fs$2 = require('fs');
 var path = require('node:path');
+var fs$2 = require('fs');
 
 function _interopNamespaceDefault(e) {
     var n = Object.create(null);
@@ -24,8 +24,8 @@ function _interopNamespaceDefault(e) {
 
 var fs__namespace$2 = /*#__PURE__*/_interopNamespaceDefault(fs);
 var fs__namespace = /*#__PURE__*/_interopNamespaceDefault(fs$1);
-var fs__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(fs$2);
 var path__namespace = /*#__PURE__*/_interopNamespaceDefault(path);
+var fs__namespace$1 = /*#__PURE__*/_interopNamespaceDefault(fs$2);
 
 let e$1 = class e extends Error{constructor(e){super(e),this.name="TreeNavigateError";}};const t$1="--tree-leaf";var i$1;let r$1 = class r{#e={};#t=".";#i=false;#r=true;constructor(){}static from(e,t={}){const r=new i$1;return r.#e=e,r.#t=t.delimiter??".",r.#i=t.allowWildcard??false,r.#r=t.allowRecursiveWildcard??true,r}subtree(t){const r=t.split(this.#t),a=this.#a(r,this.#e);if(!a)throw new e$1(`Path '${t}' does not exist`);if(i$1.#l(a.value)||i$1.#s(a.value))throw new e$1(`Path '${t}' is not a subtree`);const l=a.path.reduce((e,t)=>e[t],this.#e),s=new i$1;return s.#e=l,s.#t=this.#t,s.#i=this.#i,s}get(e,t){return this.walk(e,t)?.value??null}walk(e,t={}){if(""===e)return t.allowIntermediate?{value:this.#e,path:[]}:null;const r=e.split(this.#t),a=this.#a(r,this.#e);if(!a)return null;const l=a.value;return i$1.#l(l)?a:i$1.#s(l)?{value:l.value,path:a.path}:t.allowIntermediate?a:null}trace(e){const t=e.split(this.#t),r={treePath:[]},a=this.#a(t,this.#e,r);let l,s;if(a){const e=a.value;return i$1.#l(e)?(l=true,s=e):i$1.#s(e)?(l=true,s=e.value):(l=false,s=e),{find:true,isLeaf:l,value:s,nodePath:a?.path??[],tracePath:r.treePath,untracePath:t}}return {find:false,isLeaf:false,value:void 0,nodePath:[],tracePath:r.treePath,untracePath:t}}#a(e,t,r={treePath:[]}){const{treePath:a}=r,l=e.shift();if(null==l)return {value:t,path:[]};if("object"!=typeof t||i$1.#s(t))return e.unshift(l),null;if(a.push(l),l in t){const i=this.#a(e,t[l],r);if(i)return {value:i.value,path:[l,...i.path]}}else if(this.#i){if("*"in t){const i=this.#a(e,t["*"],r);if(i)return {value:i.value,path:["*",...i.path]}}if(this.#r&&"**/*"in t)return {value:t["**/*"],path:["**/*"]}}return null}static#l(e){return null==e||"object"!=typeof e}static#s(e){return 1==e[t$1]}};i$1=r$1;
 
@@ -513,31 +513,73 @@ class SchemaFlattener {
 }
 
 class JSONFS {
+    #writeLock = Promise.resolve();
     async read(filename) {
-        let contents;
-        if (fs.existsSync(filename)) {
-            const jsonText = await fs__namespace.readFile(filename, 'utf8');
-            try {
-                contents = JSON.parse(jsonText);
-            }
-            catch {
-                contents = {};
-            }
+        if (!fs.existsSync(filename)) {
+            return {};
         }
-        else {
-            contents = {};
+        const jsonText = await fs__namespace.readFile(filename, 'utf8');
+        if (jsonText.trim() === '') {
+            throw new Error(`JSON file is empty: "${filename}"`);
+        }
+        try {
+            return JSON.parse(jsonText);
+        }
+        catch (error) {
+            throw new Error(`Failed to parse JSON from "${filename}": ` +
+                `${error instanceof Error ? error.message : String(error)}. ` +
+                `Content preview: "${jsonText.substring(0, 100)}..."`);
         }
-        return contents;
     }
     async write(filename, contents) {
+        // Serialize writes using a lock chain
+        const previousLock = this.#writeLock;
+        let releaseLock;
+        this.#writeLock = new Promise((resolve) => {
+            releaseLock = resolve;
+        });
+        try {
+            // Wait for previous write to complete
+            await previousLock;
+            // Perform atomic write
+            await this.#atomicWrite(filename, contents);
+        }
+        finally {
+            releaseLock();
+        }
+    }
+    async #atomicWrite(filename, contents) {
         const jsonString = JSON.stringify(contents, null, 4);
-        await fs__namespace.writeFile(filename, jsonString, 'utf8');
+        const dir = path__namespace.dirname(filename);
+        // Generate unique temp file name
+        const tempFile = `${filename}.tmp.${Date.now()}.${Math.random().toString(36).substring(2)}`;
+        try {
+            // Ensure parent directory exists (create if needed)
+            await fs__namespace.mkdir(dir, { recursive: true });
+            // Write to temp file
+            await fs__namespace.writeFile(tempFile, jsonString, 'utf8');
+            // Atomic rename (this is atomic on POSIX systems)
+            await fs__namespace.rename(tempFile, filename);
+        }
+        catch (error) {
+            // Clean up temp file on failure
+            try {
+                if (fs.existsSync(tempFile)) {
+                    await fs__namespace.rm(tempFile);
+                }
+            }
+            catch {
+                // Ignore cleanup errors
+            }
+            throw error;
+        }
     }
     async rm(filename) {
         try {
             await fs__namespace.rm(filename);
         }
-        catch (error) {
+        catch {
+            // Ignore errors (file might not exist)
         }
     }
     async exists(filename) {
@@ -565,36 +607,28 @@ class DefaultValueProvider {
     constructor(navigate = null) {
         this.#navigate = navigate;
     }
-    /**
-     *
-     */
-    get(key, baseValue) {
+    get(key) {
         if (this.#navigate == null) {
-            return baseValue;
+            return undefined;
         }
         const result = this.#navigate.walk(key, { allowIntermediate: true });
         if (result == null) {
             return undefined;
         }
         else if (isJSONTypeData(result.value)) {
-            if (baseValue != null) {
-                return baseValue;
-            }
-            else {
-                const defaultValue = result.value.default_value;
-                return ((defaultValue != null)
-                    ? defaultValue
-                    : undefined);
-            }
+            const defaultValue = result.value.default_value;
+            return ((defaultValue != null)
+                ? defaultValue
+                : undefined);
         }
         else {
             // for (const [key, value] of Object.entries(result.value)) {
             //     console.log(key, value);
             // }
-            return this.#getDefaultData(result.value, baseValue);
+            return this.#getDefaultData(result.value);
         }
     }
-    #getDefaultData(typeData, baseValue) {
+    #getDefaultData(typeData) {
         if (t$1 in typeData) {
             if (typeData.value.default_value != null) {
                 return typeData.value.default_value;
@@ -602,17 +636,18 @@ class DefaultValueProvider {
             return undefined;
         }
         else {
-            let result = baseValue;
+            let hasKey = false;
+            const result = {};
             for (const [key, value] of Object.entries(typeData)) {
                 const defaultValue = this.#getDefaultData(value);
                 if (defaultValue !== undefined) {
-                    result ??= {};
-                    if (!(key in result)) {
-                        result[key] = defaultValue;
-                    }
+                    result[key] = defaultValue;
+                    hasKey = true;
                 }
             }
-            return result;
+            return (hasKey
+                ? result
+                : undefined);
         }
     }
 }
@@ -692,8 +727,8 @@ class JSONAccessor {
     getOne(key) {
         this.#ensureNotDropped();
         let value = this.#getData(key);
-        if (value == null || typeof value === 'object') {
-            value = this.#defaultValueProvider.get(key, value);
+        if (value == null) {
+            value = this.#defaultValueProvider.get(key);
         }
         return value;
     }
@@ -702,8 +737,8 @@ class JSONAccessor {
         const result = {};
         for (const key of keys) {
             let value = this.#getData(key);
-            if (value == null || typeof value === 'object') {
-                value = this.#defaultValueProvider.get(key, value);
+            if (value == null) {
+                value = this.#defaultValueProvider.get(key);
             }
             const resolved = resolveNestedRef(result, key, true);
             resolved.parent[resolved.key] = value;
@@ -889,7 +924,7 @@ class BinaryAccessor {
     async writeBase64(data) {
         this.#ensureNotDropped();
         const buffer = Buffer.from(data, 'base64');
-        this.write(buffer);
+        await this.write(buffer);
     }
     async readBase64() {
         this.#ensureNotDropped();
@@ -897,9 +932,11 @@ class BinaryAccessor {
         return buffer.toString('base64');
     }
     async drop() {
-        this.#ensureNotDropped();
+        if (this.#dropped)
+            return;
+        this.#dropped = true;
         if (fs.existsSync(this.#filePath)) {
-            fs__namespace.rm(this.#filePath, { force: true });
+            await fs__namespace.rm(this.#filePath, { force: true });
         }
     }
     async commit() {
@@ -1486,7 +1523,7 @@ class StorageAccessControl {
         chainDependency();
         return ac;
     }
-    async release(identifier) {
+    async destroy(identifier) {
         const walked = this.accessTree.walk(identifier);
         if (!walked) {
             throw new NotRegisterError(`'${identifier}' is not registered.`);
@@ -1494,11 +1531,11 @@ class StorageAccessControl {
         if (this.checkAccessIsDirectory(walked.value)) {
             throw new DirectoryAccessError(`> '${identifier}' is directory.`);
         }
-        await this.#events.onRelease(identifier);
+        await this.#events.onDestroy(identifier);
     }
-    async releaseDir(identifier) {
+    async destroyDir(identifier) {
         this.validateDirectoryPath(identifier);
-        await this.#events.onRelease(identifier);
+        await this.#events.onDestroy(identifier);
     }
     getAccessType(identifier) {
         const getAT = (access) => {
@@ -1522,6 +1559,16 @@ class StorageAccessControl {
             }
         }
     }
+    validateAccess(identifier, accessType) {
+        const walked = this.accessTree.walk(identifier, { allowIntermediate: true });
+        if (!walked) {
+            throw new NotRegisterError(`'${identifier}' is not registered.`);
+        }
+        if (this.checkAccessIsDirectory(walked.value)) {
+            throw new DirectoryAccessError(`'${identifier}' is directory.`);
+        }
+        return this.validateAndResolveAccess(walked.value, accessType, identifier);
+    }
     validateDirectoryPath(identifier) {
         const walked = this.accessTree.walk(identifier, { allowIntermediate: true });
         if (!walked || !this.checkAccessIsDirectory(walked.value)) {
@@ -1597,6 +1644,30 @@ class ACSubStorage {
     async accessAsBinary(identifier) {
         return await this.access(identifier, 'binary');
     }
+    async create(identifier, accessType) {
+        return await this.#master.create(this.#prefix + ':' + identifier, accessType);
+    }
+    async createAsJSON(identifier) {
+        return await this.create(identifier, 'json');
+    }
+    async createAsText(identifier) {
+        return await this.create(identifier, 'text');
+    }
+    async createAsBinary(identifier) {
+        return await this.create(identifier, 'binary');
+    }
+    async open(identifier, accessType) {
+        return await this.#master.open(this.#prefix + ':' + identifier, accessType);
+    }
+    async openAsJSON(identifier) {
+        return await this.open(identifier, 'json');
+    }
+    async openAsText(identifier) {
+        return await this.open(identifier, 'text');
+    }
+    async openAsBinary(identifier) {
+        return await this.open(identifier, 'binary');
+    }
     async copy(oldIdentifier, newIdentifier) {
         await this.#master.copy(this.#prefix + ':' + oldIdentifier, this.#prefix + ':' + newIdentifier);
     }
@@ -1612,6 +1683,15 @@ class ACSubStorage {
     async dropAll() {
         await this.#master.dropDir(this.#prefix);
     }
+    async release(identifier) {
+        await this.#master.release(this.#prefix + ':' + identifier);
+    }
+    async releaseDir(identifier) {
+        await this.#master.releaseDir(this.#prefix + ':' + identifier);
+    }
+    async releaseAll() {
+        await this.#master.releaseDir(this.#prefix);
+    }
     async commit(identifier = '') {
         await this.#master.commit(this.#prefix + ':' + identifier);
     }
@@ -1652,63 +1732,87 @@ class ACStorage {
         const cacheData = JSON.stringify(this.accessCache, null, 4);
         fs__namespace$2.writeFileSync(this.cachePath, cacheData, 'utf8');
     }
-    initAccessControl() {
-        const onAccess = async (identifier, sa) => {
-            const targetPath = path__namespace.join(this.basePath, identifier.replaceAll(':', '/'));
-            this.eventListeners.access?.(identifier, sa);
-            let item = this.accessors.get(identifier);
-            if (item != undefined && !item.isDropped()) {
-                return item;
+    async getOrCreateAccessorFromAccess(identifier, sa, mode) {
+        const targetPath = path__namespace.join(this.basePath, identifier.replaceAll(':', '/'));
+        this.eventListeners.access?.(identifier, sa);
+        let item = this.accessors.get(identifier);
+        if (item != undefined && !item.isDropped()) {
+            if (mode === 'create') {
+                throw new StorageError(`File '${identifier}' already exists in memory`);
             }
-            let acm;
-            switch (sa.accessType) {
-                case 'directory':
-                    acm = DirectoryAccessorManager.fromFS(targetPath, sa.tree);
-                    break;
-                case 'json':
-                    acm = JSONAccessorManager.fromFS(targetPath, sa.structure);
-                    break;
-                case 'binary':
-                    acm = BinaryAccessorManager.fromFS(targetPath);
-                    break;
-                case 'text':
-                    acm = TextAccessorManager.fromFS(targetPath);
-                    break;
-                case 'custom':
-                    const event = this.customAccessEvents[sa.id];
-                    if (!event) {
-                        throw new StorageError('Invalid access type');
-                    }
-                    const ac = await event.init(targetPath, ...sa.args);
-                    acm = CustomAccessorManager.from(ac, {
-                        customId: sa.id,
-                        event,
-                        actualPath: targetPath,
-                        customArgs: sa.args,
-                    });
-                    break;
-                default:
-                    // 기본 타입 이외에는 custom 타입으로 wrap되기 때문에 이 경우가 발생하지 않음
+            return item;
+        }
+        let acm;
+        switch (sa.accessType) {
+            case 'directory':
+                acm = DirectoryAccessorManager.fromFS(targetPath, sa.tree);
+                break;
+            case 'json':
+                acm = JSONAccessorManager.fromFS(targetPath, sa.structure);
+                break;
+            case 'binary':
+                acm = BinaryAccessorManager.fromFS(targetPath);
+                break;
+            case 'text':
+                acm = TextAccessorManager.fromFS(targetPath);
+                break;
+            case 'custom':
+                const event = this.customAccessEvents[sa.id];
+                if (!event) {
                     throw new StorageError('Invalid access type');
+                }
+                const ac = await event.init(targetPath, ...sa.args);
+                acm = CustomAccessorManager.from(ac, {
+                    customId: sa.id,
+                    event,
+                    actualPath: targetPath,
+                    customArgs: sa.args,
+                });
+                break;
+            default:
+                throw new StorageError('Invalid access type');
+        }
+        const exists = await acm.exists();
+        if (mode === 'create') {
+            if (exists) {
+                throw new StorageError(`File '${identifier}' already exists on disk`);
             }
-            if (!await acm.exists())
+            await acm.create();
+        }
+        else if (mode === 'open') {
+            if (!exists) {
+                throw new StorageError(`File '${identifier}' does not exist`);
+            }
+            await acm.load();
+        }
+        else {
+            if (!exists)
                 await acm.create();
             else
                 await acm.load();
-            this.accessCache[identifier] = sa.accessType !== 'custom' ? sa.accessType : sa.id;
-            this.accessors.set(identifier, acm);
-            return acm;
+        }
+        this.accessCache[identifier] = sa.accessType !== 'custom' ? sa.accessType : sa.id;
+        this.accessors.set(identifier, acm);
+        return acm;
+    }
+    async getOrCreateAccessor(identifier, accessType, mode) {
+        const sa = this.accessControl.validateAccess(identifier, accessType);
+        return await this.getOrCreateAccessorFromAccess(identifier, sa, mode);
+    }
+    initAccessControl() {
+        const onAccess = async (identifier, sa) => {
+            return await this.getOrCreateAccessorFromAccess(identifier, sa, 'access');
         };
-        const onRelease = async (identifier) => {
+        const onDestroy = async (identifier) => {
             const accessor = this.accessors.get(identifier);
             if (!accessor)
                 return;
             for (const child of accessor.dependent) {
-                await onRelease(child);
+                await onDestroy(child);
             }
             if (identifier === '')
                 return;
-            this.eventListeners.release?.(identifier);
+            this.eventListeners.destroy?.(identifier);
             if (!accessor.isDropped())
                 await accessor.drop();
             delete this.accessCache[identifier];
@@ -1722,7 +1826,7 @@ class ACStorage {
         };
         return new StorageAccessControl({
             onAccess,
-            onRelease,
+            onDestroy,
             onChainDependency,
         });
     }
@@ -1731,8 +1835,8 @@ class ACStorage {
             case 'access':
                 this.eventListeners.access = listener;
                 break;
-            case 'release':
-                this.eventListeners.release = listener;
+            case 'destroy':
+                this.eventListeners.destroy = listener;
                 break;
         }
     }
@@ -1761,6 +1865,32 @@ class ACStorage {
     async accessAsBinary(identifier) {
         return await this.access(identifier, 'binary');
     }
+    async create(identifier, accessType) {
+        const acm = await this.getOrCreateAccessor(identifier, accessType, 'create');
+        return acm.accessor;
+    }
+    async createAsJSON(identifier) {
+        return await this.create(identifier, 'json');
+    }
+    async createAsText(identifier) {
+        return await this.create(identifier, 'text');
+    }
+    async createAsBinary(identifier) {
+        return await this.create(identifier, 'binary');
+    }
+    async open(identifier, accessType) {
+        const acm = await this.getOrCreateAccessor(identifier, accessType, 'open');
+        return acm.accessor;
+    }
+    async openAsJSON(identifier) {
+        return await this.open(identifier, 'json');
+    }
+    async openAsText(identifier) {
+        return await this.open(identifier, 'text');
+    }
+    async openAsBinary(identifier) {
+        return await this.open(identifier, 'binary');
+    }
     async copy(oldIdentifier, newIdentifier) {
         const accessType = this.validateAndGetAccessTypePair(oldIdentifier, newIdentifier);
         await this.commit(oldIdentifier);
@@ -1808,13 +1938,40 @@ class ACStorage {
         if (identifier === '') {
             throw new StorageError('Cannot drop the root directory. use dropAll() instead.');
         }
-        await this.accessControl.releaseDir(identifier);
+        await this.accessControl.destroyDir(identifier);
     }
     async drop(identifier) {
-        await this.accessControl.release(identifier);
+        await this.accessControl.destroy(identifier);
     }
     async dropAll() {
-        await this.accessControl.releaseDir('');
+        await this.accessControl.destroyDir('');
+    }
+    async release(identifier) {
+        await this.commit(identifier);
+        await this.#unloadFromMemory(identifier);
+    }
+    async releaseDir(identifier) {
+        if (identifier === '') {
+            throw new StorageError('Cannot release the root directory. use releaseAll() instead.');
+        }
+        await this.commit(identifier);
+        await this.#unloadFromMemory(identifier);
+    }
+    async releaseAll() {
+        await this.commitAll();
+        await this.#unloadFromMemory('');
+    }
+    async #unloadFromMemory(identifier) {
+        const accessor = this.accessors.get(identifier);
+        if (!accessor)
+            return;
+        for (const child of accessor.dependent) {
+            await this.#unloadFromMemory(child);
+        }
+        if (identifier !== '') {
+            delete this.accessCache[identifier];
+            this.accessors.delete(identifier);
+        }
     }
     async commit(identifier = '') {
         await this.#commitRecursive(identifier);
@@ -1840,62 +1997,82 @@ class MemACStorage extends ACStorage {
     constructor() {
         super('', { noCache: true });
     }
-    initAccessControl() {
-        const onAccess = async (identifier, sa) => {
-            this.eventListeners.access?.(identifier, sa);
-            let item = this.accessors.get(identifier);
-            if (item != undefined && !item.isDropped()) {
-                return item;
+    async getOrCreateAccessorFromAccess(identifier, sa, mode) {
+        this.eventListeners.access?.(identifier, sa);
+        let item = this.accessors.get(identifier);
+        if (item != undefined && !item.isDropped()) {
+            if (mode === 'create') {
+                throw new StorageError(`File '${identifier}' already exists in memory`);
             }
-            let acm;
-            switch (sa.accessType) {
-                case 'directory':
-                    acm = DirectoryAccessorManager.fromMemory(sa.tree);
-                    break;
-                case 'json':
-                    acm = JSONAccessorManager.fromMemory(sa.structure);
-                    break;
-                case 'binary':
-                    acm = BinaryAccessorManager.fromMemory();
-                    break;
-                case 'text':
-                    acm = TextAccessorManager.fromMemory();
-                    break;
-                case 'custom':
-                    const event = this.customAccessEvents[sa.id];
-                    if (!event) {
-                        throw new StorageError('Invalid access type');
-                    }
-                    const ac = await event.init(null, ...sa.args);
-                    acm = CustomAccessorManager.from(ac, {
-                        customId: sa.id,
-                        event,
-                        actualPath: null,
-                        customArgs: sa.args,
-                    });
-                    break;
-                default:
-                    // 기본 타입 이외에는 custom 타입으로 wrap되기 때문에 이 경우가 발생하지 않음
-                    throw new StorageError('Logic Error : Invalid access type');
+            return item;
+        }
+        let acm;
+        switch (sa.accessType) {
+            case 'directory':
+                acm = DirectoryAccessorManager.fromMemory(sa.tree);
+                break;
+            case 'json':
+                acm = JSONAccessorManager.fromMemory(sa.structure);
+                break;
+            case 'binary':
+                acm = BinaryAccessorManager.fromMemory();
+                break;
+            case 'text':
+                acm = TextAccessorManager.fromMemory();
+                break;
+            case 'custom':
+                const event = this.customAccessEvents[sa.id];
+                if (!event) {
+                    throw new StorageError('Invalid access type');
+                }
+                const ac = await event.init(null, ...sa.args);
+                acm = CustomAccessorManager.from(ac, {
+                    customId: sa.id,
+                    event,
+                    actualPath: null,
+                    customArgs: sa.args,
+                });
+                break;
+            default:
+                throw new StorageError('Logic Error : Invalid access type');
+        }
+        const exists = await acm.exists();
+        if (mode === 'create') {
+            if (exists) {
+                throw new StorageError(`File '${identifier}' already exists in memory`);
             }
-            if (!acm.exists())
-                acm.create();
+            await acm.create();
+        }
+        else if (mode === 'open') {
+            if (!exists) {
+                throw new StorageError(`File '${identifier}' does not exist`);
+            }
+            await acm.load();
+        }
+        else {
+            if (!exists)
+                await acm.create();
             else
-                acm.load();
-            this.accessCache[identifier] = sa.accessType !== 'custom' ? sa.accessType : sa.id;
-            this.accessors.set(identifier, acm);
-            return acm;
+                await acm.load();
+        }
+        this.accessCache[identifier] = sa.accessType !== 'custom' ? sa.accessType : sa.id;
+        this.accessors.set(identifier, acm);
+        return acm;
+    }
+    initAccessControl() {
+        const onAccess = async (identifier, sa) => {
+            return await this.getOrCreateAccessorFromAccess(identifier, sa, 'access');
         };
-        const onRelease = async (identifier) => {
+        const onDestroy = async (identifier) => {
             const accessor = this.accessors.get(identifier);
             if (!accessor)
                 return;
             for (const child of accessor.dependent) {
-                await onRelease(child);
+                await onDestroy(child);
             }
             if (identifier === '')
                 return;
-            this.eventListeners.release?.(identifier);
+            this.eventListeners.destroy?.(identifier);
             if (!accessor.isDropped())
                 accessor.drop();
             delete this.accessCache[identifier];
@@ -1909,10 +2086,37 @@ class MemACStorage extends ACStorage {
         };
         return new StorageAccessControl({
             onAccess,
-            onRelease,
+            onDestroy,
             onChainDependency,
         });
     }
+    async release(identifier) {
+        await this.commit(identifier);
+        await this.#unloadFromMemory(identifier);
+    }
+    async releaseDir(identifier) {
+        if (identifier === '') {
+            throw new StorageError('Cannot release the root directory. use releaseAll() instead.');
+        }
+        await this.commit(identifier);
+        await this.#unloadFromMemory(identifier);
+    }
+    async releaseAll() {
+        await this.commitAll();
+        await this.#unloadFromMemory('');
+    }
+    async #unloadFromMemory(identifier) {
+        const accessor = this.accessors.get(identifier);
+        if (!accessor)
+            return;
+        for (const child of accessor.dependent) {
+            await this.#unloadFromMemory(child);
+        }
+        if (identifier !== '') {
+            delete this.accessCache[identifier];
+            this.accessors.delete(identifier);
+        }
+    }
 }
 
 class StorageAccess {