@xdarkicex/openclaw-memory-libravdb 1.5.4 → 1.6.0

package/dist/grpc-client.js

@@ -1,188 +0,0 @@
-import { createHmac } from "node:crypto";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-import fs from "node:fs";
-import * as grpc from "@grpc/grpc-js";
-import * as protoLoader from "@grpc/proto-loader";
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-// The proto file is expected to be copied to dist/proto/ at build time.
-// In source, it's at api/proto/.
-const PROTO_PATH = path.resolve(__dirname, "./proto/intelligence_kernel/v1/kernel.proto");
-export function resolveGrpcTarget(endpoint) {
-    return endpoint.startsWith("tcp:") ? endpoint.substring(4) : endpoint;
-}
-/**
- * Selects gRPC credential mode based on endpoint address class.
- *
- * - Unix socket endpoints → plaintext (local-only transport)
- * - Loopback addresses (localhost, 127.0.0.1, ::1) → plaintext
- * - All other TCP and DNS targets → TLS
- *
- * resolveGrpcCredentials uses this classification to return the
- * appropriate grpc.ChannelCredentials. Pass tlsCaPath to load a
- * custom CA certificate PEM file for self-signed or private CA
- * deployments. Omit tlsCaPath for publicly trusted certificates
- * (Let's Encrypt, cert-manager) — the system CA pool is used.
- */
-export function resolveGrpcCredentialMode(endpoint, tlsMode) {
-    if (tlsMode === "tls")
-        return "tls";
-    if (tlsMode === "insecure")
-        return "insecure";
-    // "auto" or undefined — address-based heuristic
-    const target = resolveGrpcTarget(endpoint).trim();
-    if (target.startsWith("unix:"))
-        return "insecure";
-    const host = extractGrpcHost(target);
-    return isLoopbackHost(host) ? "insecure" : "tls";
-}
-export function resolveGrpcCredentials(endpoint, tlsCaPath, tlsMode, tlsClientCertPath, tlsClientKeyPath) {
-    if (resolveGrpcCredentialMode(endpoint, tlsMode) === "insecure") {
-        return grpc.credentials.createInsecure();
-    }
-    // tlsMode is "tls" or "auto"/undefined resolved to "tls"
-    let rootCerts = null;
-    if (tlsCaPath) {
-        try {
-            rootCerts = fs.readFileSync(tlsCaPath);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            throw new Error(`LibraVDB: failed to load TLS CA certificate from "${tlsCaPath}": ${msg}`);
-        }
-    }
-    // Client certificate and key must both be present or both absent
-    const hasCert = tlsClientCertPath !== undefined;
-    const hasKey = tlsClientKeyPath !== undefined;
-    if (hasCert !== hasKey) {
-        throw new Error("LibraVDB: grpcEndpointTlsClientCert and grpcEndpointTlsClientKey " +
-            "must both be set or both be omitted");
-    }
-    let clientKey = null;
-    let clientCert = null;
-    if (tlsClientCertPath && tlsClientKeyPath) {
-        try {
-            clientCert = fs.readFileSync(tlsClientCertPath);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            throw new Error(`LibraVDB: failed to load TLS client certificate from "${tlsClientCertPath}": ${msg}`);
-        }
-        try {
-            clientKey = fs.readFileSync(tlsClientKeyPath);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            throw new Error(`LibraVDB: failed to load TLS client key from "${tlsClientKeyPath}": ${msg}`);
-        }
-    }
-    return grpc.credentials.createSsl(rootCerts, clientKey, clientCert);
-}
-function extractGrpcHost(target) {
-    const withoutDnsPrefix = target.startsWith("dns:///") ? target.slice("dns:///".length) : target;
-    if (withoutDnsPrefix.startsWith("[")) {
-        const closeBracket = withoutDnsPrefix.indexOf("]");
-        return closeBracket > 0 ? withoutDnsPrefix.slice(1, closeBracket) : withoutDnsPrefix;
-    }
-    const portSeparator = withoutDnsPrefix.lastIndexOf(":");
-    return portSeparator > 0 ? withoutDnsPrefix.slice(0, portSeparator) : withoutDnsPrefix;
-}
-function isLoopbackHost(host) {
-    const normalized = host.toLowerCase();
-    return normalized === "localhost" || normalized === "127.0.0.1" || normalized === "::1";
-}
-export class GrpcKernelClient {
-    client;
-    secret;
-    timeoutMs;
-    nonceHex;
-    constructor(options) {
-        this.secret = options.secret;
-        this.timeoutMs = options.timeoutMs ?? 30000;
-        const packageDefinition = protoLoader.loadSync(PROTO_PATH, {
-            keepCase: true,
-            longs: String,
-            enums: String,
-            defaults: true,
-            oneofs: true,
-        });
-        const protoDescriptor = grpc.loadPackageDefinition(packageDefinition);
-        const kernelService = protoDescriptor.intelligence_kernel.v1.IntelligenceKernel;
-        const target = resolveGrpcTarget(options.endpoint);
-        this.client = new kernelService(target, resolveGrpcCredentials(options.endpoint, options.tlsCaPath, options.tlsMode, options.tlsClientCertPath, options.tlsClientKeyPath));
-    }
-    getMetadata(signed = true) {
-        const md = new grpc.Metadata();
-        if (this.secret && signed) {
-            if (!this.nonceHex) {
-                throw new Error("call initializeSession before authenticated RPCs");
-            }
-            // Challenge-response: HMAC(secret, nonce) — the secret is the HMAC key,
-            // the server-issued nonce is the message. The previous implementation
-            // swapped these, computing HMAC(nonce, secret), which is cryptographically
-            // incorrect: the nonce is sent in the clear and must not be used as the key.
-            const hmac = createHmac("sha256", this.secret);
-            hmac.update(this.nonceHex);
-            const signature = hmac.digest("hex");
-            md.add("x-libravdb-auth", signature);
-        }
-        return md;
-    }
-    call(method, req, signed = true) {
-        return new Promise((resolve, reject) => {
-            const deadline = new Date(Date.now() + this.timeoutMs);
-            this.client[method](req, this.getMetadata(signed), { deadline }, (err, resp) => {
-                if (err) {
-                    reject(err);
-                }
-                else {
-                    resolve(resp);
-                }
-            });
-        });
-    }
-    async initializeSession(req) {
-        return new Promise((resolve, reject) => {
-            const deadline = new Date(Date.now() + this.timeoutMs);
-            this.client.InitializeSession(req, this.getMetadata(false), { deadline }, (err, resp) => {
-                if (err) {
-                    reject(err);
-                    return;
-                }
-                const nonce = resp?.server_metadata?.nonce;
-                if (this.secret && (typeof nonce !== "string" || nonce.length === 0)) {
-                    reject(new Error("InitializeSession response missing auth nonce"));
-                    return;
-                }
-                if (typeof nonce === "string" && nonce.length > 0) {
-                    this.nonceHex = nonce;
-                }
-                resolve(resp);
-            });
-        });
-    }
-    async assembleContext(req) {
-        return this.call("AssembleContext", req);
-    }
-    async rankCandidates(req) {
-        return this.call("RankCandidates", req);
-    }
-    async ingestMessage(req) {
-        return this.call("IngestMessage", req);
-    }
-    async afterTurn(req) {
-        return this.call("AfterTurn", req);
-    }
-    async bootstrapSession(req) {
-        return this.call("BootstrapSession", req);
-    }
-    async compactSession(req) {
-        return this.call("CompactSession", req);
-    }
-    async getStatus(req = {}) {
-        return this.call("GetStatus", req);
-    }
-    close() {
-        this.client.close();
-    }
-}

