mftsccs-node 0.2.23 → 0.2.25

package/dist/types/Database/NoIndexDb.d.ts

@@ -1,20 +1,18 @@
 /**
- * No-operation IndexedDB interface module for environments without IndexedDB support.
+ * In-memory database compatibility module for the Node package.
  *
- * This module provides stub implementations of database operations that are used when
- * IndexedDB is not available or when database functionality needs to be disabled.
- * All functions are no-ops or return default values, allowing the application to
- * run without actual database persistence.
+ * The original frontend package used IndexedDB. The Node package keeps the same
+ * small storage API so existing data structures can run unchanged, but values are
+ * stored only in process memory and are lost when the process exits.
  *
  * @module Database/NoIndexDb
  * @see https://documentation.freeschema.com for reference
  */
 import { SettingData } from "../DataStructures/SettingData";
 /**
- * Opens or returns a reference to the IndexedDB database.
+ * Opens or returns a reference to the legacy IndexedDB database handle.
  *
- * In this no-op implementation, it simply returns the static database reference
- * from IndexDb without performing any actual initialization.
+ * This Node compatibility implementation does not initialize a real database.
  *
  * @param databaseName - The name of the database to open
  * @returns The static IDBDatabase reference from IndexDb.db
@@ -32,10 +30,10 @@ import { SettingData } from "../DataStructures/SettingData";
  */
 export declare function openDatabase(databaseName: string): IDBDatabase;
 /**
- * Stores an object to the database (no-op implementation).
+ * Stores an object in the in-memory compatibility store.
  *
- * This function provides a stub for storing data to IndexedDB. In this no-op
- * implementation, it does not perform any actual storage operations.
+ * Values are not persisted to disk. Use this only as a runtime cache for the
+ * current Node process.
  *
  * @param databaseName - The name of the database or object store
  * @param object - The object to store (can be any type)
@@ -48,15 +46,15 @@ export declare function openDatabase(databaseName: string): IDBDatabase;
  * ```
  *
  * @remarks
- * This is a placeholder implementation. Use the full database module for actual persistence.
+ * This is not durable storage.
  */
 export declare function storeToDatabase(databaseName: string, object: any): void;
 /**
- * Retrieves statistics and settings from the database.
+ * Retrieves statistics and settings from the in-memory store.
  *
  * Returns a new SettingData instance initialized with default values.
  * This provides a consistent interface for accessing settings even when
- * database functionality is disabled.
+ * durable database functionality is disabled.
  *
  * @returns A new SettingData instance with AI features enabled (true)
  *
@@ -73,10 +71,9 @@ export declare function storeToDatabase(databaseName: string, object: any): void
  */
 export declare function GetStatsFromDatabase(): SettingData;
 /**
- * Updates the AI flag in settings (no-op implementation).
+ * Updates the AI flag in the in-memory settings store.
  *
- * This function provides a stub for updating AI-related settings in the database.
- * In this no-op implementation, it does not perform any actual updates.
+ * The update is process-local and is not persisted to disk.
  *
  * @param object - The SettingData object containing the new AI flag value
  *
@@ -88,16 +85,16 @@ export declare function GetStatsFromDatabase(): SettingData;
  * ```
  *
  * @remarks
- * This is a placeholder implementation. Changes are not persisted.
+ * Changes are not persisted across process restarts.
  *
  * @see SettingData for the settings data structure
  */
 export declare function AiUpdateFlag(object: SettingData): void;
 /**
- * Retrieves an object from the database by type and ID (no-op implementation).
+ * Retrieves objects from the in-memory store by property and value.
  *
- * This async function provides a stub for fetching data from IndexedDB based on
- * type and ID. In this no-op implementation, it returns undefined.
+ * This async function mirrors the old IndexedDB API shape while using the
+ * process-local compatibility store.
  *
  * @param databaseName - The name of the database or object store
  * @param type - The type of object to retrieve (e.g., 'concept', 'setting')
@@ -111,14 +108,14 @@ export declare function AiUpdateFlag(object: SettingData): void;
  * ```
  *
  * @remarks
- * This is a placeholder implementation. Use the full database module for actual retrieval.
+ * This is not durable storage.
  */
