@olane/o-node 0.7.12-alpha.4 → 0.7.12-alpha.41

package/dist/o-core/src/streaming/stream-handler.base.d.ts

@@ -0,0 +1,85 @@
+import { oError } from '../error/o-error.js';
+import { oRequest } from '@olane/o-protocol';
+/**
+ * State machine states for streaming operations
+ */
+export declare enum StreamHandlerState {
+    IDLE = "idle",
+    STREAMING = "streaming",
+    COMPLETED = "completed",
+    ERROR = "error"
+}
+/**
+ * Options for stream handler operations
+ */
+export interface StreamHandlerOptions {
+    /**
+     * Enable metrics tracking
+     */
+    enableMetrics?: boolean;
+}
+/**
+ * Abstract base class for handling streaming operations.
+ * Provides transport-agnostic AsyncGenerator iteration, chunk sequencing,
+ * error handling, and state management.
+ *
+ * Implementations must provide the sendChunk method for transport-specific
+ * chunk transmission.
+ */
+export declare abstract class StreamHandlerBase {
+    protected state: StreamHandlerState;
+    protected currentSequence: number;
+    protected options: StreamHandlerOptions;
+    constructor(options?: StreamHandlerOptions);
+    /**
+     * Get the current state of the stream handler
+     */
+    getState(): StreamHandlerState;
+    /**
+     * Get the current sequence number
+     */
+    getCurrentSequence(): number;
+    /**
+     * Abstract method that implementations must provide to send a chunk.
+     * This method should handle the actual transmission using the specific transport.
+     *
+     * @param chunk - The data chunk to send
+     * @param sequence - The sequence number of this chunk
+     * @param isLast - Whether this is the final chunk
+     * @param request - The original request
+     */
+    protected abstract sendChunk(chunk: unknown, sequence: number, isLast: boolean, request: oRequest): Promise<void>;
+    /**
+     * Optional hook called when streaming starts
+     */
+    protected onStreamStart?(request: oRequest): void;
+    /**
+     * Optional hook called when streaming completes successfully
+     */
+    protected onStreamComplete?(request: oRequest, totalChunks: number): void;
+    /**
+     * Optional hook called when streaming encounters an error
+     */
+    protected onStreamError?(request: oRequest, error: oError): void;
+    /**
+     * Handle streaming of an AsyncGenerator.
+     * Iterates through the generator, sends each chunk with proper sequencing,
+     * and handles errors appropriately.
+     *
+     * @param generator - The AsyncGenerator to stream
+     * @param request - The original request
+     * @returns Promise that resolves when streaming is complete
+     */
+    handleStream(generator: AsyncGenerator<any>, request: oRequest): Promise<void>;
+    /**
+     * Convert any error to an oError instance
+     * @param error - The error to convert
+     * @returns An oError instance
+     */
+    protected convertToOError(error: unknown): oError;
+    /**
+     * Reset the handler state for reuse
+     */
+    reset(): void;
+}
+//# sourceMappingURL=stream-handler.base.d.ts.map

package/dist/o-core/src/streaming/stream-handler.base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-handler.base.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/streaming/stream-handler.base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,qBAAqB,CAAC;AAE7C,OAAO,EAAE,QAAQ,EAAE,MAAM,mBAAmB,CAAC;AAE7C;;GAEG;AACH,oBAAY,kBAAkB;IAC5B,IAAI,SAAS;IACb,SAAS,cAAc;IACvB,SAAS,cAAc;IACvB,KAAK,UAAU;CAChB;AAED;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,aAAa,CAAC,EAAE,OAAO,CAAC;CACzB;AAED;;;;;;;GAOG;AACH,8BAAsB,iBAAiB;IACrC,SAAS,CAAC,KAAK,EAAE,kBAAkB,CAA2B;IAC9D,SAAS,CAAC,eAAe,EAAE,MAAM,CAAK;IACtC,SAAS,CAAC,OAAO,EAAE,oBAAoB,CAAC;gBAE5B,OAAO,GAAE,oBAAyB;IAO9C;;OAEG;IACI,QAAQ,IAAI,kBAAkB;IAIrC;;OAEG;IACI,kBAAkB,IAAI,MAAM;IAInC;;;;;;;;OAQG;IACH,SAAS,CAAC,QAAQ,CAAC,SAAS,CAC1B,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,MAAM,EAChB,MAAM,EAAE,OAAO,EACf,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,IAAI,CAAC;IAEhB;;OAEG;IACH,SAAS,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE,QAAQ,GAAG,IAAI;IAEjD;;OAEG;IACH,SAAS,CAAC,gBAAgB,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,GAAG,IAAI;IAEzE;;OAEG;IACH,SAAS,CAAC,aAAa,CAAC,CAAC,OAAO,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,GAAG,IAAI;IAEhE;;;;;;;;OAQG;IACU,YAAY,CACvB,SAAS,EAAE,cAAc,CAAC,GAAG,CAAC,EAC9B,OAAO,EAAE,QAAQ,GAChB,OAAO,CAAC,IAAI,CAAC;IAqDhB;;;;OAIG;IACH,SAAS,CAAC,eAAe,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM;IAoBjD;;OAEG;IACI,KAAK,IAAI,IAAI;CAIrB"}

