@adaas/a-frame 0.1.1 → 0.1.2

package/dist/node/chunk-JN3UJBUH.mjs

@@ -0,0 +1,608 @@
+import { A_FrameStorageCodec } from './chunk-OYZAQMKD.mjs';
+import { A_FrameCredentials } from './chunk-SL7FT5R5.mjs';
+import { A_FrameCrypto } from './chunk-UPA7VN4R.mjs';
+import { A_FrameEnv } from './chunk-5OTXZ7BB.mjs';
+import { A_FrameNamespace, A_FrameNamespaceFeatures } from './chunk-AMMQ76RJ.mjs';
+import { A_FrameDefinition, A_FrameDefinitionFeatures } from './chunk-RVXASBMQ.mjs';
+import { __decorateClass, __decorateParam } from './chunk-OI76LHVT.mjs';
+import { A_Feature, A_Inject, A_Caller, A_Error, A_Fragment, A_Component, A_Scope, A_Context } from '@adaas/a-concept';
+import fs from 'fs/promises';
+import path from 'path';
+
+var A_FrameContext = class extends A_Fragment {
+  constructor() {
+    super({ name: "a-frame-context" });
+  }
+  get encryptionKey() {
+    return this._credentials?.encryptionKey;
+  }
+  get serverVersion() {
+    return this._credentials?.serverVersion;
+  }
+  isAuthenticated() {
+    return !!this._credentials?.isAuthenticated;
+  }
+  setCredentials(credentialsRequest) {
+    if (credentialsRequest.error || !credentialsRequest.response) {
+      this._credentials = void 0;
+      return;
+    }
+    this._credentials = new A_FrameCredentials(credentialsRequest.response);
+  }
+};
+
+// src/lib/A-FrameStorage/A-FrameStorage.constants.ts
+var A_FrameStorageFeatures = {
+  SaveDefinitions: "_A_FRAME_STORAGE_SAVE",
+  LoadDefinitions: "_A_FRAME_STORAGE_LOAD",
+  DestroyDefinitions: "_A_FRAME_STORAGE_DESTROY",
+  SaveNamespaces: "_A_FRAME_STORAGE_SAVE_NAMESPACES",
+  LoadNamespaces: "_A_FRAME_STORAGE_LOAD_NAMESPACES",
+  DestroyNamespaces: "_A_FRAME_STORAGE_DESTROY_NAMESPACES"
+};
+var A_FrameStorageOperation = class extends A_Fragment {
+  constructor(params) {
+    super({ name: "a-frame-storage-operation" });
+    this._params = params;
+  }
+  /**
+   * If the operation succeeded, this will contain the result data. If the operation failed, this will be undefined.
+   */
+  get result() {
+    return this._result;
+  }
+  /**
+   * If the operation failed, this will contain an error object with details about the failure. If the operation succeeded, this will be undefined.
+   */
+  get error() {
+    return this._error;
+  }
+  /**
+   * Parameters used to execute the operation, e.g. definitionId and namespaceId for a saveDefinition operation.
+   */
+  get params() {
+    return this._params;
+  }
+  /**
+   * Marks the operation as completed successfully with the given result. This will set the `result` property and leave `error` as undefined.
+   * 
+   * @param result 
+   */
+  complete(result) {
+    this._result = result;
+  }
+  /**
+   * Marks the operation as failed with the given error. This will set the `error` property and leave `result` as undefined.
+   * 
+   * @param error 
+   */
+  fail(error) {
+    this._error = error;
+  }
+};
+var A_FrameStorageError = class extends A_Error {
+};
+A_FrameStorageError.SaveDefinitionFailed = "SaveDefinitionFailed";
+A_FrameStorageError.LoadDefinitionsFailed = "LoadDefinitionsFailed";
+A_FrameStorageError.DestroyDefinitionsFailed = "DestroyDefinitionsFailed";
+A_FrameStorageError.SaveNamespaceFailed = "SaveNamespaceFailed";
+A_FrameStorageError.LoadNamespacesFailed = "LoadNamespacesFailed";
+A_FrameStorageError.DestroyNamespacesFailed = "DestroyNamespacesFailed";
+var A_FrameStorage = class extends A_Component {
+  async saveDefinitions(definitions) {
+    const context = new A_FrameStorageOperation({
+      records: definitions
+    });
+    const executionScope = new A_Scope({
+      name: "A_FrameStorage.saveDefinitions",
+      fragments: [context]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameStorageFeatures.SaveDefinitions, executionScope);
+      executionScope.destroy();
+      return context;
+    } catch (error) {
+      context.fail(new A_FrameStorageError({
+        title: A_FrameStorageError.SaveDefinitionFailed,
+        description: `Failed to save definition records.`
+      }));
+      executionScope.destroy();
+      return context;
+    }
+  }
+  async loadDefinitions(namespaceId, definitionId) {
+    const context = new A_FrameStorageOperation({
+      namespaceId
+    });
+    const executionScope = new A_Scope({
+      name: "A_FrameStorage.loadDefinitions",
+      fragments: [context]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameStorageFeatures.LoadDefinitions, executionScope);
+      executionScope.destroy();
+      return context;
+    } catch (error) {
+      context.fail(new A_FrameStorageError({
+        title: A_FrameStorageError.LoadDefinitionsFailed,
+        description: `Failed to load definition records.`
+      }));
+      executionScope.destroy();
+      return context;
+    }
+  }
+  async destroyDefinitions(namespaceId, definitionId) {
+    const context = new A_FrameStorageOperation({
+      namespaceId,
+      definitionId
+    });
+    const executionScope = new A_Scope({
+      name: "A_FrameStorage.destroyDefinitions",
+      fragments: [context]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameStorageFeatures.DestroyDefinitions, executionScope);
+      executionScope.destroy();
+      return context;
+    } catch (error) {
+      context.fail(new A_FrameStorageError({
+        title: A_FrameStorageError.DestroyDefinitionsFailed,
+        description: `Failed to destroy definition records.`
+      }));
+      executionScope.destroy();
+      return context;
+    }
+  }
+  async saveNamespaces(namespaces) {
+    const context = new A_FrameStorageOperation({
+      records: namespaces
+    });
+    const executionScope = new A_Scope({
+      name: "A_FrameStorage.saveNamespaces",
+      fragments: [context]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameStorageFeatures.SaveNamespaces, executionScope);
+      executionScope.destroy();
+      return context;
+    } catch (error) {
+      context.fail(new A_FrameStorageError({
+        title: A_FrameStorageError.SaveNamespaceFailed,
+        description: `Failed to save namespace records.`
+      }));
+      executionScope.destroy();
+      return context;
+    }
+  }
+  async loadNamespaces(namespaceIds) {
+    const context = new A_FrameStorageOperation({
+      namespaces: namespaceIds
+    });
+    const executionScope = new A_Scope({
+      name: "A_FrameStorage.loadNamespaces",
+      fragments: [context]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameStorageFeatures.LoadNamespaces, executionScope);
+      executionScope.destroy();
+      return context;
+    } catch (error) {
+      context.fail(new A_FrameStorageError({
+        title: A_FrameStorageError.LoadNamespacesFailed,
+        description: `Failed to load namespace records.`
+      }));
+      executionScope.destroy();
+      return context;
+    }
+  }
+  async destroyNamespaces(namespacesIds) {
+    const context = new A_FrameStorageOperation({
+      namespaces: namespacesIds
+    });
+    const executionScope = new A_Scope({
+      name: "A_FrameStorage.destroyNamespaces",
+      fragments: [context]
+    }).inherit(A_Context.scope(this));
+    try {
+      await this.call(A_FrameStorageFeatures.DestroyNamespaces, executionScope);
+      executionScope.destroy();
+      return context;
+    } catch (error) {
+      context.fail(new A_FrameStorageError({
+        title: A_FrameStorageError.DestroyNamespacesFailed,
+        description: `Failed to destroy namespace records.`
+      }));
+      executionScope.destroy();
+      return context;
+    }
+  }
+};
+var A_FrameNodeStorage = class extends A_FrameStorage {
+  /** Returns file contents, or null when the file does not exist yet. Re-throws all other I/O errors. */
+  async tryReadFile(filePath) {
+    try {
+      return await fs.readFile(filePath);
+    } catch (err) {
+      if (err?.code === "ENOENT") return null;
+      throw err;
+    }
+  }
+  /**
+   * Resolves extra storage directories by expanding each comma-separated glob
+   * pattern in `pattern`.  Returns an empty array when `pattern` is blank or
+   * when no paths match.  Errors from unsupported patterns are swallowed so
+   * that a bad env value never breaks the application.
+   */
+  async listExtraStorageDirs(pattern) {
+    if (!pattern) return [];
+    const dirs = [];
+    for (const p of pattern.split(",").map((s) => s.trim()).filter(Boolean)) {
+      try {
+        for await (const match of fs.glob(p)) {
+          dirs.push(match);
+        }
+      } catch {
+      }
+    }
+    return dirs;
+  }
+  async saveDefinitionToDisk(definition, env, context, codec, aFrameCrypto) {
+    const namespace = definition.namespace;
+    const incoming = definition.toJSON();
+    if (!incoming.embedding)
+      throw new Error("Only definitions with embeddings can be saved to storage");
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getDefinitionsFileName(namespace.id)));
+    const existing = rawBuf ? codec.decodePayload(await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey)) : [];
+    const merged = /* @__PURE__ */ new Map();
+    for (const r of existing) merged.set(r.hash, r);
+    merged.set(incoming.hash, incoming);
+    const records = Array.from(merged.values());
+    const payload = codec.encodePayload(records);
+    const encrypted = await aFrameCrypto.encryptBytes(payload, context.encryptionKey);
+    await fs.mkdir(env.A_FRAME_STORAGE_DIR, { recursive: true });
+    await fs.writeFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getDefinitionsFileName(namespace.id)), encrypted);
+  }
+  async loadDefinitionFromDisk(definition, env, context, codec, aFrameCrypto) {
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getDefinitionsFileName(definition.namespace.id)));
+    if (rawBuf) {
+      const plain = await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey);
+      const record = codec.decodePayload(plain).find((r) => r.aseid === definition.aseid.toString());
+      if (record && record.hash === definition.hash && record.aFrameServerVersion === context.serverVersion) {
+        definition.fromJSON(record);
+        return;
+      }
+    }
+    for (const dir of await this.listExtraStorageDirs(env.A_FRAME_STORAGE_PATTERN)) {
+      const extraBuf = await this.tryReadFile(path.join(dir, codec.getDefinitionsFileName(definition.namespace.id)));
+      if (!extraBuf) continue;
+      try {
+        const plain = await aFrameCrypto.decryptBytes(new Uint8Array(extraBuf), context.encryptionKey);
+        const record = codec.decodePayload(plain).find((r) => r.aseid === definition.aseid.toString());
+        if (record && record.hash === definition.hash && record.aFrameServerVersion === context.serverVersion) {
+          definition.fromJSON(record);
+          return;
+        }
+      } catch {
+      }
+    }
+  }
+  async destroyDefinitionFromDisk(definition, env, context, codec, aFrameCrypto) {
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getDefinitionsFileName(definition.namespace.id)));
+    if (!rawBuf) return;
+    const plain = await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey);
+    const records = codec.decodePayload(plain);
+    const filtered = records.filter((r) => r.aseid !== definition.aseid.toString());
+    const payload = codec.encodePayload(filtered);
+    const encrypted = await aFrameCrypto.encryptBytes(payload, context.encryptionKey);
+    await fs.mkdir(env.A_FRAME_STORAGE_DIR, { recursive: true });
+    await fs.writeFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getDefinitionsFileName(definition.namespace.id)), encrypted);
+  }
+  async saveNamespaceToDisk(namespace, env, context, codec, aFrameCrypto) {
+    const incoming = namespace.toJSON();
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getNamespaceFileName()));
+    const existing = rawBuf ? codec.decodeNamespacePayload(await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey)) : [];
+    const merged = /* @__PURE__ */ new Map();
+    for (const r of existing) merged.set(r.aseid, r);
+    merged.set(incoming.aseid.toString(), incoming);
+    const records = Array.from(merged.values());
+    const payload = codec.encodeNamespacePayload(records);
+    const encrypted = await aFrameCrypto.encryptBytes(payload, context.encryptionKey);
+    await fs.mkdir(env.A_FRAME_STORAGE_DIR, { recursive: true });
+    await fs.writeFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getNamespaceFileName()), encrypted);
+  }
+  async loadNamespaceFromDisk(namespace, env, context, aFrameCrypto, codec) {
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getNamespaceFileName()));
+    if (rawBuf) {
+      const plain = await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey);
+      const record = codec.decodeNamespacePayload(plain).find((r) => r.aseid === namespace.aseid.toString());
+      if (record && record.hash === namespace.hash && record.aFrameServerVersion === context.serverVersion) {
+        namespace.fromJSON(record);
+        return;
+      }
+    }
+    for (const dir of await this.listExtraStorageDirs(env.A_FRAME_STORAGE_PATTERN)) {
+      const extraBuf = await this.tryReadFile(path.join(dir, codec.getNamespaceFileName()));
+      if (!extraBuf) continue;
+      try {
+        const plain = await aFrameCrypto.decryptBytes(new Uint8Array(extraBuf), context.encryptionKey);
+        const record = codec.decodeNamespacePayload(plain).find((r) => r.aseid === namespace.aseid.toString());
+        if (record && record.hash === namespace.hash && record.aFrameServerVersion === context.serverVersion) {
+          namespace.fromJSON(record);
+          return;
+        }
+      } catch {
+      }
+    }
+  }
+  async destroyNamespaceFromLocalFileStorage(namespace, env, context, codec, aFrameCrypto) {
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getNamespaceFileName()));
+    if (!rawBuf) return;
+    const plain = await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey);
+    const records = codec.decodeNamespacePayload(plain);
+    const filtered = records.filter((r) => r.aseid !== namespace.aseid.toString());
+    const payload = codec.encodeNamespacePayload(filtered);
+    const encrypted = await aFrameCrypto.encryptBytes(payload, context.encryptionKey);
+    await fs.mkdir(env.A_FRAME_STORAGE_DIR, { recursive: true });
+    await fs.writeFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getNamespaceFileName()), encrypted);
+    try {
+      await fs.unlink(path.join(env.A_FRAME_STORAGE_DIR, codec.getDefinitionsFileName(namespace.id)));
+    } catch {
+    }
+  }
+  async saveDefinitionsToDisk(env, operation, context, codec, aFrameCrypto) {
+    const records = operation.params.records;
+    const namespace = records[0].namespace;
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getDefinitionsFileName(namespace)));
+    const existing = rawBuf ? codec.decodePayload(await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey)) : [];
+    const merged = /* @__PURE__ */ new Map();
+    for (const r of existing) merged.set(r.hash, r);
+    for (const d of records) merged.set(d.hash, d);
+    const result = Array.from(merged.values());
+    const payload = codec.encodePayload(result);
+    const encrypted = await aFrameCrypto.encryptBytes(payload, context.encryptionKey);
+    await fs.mkdir(env.A_FRAME_STORAGE_DIR, { recursive: true });
+    await fs.writeFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getDefinitionsFileName(namespace)), encrypted);
+    operation.complete({
+      saved: records.length
+    });
+  }
+  async loadDefinitionsFromDisk(env, operation, context, codec, aFrameCrypto) {
+    const namespace = operation.params.namespaceId;
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getDefinitionsFileName(namespace)));
+    const primaryRecords = rawBuf ? codec.decodePayload(await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey)) : [];
+    const merged = /* @__PURE__ */ new Map();
+    for (const r of primaryRecords) merged.set(r.hash, r);
+    for (const dir of await this.listExtraStorageDirs(env.A_FRAME_STORAGE_PATTERN)) {
+      const extraBuf = await this.tryReadFile(path.join(dir, codec.getDefinitionsFileName(namespace)));
+      if (!extraBuf) continue;
+      try {
+        const extraRecords = codec.decodePayload(
+          await aFrameCrypto.decryptBytes(new Uint8Array(extraBuf), context.encryptionKey)
+        );
+        for (const r of extraRecords) {
+          if (!merged.has(r.hash)) merged.set(r.hash, r);
+        }
+      } catch {
+      }
+    }
+    operation.complete({
+      records: Array.from(merged.values())
+    });
+  }
+  async destroyDefinitionsFromDisk(env, operation, context, codec, aFrameCrypto) {
+    const namespace = operation.params.namespaceId;
+    const definitionId = operation.params.definitionId;
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getDefinitionsFileName(namespace)));
+    const records = rawBuf ? codec.decodePayload(await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey)) : [];
+    const filtered = records.filter((r) => r.aseid !== definitionId);
+    const payload = codec.encodePayload(filtered);
+    const encrypted = await aFrameCrypto.encryptBytes(payload, context.encryptionKey);
+    await fs.mkdir(env.A_FRAME_STORAGE_DIR, { recursive: true });
+    await fs.writeFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getDefinitionsFileName(namespace)), encrypted);
+    operation.complete({
+      records: filtered
+    });
+  }
+  async saveNamespacesToDisk(env, operation, context, codec, aFrameCrypto) {
+    const records = operation.params.records;
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getNamespaceFileName()));
+    const existing = rawBuf ? codec.decodeNamespacePayload(await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey)) : [];
+    const merged = /* @__PURE__ */ new Map();
+    for (const r of existing) merged.set(r.aseid, r);
+    for (const d of records) merged.set(d.aseid.toString(), d);
+    const result = Array.from(merged.values());
+    const payload = codec.encodeNamespacePayload(result);
+    const encrypted = await aFrameCrypto.encryptBytes(payload, context.encryptionKey);
+    await fs.mkdir(env.A_FRAME_STORAGE_DIR, { recursive: true });
+    await fs.writeFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getNamespaceFileName()), encrypted);
+    operation.complete({
+      success: true
+    });
+  }
+  async loadNamespacesFromDisk(env, operation, context, codec, aFrameCrypto) {
+    const ids = operation.params.namespaces;
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getNamespaceFileName()));
+    const primaryRecords = rawBuf ? codec.decodeNamespacePayload(await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey)) : [];
+    const merged = /* @__PURE__ */ new Map();
+    for (const r of primaryRecords) merged.set(r.aseid, r);
+    for (const dir of await this.listExtraStorageDirs(env.A_FRAME_STORAGE_PATTERN)) {
+      const extraBuf = await this.tryReadFile(path.join(dir, codec.getNamespaceFileName()));
+      if (!extraBuf) continue;
+      try {
+        const extraRecords = codec.decodeNamespacePayload(
+          await aFrameCrypto.decryptBytes(new Uint8Array(extraBuf), context.encryptionKey)
+        );
+        for (const r of extraRecords) {
+          if (!merged.has(r.aseid)) merged.set(r.aseid, r);
+        }
+      } catch {
+      }
+    }
+    const allRecords = Array.from(merged.values());
+    operation.complete({
+      records: ids ? allRecords.filter((r) => ids.includes(r.name)) : allRecords
+    });
+  }
+  async destroyNamespacesFromDisk(env, operation, context, codec, aFrameCrypto) {
+    const ids = operation.params.namespaces;
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getNamespaceFileName()));
+    const records = rawBuf ? codec.decodeNamespacePayload(await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey)) : [];
+    const filtered = records.filter((r) => !ids.includes(r.aseid));
+    const payload = codec.encodeNamespacePayload(filtered);
+    const encrypted = await aFrameCrypto.encryptBytes(payload, context.encryptionKey);
+    await fs.mkdir(env.A_FRAME_STORAGE_DIR, { recursive: true });
+    await fs.writeFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getNamespaceFileName()), encrypted);
+    try {
+      for (const id of ids) {
+        await fs.unlink(path.join(env.A_FRAME_STORAGE_DIR, codec.getDefinitionsFileName(id)));
+      }
+      operation.complete({
+        success: true
+      });
+    } catch (error) {
+      operation.fail(new A_FrameStorageError({
+        title: A_FrameStorageError.DestroyNamespacesFailed,
+        description: `Failed to destroy namespace records.`
+      }));
+      operation.complete({
+        success: false
+      });
+    }
+  }
+};
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameDefinitionFeatures.Save,
+    scope: [A_FrameDefinition]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv)),
+  __decorateParam(2, A_Inject(A_FrameContext)),
+  __decorateParam(3, A_Inject(A_FrameStorageCodec)),
+  __decorateParam(4, A_Inject(A_FrameCrypto))
+], A_FrameNodeStorage.prototype, "saveDefinitionToDisk", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameDefinitionFeatures.Load,
+    scope: [A_FrameDefinition]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv)),
+  __decorateParam(2, A_Inject(A_FrameContext)),
+  __decorateParam(3, A_Inject(A_FrameStorageCodec)),
+  __decorateParam(4, A_Inject(A_FrameCrypto))
+], A_FrameNodeStorage.prototype, "loadDefinitionFromDisk", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameDefinitionFeatures.Destroy,
+    scope: [A_FrameDefinition]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv)),
+  __decorateParam(2, A_Inject(A_FrameContext)),
+  __decorateParam(3, A_Inject(A_FrameStorageCodec)),
+  __decorateParam(4, A_Inject(A_FrameCrypto))
+], A_FrameNodeStorage.prototype, "destroyDefinitionFromDisk", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameNamespaceFeatures.Save,
+    scope: [A_FrameNamespace]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv)),
+  __decorateParam(2, A_Inject(A_FrameContext)),
+  __decorateParam(3, A_Inject(A_FrameStorageCodec)),
+  __decorateParam(4, A_Inject(A_FrameCrypto))
+], A_FrameNodeStorage.prototype, "saveNamespaceToDisk", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameNamespaceFeatures.Load,
+    scope: [A_FrameNamespace]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv)),
+  __decorateParam(2, A_Inject(A_FrameContext)),
+  __decorateParam(3, A_Inject(A_FrameCrypto)),
+  __decorateParam(4, A_Inject(A_FrameStorageCodec))
+], A_FrameNodeStorage.prototype, "loadNamespaceFromDisk", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameNamespaceFeatures.Destroy,
+    scope: [A_FrameNamespace]
+  }),
+  __decorateParam(0, A_Inject(A_Caller)),
+  __decorateParam(1, A_Inject(A_FrameEnv)),
+  __decorateParam(2, A_Inject(A_FrameContext)),
+  __decorateParam(3, A_Inject(A_FrameStorageCodec)),
+  __decorateParam(4, A_Inject(A_FrameCrypto))
+], A_FrameNodeStorage.prototype, "destroyNamespaceFromLocalFileStorage", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameStorageFeatures.SaveDefinitions,
+    scope: [A_FrameStorage]
+  }),
+  __decorateParam(0, A_Inject(A_FrameEnv)),
+  __decorateParam(1, A_Inject(A_FrameStorageOperation)),
+  __decorateParam(2, A_Inject(A_FrameContext)),
+  __decorateParam(3, A_Inject(A_FrameStorageCodec)),
+  __decorateParam(4, A_Inject(A_FrameCrypto))
+], A_FrameNodeStorage.prototype, "saveDefinitionsToDisk", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameStorageFeatures.LoadDefinitions,
+    scope: [A_FrameStorage]
+  }),
+  __decorateParam(0, A_Inject(A_FrameEnv)),
+  __decorateParam(1, A_Inject(A_FrameStorageOperation)),
+  __decorateParam(2, A_Inject(A_FrameContext)),
+  __decorateParam(3, A_Inject(A_FrameStorageCodec)),
+  __decorateParam(4, A_Inject(A_FrameCrypto))
+], A_FrameNodeStorage.prototype, "loadDefinitionsFromDisk", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameStorageFeatures.DestroyDefinitions,
+    scope: [A_FrameStorage]
+  }),
+  __decorateParam(0, A_Inject(A_FrameEnv)),
+  __decorateParam(1, A_Inject(A_FrameStorageOperation)),
+  __decorateParam(2, A_Inject(A_FrameContext)),
+  __decorateParam(3, A_Inject(A_FrameStorageCodec)),
+  __decorateParam(4, A_Inject(A_FrameCrypto))
+], A_FrameNodeStorage.prototype, "destroyDefinitionsFromDisk", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameStorageFeatures.SaveNamespaces,
+    scope: [A_FrameStorage]
+  }),
+  __decorateParam(0, A_Inject(A_FrameEnv)),
+  __decorateParam(1, A_Inject(A_FrameStorageOperation)),
+  __decorateParam(2, A_Inject(A_FrameContext)),
+  __decorateParam(3, A_Inject(A_FrameStorageCodec)),
+  __decorateParam(4, A_Inject(A_FrameCrypto))
+], A_FrameNodeStorage.prototype, "saveNamespacesToDisk", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameStorageFeatures.LoadNamespaces,
+    scope: [A_FrameStorage]
+  }),
+  __decorateParam(0, A_Inject(A_FrameEnv)),
+  __decorateParam(1, A_Inject(A_FrameStorageOperation)),
+  __decorateParam(2, A_Inject(A_FrameContext)),
+  __decorateParam(3, A_Inject(A_FrameStorageCodec)),
+  __decorateParam(4, A_Inject(A_FrameCrypto))
+], A_FrameNodeStorage.prototype, "loadNamespacesFromDisk", 1);
+__decorateClass([
+  A_Feature.Extend({
+    name: A_FrameStorageFeatures.DestroyNamespaces,
+    scope: [A_FrameStorage]
+  }),
+  __decorateParam(0, A_Inject(A_FrameEnv)),
+  __decorateParam(1, A_Inject(A_FrameStorageOperation)),
+  __decorateParam(2, A_Inject(A_FrameContext)),
+  __decorateParam(3, A_Inject(A_FrameStorageCodec)),
+  __decorateParam(4, A_Inject(A_FrameCrypto))
+], A_FrameNodeStorage.prototype, "destroyNamespacesFromDisk", 1);
+
+export { A_FrameContext, A_FrameNodeStorage, A_FrameStorage, A_FrameStorageError, A_FrameStorageFeatures, A_FrameStorageOperation };
+//# sourceMappingURL=chunk-JN3UJBUH.mjs.map
+//# sourceMappingURL=chunk-JN3UJBUH.mjs.map