-export declare function getFromDatabaseWithType(databaseName: string, type: string, id: number): Promise<void>;
+export declare function getFromDatabaseWithType(databaseName: string, type: string, id: number): Promise<any[]>;
 /**
- * Retrieves objects from the database using legacy method (no-op implementation).
+ * Retrieves all objects from a named in-memory store.
  *
- * This async function provides a stub for the older method of fetching data from
- * IndexedDB. In this no-op implementation, it returns undefined.
+ * This async function preserves the older IndexedDB-oriented method name while
+ * returning data from the process-local compatibility store.
  *
  * @param databaseName - The name of the database or object store
  * @returns Promise resolving to undefined
@@ -135,12 +132,11 @@ export declare function getFromDatabaseWithType(databaseName: string, type: stri
  *
  * @see getFromDatabaseWithType for the current retrieval method
  */
-export declare function getFromDatabaseWithTypeOld(databaseName: string): Promise<void>;
+export declare function getFromDatabaseWithTypeOld(databaseName: string): Promise<any[]>;
 /**
- * Removes an object from the database by ID (no-op implementation).
+ * Removes an object from the in-memory store by ID.
  *
- * This function provides a stub for deleting data from IndexedDB. In this no-op
- * implementation, it does not perform any actual deletion.
+ * The deletion is process-local and is not persisted to disk.
  *
  * @param databaseName - The name of the database or object store
  * @param id - The numeric ID of the object to remove
@@ -152,14 +148,14 @@ export declare function getFromDatabaseWithTypeOld(databaseName: string): Promis
  * ```
  *
  * @remarks
- * This is a placeholder implementation. Use the full database module for actual deletion.
+ * This is not durable storage.
  */
 export declare function removeFromDatabase(databaseName: string, id: number): void;
 /**
- * Retrieves all objects from the local database (no-op implementation).
+ * Retrieves all objects from a local in-memory store.
  *
- * This async function provides a stub for fetching all data from a local IndexedDB
- * object store. In this no-op implementation, it returns undefined.
+ * This async function preserves the local IndexedDB API shape while returning
+ * process-local data.
  *
  * @param databaseName - The name of the database or object store
  * @returns Promise resolving to undefined
@@ -171,8 +167,8 @@ export declare function removeFromDatabase(databaseName: string, id: number): vo
  * ```
  *
  * @remarks
- * This is a placeholder implementation. Use the full database module for actual bulk retrieval.
+ * This is not durable storage.
  *
  * @see LocalIndexDb for local database operations
  */
-export declare function getAllFromLocalDb(databaseName: string): Promise<void>;
+export declare function getAllFromLocalDb(databaseName: string): Promise<any[]>;

package/dist/types/Services/Common/DecodeCountInfo.d.ts

@@ -33,7 +33,7 @@ export declare function DecodeCountInfo(countStrings?: string[]): CountInfo[];
  *
  * @async
  * @param {CountInfo[]} countInfos - Array of CountInfo objects to process
- * @returns {Promise<any>} A promise that resolves to a dictionary mapping concept IDs to enriched CountInfo objects
+ * @returns {Promise<any>} A promise that resolves to a dictionary mapping concept IDs to arrays of enriched CountInfo objects
  *
  * @example
  * ```typescript
@@ -43,8 +43,8 @@ export declare function DecodeCountInfo(countStrings?: string[]): CountInfo[];
  * ];
  * const dictionary = await GetConnectionTypeForCount(countInfos);
  * // dictionary = {
- * //   123: { conceptId: 123, connectionTypeId: 456, count: 42, connectionType: "follows" },
- * //   789: { conceptId: 789, connectionTypeId: 456, count: 15, connectionType: "follows" }
+ * //   123: [{ conceptId: 123, connectionTypeId: 456, count: 42, connectionType: "follows" }],
+ * //   789: [{ conceptId: 789, connectionTypeId: 456, count: 15, connectionType: "follows" }]
  * // }
  * ```
  *
@@ -52,6 +52,7 @@ export declare function DecodeCountInfo(countStrings?: string[]): CountInfo[];
  * - Fetches concept objects for each connectionTypeId
  * - Adds connectionType (character value) to each CountInfo
  * - Returns dictionary indexed by conceptId for fast lookup
+ * - Preserves multiple counts for the same concept across different connection types
  * - Used by formatting functions to add count information
  */
 export declare function GetConnectionTypeForCount(countInfos: CountInfo[]): Promise<any>;