package/dist/rpc-protobuf-codecs.d.ts

@@ -1,71 +0,0 @@
-import { AfterTurnKernelRequest, AfterTurnKernelResponse, AssembleContextInternalRequest, AssembleContextInternalResponse, BootstrapSessionKernelRequest, BootstrapSessionKernelResponse, CompactSessionRequest, CompactSessionResponse, DeleteAuthoredDocumentResponse, DreamPromotionResponse, ExportMemoryResponse, FlushNamespaceResponse, FlushResponse, HealthResponse, IngestMarkdownDocumentResponse, IngestMessageKernelRequest, IngestMessageKernelResponse, MemoryStatusResponse, RankCandidatesRequest, RankCandidatesResponse, RebuildIndexRequest, RebuildIndexResponse, SearchTextResponse, SessionLifecycleHintResponse } from "@xdarkicex/libravdb-contracts";
-import type { LifecycleHint } from "./plugin-runtime.js";
-export type RpcMethodCodec<Params = unknown, Result = unknown> = {
-    encodeParams(params: Params): Uint8Array;
-    decodeResult(bytes: Uint8Array): Result;
-};
-export type RpcMethodName = keyof typeof rpcProtobufCodecs;
-export declare const rpcProtobufCodecs: {
-    health: RpcMethodCodec<Record<string, never>, HealthResponse>;
-    status: RpcMethodCodec<Record<string, never>, MemoryStatusResponse>;
-    flush: RpcMethodCodec<Record<string, never>, FlushResponse>;
-    session_lifecycle_hint: RpcMethodCodec<LifecycleHint, SessionLifecycleHintResponse>;
-    search_text: RpcMethodCodec<{
-        collection: string;
-        text: string;
-        k?: number;
-        excludeIds?: string[];
-    }, SearchTextResponse>;
-    search_text_collections: RpcMethodCodec<{
-        collections: string[];
-        text: string;
-        k?: number;
-        excludeByCollection?: Record<string, unknown>;
-    }, SearchTextResponse>;
-    list_collection: RpcMethodCodec<{
-        collection: string;
-    }, SearchTextResponse>;
-    list_lifecycle_journal: RpcMethodCodec<{
-        sessionId?: string;
-        limit?: number;
-    }, SearchTextResponse>;
-    export_memory: RpcMethodCodec<{
-        userId?: string;
-        namespace?: string;
-    }, ExportMemoryResponse>;
-    flush_namespace: RpcMethodCodec<{
-        userId?: string;
-        namespace?: string;
-    }, FlushNamespaceResponse>;
-    promote_dream_entries: RpcMethodCodec<{
-        userId: string;
-        sourceDoc: string;
-        sourceRoot?: string;
-        sourcePath?: string;
-        sourceKind?: string;
-        fileHash?: string;
-        sourceSize?: number;
-        sourceMtimeMs?: number;
-        ingestVersion?: number;
-        hashBackend?: string;
-        entries?: Array<Record<string, unknown>>;
-    }, DreamPromotionResponse>;
-    ingest_markdown_document: RpcMethodCodec<{
-        sourceDoc: string;
-        text: string;
-        tokenizerId?: string;
-        coreDoc?: boolean;
-        sourceMeta?: Record<string, unknown>;
-    }, IngestMarkdownDocumentResponse>;
-    delete_authored_document: RpcMethodCodec<{
-        sourceDoc: string;
-    }, DeleteAuthoredDocumentResponse>;
-    bootstrap_session_kernel: RpcMethodCodec<BootstrapSessionKernelRequest, BootstrapSessionKernelResponse>;
-    ingest_message_kernel: RpcMethodCodec<IngestMessageKernelRequest, IngestMessageKernelResponse>;
-    after_turn_kernel: RpcMethodCodec<AfterTurnKernelRequest, AfterTurnKernelResponse>;
-    assemble_context_internal: RpcMethodCodec<AssembleContextInternalRequest, AssembleContextInternalResponse>;
-    compact_session: RpcMethodCodec<CompactSessionRequest, CompactSessionResponse>;
-    rank_candidates: RpcMethodCodec<RankCandidatesRequest, RankCandidatesResponse>;
-    rebuild_index: RpcMethodCodec<RebuildIndexRequest, RebuildIndexResponse>;
-};
-export declare function getRpcMethodCodec(method: string): RpcMethodCodec<any, any> | undefined;