package/dist/o-core/src/streaming/stream-handler.base.js

@@ -0,0 +1,112 @@
+import { oError } from '../error/o-error.js';
+import { oErrorCodes } from '../error/enums/codes.error.js';
+/**
+ * State machine states for streaming operations
+ */
+export var StreamHandlerState;
+(function (StreamHandlerState) {
+    StreamHandlerState["IDLE"] = "idle";
+    StreamHandlerState["STREAMING"] = "streaming";
+    StreamHandlerState["COMPLETED"] = "completed";
+    StreamHandlerState["ERROR"] = "error";
+})(StreamHandlerState || (StreamHandlerState = {}));
+/**
+ * Abstract base class for handling streaming operations.
+ * Provides transport-agnostic AsyncGenerator iteration, chunk sequencing,
+ * error handling, and state management.
+ *
+ * Implementations must provide the sendChunk method for transport-specific
+ * chunk transmission.
+ */
+export class StreamHandlerBase {
+    constructor(options = {}) {
+        this.state = StreamHandlerState.IDLE;
+        this.currentSequence = 0;
+        this.options = {
+            enableMetrics: true,
+            ...options,
+        };
+    }
+    /**
+     * Get the current state of the stream handler
+     */
+    getState() {
+        return this.state;
+    }
+    /**
+     * Get the current sequence number
+     */
+    getCurrentSequence() {
+        return this.currentSequence;
+    }
+    /**
+     * Handle streaming of an AsyncGenerator.
+     * Iterates through the generator, sends each chunk with proper sequencing,
+     * and handles errors appropriately.
+     *
+     * @param generator - The AsyncGenerator to stream
+     * @param request - The original request
+     * @returns Promise that resolves when streaming is complete
+     */
+    async handleStream(generator, request) {
+        this.state = StreamHandlerState.STREAMING;
+        this.currentSequence = 0;
+        // Call optional hook
+        if (this.onStreamStart) {
+            this.onStreamStart(request);
+        }
+        try {
+            // Iterate through the generator and send each chunk
+            for await (const chunk of generator) {
+                this.currentSequence++;
+                await this.sendChunk(chunk, this.currentSequence, false, request);
+            }
+            // Send final empty chunk to signal completion
+            await this.sendChunk(null, this.currentSequence, true, request);
+            this.state = StreamHandlerState.COMPLETED;
+            // Call optional hook
+            if (this.onStreamComplete) {
+                this.onStreamComplete(request, this.currentSequence);
+            }
+        }
+        catch (error) {
+            this.state = StreamHandlerState.ERROR;
+            // Convert error to oError if needed
+            const oErrorInstance = this.convertToOError(error);
+            // Call optional hook
+            if (this.onStreamError) {
+                this.onStreamError(request, oErrorInstance);
+            }
+            // Send error as final chunk
+            try {
+                await this.sendChunk(oErrorInstance.toJSON(), this.currentSequence, true, request);
+            }
+            catch (sendError) {
+                console.error('Failed to send error chunk:', sendError);
+                throw oErrorInstance;
+            }
+            throw oErrorInstance;
+        }
+    }
+    /**
+     * Convert any error to an oError instance
+     * @param error - The error to convert
+     * @returns An oError instance
+     */
+    convertToOError(error) {
+        if (error instanceof oError) {
+            return error;
+        }
+        if (error instanceof Error) {
+            return new oError(oErrorCodes.UNKNOWN, error.message, { stack: error.stack });
+        }
+        return new oError(oErrorCodes.UNKNOWN, String(error), { originalError: error });
+    }
+    /**
+     * Reset the handler state for reuse
+     */
+    reset() {
+        this.state = StreamHandlerState.IDLE;
+        this.currentSequence = 0;
+    }
+}

