npm - @ibgib/web-gib - Versions diffs - 0.0.52 → 0.0.55 - Mend

@ibgib/web-gib 0.0.52 → 0.0.55

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (150) hide show

package/src/api/ibgib-api-bridge.mts ADDED Viewed

@@ -0,0 +1,292 @@
+/**
+ * @module api/ibgib-api-bridge
+ *
+ * Base REST API bridge class for interacting with serve-gib endpoints from browser clients.
+ */
+import { extractErrorMsg } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
+import { IbGib_V1 } from "@ibgib/ts-gib/dist/V1/types.mjs";
+const logalot = false;
+export class IbGibApiBridge {
+    protected lc: string = `[${IbGibApiBridge.name}]`;
+    protected async parseResponseJson<T = any>(response: Response, url: string): Promise<T> {
+        const contentType = response.headers.get('content-type') || '';
+        if (!contentType.includes('application/json')) {
+            const text = await response.text();
+            if (text.trim().toLowerCase().startsWith('<!doctype html') || text.includes('<html')) {
+                throw new Error(`API request to '${url}' failed (${response.status} ${response.statusText}): Received HTML fallback instead of JSON. Check API route matching and parameters.`);
+            }
+            throw new Error(`API request to '${url}' failed (${response.status} ${response.statusText}): Returned non-JSON content type '${contentType}': ${text.slice(0, 150)}`);
+        }
+        return await response.json();
+    }
+    /**
+     * Posts a single genesis keystone ibgib to the server to create a new domain.
+     */
+    public async postGenesisKeystone(keystoneIbGib: IbGib_V1): Promise<{ success: boolean; message?: string; addr?: string }> {
+        const lc = `${this.lc}[${this.postGenesisKeystone.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} starting... (I: eecd082fc4a4381c8857928e8b090826)`); }
+            const url = '/api/keystone/genesis';
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ keystoneIbGib }),
+            });
+            const data = await this.parseResponseJson(response, url);
+            if (!response.ok) {
+                const errorMsg = data.message || data.error || 'Unknown error';
+                console.error(`${lc} server rejected genesis keystone: ${errorMsg}`);
+                return { success: false, message: errorMsg, addr: data.addr };
+            }
+            if (logalot) { console.log(`${lc} genesis keystone posted successfully.`); }
+            return { success: true, addr: data.addr };
+        } catch (error) {
+            const errorMsg = extractErrorMsg(error);
+            console.error(`${lc} error: ${errorMsg}`);
+            return { success: false, message: errorMsg };
+        }
+    }
+    /**
+     * PUTs an evolved domain keystone and any related keystones to the server.
+     */
+    public async putEvolveKeystone({
+        domainAddr,
+        keystoneIbGib,
+        relatedKeystoneIbGibs = [],
+        revokeTokens
+    }: {
+        domainAddr: string;
+        keystoneIbGib: IbGib_V1;
+        relatedKeystoneIbGibs?: IbGib_V1[];
+        revokeTokens?: Record<string, string>;
+    }): Promise<{ success: boolean; message?: string }> {
+        const lc = `${this.lc}[${this.putEvolveKeystone.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} posting evolved keystone...`); }
+            const url = `/api/keystone/evolve/${encodeURIComponent(domainAddr)}`;
+            const response = await fetch(url, {
+                method: 'PUT',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    keystoneIbGib,
+                    relatedKeystoneIbGibs,
+                    revokeTokens
+                }),
+            });
+            const data = await this.parseResponseJson(response, url);
+            if (!response.ok) {
+                const errorMsg = data.message || data.error || 'Unknown error';
+                console.error(`${lc} server rejected keystone evolution: ${errorMsg}`);
+                return { success: false, message: errorMsg };
+            }
+            if (logalot) { console.log(`${lc} keystone evolution accepted by server.`); }
+            return { success: true };
+        } catch (error) {
+            const errorMsg = extractErrorMsg(error);
+            console.error(`${lc} fetch error: ${errorMsg}`);
+            return { success: false, message: errorMsg };
+        }
+    }
+    /**
+     * Looks up a primary identity keystone on the server by username or email.
+     */
+    public async lookupPrimaryKeystone({ identifier }: { identifier: string }): Promise<{ success: boolean; message?: string; tjpAddr?: string; primaryKeystoneIbGib?: IbGib_V1 }> {
+        const lc = `${this.lc}[${this.lookupPrimaryKeystone.name}]`;
+        try {
+            const url = '/api/keystone/lookup';
+            const response = await fetch(url, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ identifier }),
+            });
+            const data = await this.parseResponseJson(response, url);
+            if (!response.ok) {
+                const errorMsg = data.message || data.error || 'Identity not found';
+                console.error(`${lc} server lookup failed: ${errorMsg}`);
+                return { success: false, message: errorMsg };
+            }
+            return {
+                success: true,
+                tjpAddr: data.tjpAddr,
+                primaryKeystoneIbGib: data.primaryKeystoneIbGib
+            };
+        } catch (error) {
+            const errorMsg = extractErrorMsg(error);
+            console.error(`${lc} lookup fetch error: ${errorMsg}`);
+            return { success: false, message: errorMsg };
+        }
+    }
+    /**
+     * Checks if an email address is available on the server before local genesis.
+     */
+    public async checkEmailAvailability({ email }: { email: string }): Promise<{ available: boolean; message?: string }> {
+        const lc = `${this.lc}[${this.checkEmailAvailability.name}]`;
+        try {
+            const url = `/api/keystone/check-email?email=${encodeURIComponent(email)}`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+            });
+            const data = await this.parseResponseJson(response, url);
+            if (!response.ok) {
+                const errorMsg = data.message || data.error || 'Server check failed';
+                console.error(`${lc} email check failed: ${errorMsg}`);
+                return { available: false, message: errorMsg };
+            }
+            return {
+                available: data.available ?? true,
+                message: data.message
+            };
+        } catch (error) {
+            const errorMsg = extractErrorMsg(error);
+            console.error(`${lc} check email error: ${errorMsg}`);
+            return { available: true }; // network error fallback
+        }
+    }
+    public async getKeystoneGraph(domainAddr: string): Promise<{ success: boolean; message?: string; graph?: Record<string, any> }> {
+        const lc = `${this.lc}[${this.getKeystoneGraph.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} fetching keystone graph...`); }
+            const url = `/api/keystone/${encodeURIComponent(domainAddr)}?getLatest=true&getGraph=true`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Accept': 'application/json',
+                }
+            });
+            const data = await this.parseResponseJson(response, url);
+            if (!response.ok) {
+                const errorMsg = data.message || data.error || 'Unknown error';
+                console.error(`${lc} server rejected keystone graph get: ${errorMsg}`);
+                return { success: false, message: errorMsg };
+            }
+            return { success: true, graph: data.domainGraph };
+        } catch (error) {
+            const errorMsg = extractErrorMsg(error);
+            console.error(`${lc} fetch error: ${errorMsg}`);
+            return { success: false, message: errorMsg };
+        }
+    }
+    /**
+     * GETs a single ibGib frame from the server's domain space.
+     */
+    public async getIbGib(domainAddr: string, ibGibAddr: string, getLatest = false): Promise<{ success: boolean; message?: string; ibGib?: IbGib_V1 }> {
+        const lc = `${this.lc}[${this.getIbGib.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} fetching single ibGib frame...`); }
+            const url = `/api/ibgib/${encodeURIComponent(domainAddr)}/${encodeURIComponent(ibGibAddr)}?getLatest=${getLatest}&getGraph=false`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Accept': 'application/json',
+                }
+            });
+            const data = await this.parseResponseJson(response, url);
+            if (!response.ok) {
+                const errorMsg = data.message || data.error || 'Unknown error';
+                console.error(`${lc} server rejected ibGib get: ${errorMsg}`);
+                return { success: false, message: errorMsg };
+            }
+            return { success: true, ibGib: data };
+        } catch (error) {
+            const errorMsg = extractErrorMsg(error);
+            console.error(`${lc} fetch error: ${errorMsg}`);
+            return { success: false, message: errorMsg };
+        }
+    }
+    /**
+     * GETs the full dependency graph of an ibGib from the server's domain space.
+     */
+    public async getIbGibGraph(domainAddr: string, ibGibAddr: string, getLatest = false): Promise<{ success: boolean; message?: string; graph?: Record<string, IbGib_V1>; addr?: string }> {
+        const lc = `${this.lc}[${this.getIbGibGraph.name}]`;
+        try {
+            if (logalot) { console.log(`${lc} fetching ibGib graph...`); }
+            const url = `/api/ibgib/${encodeURIComponent(domainAddr)}/${encodeURIComponent(ibGibAddr)}?getLatest=${getLatest}&getGraph=true`;
+            const response = await fetch(url, {
+                method: 'GET',
+                headers: {
+                    'Accept': 'application/json',
+                }
+            });
+            const data = await response.json();
+            if (!response.ok) {
+                const errorMsg = data.message || data.error || 'Unknown error';
+                console.error(`${lc} server rejected ibGib graph get: ${errorMsg}`);
+                return { success: false, message: errorMsg };
+            }
+            return { success: true, graph: data.graph, addr: data.addr };
+        } catch (error) {
+            const errorMsg = extractErrorMsg(error);
+            console.error(`${lc} fetch error: ${errorMsg}`);
+            return { success: false, message: errorMsg };
+        }
+    }
+}
+let _apiBridge: IbGibApiBridge | undefined;
+/**
+ * Returns the global API bridge instance, creating a default IbGibApiBridge if not set.
+ */
+export function getApiBridge(): IbGibApiBridge {
+    if (!_apiBridge) {
+        _apiBridge = new IbGibApiBridge();
+    }
+    return _apiBridge;
+}
+/**
+ * Registers a custom API bridge instance (e.g. SpaceGibApiBridge or app-specific subclass).
+ */
+export function setApiBridge(bridge: IbGibApiBridge): void {
+    _apiBridge = bridge;
+}