package/dist/rpc-protobuf-codecs.js

@@ -1,91 +0,0 @@
-import { AfterTurnKernelRequest, AfterTurnKernelResponse, AssembleContextInternalRequest, AssembleContextInternalResponse, BootstrapSessionKernelRequest, BootstrapSessionKernelResponse, CompactSessionRequest, CompactSessionResponse, DeleteAuthoredDocumentRequest, DeleteAuthoredDocumentResponse, DreamPromotionResponse, ExportMemoryRequest, ExportMemoryResponse, FlushNamespaceRequest, FlushNamespaceResponse, FlushResponse, HealthResponse, IngestMarkdownDocumentRequest, IngestMarkdownDocumentResponse, IngestMessageKernelRequest, IngestMessageKernelResponse, ListCollectionRequest, ListLifecycleJournalRequest, MemoryStatusResponse, PromoteDreamEntriesRequest, RankCandidatesRequest, RankCandidatesResponse, RebuildIndexRequest, RebuildIndexResponse, SearchTextCollectionsRequest, SearchTextRequest, SearchTextResponse, SessionLifecycleHintRequest, SessionLifecycleHintResponse, StringList, } from "@xdarkicex/libravdb-contracts";
-function encodeMessage(schema, init) {
-    return new schema(init).toBinary();
-}
-function decodeProtobufResult(schema, bytes) {
-    return new schema().fromBinary(bytes).toJson();
-}
-function emptyBytes() {
-    return new Uint8Array(0);
-}
-function normalizeSearchTextResponse(bytes) {
-    const response = decodeProtobufResult(SearchTextResponse, bytes);
-    if (!Array.isArray(response.results)) {
-        response.results = [];
-    }
-    for (const item of response.results) {
-        if (!item || typeof item !== "object" || Array.isArray(item)) {
-            continue;
-        }
-        if (!item.metadata || typeof item.metadata !== "object" || Array.isArray(item.metadata)) {
-            item.metadata = {};
-        }
-        if (typeof item.text !== "string") {
-            item.text = "";
-        }
-        if (typeof item.score !== "number" || !Number.isFinite(item.score)) {
-            item.score = 0;
-        }
-    }
-    return response;
-}
-function normalizeAssembleContextInternalResponse(bytes) {
-    const response = decodeProtobufResult(AssembleContextInternalResponse, bytes);
-    if (!Array.isArray(response.messages)) {
-        response.messages = [];
-    }
-    return response;
-}
-function normalizeExcludeByCollection(value) {
-    const normalized = {};
-    if (!value) {
-        return normalized;
-    }
-    for (const [collection, raw] of Object.entries(value)) {
-        if (raw instanceof StringList) {
-            normalized[collection] = raw;
-            continue;
-        }
-        const values = Array.isArray(raw)
-            ? raw
-            : raw && typeof raw === "object" && Array.isArray(raw.values)
-                ? (raw.values)
-                : [];
-        normalized[collection] = new StringList({ values });
-    }
-    return normalized;
-}
-function codec(encodeParams, decodeResult) {
-    return { encodeParams, decodeResult };
-}
-const encodeEmpty = () => emptyBytes();
-export const rpcProtobufCodecs = {
-    health: codec(encodeEmpty, (bytes) => decodeProtobufResult(HealthResponse, bytes)),
-    status: codec(encodeEmpty, (bytes) => decodeProtobufResult(MemoryStatusResponse, bytes)),
-    flush: codec(encodeEmpty, (bytes) => decodeProtobufResult(FlushResponse, bytes)),
-    session_lifecycle_hint: codec((params) => encodeMessage(SessionLifecycleHintRequest, params), (bytes) => decodeProtobufResult(SessionLifecycleHintResponse, bytes)),
-    search_text: codec((params) => encodeMessage(SearchTextRequest, params), normalizeSearchTextResponse),
-    search_text_collections: codec((params) => encodeMessage(SearchTextCollectionsRequest, {
-        collections: params.collections,
-        text: params.text,
-        k: params.k ?? 0,
-        excludeByCollection: normalizeExcludeByCollection(params.excludeByCollection),
-    }), normalizeSearchTextResponse),
-    list_collection: codec((params) => encodeMessage(ListCollectionRequest, params), normalizeSearchTextResponse),
-    list_lifecycle_journal: codec((params) => encodeMessage(ListLifecycleJournalRequest, params), normalizeSearchTextResponse),
-    export_memory: codec((params) => encodeMessage(ExportMemoryRequest, params), (bytes) => decodeProtobufResult(ExportMemoryResponse, bytes)),
-    flush_namespace: codec((params) => encodeMessage(FlushNamespaceRequest, params), (bytes) => decodeProtobufResult(FlushNamespaceResponse, bytes)),
-    promote_dream_entries: codec((params) => encodeMessage(PromoteDreamEntriesRequest, params), (bytes) => decodeProtobufResult(DreamPromotionResponse, bytes)),
-    ingest_markdown_document: codec((params) => encodeMessage(IngestMarkdownDocumentRequest, params), (bytes) => decodeProtobufResult(IngestMarkdownDocumentResponse, bytes)),
-    delete_authored_document: codec((params) => encodeMessage(DeleteAuthoredDocumentRequest, params), (bytes) => decodeProtobufResult(DeleteAuthoredDocumentResponse, bytes)),
-    bootstrap_session_kernel: codec((params) => encodeMessage(BootstrapSessionKernelRequest, params), (bytes) => decodeProtobufResult(BootstrapSessionKernelResponse, bytes)),
-    ingest_message_kernel: codec((params) => encodeMessage(IngestMessageKernelRequest, params), (bytes) => decodeProtobufResult(IngestMessageKernelResponse, bytes)),
-    after_turn_kernel: codec((params) => encodeMessage(AfterTurnKernelRequest, params), (bytes) => decodeProtobufResult(AfterTurnKernelResponse, bytes)),
-    assemble_context_internal: codec((params) => encodeMessage(AssembleContextInternalRequest, params), normalizeAssembleContextInternalResponse),
-    compact_session: codec((params) => encodeMessage(CompactSessionRequest, params), (bytes) => decodeProtobufResult(CompactSessionResponse, bytes)),
-    rank_candidates: codec((params) => encodeMessage(RankCandidatesRequest, params), (bytes) => decodeProtobufResult(RankCandidatesResponse, bytes)),
-    rebuild_index: codec((params) => encodeMessage(RebuildIndexRequest, params), (bytes) => decodeProtobufResult(RebuildIndexResponse, bytes)),
-};
-export function getRpcMethodCodec(method) {
-    return rpcProtobufCodecs[method];
-}