package/dist/o-core/src/streaming/stream-transport.interface.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Stream status states
+ */
+export declare enum StreamStatus {
+    OPEN = "open",
+    CLOSING = "closing",
+    CLOSED = "closed",
+    RESET = "reset"
+}
+/**
+ * Transport-agnostic interface for stream operations.
+ * Implementations can use libp2p, WebSockets, HTTP/2, or any other streaming transport.
+ */
+export interface IStreamTransport {
+    /**
+     * Send data through the stream with backpressure handling
+     * @param data - The data to send (UTF-8 encoded bytes)
+     * @returns Promise that resolves when data is sent (handles backpressure internally)
+     */
+    send(data: Uint8Array): Promise<void>;
+    /**
+     * Set up a message handler for incoming data
+     * @param handler - Callback function to handle incoming messages
+     */
+    onMessage(handler: (data: Uint8Array) => void): void;
+    /**
+     * Remove the message handler
+     */
+    removeMessageHandler(): void;
+    /**
+     * Close the stream and clean up resources
+     * @returns Promise that resolves when stream is closed
+     */
+    close(): Promise<void>;
+    /**
+     * Get the current status of the stream
+     * @returns The current stream status
+     */
+    getStatus(): StreamStatus;
+    /**
+     * Check if the stream is in a usable state
+     * @returns true if stream can send/receive data
+     */
+    isOpen(): boolean;
+}
+/**
+ * Configuration options for stream transport operations
+ */
+export interface StreamTransportConfig {
+    /**
+     * Timeout in milliseconds for drain operations when handling backpressure
+     * @default 30000 (30 seconds)
+     */
+    drainTimeoutMs?: number;
+    /**
+     * Maximum time in milliseconds to wait for the first message
+     * @default 120000 (2 minutes)
+     */
+    readTimeoutMs?: number;
+}
+//# sourceMappingURL=stream-transport.interface.d.ts.map

package/dist/o-core/src/streaming/stream-transport.interface.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stream-transport.interface.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/streaming/stream-transport.interface.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,oBAAY,YAAY;IACtB,IAAI,SAAS;IACb,OAAO,YAAY;IACnB,MAAM,WAAW;IACjB,KAAK,UAAU;CAChB;AAED;;;GAGG;AACH,MAAM,WAAW,gBAAgB;IAC/B;;;;OAIG;IACH,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtC;;;OAGG;IACH,SAAS,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,UAAU,KAAK,IAAI,GAAG,IAAI,CAAC;IAErD;;OAEG;IACH,oBAAoB,IAAI,IAAI,CAAC;IAE7B;;;OAGG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;;OAGG;IACH,SAAS,IAAI,YAAY,CAAC;IAE1B;;;OAGG;IACH,MAAM,IAAI,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;OAGG;IACH,cAAc,CAAC,EAAE,MAAM,CAAC;IAExB;;;OAGG;IACH,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB"}

package/dist/o-core/src/streaming/stream-transport.interface.js

@@ -0,0 +1,10 @@
+/**
+ * Stream status states
+ */
+export var StreamStatus;
+(function (StreamStatus) {
+    StreamStatus["OPEN"] = "open";
+    StreamStatus["CLOSING"] = "closing";
+    StreamStatus["CLOSED"] = "closed";
+    StreamStatus["RESET"] = "reset";
+})(StreamStatus || (StreamStatus = {}));

package/dist/o-core/src/transports/custom.transport.d.ts

@@ -0,0 +1,6 @@
+import { oTransport } from './o-transport.js';
+export declare class oCustomTransport extends oTransport {
+    constructor(value: string);
+    toString(): string;
+}
+//# sourceMappingURL=custom.transport.d.ts.map

package/dist/o-core/src/transports/custom.transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"custom.transport.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/transports/custom.transport.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAE9C,qBAAa,gBAAiB,SAAQ,UAAU;gBAClC,KAAK,EAAE,MAAM;IAIzB,QAAQ,IAAI,MAAM;CAGnB"}

package/dist/o-core/src/transports/custom.transport.js