package/src/app-bootstrap/init-orchestration.mts CHANGED Viewed

@@ -213,7 +213,7 @@ export async function dynamicallyLoadBootstrapScript(
  * @param globalThisKey  The per-app namespace key used to find the bootstrap
  *   promise on globalThis.
  */
-export function getComponentCtorArg(globalThisKey: string): IbGibDynamicComponentMetaCtorOpts {
+export function getComponentCtorArg(globalThisKey?: string): IbGibDynamicComponentMetaCtorOpts {
     const fnGetMetaspace = async () => getGlobalMetaspace_waitIfNeeded();
     const bootstrapPromiseWrapper = new Promise<void>(async (resolve, reject) => {
@@ -222,16 +222,27 @@ export function getComponentCtorArg(globalThisKey: string): IbGibDynamicComponen
             let counter = 0;
             let bootstrapPromise: Promise<void> | undefined;
             do {
-                bootstrapPromise =
-                    getIbGibGlobalThis_IbGibApp(globalThisKey)?.bootstrapPromise;
+                if (globalThisKey) {
+                    bootstrapPromise = getIbGibGlobalThis_IbGibApp(globalThisKey)?.bootstrapPromise;
+                } else {
+                    bootstrapPromise = (globalThis as any).ibgib?.bootstrapPromise;
+                    if (!bootstrapPromise && (globalThis as any).ibgib) {
+                        const keys = Object.keys((globalThis as any).ibgib);
+                        for (const k of keys) {
+                            if ((globalThis as any).ibgib[k]?.bootstrapPromise) {
+                                bootstrapPromise = (globalThis as any).ibgib[k].bootstrapPromise;
+                                break;
+                            }
+                        }
+                    }
+                }
                 counter++;
                 if (counter > maxTries) { break; }
                 await delay(10);
             } while (bootstrapPromise === undefined);
             if (!bootstrapPromise) {
-                throw new Error(
-                    `Timed out waiting for bootstrapPromise on key '${globalThisKey}'. (E: 4c48ce92ibgib-common26)`
-                );
+                resolve();
+                return;
             }
             await bootstrapPromise;
             resolve();

package/src/custom.d.ts ADDED Viewed

@@ -0,0 +1,11 @@
+// Tell TypeScript that importing a .html file will return a string.
+declare module '*.html' {
+  const value: string;
+  export default value;
+}
+// Tell TypeScript that importing a .css file will return a string.
+declare module '*.css' {
+  const value: string;
+  export default value;
+}

package/src/identity/keystone-sync-service.mts ADDED Viewed

@@ -0,0 +1,257 @@
+/**
+ * @module identity/keystone-sync-service
+ *
+ * On-Demand Keystone Sync Service.
+ * Provides functions to check for keystone updates on the server and sync updated keystone DAG graphs locally.
+ */
+import { extractErrorMsg } from "@ibgib/helper-gib/dist/helpers/utils-helper.mjs";
+import { getIbAndGib, getIbGibAddr } from "@ibgib/ts-gib/dist/helper.mjs";
+import { getGibInfo } from "@ibgib/ts-gib/dist/V1/transforms/transform-helper.mjs";
+import { KeystoneIbGib_V1 } from "@ibgib/core-gib/dist/keystone/keystone-types.mjs";
+import { getTimelinesGroupedByTjp, getTjpAddr, toDto } from "@ibgib/core-gib/dist/common/other/ibgib-helper.mjs";
+import { updateSpecialIndex } from "@ibgib/core-gib/dist/timeline/timeline-api.mjs";
+import { getApiBridge } from "../api/ibgib-api-bridge.mjs";
+import { getGlobalMetaspace_waitIfNeeded } from "../helpers.mjs";
+import { EVENT_IBGIB_IDENTITY_UPDATE_AVAILABLE } from "../ui/ui-constants.mjs";
+import { EventIbGibIdentityUpdateAvailableDetail } from "../ui/ui-types.mjs";
+export interface KeystoneUpdateCheckResult {
+    hasUpdate: boolean;
+    serverN: number;
+    localN: number;
+    serverLatestAddr: string;
+    graph: Record<string, KeystoneIbGib_V1>;
+}
+export class KeystoneSyncService {
+    protected lc: string = `[KeystoneSyncService]`;
+    private dispatchUpdateAvailableEvent(detail: EventIbGibIdentityUpdateAvailableDetail): void {
+        if (typeof window !== 'undefined') {
+            window.dispatchEvent(new CustomEvent(EVENT_IBGIB_IDENTITY_UPDATE_AVAILABLE, {
+                detail,
+                bubbles: true,
+                composed: true,
+            }));
+        }
+    }
+    /**
+     * Checks if a server update exists for the given active primary keystone address.
+     */
+    public async checkForKeystoneUpdate({
+        activePrimaryAddr,
+        metaspace,
+        space
+    }: {
+        activePrimaryAddr: string;
+        metaspace?: any;
+        space?: any;
+    }): Promise<KeystoneUpdateCheckResult> {
+        const lc = `${this.lc}[${this.checkForKeystoneUpdate.name}]`;
+        try {
+            if (!metaspace) {
+                metaspace = await getGlobalMetaspace_waitIfNeeded();
+            }
+            if (!metaspace) {
+                throw new Error("Metaspace not available.");
+            }
+            if (!space) {
+                space = await metaspace.getLocalUserSpace({ lock: false });
+            }
+            if (!space) {
+                throw new Error("Local user space not available.");
+            }
+            // Determine local latest address & frame
+            const localLatestAddr = (await metaspace.getLatestAddr({ addr: activePrimaryAddr, space })) || activePrimaryAddr;
+            const resLocal = await metaspace.get({ addrs: [localLatestAddr], space });
+            const localFrame = (resLocal.success && resLocal.ibGibs && resLocal.ibGibs.length > 0)
+                ? (resLocal.ibGibs[0] as KeystoneIbGib_V1)
+                : undefined;
+            const localN = localFrame?.data?.n ?? 0;
+            // Fetch server graph using activePrimaryAddr (resolving to full domain TJP address, e.g. "keystone^hash")
+            const { ib } = getIbAndGib({ ibGibAddr: activePrimaryAddr });
+            const info = getGibInfo({ ibGibAddr: activePrimaryAddr });
+            const fallbackTjp = info.tjpGib ? `${ib}^${info.tjpGib}` : activePrimaryAddr;
+            const domainTjpAddr = (localFrame ? getTjpAddr({ ibGib: localFrame }) : undefined) || fallbackTjp;
+            const resGraph = await getApiBridge().getKeystoneGraph(domainTjpAddr);
+            if (!resGraph.success || !resGraph.graph) {
+                const res: KeystoneUpdateCheckResult = {
+                    hasUpdate: false,
+                    serverN: localN,
+                    localN,
+                    serverLatestAddr: localLatestAddr,
+                    graph: {}
+                };
+                this.dispatchUpdateAvailableEvent({
+                    activePrimaryAddr,
+                    hasUpdate: res.hasUpdate,
+                    serverN: res.serverN,
+                    localN: res.localN,
+                    serverLatestAddr: res.serverLatestAddr,
+                });
+                return res;
+            }
+            const graph = resGraph.graph as Record<string, KeystoneIbGib_V1>;
+            const graphIbGibs = Object.values(graph);
+            // Group timelines by TJP to isolate primary domain timeline
+            const timelinesMap = getTimelinesGroupedByTjp({ ibGibs: graphIbGibs });
+            // Look for timeline under domainTjpAddr or activePrimaryAddr or first available
+            const domainTimeline = timelinesMap[domainTjpAddr] || timelinesMap[activePrimaryAddr] || timelinesMap[Object.keys(timelinesMap)[0]] || [];
+            if (domainTimeline.length === 0) {
+                const res: KeystoneUpdateCheckResult = {
+                    hasUpdate: false,
+                    serverN: localN,
+                    localN,
+                    serverLatestAddr: localLatestAddr,
+                    graph
+                };
+                this.dispatchUpdateAvailableEvent({
+                    activePrimaryAddr,
+                    hasUpdate: res.hasUpdate,
+                    serverN: res.serverN,
+                    localN: res.localN,
+                    serverLatestAddr: res.serverLatestAddr,
+                });
+                return res;
+            }
+            // Domain timeline sorted ascending by n
+            const sortedDomainTimeline = [...domainTimeline].sort((a, b) => (a.data?.n ?? 0) - (b.data?.n ?? 0));
+            const serverLatestFrame = sortedDomainTimeline[sortedDomainTimeline.length - 1] as KeystoneIbGib_V1;
+            const serverN = serverLatestFrame.data?.n ?? 0;
+            const serverLatestAddr = getIbGibAddr({ ibGib: serverLatestFrame });
+            const hasUpdate = serverN > localN;
+            const res: KeystoneUpdateCheckResult = {
+                hasUpdate,
+                serverN,
+                localN,
+                serverLatestAddr,
+                graph
+            };
+            this.dispatchUpdateAvailableEvent({
+                activePrimaryAddr,
+                hasUpdate: res.hasUpdate,
+                serverN: res.serverN,
+                localN: res.localN,
+                serverLatestAddr: res.serverLatestAddr,
+            });
+            return res;
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            const res: KeystoneUpdateCheckResult = {
+                hasUpdate: false,
+                serverN: 0,
+                localN: 0,
+                serverLatestAddr: activePrimaryAddr,
+                graph: {}
+            };
+            this.dispatchUpdateAvailableEvent({
+                activePrimaryAddr,
+                hasUpdate: false,
+                serverN: 0,
+                localN: 0,
+                serverLatestAddr: activePrimaryAddr,
+            });
+            return res;
+        }
+    }
+    /**
+     * Checks for updates and registers any missing server keystone frames into local space.
+     * Returns the updated (or current) primary keystone frame.
+     */
+    public async updateActiveKeystone({
+        activePrimaryAddr,
+        metaspace,
+        space
+    }: {
+        activePrimaryAddr: string;
+        metaspace?: any;
+        space?: any;
+    }): Promise<KeystoneIbGib_V1 | undefined> {
+        const lc = `${this.lc}[${this.updateActiveKeystone.name}]`;
+        try {
+            if (!metaspace) {
+                metaspace = await getGlobalMetaspace_waitIfNeeded();
+            }
+            if (!metaspace) {
+                throw new Error("Metaspace not available.");
+            }
+            if (!space) {
+                space = await metaspace.getLocalUserSpace({ lock: false });
+            }
+            if (!space) {
+                throw new Error("Local user space not available.");
+            }
+            const updateInfo = await this.checkForKeystoneUpdate({ activePrimaryAddr, metaspace, space });
+            if (updateInfo.hasUpdate && Object.keys(updateInfo.graph).length > 0) {
+                const graphIbGibs = Object.values(updateInfo.graph);
+                // Put all graph ibgibs into space
+                await metaspace.put({ ibGibs: graphIbGibs, space });
+                // Group by TJP and register each frame ascending by n
+                const timelinesMap = getTimelinesGroupedByTjp({ ibGibs: graphIbGibs });
+                for (const tjpKey of Object.keys(timelinesMap)) {
+                    const timeline = timelinesMap[tjpKey];
+                    const sorted = [...timeline].sort((a, b) => (a.data?.n ?? 0) - (b.data?.n ?? 0));
+                    for (const frame of sorted) {
+                        await metaspace.registerNewIbGib({ ibGib: frame, space });
+                    }
+                }
+                // Get updated latest primary frame
+                const domainTjp = getGibInfo({ ibGibAddr: activePrimaryAddr }).tjpGib ?? activePrimaryAddr;
+                const domainTimeline = timelinesMap[domainTjp] || timelinesMap[activePrimaryAddr] || timelinesMap[Object.keys(timelinesMap)[0]];
+                const sortedDomain = [...domainTimeline].sort((a, b) => (a.data?.n ?? 0) - (b.data?.n ?? 0));
+                const updatedLatestFrame = sortedDomain[sortedDomain.length - 1] as KeystoneIbGib_V1;
+                if (updatedLatestFrame) {
+                    // Update special index locally
+                    await updateSpecialIndex({
+                        type: "keystones",
+                        rel8nInfos: [{
+                            rel8nName: "keystone",
+                            ibGibs: [toDto({ ibGib: updatedLatestFrame })]
+                        }],
+                        metaspace,
+                        space
+                    });
+                    return updatedLatestFrame;
+                }
+            }
+            // If no update or update failed, return current local frame
+            const localLatestAddr = (await metaspace.getLatestAddr({ addr: activePrimaryAddr, space })) || activePrimaryAddr;
+            const resLocal = await metaspace.get({ addrs: [localLatestAddr], space });
+            if (resLocal.success && resLocal.ibGibs && resLocal.ibGibs.length > 0) {
+                return resLocal.ibGibs[0] as KeystoneIbGib_V1;
+            }
+            return undefined;
+        } catch (error) {
+            console.error(`${lc} ${extractErrorMsg(error)}`);
+            throw error;
+        }
+    }
+}
+let _keystoneSyncSvc: KeystoneSyncService | undefined;
+export function getKeystoneSyncService(): KeystoneSyncService {
+    if (!_keystoneSyncSvc) {
+        _keystoneSyncSvc = new KeystoneSyncService();
+    }
+    return _keystoneSyncSvc;
+}

package/src/index.mts CHANGED Viewed

@@ -1,29 +1,28 @@
-// /**
-//  * @ibgib/web-gib
-//  *
-//  * Front Door: Streamlined App Bootstrapping
-//  */
+/**
+ * @module @ibgib/web-gib
+ *
+ * Front Door: Streamlined App Bootstrapping & Web Components
+ */
-// export {
-//     bootstrapIbGibApp
-// } from "./app-bootstrap/bootstrap.mjs";
+export * from "./app-bootstrap/bootstrap.mjs";
+export * from "./app-bootstrap/types.mjs";
+export * from "./app-bootstrap/init-orchestration.mjs";
-// export {
-//     IbGibAmbientContextConfig,
-//     IbGibGlobalThis_IbGibApp
-// } from "./app-bootstrap/types.mjs";
+export * from "./constants.mjs";
+export * from "./types.mjs";
+export * from "./helpers.web.mjs";
+export * from "./helpers.mjs";
-// export {
-//     initIbGibStorage,
-//     dynamicallyLoadBootstrapScript,
-//     getComponentCtorArg
-// } from "./app-bootstrap/init-orchestration.mjs";
+// REST API bridge
+export * from "./api/ibgib-api-bridge.mjs";
+// Identity & Sync services
+export * from "./identity/keystone-sync-service.mjs";
+// Identity UI components
+export * from "./ui/component/identity/index.mjs";
+// UI constants & types
+export * from "./ui/ui-constants.mjs";
+export * from "./ui/ui-types.mjs";
-// /**
-//  * Toolbox: Library Internals
-//  * (Only export what's necessary for advanced users)
-//  */
-// export * from "./constants.mjs";
-// export * from "./types.mjs";
-// export * from "./helpers.web.mjs";
-// export * from "./helpers.mjs";