package/dist/types/Services/Common/ErrorPosting.d.ts

@@ -5,25 +5,23 @@
 import { HttpResponse } from "../Http/HttpClient.service";
 /**
  * Handles HTTP errors by creating and throwing structured error responses.
- * Specifically handles 401 Unauthorized errors.
  *
- * @param {Response} response - The HTTP Response object to process
- * @throws {FreeSchemaResponse} Throws a structured error response for unauthorized requests
+ * @param {Response | HttpResponse} response - The HTTP response object to process
+ * @throws {FreeSchemaResponse} Throws a structured error response for any non-OK response
  *
  * @example
  * ```typescript
  * const response = await fetch("https://api.example.com/data");
  * HandleHttpError(response);
- * // Throws FreeSchemaResponse if status is 401
+ * // Throws FreeSchemaResponse if response.ok is false
  * ```
  *
  * @remarks
- * - Currently only handles 401 status codes
+ * - Handles any non-2xx status code
  * - Creates FreeSchemaResponse with status text, success=false, status code, and URL
- * - Other status codes are not handled (function returns normally)
  * - Useful for API call error handling
  */
-export declare function HandleHttpError(response: Response): void;
+export declare function HandleHttpError(response: Response | HttpResponse): void;
 export declare function HandleHttpErrorHttp(response: HttpResponse): void;
 /**
  * Handles internal application errors by creating and throwing structured error responses.

package/dist/types/Services/CreateConnectionBetweenTwoConcepts.d.ts

@@ -32,7 +32,7 @@ import { Connection } from "../DataStructures/Connection";
  * @param both - If true, creates connections in both directions (default: false)
  * @param count - If true, maintains a count of relationships for this linker type (default: false)
  *
- * @returns A promise that resolves to the created forward Connection object
+ * @returns A promise that resolves to the created forward Connection object with a reserved ID
  *
  * @example
  * ```typescript
@@ -71,6 +71,7 @@ import { Connection } from "../DataStructures/Connection";
  * - Forward connection type pattern: `{sourceType}_s_{linker}_s`
  * - Backward connection type pattern: `{targetType}_s_{linker}_by`
  * - Count concept pattern: `{type}_s_{linker}_count`
+ * - Uses reserved connection IDs for forward and backward connections
  * - Uses session information ID 999 and access level 4 as defaults
  * - Counting creates/updates a separate count concept for relationship analytics
  * - The backward connection is created first if both=true
@@ -199,12 +200,12 @@ export declare function CountRelationship(linker: string, concept: Concept, pass
  * - Uses CreateTheConnectionGeneral for proper ID reservation and persistence
  * - Forward connection type pattern: `{sourceType}_s_{linker}_s`
  * - Backward connection type pattern: `{targetType}_s_{linker}_by`
- * - Backward connections still use basic Connection creation (not CreateTheConnectionGeneral)
+ * - Forward and backward connections both use CreateTheConnectionGeneral
  * - Uses session information ID 999, order 1000, and access level 4
  * - Connection is marked for update (toUpdate = true) via CreateTheConnectionGeneral
  * - Recommended for production use over CreateConnectionBetweenTwoConcepts
  *
- * @see {@link CreateConnectionBetweenTwoConcepts} for the temporary version
+ * @see {@link CreateConnectionBetweenTwoConcepts} for the compatibility export
  * @see {@link CreateTheConnectionGeneral} for the underlying connection creation
  * @see {@link CountRelationship} for relationship counting implementation
  */

package/dist/types/Services/CreateTheComposition.d.ts

@@ -90,7 +90,7 @@ import { Concept } from "../DataStructures/Concept";
  * - Primitive values (strings, numbers) are stored as characterValue in leaf concepts
  * - Nested objects and arrays are recursively converted into sub-compositions
  * - All concepts are connected using the mainKey (root concept ID) as the connection type
- * - Uses temporary connections (via createTheConnection) with random IDs
+ * - Uses reserved connection IDs for persistence
  * - Default values: userId=999, accessId=4, sessionInformationId=999
  * - The function modifies SyncData by adding all created concepts and connections
  * - Complex objects become type concepts with isComposition=true
@@ -98,6 +98,6 @@ import { Concept } from "../DataStructures/Concept";
  *
  * @see {@link GetComposition} for reconstructing compositions back to JSON
  * @see {@link MakeTheInstanceConcept} for individual concept creation