@@ -0,0 +1,10 @@
+import { TransportType } from './interfaces/transport-type.enum.js';
+import { oTransport } from './o-transport.js';
+export class oCustomTransport extends oTransport {
+    constructor(value) {
+        super(value, TransportType.CUSTOM);
+    }
+    toString() {
+        return this.value.toString();
+    }
+}

package/dist/o-core/src/transports/index.d.ts

@@ -0,0 +1,4 @@
+export * from './o-transport.js';
+export * from './custom.transport.js';
+export * from './interfaces/transport-type.enum.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/o-core/src/transports/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/transports/index.ts"],"names":[],"mappings":"AAAA,cAAc,kBAAkB,CAAC;AACjC,cAAc,uBAAuB,CAAC;AACtC,cAAc,qCAAqC,CAAC"}

package/dist/o-core/src/transports/index.js

@@ -0,0 +1,3 @@
+export * from './o-transport.js';
+export * from './custom.transport.js';
+export * from './interfaces/transport-type.enum.js';

package/dist/o-core/src/transports/interfaces/transport-type.enum.d.ts

@@ -0,0 +1,5 @@
+export declare enum TransportType {
+    LIBP2P = "libp2p",
+    CUSTOM = "custom"
+}
+//# sourceMappingURL=transport-type.enum.d.ts.map

package/dist/o-core/src/transports/interfaces/transport-type.enum.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"transport-type.enum.d.ts","sourceRoot":"","sources":["../../../../../../o-core/src/transports/interfaces/transport-type.enum.ts"],"names":[],"mappings":"AAAA,oBAAY,aAAa;IACvB,MAAM,WAAW;IACjB,MAAM,WAAW;CAClB"}

package/dist/o-core/src/transports/interfaces/transport-type.enum.js

@@ -0,0 +1,5 @@
+export var TransportType;
+(function (TransportType) {
+    TransportType["LIBP2P"] = "libp2p";
+    TransportType["CUSTOM"] = "custom";
+})(TransportType || (TransportType = {}));

package/dist/o-core/src/transports/o-transport.d.ts

@@ -0,0 +1,10 @@
+import { oObject } from '../core/o-object.js';
+import { TransportType } from './interfaces/transport-type.enum.js';
+export declare abstract class oTransport extends oObject {
+    readonly value: any;
+    readonly type: TransportType;
+    constructor(value: any, type?: TransportType);
+    abstract toString(): string;
+    toJSON(): any;
+}
+//# sourceMappingURL=o-transport.d.ts.map

package/dist/o-core/src/transports/o-transport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"o-transport.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/transports/o-transport.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,aAAa,EAAE,MAAM,qCAAqC,CAAC;AAEpE,8BAAsB,UAAW,SAAQ,OAAO;IAC9C,SAAgB,KAAK,EAAE,GAAG,CAAC;IAC3B,SAAgB,IAAI,EAAE,aAAa,CAAwB;gBAE/C,KAAK,EAAE,GAAG,EAAE,IAAI,GAAE,aAAoC;IAMlE,QAAQ,CAAC,QAAQ,IAAI,MAAM;IAE3B,MAAM,IAAI,GAAG;CAMd"}

package/dist/o-core/src/transports/o-transport.js

@@ -0,0 +1,16 @@
+import { oObject } from '../core/o-object.js';
+import { TransportType } from './interfaces/transport-type.enum.js';
+export class oTransport extends oObject {
+    constructor(value, type = TransportType.LIBP2P) {
+        super();
+        this.type = TransportType.LIBP2P;
+        this.value = value;
+        this.type = type;
+    }
+    toJSON() {
+        return {
+            value: this.value,
+            type: this.type,
+        };
+    }
+}

package/dist/o-core/src/utils/core.utils.d.ts

