@adaas/a-frame 0.0.21 → 0.0.23

package/jest.config.ts

@@ -5,18 +5,28 @@ const config: Config.InitialOptions = {
     verbose: true,
     setupFilesAfterEnv: ['<rootDir>/tests/jest.setup.ts'],
     roots: ['<rootDir>/tests'],
+    testPathIgnorePatterns: ['/node_modules/', '\\.browser\\.test\\.ts$'],
     transform: {
         '^.+\\.tsx?$': 'ts-jest'
     },
     moduleNameMapper: {
-        "@adaas/a-frame/constants/(.*)": ["<rootDir>/src/constants/$1"],
-        "@adaas/a-frame/global/(.*)": ["<rootDir>/src/global/$1"],
-        "@adaas/a-frame/types/(.*)": ["<rootDir>/src/types/$1"],
-        "@adaas/a-frame/helpers/(.*)": ["<rootDir>/src/helpers/$1"],
-        "@adaas/a-frame/decorators/(.*)": ["<rootDir>/src/decorators/$1"],
-        "@adaas/a-frame/base/(.*)": ["<rootDir>/src/base/$1"],
-        "@adaas/a-frame/utils/(.*)": ["<rootDir>/src/utils/$1"]
+        "@adaas/a-frame/constants/(.*)": "<rootDir>/src/constants/$1",
+        "@adaas/a-frame/utils/(.*)": "<rootDir>/src/utils/$1",
+        "@adaas/a-frame/helpers/(.*)": "<rootDir>/src/helpers/$1",
+        "@adaas/a-frame/types": "<rootDir>/src/types",
+        "@adaas/a-frame/core": "<rootDir>/src/lib/A-Frame/index.ts",
+        "@adaas/a-frame/bundle": "<rootDir>/src/lib/A-FrameBundle/index.ts",
+        "@adaas/a-frame/channel": "<rootDir>/src/lib/A-FrameChannel/index.ts",
+        "@adaas/a-frame/crypto": "<rootDir>/src/lib/A-FrameCrypto/index.ts",
+        "@adaas/a-frame/definition": "<rootDir>/src/lib/A-FrameDefinition/index.ts",
+        "@adaas/a-frame/dynamic-feature": "<rootDir>/src/lib/A-FrameDynamicFeature/index.ts",
+        "@adaas/a-frame/dynamic-structure": "<rootDir>/src/lib/A-FrameDynamicStructure/index.ts",
+        "@adaas/a-frame/env": "<rootDir>/src/lib/A-FrameEnv/index.ts",
+        "@adaas/a-frame/index": "<rootDir>/src/lib/A-FrameIndex/index.ts",
+        "@adaas/a-frame/logger": "<rootDir>/src/lib/A-FrameLogger/index.ts",
+        "@adaas/a-frame/namespace": "<rootDir>/src/lib/A-FrameNamespace/index.ts",
+        "@adaas/a-frame/storage": "<rootDir>/src/lib/A-FrameStorage/index.ts",
+        "@adaas/a-frame/vector": "<rootDir>/src/lib/A-FrameVector/index.ts",
     }
-
 };
 export default config;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adaas/a-frame",