- * @see {@link createTheConnection} for connection creation logic
+ * @see {@link CreateTheConnectionGeneral} for connection creation logic
  */
 export default function CreateTheComposition(json: any, ofTheConceptId?: number | null, ofTheConceptUserId?: number | null, mainKey?: number | null, userId?: number | null, accessId?: number | null, sessionInformationId?: number | null): Promise<Concept>;

package/dist/types/Services/CreateTheConnection.d.ts

@@ -8,13 +8,18 @@
  * @module CreateTheConnection
  */
 import { Connection } from "../DataStructures/Connection";
+type ConnectionConceptIds = {
+    ofTheConceptId: number;
+    toTheConceptId: number;
+};
+export declare function validateConnectionConceptIds(ofTheConceptId: number | string, toTheConceptId: number | string): ConnectionConceptIds;
 /**
  * Creates a temporary connection between two concepts with default settings.
  *
  * This function establishes a basic connection relationship between a source concept
  * (ofTheConcept) and a target concept (toTheConcept). The created connection is marked
  * as temporary (isTemp = true) and assigned a random ID. It automatically handles the
- * special case where a concept connects to itself by setting predefined IDs.
+ * Self-referencing connections are rejected before they can enter the sync queue.
  *
  * The function uses default values for security (0), access level (4), and order (1),
  * making it suitable for quick connection creation during prototyping or when advanced
@@ -48,8 +53,7 @@ import { Connection } from "../DataStructures/Connection";
  *
  * @remarks
  * - The connection is marked as temporary (isTemp = true) and assigned a random ID
- * - Self-referencing connections (where ofTheConceptId equals toTheConceptId) are handled
- *   specially by setting ofTheConceptId to 0 and toTheConceptId to 1
+ * - Self-referencing connections are rejected
  * - Default security level is set to 0 and access level to 4
  * - The connection is automatically added to SyncData for later synchronization
  * - For production use with reserved IDs and more control, consider using CreateTheConnectionGeneral
@@ -58,4 +62,5 @@ import { Connection } from "../DataStructures/Connection";
  * @see {@link Connection} for the connection data structure
  * @see {@link SyncData.AddConnection} for how connections are queued for sync
  */
-export declare function createTheConnection(ofTheConceptId: number, ofTheConceptUserId: number, toTheConceptId: number, toTheConceptUserId: number, typeId: number, sessionInformationId: number, sessionInformationUserId: number): Connection;
+export declare function createTheConnection(ofTheConceptId: number | string, ofTheConceptUserId: number, toTheConceptId: number | string, toTheConceptUserId: number, typeId: number, sessionInformationId: number, sessionInformationUserId: number): Connection;
+export {};

package/dist/types/Services/CreateTheConnectionGeneral.d.ts

@@ -7,9 +7,9 @@
  *
  * @module CreateTheConnectionGeneral
  */
-import { Concept } from "../app";
+import type { Concept } from "../DataStructures/Concept";
 import { Connection } from "../DataStructures/Connection";
-import { InnerActions } from "../DataStructures/Transaction/Transaction";
+import type { InnerActions } from "../DataStructures/Transaction/Transaction";
 /**
  * Creates a permanent connection between two concepts with reserved ID and full configuration.
  *
@@ -61,7 +61,7 @@ import { InnerActions } from "../DataStructures/Transaction/Transaction";
  * - Uses reserved IDs from ReservedConnectionIds for guaranteed uniqueness
  * - Connection is marked as non-temporary (isTemp = false) for persistence
  * - Sets toUpdate = true to ensure database synchronization
- * - Self-referencing connections are handled by setting ofTheConceptId to 0 and toTheConceptId to 1
+ * - Self-referencing connections are rejected before they can enter the sync queue
  * - The connection is added to both SyncData and the provided actions object
  * - If passedUserId is 999, the function defaults to using ofTheConceptUserId
  *
@@ -69,7 +69,7 @@ import { InnerActions } from "../DataStructures/Transaction/Transaction";
  * @see {@link CreateConnection} for a simplified high-level connection API
  * @see {@link ReservedConnectionIds.getId} for ID reservation mechanism
  */