@@ -0,0 +1,34 @@
+import { Stream } from '@olane/o-config';
+import { oAddress } from '../router/o-address.js';
+import { oResponse } from '../connection/o-response.js';
+import { oRequest } from '../connection/o-request.js';
+import { CID } from 'multiformats';
+import { oObject } from '../core/o-object.js';
+export declare class CoreUtils extends oObject {
+    static generatePeerId(): Promise<any>;
+    static doHealthCheck(address: oAddress, node: any): Promise<boolean>;
+    static healthCheck(config: {
+        type?: 'leader' | 'parent' | 'child';
+        address?: oAddress;
+        node: any;
+        timeout?: number;
+    }): Promise<boolean>;
+    static generatePrivateKey(seed: string): Promise<any>;
+    /**
+     * Convert any user phrase to exactly 32 bytes for Ed25519 key generation.
+     * This function uses SHA-256 hashing to ensure:
+     * - Deterministic: Same phrase always produces same seed
+     * - Uniform distribution: Good entropy even for weak phrases
+     * - Exactly 32 bytes: Meets Ed25519 cryptographic requirements
+     */
+    static phraseToSeedBytes(phrase: string): Uint8Array;
+    static phraseToSeed(phrase: string): string;
+    static childAddress(parentAddress: oAddress, childAddress: oAddress): oAddress;
+    static sendResponse(response: oResponse, stream: Stream): Promise<void>;
+    static sendStreamResponse(response: oResponse, stream: Stream): Promise<void>;
+    static processStream(event: any): Promise<any>;
+    static processStreamRequest(event: any): Promise<oRequest>;
+    static processStreamResponse(event: any): Promise<oResponse>;
+    static toCID(data: any): Promise<CID>;
+}
+//# sourceMappingURL=core.utils.d.ts.map

package/dist/o-core/src/utils/core.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"core.utils.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/utils/core.utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,MAAM,EAGP,MAAM,iBAAiB,CAAC;AAEzB,OAAO,EAAE,QAAQ,EAAE,MAAM,wBAAwB,CAAC;AAClD,OAAO,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAC;AACtD,OAAO,EAAE,GAAG,EAAE,MAAM,cAAc,CAAC;AAGnC,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAE9C,qBAAa,SAAU,SAAQ,OAAO;WACvB,cAAc,IAAI,OAAO,CAAC,GAAG,CAAC;IAK3C,MAAM,CAAC,aAAa,CAAC,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,OAAO,CAAC;WAkBvD,WAAW,CAAC,MAAM,EAAE;QAC/B,IAAI,CAAC,EAAE,QAAQ,GAAG,QAAQ,GAAG,OAAO,CAAC;QACrC,OAAO,CAAC,EAAE,QAAQ,CAAC;QACnB,IAAI,EAAE,GAAG,CAAC;QACV,OAAO,CAAC,EAAE,MAAM,CAAC;KAClB,GAAG,OAAO,CAAC,OAAO,CAAC;WA4BP,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,CAAC;IAQ3D;;;;;;OAMG;WACW,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,UAAU;WAO7C,YAAY,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM;WAOpC,YAAY,CACxB,aAAa,EAAE,QAAQ,EACvB,YAAY,EAAE,QAAQ,GACrB,QAAQ;WAIS,YAAY,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM;WAahD,kBAAkB,CAAC,QAAQ,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM;WAgBtD,aAAa,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;WAMvC,oBAAoB,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,QAAQ,CAAC;WAKnD,qBAAqB,CAAC,KAAK,EAAE,GAAG,GAAG,OAAO,CAAC,SAAS,CAAC;WAOrD,KAAK,CAAC,IAAI,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC;CAMnD"}

package/dist/o-core/src/utils/core.utils.js

