@adaas/a-frame 0.0.23 → 0.1.1

package/dist/node/chunk-5BKCX2RO.mjs

@@ -0,0 +1,33 @@
+import { version } from './chunk-OYC6L5NX.mjs';
+import { A_Fragment } from '@adaas/a-concept';
+
+var A_FrameEnv = class extends A_Fragment {
+  get A_FRAME_FILE_EXTENSION() {
+    return ".aframe";
+  }
+  get A_FRAME_NAMESPACES_BIN() {
+    return `__namespaces${this.A_FRAME_FILE_EXTENSION}`;
+  }
+  get A_FRAME_SYNC() {
+    return process.env.A_FRAME_SYNC === "false" ? false : true;
+  }
+  get A_FRAME_TOKEN() {
+    return process.env.A_FRAME_TOKEN || "";
+  }
+  get A_FRAME_SERVER_URL() {
+    return process.env.A_FRAME_SERVER_URL || "http://localhost:3663";
+  }
+  get A_FRAME_SERVER_API_KEY() {
+    return process.env.A_FRAME_SERVER_API_KEY || "";
+  }
+  get A_FRAME_STORAGE_DIR() {
+    return process.env.A_FRAME_STORAGE_DIR || ".aframestr";
+  }
+  get A_FRAME_VERSION() {
+    return version || "0.0.1";
+  }
+};
+
+export { A_FrameEnv };
+//# sourceMappingURL=chunk-5BKCX2RO.mjs.map
+//# sourceMappingURL=chunk-5BKCX2RO.mjs.map

package/dist/node/chunk-5BKCX2RO.mjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../src/lib/A-FrameEnv/A-FrameEnv.fragment.env-node.ts"],"names":[],"mappings":";;;AAKO,IAAM,UAAA,GAAN,cAAyB,UAAA,CAAkC;AAAA,EAE9D,IAAI,sBAAA,GAAyB;AACzB,IAAA,OAAO,SAAA;AAAA,EACX;AAAA,EAEA,IAAI,sBAAA,GAAyB;AACzB,IAAA,OAAO,CAAA,YAAA,EAAe,KAAK,sBAAsB,CAAA,CAAA;AAAA,EACrD;AAAA,EAEA,IAAI,YAAA,GAAe;AACf,IAAA,OAAO,OAAA,CAAQ,GAAA,CAAI,YAAA,KAAiB,OAAA,GAAU,KAAA,GAAQ,IAAA;AAAA,EAC1D;AAAA,EAEA,IAAI,aAAA,GAAgB;AAChB,IAAA,OAAO,OAAA,CAAQ,IAAI,aAAA,IAAiB,EAAA;AAAA,EACxC;AAAA,EAEA,IAAI,kBAAA,GAAqB;AACrB,IAAA,OAAO,OAAA,CAAQ,IAAI,kBAAA,IAAsB,uBAAA;AAAA,EAC7C;AAAA,EAEA,IAAI,sBAAA,GAAyB;AACzB,IAAA,OAAO,OAAA,CAAQ,IAAI,sBAAA,IAA0B,EAAA;AAAA,EACjD;AAAA,EAEA,IAAI,mBAAA,GAAsB;AACtB,IAAA,OAAO,OAAA,CAAQ,IAAI,mBAAA,IAAuB,YAAA;AAAA,EAC9C;AAAA,EAEA,IAAI,eAAA,GAAkB;AAClB,IAAA,OAAW,OAAA,IAAW,OAAA;AAAA,EAC1B;AACJ","file":"chunk-5BKCX2RO.mjs","sourcesContent":["import { A_Fragment } from \"@adaas/a-concept\";\nimport * as pkg from '../../../package.json';\nimport { IA_FrameEnv } from \"./A-FrameEnv.types\";\n\n\nexport class A_FrameEnv extends A_Fragment implements IA_FrameEnv {\n\n    get A_FRAME_FILE_EXTENSION() {\n        return '.aframe';\n    }\n\n    get A_FRAME_NAMESPACES_BIN() {\n        return `__namespaces${this.A_FRAME_FILE_EXTENSION}`;\n    }\n\n    get A_FRAME_SYNC() {\n        return process.env.A_FRAME_SYNC === 'false' ? false : true;\n    }\n\n    get A_FRAME_TOKEN() {\n        return process.env.A_FRAME_TOKEN || '';\n    }\n\n    get A_FRAME_SERVER_URL() {\n        return process.env.A_FRAME_SERVER_URL || 'http://localhost:3663';\n    }\n\n    get A_FRAME_SERVER_API_KEY() {\n        return process.env.A_FRAME_SERVER_API_KEY || '';\n    }\n\n    get A_FRAME_STORAGE_DIR() {\n        return process.env.A_FRAME_STORAGE_DIR || '.aframestr';\n    }\n\n    get A_FRAME_VERSION() {\n        return pkg.version || '0.0.1';\n    }\n}"]}

package/dist/node/chunk-6KAGWGTE.mjs

@@ -0,0 +1,529 @@
+import { A_FrameStorageCodec } from './chunk-3ONWH75E.mjs';
+import { A_FrameEnv } from './chunk-5BKCX2RO.mjs';
+import { A_FrameNamespace, A_FrameNamespaceFeatures } from './chunk-APRYHBEF.mjs';
+import { A_FrameCrypto } from './chunk-UPA7VN4R.mjs';
+import { A_FrameDefinition, A_FrameDefinitionFeatures } from './chunk-B7BXP7K4.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?.encryption_key;
+  }
+  get serverVersion() {
+    return this.credentials?.server_version;
+  }
+  isAuthenticated() {
+    return !!this.credentials;
+  }
+  setCredentials(credentials) {
+    if (credentials.error) {
+      this.credentials = void 0;
+      return;
+    }
+    this.credentials = credentials.response || void 0;
+  }
+};
+
+// 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;
+    }
+  }
+  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.getFileName(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.getFileName(namespace.id)), encrypted);
+  }
+  async loadDefinitionFromDisk(definition, env, context, codec, aFrameCrypto) {
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getFileName(definition.namespace.id)));
+    if (!rawBuf) return;
+    const plain = await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey);
+    const records = codec.decodePayload(plain);
+    const record = records.find((r) => r.aseid === definition.aseid.toString());
+    if (record && record.hash === definition.hash && record.aFrameServerVersion === context.serverVersion) {
+      definition.fromJSON(record);
+    }
+  }
+  async destroyDefinitionFromDisk(definition, env, context, codec, aFrameCrypto) {
+    const rawBuf = await this.tryReadFile(path.join(env.A_FRAME_STORAGE_DIR, codec.getFileName(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.getFileName(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) return;
+    const plain = await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey);
+    const records = codec.decodeNamespacePayload(plain);
+    const record = records.find((r) => r.aseid === namespace.aseid.toString());
+    if (record && record.hash === namespace.hash && record.aFrameServerVersion === context.serverVersion) {
+      namespace.fromJSON(record);
+    }
+  }
+  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.getFileName(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.getFileName(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.getFileName(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.getFileName(namespace)));
+    const records = rawBuf ? codec.decodePayload(await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey)) : [];
+    operation.complete({
+      records
+    });
+  }
+  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.getFileName(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.getFileName(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 records = rawBuf ? codec.decodeNamespacePayload(await aFrameCrypto.decryptBytes(new Uint8Array(rawBuf), context.encryptionKey)) : [];
+    operation.complete({
+      records: ids ? records.filter((r) => ids.includes(r.name)) : records
+    });
+  }
+  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.getFileName(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-6KAGWGTE.mjs.map
+//# sourceMappingURL=chunk-6KAGWGTE.mjs.map