-export declare function CreateTheConnectionGeneral(ofTheConceptId: number, ofTheConceptUserId: number, toTheConceptId: number, toTheConceptUserId: number, typeId: number, sessionInformationId: number, sessionInformationUserId: number, orderId?: number, accessId?: number, passedUserId?: number, actions?: InnerActions): Promise<Connection>;
+export declare function CreateTheConnectionGeneral(ofTheConceptId: number | string, ofTheConceptUserId: number, toTheConceptId: number | string, toTheConceptUserId: number, typeId: number, sessionInformationId: number, sessionInformationUserId: number, orderId?: number, accessId?: number, passedUserId?: number, actions?: InnerActions): Promise<Connection>;
 /**
  * Creates a connection between two concepts using a type string identifier.
  *

package/dist/types/Services/GetDataFromIndexDb.d.ts

@@ -1,21 +1,21 @@
 /**
- * IndexedDB Data Retrieval Service
+ * Runtime Cache Hydration Service
  *
- * This module provides comprehensive functionality for loading data from IndexedDB into
- * in-memory data structures. It handles both regular and local database data, loading
- * connections and concepts into their respective memory structures for efficient access.
+ * This module loads data from the Node package's process-local compatibility store
+ * into in-memory data structures. It keeps the original IndexedDB-oriented function
+ * names used by the frontend package, but it does not provide durable storage.
  *
  * The service supports two data contexts:
- * - Global/synced data: Loaded from standard IndexedDB stores
- * - Local data: Loaded from local-only IndexedDB stores for offline or user-specific data
+ * - Global/synced data: Loaded from the process-local compatibility store
+ * - Local data: Loaded from local process memory for API compatibility
  *
  * @module GetDataFromIndexDb
  */
 /**
- * Loads data from the standard IndexedDB stores into memory.
+ * Loads data from the standard process-local stores into memory.
  *
  * This is the main entry point for initializing the application's in-memory data structures
- * from persisted database records. Currently focuses on loading connections, with concept
+ * from runtime cache records. Currently focuses on loading connections, with concept
  * loading functionality commented out for optimization or architectural reasons.
  *
  * The function delegates to specialized helpers to load different data types, ensuring

package/dist/types/Services/Http/HttpClient.service.d.ts

@@ -100,6 +100,13 @@ export declare class HttpResponse {
  * ```
  */
 export declare function requestWithRetry(method: string, url: string, headers?: Record<string, string>, body?: any, maxRetries?: number): Promise<HttpResponse>;