@@ -0,0 +1,123 @@
+import { generateKeyPairFromSeed, createEd25519PeerId, Uint8ArrayList, } from '@olane/o-config';
+import { createHash } from 'crypto';
+import { oAddress } from '../router/o-address.js';
+import { oResponse } from '../connection/o-response.js';
+import { oRequest } from '../connection/o-request.js';
+import { CID } from 'multiformats';
+import * as json from 'multiformats/codecs/json';
+import { sha256 } from 'multiformats/hashes/sha2';
+import { oObject } from '../core/o-object.js';
+export class CoreUtils extends oObject {
+    static async generatePeerId() {
+        const peerId = await createEd25519PeerId();
+        return peerId;
+    }
+    static doHealthCheck(address, node) {
+        return new Promise(async (resolve, reject) => {
+            const timer = setTimeout(() => {
+                reject(new Error('Health check timed out'));
+            }, 30000); // 30 seconds
+            const response = await node.use(new oAddress(address.toString() + '/ping', address.transports));
+            clearTimeout(timer);
+            if (response.result.error) {
+                reject(new Error('Health check failed'));
+            }
+            else {
+                resolve(true);
+            }
+        });
+    }
+    static async healthCheck(config) {
+        if (!config.node) {
+            throw new Error('Node is required');
+        }
+        const { type, address, node } = config;
+        if (type === 'leader') {
+            return CoreUtils.doHealthCheck(node.leader, node);
+        }
+        else if (type === 'parent') {
+            return CoreUtils.doHealthCheck(node.parent, node);
+        }
+        else if (type === 'child') {
+            const children = node.hierarchyManager.getChildren();
+            return (await Promise.all(children.map((child) => CoreUtils.doHealthCheck(child, node)))).every((result) => result === true);
+        }
+        if (address) {
+            return CoreUtils.doHealthCheck(address, node);
+        }
+        throw new Error('Address is required');
+    }
+    static async generatePrivateKey(seed) {
+        // Convert any user phrase to exactly 32 bytes using SHA-256
+        const seedBytes = CoreUtils.phraseToSeedBytes(seed);
+        const privateKey = await generateKeyPairFromSeed('Ed25519', seedBytes);
+        return privateKey;
+    }
+    /**
+     * Convert any user phrase to exactly 32 bytes for Ed25519 key generation.
+     * This function uses SHA-256 hashing to ensure:
+     * - Deterministic: Same phrase always produces same seed
+     * - Uniform distribution: Good entropy even for weak phrases
+     * - Exactly 32 bytes: Meets Ed25519 cryptographic requirements
+     */
+    static phraseToSeedBytes(phrase) {
+        // Use SHA-256 to create a consistent 32-byte hash
+        const hash = createHash('sha256').update(phrase, 'utf8').digest();
+        return new Uint8Array(hash);
+    }
+    // Legacy utility function to convert any phrase into a 32-character hex string
+    static phraseToSeed(phrase) {
+        // Use SHA-256 to create a consistent 32-byte hash
+        const hash = createHash('sha256').update(phrase).digest('hex');
+        // Take the first 32 characters of the hex string
+        return hash.substring(0, 32);
+    }
+    static childAddress(parentAddress, childAddress) {
+        return new oAddress(parentAddress.toString() + '/' + childAddress.paths);
+    }
+    static async sendResponse(response, stream) {
+        if (stream.status !== 'open') {
+            return;
+        }
+        try {
+            await stream.send(new TextEncoder().encode(response.toString()));
+            await stream.close();
+        }
+        catch (error) {
+            console.error('Error sending response: ', error);
+        }
+    }
+    static async sendStreamResponse(response, stream) {
+        const utils = new CoreUtils();
+        if (!stream || stream.status !== 'open') {
+            utils.logger.warn('Stream is not open. Status: ' + stream?.status || 'undefined');
+            return;
+        }
+        try {
+            await stream.send(new TextEncoder().encode(response.toString()));
+        }
+        catch (error) {
+            utils.logger.error('Error sending stream response: ', error);
+        }
+    }
+    static async processStream(event) {
+        const bytes = event.data instanceof Uint8ArrayList ? event.data.subarray() : event.data;
+        return JSON.parse(new TextDecoder().decode(bytes));
+    }
+    static async processStreamRequest(event) {
+        const req = await CoreUtils.processStream(event);
+        return new oRequest(req);
+    }
+    static async processStreamResponse(event) {
+        const res = await CoreUtils.processStream(event);
+        return new oResponse({
+            ...res.result,
+        });
+    }
+    static async toCID(data) {
+        const bytes = json.encode(data);
+        const hash = await sha256.digest(bytes);
+        const cid = CID.create(1, json.code, hash);
+        return cid;
+    }
+}

package/dist/o-core/src/utils/index.d.ts

@@ -0,0 +1,6 @@
+export * from './object.utils.js';
+export * from './regex.utils.js';
+export * from './remote.utils.js';
+export * from './logger.js';
+export * from './core.utils.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/o-core/src/utils/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/utils/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,kBAAkB,CAAC;AACjC,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,iBAAiB,CAAC"}

package/dist/o-core/src/utils/index.js

@@ -0,0 +1,5 @@
+export * from './object.utils.js';
+export * from './regex.utils.js';
+export * from './remote.utils.js';
+export * from './logger.js';
+export * from './core.utils.js';

package/dist/o-core/src/utils/logger.d.ts