-  "version": "0.0.21",
+  "version": "0.0.23",
   "description": "A-frame is index build engine for A-Concept ecosystem. It provides a way to build index structures for A-Concept basics",
   "license": "Apache-2.0",
   "author": {
@@ -16,7 +16,7 @@
     "url": "git+https://github.com/ADAAS-org/adaas-a-frame.git"
   },
   "bin": {
-    "a-frame": "./dist/index.js"
+    "a-frame": "./dist/index.cjs"
   },
   "exports": {
     ".": {
@@ -24,16 +24,126 @@
         "types": "./dist/browser/index.d.mts",
         "import": "./dist/browser/index.mjs"
       },
-      "node": {
-        "types": "./dist/node/index.d.ts",
-        "import": "./dist/node/index.mjs",
-        "require": "./dist/node/index.cjs"
+      "types": "./dist/node/index.d.ts",
+      "import": "./dist/node/index.mjs",
+      "require": "./dist/node/index.cjs"
+    },
+    "./core": {
+      "browser": {
+        "types": "./dist/browser/core.d.mts",
+        "import": "./dist/browser/core.mjs"
+      },
+      "types": "./dist/node/core.d.ts",
+      "import": "./dist/node/core.mjs",
+      "require": "./dist/node/core.cjs"
+    },
+    "./bundle": {
+      "browser": {
+        "types": "./dist/browser/bundle.d.mts",
+        "import": "./dist/browser/bundle.mjs"
+      },
+      "types": "./dist/node/bundle.d.ts",
+      "import": "./dist/node/bundle.mjs",
+      "require": "./dist/node/bundle.cjs"
+    },
+    "./channel": {
+      "browser": {
+        "types": "./dist/browser/channel.d.mts",
+        "import": "./dist/browser/channel.mjs"
+      },
+      "types": "./dist/node/channel.d.ts",
+      "import": "./dist/node/channel.mjs",
+      "require": "./dist/node/channel.cjs"
+    },
+    "./crypto": {
+      "browser": {
+        "types": "./dist/browser/crypto.d.mts",
+        "import": "./dist/browser/crypto.mjs"
+      },
+      "types": "./dist/node/crypto.d.ts",
+      "import": "./dist/node/crypto.mjs",
+      "require": "./dist/node/crypto.cjs"
+    },
+    "./definition": {
+      "browser": {
+        "types": "./dist/browser/definition.d.mts",
+        "import": "./dist/browser/definition.mjs"
+      },
+      "types": "./dist/node/definition.d.ts",
+      "import": "./dist/node/definition.mjs",
+      "require": "./dist/node/definition.cjs"
+    },
+    "./dynamic-feature": {
+      "browser": {
+        "types": "./dist/browser/dynamic-feature.d.mts",
+        "import": "./dist/browser/dynamic-feature.mjs"
+      },
+      "types": "./dist/node/dynamic-feature.d.ts",
+      "import": "./dist/node/dynamic-feature.mjs",
+      "require": "./dist/node/dynamic-feature.cjs"
+    },
+    "./dynamic-structure": {
+      "browser": {
+        "types": "./dist/browser/dynamic-structure.d.mts",
+        "import": "./dist/browser/dynamic-structure.mjs"
+      },
+      "types": "./dist/node/dynamic-structure.d.ts",
+      "import": "./dist/node/dynamic-structure.mjs",
+      "require": "./dist/node/dynamic-structure.cjs"
+    },
+    "./env": {
+      "browser": {
+        "types": "./dist/browser/env.d.mts",
+        "import": "./dist/browser/env.mjs"
+      },
+      "types": "./dist/node/env.d.ts",
+      "import": "./dist/node/env.mjs",
+      "require": "./dist/node/env.cjs"
+    },
+    "./index": {
+      "browser": {
+        "types": "./dist/browser/frame-index.d.mts",
+        "import": "./dist/browser/frame-index.mjs"
+      },
+      "types": "./dist/node/frame-index.d.ts",
+      "import": "./dist/node/frame-index.mjs",
+      "require": "./dist/node/frame-index.cjs"
+    },
+    "./logger": {
+      "browser": {
+        "types": "./dist/browser/logger.d.mts",
+        "import": "./dist/browser/logger.mjs"
+      },
+      "types": "./dist/node/logger.d.ts",
+      "import": "./dist/node/logger.mjs",
+      "require": "./dist/node/logger.cjs"
+    },
+    "./namespace": {
+      "browser": {
+        "types": "./dist/browser/namespace.d.mts",
+        "import": "./dist/browser/namespace.mjs"
+      },
+      "types": "./dist/node/namespace.d.ts",
+      "import": "./dist/node/namespace.mjs",
+      "require": "./dist/node/namespace.cjs"
+    },
+    "./storage": {
+      "browser": {
+        "types": "./dist/browser/storage.d.mts",
+        "import": "./dist/browser/storage.mjs"
+      },
+      "types": "./dist/node/storage.d.ts",
+      "import": "./dist/node/storage.mjs",
+      "require": "./dist/node/storage.cjs"
+    },
+    "./vector": {
+      "browser": {
+        "types": "./dist/browser/vector.d.mts",
+        "import": "./dist/browser/vector.mjs"
       },
-      "default": {
-        "types": "./dist/node/index.d.ts",
-        "import": "./dist/node/index.mjs",
-        "require": "./dist/node/index.cjs"
-      }
+      "types": "./dist/node/vector.d.ts",
+      "import": "./dist/node/vector.mjs",
+      "require": "./dist/node/vector.cjs"
     }
   },
   "keywords": [
@@ -61,6 +171,7 @@
   },
   "scripts": {
     "test": "jest --detectOpenHandles",
+    "test:browser": "jest --config jest.config.browser.ts --detectOpenHandles",
     "start": "nodemon ./tests/example-usage.ts",
     "start:test": "node -r tsconfig-paths/register -r ts-node/register ./index.ts",
     "release": "npm run test && npm run build && git add . && git commit -m \"new version created :: $(cat package.json | grep version | head -1  | awk -F: '{ print $2 }'  | sed 's/[\",]//g')\" && npm version patch && npm publish --access public",
@@ -70,7 +181,7 @@
     "build": "tsup --config tsup.config.ts"
   },
   "dependencies": {
-    "@adaas/a-concept": "^0.3.12"
+    "@adaas/a-concept": "^0.3.14"
   },
   "devDependencies": {
     "@types/chai": "^4.3.14",
@@ -78,8 +189,9 @@
     "@types/mocha": "^10.0.6",
     "@types/node": "^24.9.1",
     "chai": "^5.1.0",
-    "dotenv": "^16.4.5",
+    "dotenv": "^16.6.1",
     "jest": "^29.7.0",
+    "jest-environment-jsdom": "^29.7.0",
     "mocha": "^10.4.0",
     "nodemon": "^3.1.4",
     "ts-jest": "^29.1.2",

package/{index.ts → src/concept.ts}

@@ -1,5 +1,6 @@
 import { A_Concept } from '@adaas/a-concept';
-import { A_Frame_CLIContainer } from 'src';
+import { A_FrameCLIContainer } from './lib/A-FrameCLI/A-FrameCLI.container';
+import { A_Frame } from './lib/A-Frame/A-Frame.component.env-node';
 
 
 
@@ -7,7 +8,9 @@ import { A_Frame_CLIContainer } from 'src';
     const concept = new A_Concept({
         name: 'A-Frame CLI',
         containers: [
-            new A_Frame_CLIContainer()
+            new A_FrameCLIContainer({
+                components: [A_Frame]
+            })
         ]
     });
 

package/src/helpers/Hash.helper.ts

@@ -0,0 +1,14 @@
+
+
+export class A_FrameHashHelper {
+
+    // ─── Hash (FNV-1a 32-bit, no external deps) ──────────────────────────────────
+    static fnv1a(str: string): string {
+        let hash = 2_166_136_261; // offset basis
+        for (let i = 0; i < str.length; i++) {
+            hash ^= str.charCodeAt(i);
+            hash = (hash * 16_777_619) >>> 0; // keep 32-bit unsigned
+        }
+        return hash.toString(16).padStart(8, "0");
+    }
+}

package/src/index.ts

@@ -1,24 +0,0 @@
-// ============================================================================
-// A-Frame CLI Exports
-// ============================================================================
-export { A_Frame_CLIContainer } from './lib/containers/CLI.container';
-
-// ============================================================================
-// A-Frame Index Exports
-// ============================================================================
-export { A_Frame_Index as A_Frame } from './lib/components/Index.component.ts/Index.component';
-export { A_Frame_IndexMeta } from './lib/components/Index.component.ts/Index.meta';
-export { A_Frame_IndexError } from './lib/components/Index.component.ts/Index.error';
-
-// ============================================================================
-// A-Frame Types Exports
-// ============================================================================
-export type {
-    A_Frame_IndexOptions,
-    A_Frame_IndexDecoratorTarget,
-    A_Frame_IndexDecoratorMeta,
-    A_Frame_IndexNamespaceDecoratorTarget
-} from './lib/components/Index.component.ts/Index.types';
-
-// Export the enum as both type and value
-export { A_Frame_IndexTargetType } from './lib/components/Index.component.ts/Index.types';

package/src/lib/A-Frame/A-Frame.component.env-browser.ts

@@ -0,0 +1,124 @@
+import { A_Concept, A_Fragment, A_Inject, A_Scope, A_TYPES__A_DependencyInjectable, A_TYPES__Component_Constructor, A_TYPES__Ctor, A_TYPES__Fragment_Constructor } from "@adaas/a-concept";
+import { A_FrameBase } from "./A-Frame.component";
+import { A_FrameBrowserStorageProvider } from "../A-FrameStorage/browser/A-FrameBrowserStorage.component";
+import { A_FrameBrowserStorageBlobs } from "../A-FrameStorage/browser/A-FrameBrowserStorageBlobs.context";
+import { A_FrameStorageCodec } from "../A-FrameStorage/A-FrameStorage.codec";
+import { A_FrameIndex } from "../A-FrameIndex";
+import { A_FrameContext } from "./A-Frame.context";
+import { A_FrameLogger } from "../A-FrameLogger/A-FrameLogger.component.env-browser";
+import { A_FrameEnv } from "../A-FrameEnv/A-FrameEnv.fragment.env-browser";
+
+
+
+export class A_Frame extends A_FrameBase {
+
+    /**
+     * Default per-instance dependencies registered on first build. The blob
+     * store is intentionally omitted here — the user is expected to seed and
+     * register `A_FrameBrowserStorageBlobs` themselves (typically via
+     * `A_FrameBrowserStorageBlobs.fromBundle(bundle)` before `concept.load()`).
+     * If they don't, `A_FrameBrowserStorageProvider.onLoad()` falls back to the
+     * empty singleton.
+     */
+    get package(): Array<{ ctor: A_TYPES__Component_Constructor<any> | A_TYPES__Fragment_Constructor<any>; instance: any }> {
+        return [
+            { ctor: A_FrameContext, instance: new A_FrameContext() },
+            { ctor: A_FrameEnv, instance: new A_FrameEnv() },
+            { ctor: A_FrameStorageCodec, instance: new A_FrameStorageCodec() },
+            { ctor: A_FrameBrowserStorageProvider, instance: A_FrameBrowserStorageProvider },
+            { ctor: A_FrameLogger, instance: new A_FrameLogger() },
+        ];
+    }
+
+
+    @A_Concept.Load()
+    async injectDependencies(
+        @A_Inject(A_Scope) scope: A_Scope,
+    ) {
+        // Register every package dep that isn't already in scope.
+        this.package.forEach(({ ctor, instance }) => this.packDependency(scope, ctor, instance));
+
+        // A_FrameIndex needs to inherit the scope so its registry is visible
+        // to all later resolutions (entities query it during load).
+        if (!scope.resolve(A_FrameIndex)) {
+            const index = new A_FrameIndex();
+            index.inherit(scope);
+            scope.register(index);
+        }
+    }
+
+
+    /**
+     * Hydrate all known namespaces and definitions from the in-memory bundle
+     * blobs. Read-only — never calls embed (no network in the browser).
+     *
+     * The caller is responsible for:
+     *   1. Seeding `A_FrameBrowserStorageBlobs` from a prebuilt `A_FrameBundle`.
+     *   2. Setting `A_FrameContext.encryptionKey` and `serverVersion` so blobs
+     *      can be decrypted and validated.
+     */
+    @A_Concept.Load()
+    async load(
+        @A_Inject(A_Scope) scope: A_Scope,
+        @A_Inject(A_FrameIndex) index: A_FrameIndex,
+        @A_Inject(A_FrameContext) context: A_FrameContext,
+        @A_Inject(A_FrameLogger) logger: A_FrameLogger,
+        @A_Inject(A_FrameBrowserStorageBlobs) blobs: A_FrameBrowserStorageBlobs,
+    ) {
+        if (!context.encryptionKey) {
+            logger.warn(
+                'A_Frame (browser): no encryption key on context — blobs cannot be decrypted. ' +
+                'Call A_FrameContext.setCredentials({...}) before concept.load().'
+            );
+            return;
+        }
+
+        // Surface a soft mismatch warning when the bundle was built against a
+        // different server version than the one the user has authenticated with.
+        if (blobs.bundleMeta && context.serverVersion && blobs.bundleMeta.serverVersion !== context.serverVersion) {
+            logger.warn(
+                `A_Frame bundle was built against server v${blobs.bundleMeta.serverVersion} ` +
+                `but the current credentials report v${context.serverVersion}. ` +
+                `Hydration may skip records — rebuild the bundle.`
+            );
+        }
+
+        const namespaces = index.listNamespaces();
+        const definitions = index.listDefinitions();
+
+        await Promise.all([
+            ...namespaces.map(ns => Promise.resolve(ns.load()).catch(() => { })),
+            ...definitions.map(def => Promise.resolve(def.load()).catch(() => { })),
+        ]);
+
+        const unloaded =
+            namespaces.filter(ns => !ns.isEmbed).length +
+            definitions.filter(def => !def.isEmbed).length;
+        if (unloaded > 0) {
+            logger.warn(
+                `${unloaded} A-Frame entit${unloaded === 1 ? 'y' : 'ies'} could not be hydrated from the bundle. ` +
+                `Rebuild the bundle on the Node side to include them.`
+            );
+        }
+    }
+
+
+    @A_Concept.Build()
+    async build(
+        @A_Inject(A_Scope) scope: A_Scope,
+    ) {
+        // Build phase is now redundant for registration (handled in @Load above)
+        // but kept as a hook for downstream extensions.
+    }
+
+
+    @A_Concept.Start()
+    async start(
+        @A_Inject(A_Scope) scope: A_Scope,
+    ) {
+        // Start logic here
+    }
+
+
+
+}

package/src/lib/A-Frame/A-Frame.component.env-node.ts

@@ -0,0 +1,106 @@
+import { A_Concept, A_Inject, A_Scope } from "@adaas/a-concept";
+import { A_FrameBase } from "./A-Frame.component";
+import { A_FrameIndex } from "../A-FrameIndex";
+import { A_FrameStorage } from "../A-FrameStorage/A-FrameStorage.component";
+import { A_FrameChannel } from "../A-FrameChannel/A-FrameChannel.component";
+import { A_FrameContext } from "./A-Frame.context";
+import { A_FrameNodeChannel } from "../A-FrameChannel/A-FrameChannel.component.env-node";
+import { A_FrameNodeStorage } from "../A-FrameStorage/node/A-FrameNodeStorage.component";
+import { A_FrameEnv } from "../A-FrameEnv/A-FrameEnv.fragment.env-node";
+import { A_FrameStorageCodec } from "../A-FrameStorage/A-FrameStorage.codec";
+import { A_FrameCrypto } from "../A-FrameCrypto/A-FrameCrypto.component.env-node";
+import { A_FrameLogger } from "../A-FrameLogger/A-FrameLogger.component.env-node";
+
+
+
+export class A_Frame extends A_FrameBase {
+
+    @A_Concept.Load()
+    async injectDependencies(
+        @A_Inject(A_Scope) scope: A_Scope,
+    ) {
+        console.log("A_Frame injecting dependencies...");
+
+        const index = new A_FrameIndex();
+        index.inherit(scope);
+
+        scope.register(index);
+        scope.register(new A_FrameEnv());
+        scope.register(new A_FrameStorageCodec());
+        scope.register(A_FrameNodeStorage)
+        scope.register(A_FrameNodeChannel);
+        scope.register(A_FrameCrypto)
+        scope.register(new A_FrameLogger());
+        scope.register(A_Frame);
+        scope.register(new A_FrameContext());
+    }
+
+
+    @A_Concept.Load()
+    async load(
+        @A_Inject(A_Scope) scope: A_Scope,
+        @A_Inject(A_FrameIndex) index: A_FrameIndex,
+        @A_Inject(A_FrameStorage) storage: A_FrameStorage,
+        @A_Inject(A_FrameContext) context: A_FrameContext,
+        @A_Inject(A_FrameChannel) channel: A_FrameChannel,
+        @A_Inject(A_FrameEnv) env: A_FrameEnv,
+    ) {
+        // 1. Authenticate — required before any storage or embedding operations
+        const credentials = await channel.getCredentials();
+        context.setCredentials(credentials);
+
+        const definedNameSpaces = index.listNamespaces();
+        const definedDefinitions = index.listDefinitions();
+
+        // 2. Hydrate all from storage in parallel.
+        //    Storage load only calls fromJSON when hash AND aFrameServerVersion match,
+        //    so items with a stale/missing cache remain un-embedded (isEmbed === false).
+        await Promise.all([
+            ...definedNameSpaces.map(ns => ns.load()),
+            ...definedDefinitions.map(def => def.load()),
+        ]);
+
+        // 3. Skip embedding API calls entirely when sync is disabled
+        if (!env.A_FRAME_SYNC) return;
+
+        // 4. Re-embed and persist items whose cache is missing or stale
+        const namespacesNeedEmbed = definedNameSpaces.filter(ns => !ns.isEmbed
+            || (ns.aFrameServerVersion !== context.serverVersion)
+            || (ns.aFrameVersion !== env.A_FRAME_VERSION) // re-embed if the client version has changed since last embed, as it may affect embedding results
+        );
+        const definitionsNeedEmbed = definedDefinitions.filter(def => !def.isEmbed
+            || (def.aFrameServerVersion !== context.serverVersion)
+            || (def.aFrameVersion !== env.A_FRAME_VERSION) // re-embed if the client version has changed since last embed, as it may affect embedding results
+        );
+
+        for (const batch of this.chunkArray(namespacesNeedEmbed, 10)) {
+            // Embed in parallel — each namespace hits its own API call independently
+            await Promise.all(batch.map(ns => ns.embed()));
+            // Save sequentially — all namespaces write to the same __namespaces.aframe file;
+            // parallel writes would race and the last writer would overwrite the others
+            for (const ns of batch) {
+                await ns.save();
+            }
+        }
+
+        for (const batch of this.chunkArray(definitionsNeedEmbed, 10)) {
+            // Embed in parallel — each definition hits its own API call independently
+            await Promise.all(batch.map(def => def.embed()));
+            // Save sequentially within a namespace — definitions in the same namespace share
+            // one file; parallel writes would race and overwrite each other's records
+            for (const def of batch) {
+                await def.save();
+            }
+        }
+    }
+
+
+    chunkArray<T>(array: T[], size: number): T[][] {
+        const result: T[][] = [];
+        for (let i = 0; i < array.length; i += size) {
+            result.push(array.slice(i, i + size));
+        }
+        return result;
+    }
+
+}

package/src/lib/A-Frame/A-Frame.component.ts

@@ -0,0 +1,62 @@
+import { A_Component, A_Scope, A_TYPES__A_DependencyInjectable, A_TYPES__Component_Constructor, A_TYPES__Ctor, A_TYPES__Fragment_Constructor } from "@adaas/a-concept";
+import { A_FrameDefineOptions, A_FrameNamespaceOptions } from "./A-Frame.types";
+import { A_FrameDefineDecorator } from "./decorators/A-FrameDefine.decorator";
+import { A_FrameNamespaceDecorator } from "./decorators/A-FrameNamespace.decorator";
+
+
+
+export class A_FrameBase extends A_Component {
+    /**
+     * Primary Decorator to define and index components, containers, entities, fragments and methods in the A-Frame Index structure
+     * 
+     * Those components will participate in AI indexing and retrieval strategy, so they can be used in the better way to build new features and components.
+     * 
+     * @param options 
+     * @returns 
+     */
+    static Define(options: A_FrameDefineOptions) {
+        return A_FrameDefineDecorator(options) as ClassDecorator & MethodDecorator;
+
+    }
+    /**
+     * Allows to define a namespace for grouping related components, containers, entities, fragments and methods together in the A-Frame Index structure. This is useful for better organization and retrieval strategy.
+     * 
+     * @param options 
+     * @returns 
+     */
+    static NameSpace(options: A_FrameNamespaceOptions) {
+        return A_FrameNamespaceDecorator(options) as ClassDecorator & MethodDecorator;
+    }
+
+
+
+    /**
+     * Default per-instance dependencies registered on first build. The blob
+     * store is intentionally omitted here — the user is expected to seed and
+     * register `A_FrameBrowserStorageBlobs` themselves (typically via
+     * `A_FrameBrowserStorageBlobs.fromBundle(bundle)` before `concept.load()`).
+     * If they don't, `A_FrameBrowserStorageProvider.onLoad()` falls back to the
+     * empty singleton.
+     */
+    get package(): Array<{ ctor: A_TYPES__Component_Constructor<any> | A_TYPES__Fragment_Constructor<any>; instance: any }> {
+        return [
+            // { ctor: A_FrameContext, instance: new A_FrameContext() },
+            // { ctor: A_FrameEnv, instance: new A_FrameEnv() },
+            // { ctor: A_FrameStorageCodec, instance: new A_FrameStorageCodec() },
+            // { ctor: A_FrameBrowserStorageProvider, instance: A_FrameBrowserStorageProvider },
+            // { ctor: A_FrameLogger, instance: new A_FrameLogger() },
+        ];
+    }
+
+
+    protected packDependency<T extends A_TYPES__A_DependencyInjectable>(
+        scope: A_Scope,
+        target: A_TYPES__Ctor<T> | T,
+        def: A_TYPES__Ctor<T> | T,
+    ) {
+        const existing = scope.resolve(target as any);
+        if (!existing) scope.register(def);
+    }
+
+
+}

package/src/lib/A-Frame/A-Frame.context.ts

@@ -0,0 +1,40 @@
+import { A_Fragment } from "@adaas/a-concept"
+import { A_FrameChannelRequest } from "../A-FrameChannel/A-FrameChannelRequest.context";
+import { A_Frame_CredentialResponse } from "../A-FrameChannel/A-FrameChannel.types";
+
+
+export class A_FrameContext extends A_Fragment {
+
+    private credentials?: A_Frame_CredentialResponse;
+
+
+    constructor() {
+        super({ name: 'a-frame-context' });
+    }
+
+
+    get encryptionKey(): string | undefined {
+        return this.credentials?.encryption_key;
+    }
+
+
+    get serverVersion(): string | undefined {
+        return this.credentials?.server_version;
+    }
+
+
+    isAuthenticated(): boolean {
+        return !!this.credentials;
+    }
+
+
+    setCredentials(credentials: A_FrameChannelRequest<A_Frame_CredentialResponse>) {
+        if (credentials.error) {
+            this.credentials = undefined;
+            return;
+        }
+
+        this.credentials = credentials.response || undefined;
+    }
+
+}

package/src/lib/{components/Index.component.ts/Index.error.ts → A-Frame/A-Frame.error.ts}

@@ -1,7 +1,7 @@
 import { A_Error } from "@adaas/a-concept";
 
 
-export class A_Frame_IndexError extends A_Error {
+export class A_FrameError extends A_Error {
 
     static readonly InvalidTarget = 'A-Frame Index Invalid Target Error';
 

package/src/lib/{components/Index.component.ts/Index.guard.ts → A-Frame/A-Frame.guard.ts}

@@ -1,16 +1,17 @@
 import { A_CommonHelper, A_TypeGuards } from "@adaas/a-concept";
-import { A_Frame_IndexDecoratorTarget, A_Frame_IndexMetaTarget } from "./Index.types";
+import { A_FrameDecoratorTarget, A_FrameMetaTarget } from "./A-Frame.types";
+import { A_FrameIndexTarget } from "../A-FrameIndex/A-FrameIndex.types";
 
 
 
-export class A_Frame_IndexTypeGuard {
+export class A_FrameTypeGuard {
     /**
      * Determines if the target is an allowed type for indexing
      * 
      * @param target 
      * @returns 
      */
-    static isAllowedTarget(target: any): target is A_Frame_IndexDecoratorTarget {
+    static isAllowedTarget(target: any): target is A_FrameDecoratorTarget {
         return A_TypeGuards.isEntityConstructor(target)
             || A_TypeGuards.isComponentConstructor(target)
             || A_TypeGuards.isContainerConstructor(target)
@@ -23,12 +24,14 @@ export class A_Frame_IndexTypeGuard {
 
 
 
-    static getTargetName(target: A_Frame_IndexDecoratorTarget): string {
+    static getTargetName(target: A_FrameDecoratorTarget): string {
         return A_CommonHelper.getComponentName(target);
     }
 
 
-    static getTargetConstructor(target: A_Frame_IndexDecoratorTarget): A_Frame_IndexMetaTarget {
-        return typeof target === 'function' ? target : target.constructor as A_Frame_IndexMetaTarget;
+    static getTargetConstructor(target: A_FrameDecoratorTarget): A_FrameIndexTarget {
+        return typeof target === 'function' ? target : target.constructor as A_FrameIndexTarget;
     }
+
+
 }