+/**
+ * Fetch-compatible wrapper backed by requestWithRetry.
+ *
+ * Use this when migrating existing fetch call sites that expect `ok`, `json()`,
+ * and `text()` while still needing automatic token refresh on 401.
+ */
+export declare function fetchWithRetry(url: string, init?: RequestInit, maxRetries?: number): Promise<HttpResponse>;
 /**
  * Convenience method for POST requests with automatic retry on 401.
  *

package/dist/types/Services/MakeTheTimestamp.d.ts

@@ -30,8 +30,8 @@ import { Concept } from "../DataStructures/Concept";
  * - Category ID is fixed at 4 for timestamp concepts
  * - Referent ID is set to 0 (no referent concept)
  * - Security ID is fixed at 999
- * - Session information ID is overridden to 999 regardless of parameter
- * - Access ID is overridden to 4 regardless of parameter
+ * - Uses the provided sessionInformationId, defaulting to 999
+ * - Uses the provided accessId
  * - All user IDs are derived from the userId parameter
  * - Type concept is created before the timestamp concept
  *

package/dist/types/Services/PatchComposition.d.ts

@@ -20,8 +20,8 @@ import { Concept } from "../DataStructures/Concept";
  * @param ofConcept - The source concept from which the connection originates
  * @param MainConcept - The main composition concept that contains both concepts and their connection
  * @param toConcept - The target concept to which the connection points
- * @returns The connection object between the two concepts within the composition context,
- *          or undefined if no such connection exists
+ * @returns The connections between the two concepts within the composition context,
+ *          or an empty array if no such connection exists
  *
  * @example
  * ```typescript
@@ -33,8 +33,8 @@ import { Concept } from "../DataStructures/Concept";
  * const profileConcept: Concept = { id: 456, type: "profile", ... };
  * const compositionConcept: Concept = { id: 789, type: "composition", ... };
  *
- * const connection = PatchComposition(userConcept, compositionConcept, profileConcept);
- * // Returns the connection object linking user to profile within the composition
+ * const connections = await PatchComposition(userConcept, compositionConcept, profileConcept);
+ * // Returns the connections linking user to profile within the composition
  * ```
  *
  * @example
@@ -44,13 +44,13 @@ import { Concept } from "../DataStructures/Concept";
  * const addressConcept = await GetTheConcept(456);
  * const mainComposition = await GetTheConcept(789);
  *
- * const existingConnection = PatchComposition(
+ * const existingConnections = await PatchComposition(
  *   userConcept,
  *   mainComposition,
  *   addressConcept
  * );
  *
- * if (existingConnection) {
+ * if (existingConnections.length > 0) {
  *   console.log("Connection already exists");
  * } else {
  *   console.log("No connection found, can create new one");
@@ -64,9 +64,9 @@ import { Concept } from "../DataStructures/Concept";
  * const toConcept = await GetTheConcept(222);
  * const composition = await GetTheConcept(333);
  *
- * const connection = PatchComposition(fromConcept, composition, toConcept);
- * if (connection) {
- *   await DeleteConnectionById(connection.id);
+ * const connections = await PatchComposition(fromConcept, composition, toConcept);
+ * if (connections.length > 0) {
+ *   await DeleteConnectionById(connections[0].id);
  * }
  * ```
  *
@@ -83,11 +83,6 @@ import { Concept } from "../DataStructures/Concept";
  * - This prevents retrieving connections from other compositions that might link the same concepts
  * - Provides composition-scoped connection lookup
  *
- * **Return Value:**
- * - The function calls an API method but doesn't explicitly handle the return
- * - The connection variable is assigned but not returned in the current implementation
- * - This may be an incomplete implementation that needs a return statement
- *
  * **Use Cases:**
  * - Verifying if a connection exists before creating a new one
  * - Finding the connection ID for deletion operations
@@ -104,4 +99,4 @@ import { Concept } from "../DataStructures/Concept";
  * @see {@link Connection} for the connection data structure
  * @see {@link UpdateComposition} for composition update operations
  */
-export default function PatchComposition(ofConcept: Concept, MainConcept: Concept, toConcept: Concept): void;
+export default function PatchComposition(ofConcept: Concept, MainConcept: Concept, toConcept: Concept): Promise<import("../app").Connection[]>;

package/dist/types/Services/UpdateComposition.d.ts

@@ -118,7 +118,7 @@ import { PatcherStructure } from '../DataStructures/PatcherStructure';
  * @see {@link CreateTheCompositionWithCache} for creating nested compositions
  * @see {@link GetTheConcept} for concept retrieval
  * @see {@link MakeTheInstanceConcept} for creating new concept instances
- * @see {@link createTheConnection} for creating connections between concepts
+ * @see {@link CreateTheConnectionGeneral} for creating connections between concepts
  * @see {@link DeleteConnectionById} for connection deletion
  * @see {@link SyncData.SyncDataOnline} for backend synchronization
  */

package/dist/types/app.d.ts