package/dist/rpc.d.ts

@@ -1,15 +0,0 @@
-import type { RpcCallOptions, SidecarSocket } from "./types.js";
-export declare class RpcClient {
-    private readonly socket;
-    private readonly options;
-    private seq;
-    private readonly pending;
-    private rxBuf;
-    private sentMagic;
-    constructor(socket: SidecarSocket, options: RpcCallOptions);
-    call<T>(method: string, params: unknown, callOptions?: Partial<RpcCallOptions>): Promise<T>;
-    private waitForReconnect;
-    private handleData;
-    private dispatchMessage;
-    private rejectAll;
-}

package/dist/rpc.js

@@ -1,203 +0,0 @@
-import { RpcRequest, RpcResponse } from "@xdarkicex/libravdb-contracts";
-import { getRpcMethodCodec } from "./rpc-protobuf-codecs.js";
-export class RpcClient {
-    socket;
-    options;
-    seq = 0n;
-    pending = new Map();
-    rxBuf = Buffer.alloc(0);
-    sentMagic = false;
-    constructor(socket, options) {
-        this.socket = socket;
-        this.options = options;
-        // Remove socket.setEncoding("utf8"); completely. The socket must stay binary.
-        socket.on("data", (chunk) => this.handleData(chunk));
-        socket.on("close", () => {
-            this.sentMagic = false; // Force magic byte on next reconnect
-            this.rejectAll(new Error("Socket closed"));
-        });
-        socket.on("error", (error) => this.rejectAll(error));
-    }
-    async call(method, params, callOptions = {}) {
-        const codec = getRpcMethodCodec(method);
-        if (!codec) {
-            throw new Error(`Unsupported LibraVDB RPC method for protobuf transport: ${method}`);
-        }
-        return await new Promise((resolve, reject) => {
-            const id = ++this.seq;
-            const timeoutMs = callOptions.timeoutMs ?? this.options.timeoutMs;
-            const deadline = Date.now() + timeoutMs;
-            const timer = setTimeout(() => {
-                this.pending.delete(id);
-                reject(new Error(`RPC timeout: ${method} (${timeoutMs}ms)`));
-            }, timeoutMs);
-            this.pending.set(id, { resolve, reject, timer, decodeResult: codec.decodeResult });
-            const buildFrame = () => {
-                const envelope = new RpcRequest({
-                    id,
-                    method,
-                    params: codec.encodeParams(params),
-                });
-                const payload = Buffer.from(envelope.toBinary());
-                const header = Buffer.alloc(4);
-                header.writeUInt32BE(payload.byteLength, 0);
-                const chunks = [];
-                const includesMagic = !this.sentMagic;
-                if (includesMagic) {
-                    chunks.push(Buffer.from([0x02]));
-                }
-                chunks.push(header, payload);
-                return { frame: Buffer.concat(chunks), includesMagic };
-            };
-            const send = (allowReconnectRetry) => {
-                if (!this.pending.has(id)) {
-                    return;
-                }
-                const { frame, includesMagic } = buildFrame();
-                try {
-                    this.socket.write(frame);
-                    if (includesMagic) {
-                        this.sentMagic = true;
-                    }
-                }
-                catch (error) {
-                    if (allowReconnectRetry && isReconnectableSocketGap(error)) {
-                        this.sentMagic = false;
-                        const remainingMs = Math.max(0, deadline - Date.now());
-                        if (remainingMs <= 0) {
-                            if (!this.pending.has(id)) {
-                                return;
-                            }
-                            clearTimeout(timer);
-                            this.pending.delete(id);
-                            reject(new Error(`RPC timeout: ${method} (${timeoutMs}ms)`));
-                            return;
-                        }
-                        void this.waitForReconnect(remainingMs)
-                            .then(() => {
-                            if (!this.pending.has(id)) {
-                                return;
-                            }
-                            send(false);
-                        })
-                            .catch((reconnectError) => {
-                            if (!this.pending.has(id)) {
-                                return;
-                            }
-                            clearTimeout(timer);
-                            this.pending.delete(id);
-                            const error = reconnectError instanceof Error
-                                ? reconnectError
-                                : new Error(String(reconnectError));
-                            reject(/^Sidecar reconnect timed out/.test(error.message)
-                                ? new Error(`RPC timeout: ${method} (${timeoutMs}ms)`)
-                                : error);
-                        });
-                        return;
-                    }
-                    clearTimeout(timer);
-                    this.pending.delete(id);
-                    reject(error instanceof Error ? error : new Error(String(error)));
-                }
-            };
-            send(true);
-        });
-    }
-    async waitForReconnect(timeoutMs) {
-        await new Promise((resolve, reject) => {
-            let settled = false;
-            const onConnect = () => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                this.socket.off("error", onError);
-                resolve();
-            };
-            const onError = (error) => {
-                if (settled)
-                    return;
-                settled = true;
-                clearTimeout(timer);
-                this.socket.off("connect", onConnect);
-                reject(error);
-            };
-            const timer = setTimeout(() => {
-                if (settled)
-                    return;
-                settled = true;
-                this.socket.off("connect", onConnect);
-                this.socket.off("error", onError);
-                reject(new Error(`Sidecar reconnect timed out (${timeoutMs}ms)`));
-            }, timeoutMs);
-            this.socket.once("connect", onConnect);
-            this.socket.once("error", onError);
-        });
-    }
-    handleData(chunk) {
-        if (chunk.byteLength > 64 << 20) {
-            this.socket.destroy();
-            return;
-        }
-        this.rxBuf = Buffer.concat([this.rxBuf, chunk]);
-        while (this.rxBuf.byteLength >= 4) {
-            const payloadLength = this.rxBuf.readUInt32BE(0);
-            if (payloadLength > 64 << 20) {
-                this.socket.destroy();
-                return;
-            }
-            const frameSize = 4 + payloadLength;
-            // Wait for the full frame to arrive
-            if (this.rxBuf.byteLength < frameSize) {
-                break;
-            }
-            const payload = this.rxBuf.subarray(4, frameSize);
-            this.rxBuf = this.rxBuf.subarray(frameSize);
-            this.dispatchMessage(payload);
-        }
-        // Compaction guard: release large backing allocations if the remainder is tiny
-        if (this.rxBuf.buffer.byteLength > 65536 &&
-            this.rxBuf.byteLength < this.rxBuf.buffer.byteLength >>> 2) {
-            this.rxBuf = Buffer.from(this.rxBuf);
-        }
-    }
-    dispatchMessage(payload) {
-        try {
-            const msg = RpcResponse.fromBinary(payload);
-            if (typeof msg.id !== "bigint") {
-                this.socket.destroy(new Error("Protocol violation: expected bigint message id"));
-                return;
-            }
-            const pending = this.pending.get(msg.id);
-            if (!pending) {
-                return;
-            }
-            clearTimeout(pending.timer);
-            this.pending.delete(msg.id);
-            if (msg.error) {
-                const message = msg.error.message?.trim() || `RPC error ${msg.error.code}`;
-                pending.reject(new Error(msg.error.code ? `${message} (${msg.error.code})` : message));
-                return;
-            }
-            try {
-                pending.resolve(pending.decodeResult(msg.result));
-            }
-            catch (error) {
-                pending.reject(error instanceof Error ? error : new Error(String(error)));
-            }
-        }
-        catch {
-            // Ignore malformed frames
-        }
-    }
-    rejectAll(error) {
-        for (const [id, pending] of this.pending.entries()) {
-            clearTimeout(pending.timer);
-            this.pending.delete(id);
-            pending.reject(error);
-        }
-    }
-}
-function isReconnectableSocketGap(error) {
-    return error instanceof Error && /Sidecar socket unavailable/i.test(error.message);
-}