@@ -0,0 +1,14 @@
+export declare class Logger {
+    private readonly name;
+    private log;
+    private suffix;
+    constructor(name: string);
+    setNamespace(name: string): void;
+    verbose(...args: any[]): void;
+    debug(...args: any[]): void;
+    info(...args: any[]): void;
+    warn(...args: any[]): void;
+    error(...args: any[]): void;
+    alert(...args: any[]): void;
+}
+//# sourceMappingURL=logger.d.ts.map

package/dist/o-core/src/utils/logger.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logger.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/utils/logger.ts"],"names":[],"mappings":"AAGA,qBAAa,MAAM;IAIL,OAAO,CAAC,QAAQ,CAAC,IAAI;IAHjC,OAAO,CAAC,GAAG,CAAW;IACtB,OAAO,CAAC,MAAM,CAAc;gBAEC,IAAI,EAAE,MAAM;IAKzC,YAAY,CAAC,IAAI,EAAE,MAAM;IAIzB,OAAO,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAItB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAIpB,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAInB,IAAI,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAInB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;IAIpB,KAAK,CAAC,GAAG,IAAI,EAAE,GAAG,EAAE;CAGrB"}

package/dist/o-core/src/utils/logger.js

@@ -0,0 +1,31 @@
+import debug from 'debug';
+import chalk from 'chalk';
+export class Logger {
+    constructor(name) {
+        this.name = name;
+        this.suffix = '';
+        this.suffix = process.env.LOG_ID ? process.env.LOG_ID + ':' : '';
+        this.log = debug('olane-os:' + this.suffix + name);
+    }
+    setNamespace(name) {
+        this.log = debug('olane-os:' + this.suffix + name);
+    }
+    verbose(...args) {
+        this.log(chalk.gray('[VERBOSE]'), ...args);
+    }
+    debug(...args) {
+        this.log(chalk.blue('[DEBUG]'), ...args);
+    }
+    info(...args) {
+        this.log(chalk.green('[INFO]'), ...args);
+    }
+    warn(...args) {
+        this.log(chalk.yellow('[WARN]'), ...args);
+    }
+    error(...args) {
+        this.log(chalk.red('[ERROR]'), ...args);
+    }
+    alert(...args) {
+        this.log(chalk.redBright('[ALERT]'), ...args);
+    }
+}

package/dist/o-core/src/utils/object.utils.d.ts

@@ -0,0 +1,5 @@
+export declare class ObjectUtils {
+    static isObject(obj: any): boolean;
+    static allKeyValues(obj: any, callback: (key: string, value: any) => Promise<any>): Promise<any>;
+}
+//# sourceMappingURL=object.utils.d.ts.map

package/dist/o-core/src/utils/object.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"object.utils.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/utils/object.utils.ts"],"names":[],"mappings":"AAAA,qBAAa,WAAW;IACtB,MAAM,CAAC,QAAQ,CAAC,GAAG,EAAE,GAAG,GAAG,OAAO;WAIrB,YAAY,CACvB,GAAG,EAAE,GAAG,EACR,QAAQ,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,GAClD,OAAO,CAAC,GAAG,CAAC;CAkBhB"}

package/dist/o-core/src/utils/object.utils.js

@@ -0,0 +1,23 @@
+export class ObjectUtils {
+    static isObject(obj) {
+        return obj !== null && typeof obj === 'object';
+    }
+    static async allKeyValues(obj, callback) {
+        if (!ObjectUtils.isObject(obj)) {
+            return obj;
+        }
+        for (const key in obj) {
+            let value = obj[key];
+            // iterate over the object if not a primitive
+            if (ObjectUtils.isObject(value)) {
+                value = await ObjectUtils.allKeyValues(value, callback);
+            }
+            else {
+                value = await callback(key, value);
+            }
+            // update the object
+            obj[key] = value;
+        }
+        return obj;
+    }
+}

package/dist/o-core/src/utils/regex.utils.d.ts

@@ -0,0 +1,4 @@
+export declare class RegexUtils {
+    static extractResultFromAI(message: string): any;
+}
+//# sourceMappingURL=regex.utils.d.ts.map

package/dist/o-core/src/utils/regex.utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"regex.utils.d.ts","sourceRoot":"","sources":["../../../../../o-core/src/utils/regex.utils.ts"],"names":[],"mappings":"AAAA,qBAAa,UAAU;IACrB,MAAM,CAAC,mBAAmB,CAAC,OAAO,EAAE,MAAM,GAAG,GAAG;CAajD"}