@@ -7,31 +7,28 @@
  * @see {@link https://documentation.freeschema.com} for detailed documentation
  */
 export { init, updateAccessToken };
-export { getOAuthToken, refreshOAuthToken, OAuthResponse } from './Services/oauth/CallOauth.service';
-export { requestWithRetry, postWithRetry, getWithRetry, putWithRetry, deleteWithRetry, patchWithRetry, HttpResponse, TokenRefreshError } from './Services/Http/HttpClient.service';
+export { getOAuthToken, refreshOAuthToken } from './Services/oauth/CallOauth.service';
+export type { OAuthResponse } from './Services/oauth/CallOauth.service';
+export { requestWithRetry, postWithRetry, getWithRetry, putWithRetry, deleteWithRetry, patchWithRetry, fetchWithRetry, HttpResponse, TokenRefreshError } from './Services/Http/HttpClient.service';
 export { SplitStrings } from './Services/SplitStrings';
 export { GetRequestHeader, GetRequestHeaderWithAuthorization } from './Services/Security/GetRequestHeader';
 export { GetCompositionList, GetCompositionListWithId } from './Services/GetCompositionList';
-export { GetCompositionListLocal, GetCompositionListLocalWithId } from './Services/Local/GetCompositionListLocal';
 export { GetAllConnectionsOfComposition } from './Api/GetAllConnectionsOfComposition';
 export { GetComposition, GetCompositionWithId, recursiveFetch, GetCompositionWithAllIds } from './Services/GetComposition';
-export { GetCompositionLocal, GetCompositionLocalWithId } from './Services/Local/GetCompositionLocal';
 export { default as CreateComposition } from './Services/CreateTheComposition';
-export { CreateTheCompositionLocal } from './Services/Local/CreateTheCompositionLocal';
 export { CreateConnectionBetweenTwoConcepts, CreateConnectionBetweenTwoConceptsGeneral } from './Services/CreateConnectionBetweenTwoConcepts';
 export { default as GetTheConcept } from './Services/GetTheConcept';
 export { default as MakeTheInstanceConcept } from './Services/MakeTheInstanceConcept';
-export { MakeTheInstanceConceptLocal } from './Services/Local/MakeTheInstanceConceptLocal';
 export { storeToDatabase, getFromDatabaseWithType, getFromDatabaseWithTypeOld } from './Database/NoIndexDb';
-export { createTheConnection as CreateTheConnection } from './Services/CreateTheConnection';
 export { default as GetConceptByCharacter } from './Services/GetConceptByCharacter';
 export { GetLink, GetLinkRaw } from './Services/GetLink';
 export { CreateDefaultConcept } from './Services/CreateDefaultConcept';
+export { CreateDefaultLConcept } from './Services/Local/CreateDefaultLConcept';
 export { MakeTheTypeConcept } from './Services/MakeTheTypeConcept';
 export { MakeTheTypeConceptApi } from './Api/MakeTheTypeConceptApi';
 export { GetLinkerConnectionFromConcepts, GetLinkerConnectionToConcepts } from './Services/GetLinkerConnectionFromConcept';
 export { DeleteConceptById } from './Services/DeleteConcept';
-export { DeleteConnectionById } from './Services/DeleteConnection';
+export { DeleteConnectionById, DeleteConnectionByIdBulk } from './Services/DeleteConnection';
 export { TrashTheConcept } from './Api/Delete/DeleteConceptInBackend';
 export { GetConnectionById } from './Services/GetConnections';
 export { MakeTheTimestamp } from './Services/MakeTheTimestamp';
@@ -54,12 +51,9 @@ export {} from './Api/GetConceptByCharacterAndType';
 export { GetRelation, GetRelationRaw } from './Services/GetRelation';
 export { recursiveFetchNew } from './Services/Composition/BuildComposition';
 export { CreateTheCompositionWithCache } from './Services/Composition/CreateCompositionCache';
-export { CreateDefaultLConcept } from './Services/Local/CreateDefaultLConcept';
 export { CreateTheConnectionGeneral, CreateConnection } from './Services/CreateTheConnectionGeneral';
-export { CreateTheConnectionLocal } from './Services/Local/CreateTheConnectionLocal';
 export { GetUserGhostId, AddGhostConcept, GetUserGhostConnectionId, AddGhostConnection } from './Services/User/UserTranslation';
 export { SearchLinkMultipleAll, FormatFromConnections } from './Services/Search/SearchLinkMultiple';
-export { UpdateCompositionLocal } from './Services/Local/UpdateCompositionLocal';
 export { GetCompositionFromConnectionsWithDataIdInObject } from './Services/GetCompositionBulk';
 export { ViewInternalData } from './Services/View/ViewInternalData';
 export { convertFromLConceptToConcept } from './Services/Conversion/ConvertConcepts';
@@ -80,9 +74,9 @@ export { ConceptsData } from './DataStructures/ConceptData';
 export { ConnectionData } from './DataStructures/ConnectionData';
 export { BinaryTree } from './DataStructures/BinaryTree';
 export { SearchQuery } from './DataStructures/SearchQuery';
-export { SignupModel } from './DataStructures/SignupModel';
-export { SigninModel } from './DataStructures/SigninModel';
-export { FreeschemaResponse } from './DataStructures/Responses/StandardResponses';
+export type { SignupModel } from './DataStructures/SignupModel';
+export type { SigninModel } from './DataStructures/SigninModel';
+export type { FreeschemaResponse } from './DataStructures/Responses/StandardResponses';
 export { PatcherStructure } from './DataStructures/PatcherStructure';
 export { SessionData } from './DataStructures/Session/SessionData';
 export { Composition } from './DataStructures/Composition/Composition';
@@ -99,10 +93,15 @@ export { TokenStorage } from './DataStructures/Security/TokenStorage';
 export { SchemaQueryListener } from './WrapperFunctions/SchemaQueryObservable';
 export { FreeschemaQuery } from './DataStructures/Search/FreeschemaQuery';
 export { GiveConnection, GetAllTheConnectionsByTypeAndOfTheConcept } from './Services/Delete/GetAllConnectionByType';
+export { GetConnectionsBetweenApi } from './Api/GetConnections/GetConnectionsBetweenApi';
+export { buildFetchConnection } from './DataStructures/FetchConnection';
+export type { FetchConnection, FetchConnectionQuery } from './DataStructures/FetchConnection';
 export { DATAID, NORMAL, JUSTDATA, ALLID, DATAIDDATE, RAW, LISTNORMAL, DATAV2 } from './Constants/FormatConstants';
 export { AccessControlService } from './Services/AccessControl/AccessControlService';
 export { PermissionSet } from './Services/AccessControl/PermissionSet';
 export { Transaction } from './DataStructures/Transaction/Transaction';
+export type { InnerActions } from './DataStructures/Transaction/Transaction';
+export { ReservedIds, ReservedConnectionIds } from './DataStructures/ReservedIds';
 /**
  * Updates the bearer access token used for authenticating API requests to the backend.
  * This token is stored globally and used by all API calls that require authentication.
@@ -126,11 +125,11 @@ declare function updateAccessToken(accessToken?: string): void;
  *
  * 1. Sets up base URLs for the main API and AI services
  * 2. Stores the authentication token for API requests (or obtains one via OAuth)
- * 3. Initializes the system (database setup)
+ * 3. Initializes the system and process-local compatibility store
  * 4. Creates binary trees from concept data for efficient querying (by ID, character, and type)
- * 5. Creates local binary trees for offline/local concept management
- * 6. Loads connection data from IndexedDB into memory
- * 7. Loads local connection data for offline operations
+ * 5. Creates local binary trees for compatibility with frontend-origin APIs
+ * 6. Loads connection data from process-local storage into memory
+ * 7. Loads local connection data from process-local storage
  *
  * All data loading operations run in parallel for optimal performance. The IdentifierFlags
  * are updated as each operation completes to indicate which data structures are ready for use.
@@ -191,8 +190,9 @@ declare function updateAccessToken(accessToken?: string): void;
  * ```
  *
  * @remarks
- * The initialization process is asynchronous but does not return a Promise. Instead,
- * it uses IdentifierFlags to signal when different components are ready:
+ * The initialization process returns a Promise that resolves after OAuth setup,
+ * system initialization, and all cache hydration tasks complete. IdentifierFlags
+ * are also updated for consumers that poll readiness:
  * - `isDataLoaded`, `isCharacterLoaded`, `isTypeLoaded` - Remote concept data ready
  * - `isLocalDataLoaded`, `isLocalTypeLoaded`, `isLocalCharacterLoaded` - Local concept data ready
  * - `isConnectionLoaded`, `isConnectionTypeLoaded` - Remote connection data ready
@@ -204,4 +204,4 @@ declare function updateAccessToken(accessToken?: string): void;
  * @see CreateBinaryTreeFromData for concept tree creation
  * @see https://documentation.freeschema.com/#installation for setup guide
  */
-declare function init(url?: string, nodeUrl?: string, applicationName?: string, config?: CCSConfig): void;
+declare function init(url?: string, nodeUrl?: string, applicationName?: string, config?: CCSConfig): Promise<void>;

package/package.json

@@ -1,10 +1,21 @@
 {
   "name": "mftsccs-node",
-  "version": "0.2.23",
+  "version": "0.2.25",
   "environment": "production",
   "description": "Full Pack of concept and connection system",
   "main": "dist/bundle.js",
+  "module": "dist/bundle.mjs",
   "types": "dist/types/app.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/types/app.d.ts",
+      "import": "./dist/bundle.mjs",
+      "require": "./dist/bundle.js",
+      "default": "./dist/bundle.js"
+    },
+    "./dist/*": "./dist/*",
+    "./package.json": "./package.json"
+  },
   "files": [
     "dist",
     "LICENSE",