package/dist/sidecar.d.ts

@@ -1,40 +0,0 @@
-import type { LoggerLike, PluginConfig, SidecarHandle, SidecarSocket } from "./types.js";
-type CloseHandler = () => void;
-type DataHandler = (chunk: Buffer) => void;
-type ErrorHandler = (error: Error) => void;
-export interface SidecarRuntime {
-    resolveEndpoint(cfg: PluginConfig): string | Promise<string>;
-    createSocket(endpoint: string): SidecarSocket;
-    scheduleRestart(delayMs: number, restart: () => void): void;
-    stabilityWindowMs?: number;
-}
-declare class PlaceholderSocket implements SidecarSocket {
-    private readonly onData;
-    private readonly onClose;
-    private readonly onError;
-    private readonly connectOnce;
-    private readonly errorOnce;
-    constructor();
-    setEncoding(_encoding: string): void;
-    on(event: "data" | "close" | "error", handler: DataHandler | CloseHandler | ErrorHandler): void;
-    once(event: "connect" | "error", handler: CloseHandler | ErrorHandler): void;
-    off(event: "connect" | "error", handler: CloseHandler | ErrorHandler): void;
-    write(chunk: Buffer | string): void;
-    destroy(): void;
-    private emitError;
-}
-export declare function startSidecar(cfg: PluginConfig, logger?: LoggerLike, runtime?: SidecarRuntime): Promise<SidecarHandle>;
-export declare function computeBackoffMs(retries: number): number;
-export declare function computeStartupConnectRetryDelay(attempt: number, waitedMs?: number): number;
-export declare function isTcpEndpoint(endpoint: string): boolean;
-export declare function parseTcpEndpoint(endpoint: string): {
-    host: string;
-    port: number;
-} | null;
-export declare function resolveEndpoint(cfg: PluginConfig): string;
-export declare function resolveConfiguredEndpoint(cfg: PluginConfig): string;
-export declare function daemonProvisioningHint(): string;
-export declare function defaultEndpoint(platform?: NodeJS.Platform, homeDir?: string, pathExists?: (path: string) => boolean): string;
-export declare function buildSidecarEnv(cfg: PluginConfig): Record<string, string>;
-export { PlaceholderSocket };
-export declare function probeSidecarEndpoint(cfg: PluginConfig): Promise<string | null>;