@anhlp/alp-client 0.0.0-stage → 0.0.1-beta.4

package/dist/integration-lock.d.ts

@@ -0,0 +1,35 @@
+/**
+ * @typedef {{ pid: number, bootTime: number, startedAt: string, ready: boolean, lockVersion?: number, owner?: string }} IntegrationLockRecord
+ * @typedef {{
+ *   acquire(): Promise<{ acquired: boolean, lock: IntegrationLockRecord }>,
+ *   setReady(ready: boolean): Promise<boolean>,
+ *   release(): Promise<boolean>,
+ * }} IntegrationLock
+ */
+/**
+ * The single-owner lock of one integration service, at `<home>/integrations/<name>.lock`, with its
+ * mutation guard `<name>.lock.reclaim`. Each instance is single-use: acquire once, then setReady and
+ * release while it owns the lock.
+ *
+ * Single-host, same PID namespace, private local filesystem only. Never reap the mutation guard.
+ * @param {string} home the ALP_HOME the integration runs under
+ * @param {string} name the integration name, for example `web`
+ * @returns {IntegrationLock}
+ */
+export function createIntegrationLock(home: string, name: string): IntegrationLock;
+export type IntegrationLockRecord = {
+    pid: number;
+    bootTime: number;
+    startedAt: string;
+    ready: boolean;
+    lockVersion?: number;
+    owner?: string;
+};
+export type IntegrationLock = {
+    acquire(): Promise<{
+        acquired: boolean;
+        lock: IntegrationLockRecord;
+    }>;
+    setReady(ready: boolean): Promise<boolean>;
+    release(): Promise<boolean>;
+};

package/dist/integration-lock.js

@@ -0,0 +1,179 @@
+// packages/client/src/integration-lock.js
+import { randomUUID } from "node:crypto";
+import { mkdir, open, rename, rmdir, unlink } from "node:fs/promises";
+import path from "node:path";
+import { assertIntegrationName, bootTime } from "./index.js";
+function createIntegrationLock(home, name) {
+  const file = path.join(home, "integrations", `${assertIntegrationName(name)}.lock`);
+  const guard = `${file}.reclaim`;
+  let phase = "new";
+  let owned;
+  const recovery = (reason) => new Error(`${reason}. Stop ALL integration processes using this ALP_HOME before manual lock-only recovery of ${file} and ${guard}; see docs/modular-monorepo.md`);
+  async function guarded(run) {
+    await mkdir(path.dirname(file), { recursive: true, mode: 448 });
+    const deadline = Date.now() + 2e4;
+    for (; ; ) {
+      try {
+        await mkdir(guard, { mode: 448 });
+        break;
+      } catch (error) {
+        if (
+          /** @type {any} */
+          error?.code !== "EEXIST"
+        ) throw error;
+        if (Date.now() >= deadline) throw recovery("Integration mutation guard remains busy or abandoned");
+        await new Promise((resolve) => setTimeout(resolve, 25));
+      }
+    }
+    const token = path.join(guard, `owner-${process.pid}-${randomUUID()}`);
+    try {
+      const handle = await open(token, "wx", 384);
+      await handle.close();
+    } catch (error) {
+      throw recovery(`Integration guard initialization failed: ${String(error)}`);
+    }
+    try {
+      return await run();
+    } finally {
+      try {
+        await unlink(token);
+      } catch (error) {
+        throw recovery(
+          /** @type {any} */
+          error?.code === "ENOENT" ? "Integration guard ownership was lost" : `Integration guard token cleanup failed: ${String(error)}`
+        );
+      }
+      try {
+        await rmdir(guard);
+      } catch (error) {
+        throw recovery(`Integration guard cleanup failed: ${String(error)}`);
+      }
+    }
+  }
+  async function snapshot() {
+    let handle;
+    try {
+      handle = await open(file, "r");
+    } catch (error) {
+      if (
+        /** @type {any} */
+        error?.code === "ENOENT"
+      ) return void 0;
+      throw error;
+    }
+    try {
+      const info = await handle.stat();
+      const raw = await handle.readFile("utf8");
+      let value;
+      try {
+        value = JSON.parse(raw);
+      } catch {
+        value = void 0;
+      }
+      return { value, info };
+    } finally {
+      await handle.close();
+    }
+  }
+  function complete(value) {
+    return value && Number.isSafeInteger(value.pid) && value.pid > 0 && typeof value.bootTime === "number" && Number.isFinite(value.bootTime) && value.bootTime > 0 && typeof value.startedAt === "string" && Number.isFinite(Date.parse(value.startedAt)) && typeof value.ready === "boolean" && (value.lockVersion === void 0 && value.owner === void 0 || value.lockVersion === 1 && typeof value.owner === "string" && /^[a-f0-9-]{36}$/.test(value.owner));
+  }
+  function dead(value) {
+    try {
+      process.kill(value.pid, 0);
+      return false;
+    } catch (error) {
+      if (
+        /** @type {any} */
+        error?.code !== "ESRCH"
+      ) return false;
+      if (Math.abs(value.bootTime - bootTime()) > 30) throw recovery("Integration owner boot context is uncertain");
+      return true;
+    }
+  }
+  function matches(current) {
+    return !!owned && current?.value?.owner === owned.owner && current.info.dev === owned.dev && current.info.ino === owned.ino;
+  }
+  return {
+    async acquire() {
+      if (phase !== "new") throw new Error("Integration lock instance has already been used");
+      phase = "acquiring";
+      try {
+        return await guarded(async () => {
+          const current = await snapshot();
+          if (current) {
+            if (!complete(current.value)) throw recovery("Integration lock is malformed, incomplete or unsupported");
+            if (!dead(current.value)) {
+              phase = "retired";
+              return { acquired: false, lock: current.value };
+            }
+            await unlink(file);
+          }
+          const value = { pid: process.pid, bootTime: bootTime(), startedAt: (/* @__PURE__ */ new Date()).toISOString(), ready: false, lockVersion: 1, owner: randomUUID() };
+          const handle = await open(file, "wx", 384);
+          let info;
+          try {
+            await handle.writeFile(JSON.stringify(value));
+            info = await handle.stat();
+          } finally {
+            await handle.close();
+          }
+          owned = { owner: value.owner, dev: info.dev, ino: info.ino };
+          phase = "owned";
+          return { acquired: true, lock: value };
+        });
+      } catch (error) {
+        phase = "retired";
+        owned = void 0;
+        throw error;
+      }
+    },
+    async setReady(ready) {
+      if (phase !== "owned") return false;
+      return guarded(async () => {
+        if (phase !== "owned") return false;
+        const current = await snapshot();
+        if (!current || !matches(current)) {
+          phase = "retired";
+          owned = void 0;
+          return false;
+        }
+        const value = { ...current.value, ready };
+        const tmp = `${file}.${randomUUID()}.tmp`;
+        const handle = await open(tmp, "wx", 384);
+        let info;
+        try {
+          try {
+            await handle.writeFile(JSON.stringify(value));
+            info = await handle.stat();
+          } finally {
+            await handle.close();
+          }
+          await rename(tmp, file);
+          owned = { owner: value.owner, dev: info.dev, ino: info.ino };
+          return true;
+        } finally {
+          await unlink(tmp).catch((error) => {
+            if (error?.code !== "ENOENT") throw error;
+          });
+        }
+      });
+    },
+    async release() {
+      if (phase !== "owned") return false;
+      return guarded(async () => {
+        if (phase !== "owned") return false;
+        const current = await snapshot();
+        const ours = matches(current);
+        phase = "retired";
+        owned = void 0;
+        if (!ours) return false;
+        await unlink(file);
+        return true;
+      });
+    }
+  };
+}
+export {
+  createIntegrationLock
+};

package/dist/ipc.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The Node transport of the ALP client: a Unix socket or Windows named pipe carrying
+ * newline-delimited JSON (plans/reference/ALPD.md §3). Node-only; the portable engine
+ * (`@anhlp/alp-client/portable`) never imports it. Socket discovery, the private-socket checks
+ * and daemon startup stay in the Node entry (`connect`, `ensureDaemon`).
+ *
+ * @typedef {import('./rpc/client.js').AlpTransport} AlpTransport
+ * @typedef {import('./rpc/client.js').TransportClose} TransportClose
+ * @typedef {{ maxFrame?: number, maxBufferedBytes?: number }} SocketTransportOptions
+ *   `maxBufferedBytes` bounds what may wait in the socket's write buffer; a send beyond it fails
+ *   as `send_failed` instead of growing memory while the daemon does not read.
+ */
+/**
+ * Wraps a connected or still-connecting socket (writes made while it connects are queued by
+ * Node). The transport owns the socket from then on.
+ * @param {import('node:net').Socket} socket
+ * @param {SocketTransportOptions} [options]
+ * @returns {AlpTransport}
+ */
+export function createSocketTransport(socket: import("node:net").Socket, { maxFrame, maxBufferedBytes }?: SocketTransportOptions): AlpTransport;
+/**
+ * The Node transport of the ALP client: a Unix socket or Windows named pipe carrying
+ * newline-delimited JSON (plans/reference/ALPD.md §3). Node-only; the portable engine
+ * (`@anhlp/alp-client/portable`) never imports it. Socket discovery, the private-socket checks
+ * and daemon startup stay in the Node entry (`connect`, `ensureDaemon`).
+ */
+export type AlpTransport = import("./rpc/client.js").AlpTransport;
+/**
+ * The Node transport of the ALP client: a Unix socket or Windows named pipe carrying
+ * newline-delimited JSON (plans/reference/ALPD.md §3). Node-only; the portable engine
+ * (`@anhlp/alp-client/portable`) never imports it. Socket discovery, the private-socket checks
+ * and daemon startup stay in the Node entry (`connect`, `ensureDaemon`).
+ */
+export type TransportClose = import("./rpc/client.js").TransportClose;
+/**
+ * `maxBufferedBytes` bounds what may wait in the socket's write buffer; a send beyond it fails
+ * as `send_failed` instead of growing memory while the daemon does not read.
+ */
+export type SocketTransportOptions = {
+    maxFrame?: number;
+    maxBufferedBytes?: number;
+};

package/dist/ipc.js

@@ -0,0 +1,69 @@
+// packages/client/src/ipc.js
+import { MAX_FRAME } from "@anhlp/alp-protocol";
+import { AlpClientError } from "./rpc/errors.js";
+import { createLineDecoder } from "./rpc/framing.js";
+function createSocketTransport(socket, { maxFrame = MAX_FRAME, maxBufferedBytes = 4 * MAX_FRAME } = {}) {
+  const decoder = createLineDecoder({ maxFrame });
+  const messages = /* @__PURE__ */ new Set();
+  const closes = /* @__PURE__ */ new Set();
+  let ended;
+  const end = (close) => {
+    if (ended) return;
+    ended = close;
+    socket.off("data", onData);
+    messages.clear();
+    const listeners = [...closes];
+    closes.clear();
+    for (const listener of listeners) listener(close);
+  };
+  const onData = (chunk) => {
+    if (ended) return;
+    let frames;
+    try {
+      frames = decoder.push(chunk);
+    } catch {
+      const error = new AlpClientError("ALP daemon frame exceeds size limit", { reason: "protocol" });
+      socket.destroy();
+      return end({ error });
+    }
+    for (const frame of frames) {
+      if (ended) return;
+      for (const listener of [...messages]) listener(frame);
+    }
+  };
+  socket.setEncoding("utf8");
+  socket.on("data", onData);
+  socket.on("error", (error) => end({ error }));
+  socket.on("close", () => end({}));
+  if (socket.destroyed) end({});
+  const gone = () => socket.destroyed || socket.writableEnded;
+  return {
+    get state() {
+      return ended || gone() ? "closed" : "open";
+    },
+    send(frame) {
+      if (!ended && gone()) end({});
+      if (ended) throw new AlpClientError("ALP daemon connection closed", { reason: "send_failed" });
+      if (socket.writableLength + frame.length > maxBufferedBytes) throw new AlpClientError(`ALP socket write buffer is over ${maxBufferedBytes} bytes`, { reason: "send_failed" });
+      socket.write(`${frame}
+`);
+    },
+    onMessage(listener) {
+      if (ended) return () => false;
+      messages.add(listener);
+      return () => messages.delete(listener);
+    },
+    onClose(listener) {
+      if (ended) return () => false;
+      closes.add(listener);
+      return () => closes.delete(listener);
+    },
+    close() {
+      if (!socket.writableEnded) socket.end(() => socket.destroy());
+      end({});
+    }
+  };
+}
+export {
+  createSocketTransport
+};

package/dist/library-test.d.ts

@@ -0,0 +1,94 @@
+/**
+ * Tries an MCP server, a hook or an ACP provider out (ALPD §43, §46). An MCP server is
+ * started and its tools listed; a provider is started and initialized; a hook runs once with a sample payload for its event, in the project (or the
+ * library when there is none), with the variables ALP gives hooks.
+ */
+export function testEntry(kind: any, name: any, { root, library, templates, scope, timeoutMs }?: {}): Promise<{
+    server?: {
+        name?: string;
+        version?: string;
+    };
+    tools: Array<{
+        name: string;
+        description?: string;
+    }>;
+    kind: any;
+    name: any;
+    source: "library" | "project" | "builtin";
+    ok: boolean;
+} | {
+    exitCode: number | null;
+    signal: string | null;
+    timedOut: boolean;
+    stdout: string;
+    stderr: string;
+    durationMs: number;
+    payload: {
+        branch?: string | undefined;
+        files?: never[] | undefined;
+        task?: any;
+        reason?: string | undefined;
+        handoff?: {
+            outcome: string;
+            summary: string;
+        } | undefined;
+        event: any;
+        sample: boolean;
+        project: any;
+        session: string;
+        agent: string;
+    };
+    wouldBlock?: boolean | undefined;
+    kind: any;
+    name: any;
+    source: "library" | "project" | "builtin";
+    ok: boolean;
+} | {
+    protocolVersion: number;
+    agent?: {
+        name?: string;
+        title?: string;
+        version?: string;
+    };
+    loadSession: boolean;
+    mcpHttp: boolean;
+    authMethods: string[];
+    models?: Array<{
+        id: string;
+        label: string;
+        description?: string;
+    }>;
+    currentModel?: string;
+    modes?: Array<{
+        id: string;
+        label: string;
+        description?: string;
+    }>;
+    currentMode?: string;
+    kind: any;
+    name: any;
+    source: "library" | "project" | "builtin";
+    ok: boolean;
+} | {
+    version: string;
+    agent: {
+        name: string;
+        title: string;
+        version: string;
+    };
+    models: {
+        id: any;
+        label: any;
+    }[];
+    currentModel: any;
+    modes: {
+        id: string;
+        label: string;
+        description: string;
+    }[];
+    currentMode: string;
+    kind: any;
+    name: any;
+    source: "library" | "project" | "builtin";
+    ok: boolean;
+}>;

package/dist/library-test.js

@@ -0,0 +1,37 @@
+// packages/client/src/library-test.js
+import path from "node:path";
+import { AlpError } from "@anhlp/alp-core/errors";
+import { getEntry } from "@anhlp/alp-core/library-edit";
+import { runHook, samplePayload } from "@anhlp/alp-core/hook-run";
+import { normalizeMcp } from "@anhlp/alp-core/validation";
+import { probeMcp } from "./mcp-probe.js";
+import { probeAcp } from "./acp-probe.js";
+import { probeAntigravity } from "./antigravity-probe.js";
+import { loadProvider } from "@anhlp/alp-core/providers";
+async function testEntry(kind, name, { root, library, templates, scope, timeoutMs } = {}) {
+  const entry = await getEntry(kind, name, { root, library, templates, scope });
+  const home = entry.source === "project" ? path.join(path.resolve(root), ".alp") : library;
+  if (kind === "mcp") {
+    const server = normalizeMcp({ mcpServers: { [name]: entry.content.server } }, path.join(home, "mcp"), `${name}.json`).mcpServers[name];
+    const result = await probeMcp(server, { cwd: root ? path.resolve(root) : library, ...timeoutMs ? { timeoutMs } : {} });
+    return { kind, name, source: entry.source, ok: true, ...result };
+  }
+  if (kind === "hooks") {
+    const hook = entry.content.hook;
+    const project = root ? path.resolve(root) : void 0;
+    const payload = samplePayload(hook.event, { project, agent: hook.match?.agent ?? "main" });
+    const env = { ALP_EVENT: hook.event, ALP_SESSION: payload.session, ALP_AGENT: payload.agent, ALP_PROJECT: project ?? "", ALP_TASK: payload.task ?? "" };
+    const result = await runHook(hook, payload, { cwd: project ?? library, env, ...timeoutMs ? { timeoutMs } : {} });
+    const ok = result.exitCode === 0 && !result.timedOut;
+    return { kind, name, source: entry.source, ok, ...hook.blocking && !ok ? { wouldBlock: true } : {}, payload, ...result };
+  }
+  if (kind === "providers") {
+    const provider = await loadProvider(library, name);
+    const result = provider.kind === "antigravity" ? await probeAntigravity(provider, { cwd: root ? path.resolve(root) : library, ...timeoutMs ? { timeoutMs } : {} }) : await probeAcp(provider, { cwd: root ? path.resolve(root) : library, ...timeoutMs ? { timeoutMs } : {} });
+    return { kind, name, source: entry.source, ok: true, ...result };
+  }
+  throw new AlpError("INVALID_KIND", `Only mcp servers, hooks and providers can be tested, not ${kind}`);
+}
+export {
+  testEntry
+};

package/dist/mcp-probe.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Starts an MCP server once and lists its tools (ALPD §43), for the Test button and
+ * `alp mcp test`. `server` is a normalized definition: { command, args, env, cwd } for
+ * stdio, or { url, headers } for HTTP. The server is stopped afterwards.
+ * @returns {Promise<{ server?: { name?: string, version?: string }, tools: Array<{ name: string, description?: string }> }>}
+ */
+export function probeMcp(server: any, { cwd, timeoutMs }?: {
+    timeoutMs?: number | undefined;
+}): Promise<{
+    server?: {
+        name?: string;
+        version?: string;
+    };
+    tools: Array<{
+        name: string;
+        description?: string;
+    }>;
+}>;
+/** A JSON-RPC session with a process over stdio; ACP providers are probed with it too. */
+export function stdioSession(server: any, cwd: any, timeoutMs: any): {
+    request(method: any, params: any): Promise<any>;
+    notify(method: any): Promise<void>;
+    close(): Promise<void>;
+};

package/dist/mcp-probe.js

@@ -0,0 +1,147 @@
+// packages/client/src/mcp-probe.js
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import { launchCommand } from "@anhlp/alp-core/providers";
+var PROTOCOL = "2025-06-18";
+var client = { name: "alp", version: "1" };
+async function probeMcp(server, { cwd, timeoutMs = 15e3 } = {}) {
+  const session = server.url ? await httpSession(server, timeoutMs) : stdioSession(server, cwd, timeoutMs);
+  try {
+    const init = await session.request("initialize", { protocolVersion: PROTOCOL, capabilities: {}, clientInfo: client });
+    await session.notify("notifications/initialized");
+    const tools = [];
+    let cursor;
+    for (let page = 0; page < 20; page++) {
+      const result = await session.request("tools/list", cursor ? { cursor } : {});
+      for (const tool of result.tools ?? []) tools.push({ name: tool.name, ...tool.description ? { description: tool.description } : {} });
+      cursor = result.nextCursor;
+      if (!cursor) break;
+    }
+    return { ...init.serverInfo ? { server: { name: init.serverInfo.name, version: init.serverInfo.version } } : {}, tools };
+  } finally {
+    await session.close();
+  }
+}
+function stdioSession(server, cwd, timeoutMs) {
+  const env = { ...process.env, ...server.env ?? {} };
+  const launch = launchCommand(server.command, server.args ?? [], env);
+  const child = spawn(launch.command, launch.args, { cwd: server.cwd ?? cwd, env, stdio: ["pipe", "pipe", "pipe"], detached: true });
+  const signal = (name) => {
+    try {
+      process.kill(-child.pid, name);
+    } catch {
+      child.kill(name);
+    }
+  };
+  let stderr = "";
+  child.stderr.setEncoding("utf8");
+  child.stderr.on("data", (chunk) => {
+    if (stderr.length < 4e3) stderr += chunk;
+  });
+  const pending = /* @__PURE__ */ new Map();
+  let exited;
+  const failAll = (error) => {
+    for (const { reject } of pending.values()) reject(error);
+    pending.clear();
+  };
+  child.on("error", (error) => {
+    exited = error;
+    failAll(error);
+  });
+  child.on("exit", (code) => {
+    exited = new Error(`${server.command} exited (${code ?? "signal"})${stderr.trim() ? `: ${stderr.trim().split("\n").slice(-3).join(" ")}` : ""}`);
+    failAll(exited);
+  });
+  createInterface({ input: child.stdout }).on("line", (line) => {
+    let message;
+    try {
+      message = JSON.parse(line);
+    } catch {
+      return;
+    }
+    const waiting = pending.get(message.id);
+    if (!waiting) return;
+    pending.delete(message.id);
+    if (message.error) waiting.reject(new Error(`${message.error.message ?? "MCP error"} (${message.error.code})`));
+    else waiting.resolve(message.result ?? {});
+  });
+  child.stdin.on("error", () => {
+  });
+  let id = 0;
+  return {
+    request(method, params) {
+      if (exited) return Promise.reject(exited);
+      const current = ++id;
+      return new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pending.delete(current);
+          reject(new Error(`${method} got no answer within ${timeoutMs / 1e3} s`));
+        }, timeoutMs);
+        pending.set(current, { resolve: (value) => {
+          clearTimeout(timer);
+          resolve(value);
+        }, reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        } });
+        child.stdin.write(JSON.stringify({ jsonrpc: "2.0", id: current, method, params }) + "\n");
+      });
+    },
+    async notify(method) {
+      if (!exited) child.stdin.write(JSON.stringify({ jsonrpc: "2.0", method }) + "\n");
+    },
+    async close() {
+      if (child.exitCode !== null || child.signalCode !== null) return;
+      const done = new Promise((resolve) => child.once("exit", resolve));
+      child.stdin.end();
+      signal("SIGTERM");
+      const timer = setTimeout(() => signal("SIGKILL"), 2e3);
+      await done;
+      clearTimeout(timer);
+    }
+  };
+}
+async function httpSession(server, timeoutMs) {
+  let sessionId;
+  let id = 0;
+  const post = async (body) => {
+    const response = await fetch(server.url, {
+      method: "POST",
+      headers: { ...server.headers ?? {}, "content-type": "application/json", accept: "application/json, text/event-stream", ...sessionId ? { "mcp-session-id": sessionId } : {}, "mcp-protocol-version": PROTOCOL },
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(timeoutMs)
+    });
+    sessionId = response.headers.get("mcp-session-id") ?? sessionId;
+    if (!response.ok) throw new Error(`${server.url} answered ${response.status} ${response.statusText}`);
+    return response;
+  };
+  return {
+    async request(method, params) {
+      const current = ++id;
+      const response = await post({ jsonrpc: "2.0", id: current, method, params });
+      const text = await response.text();
+      const messages = (response.headers.get("content-type") ?? "").includes("text/event-stream") ? text.split("\n").filter((line) => line.startsWith("data:")).map((line) => {
+        try {
+          return JSON.parse(line.slice(5));
+        } catch {
+          return void 0;
+        }
+      }) : [JSON.parse(text)];
+      const message = messages.find((entry) => entry?.id === current);
+      if (!message) throw new Error(`${method}: no answer in the response`);
+      if (message.error) throw new Error(`${message.error.message ?? "MCP error"} (${message.error.code})`);
+      return message.result ?? {};
+    },
+    async notify(method) {
+      await post({ jsonrpc: "2.0", method });
+    },
+    async close() {
+      if (sessionId) await fetch(server.url, { method: "DELETE", headers: { ...server.headers ?? {}, "mcp-session-id": sessionId }, signal: AbortSignal.timeout(timeoutMs) }).catch(() => {
+      });
+    }
+  };
+}
+export {
+  probeMcp,
+  stdioSession
+};

package/dist/portable.d.ts

@@ -0,0 +1,19 @@
+export { hello } from "./rpc/handshake.js";
+export type AlpTransport = import("./rpc/client.js").AlpTransport;
+export type TransportClose = import("./rpc/client.js").TransportClose;
+export type TransportState = import("./rpc/client.js").TransportState;
+export type AbortSignalLike = import("./rpc/client.js").AbortSignalLike;
+export type RequestOptions = import("./rpc/client.js").RequestOptions;
+export type AlpRpcClientOptions = import("./rpc/client.js").AlpRpcClientOptions;
+export type ClientInfo = import("./rpc/handshake.js").ClientInfo;
+export type ReconnectOptions = import("./rpc/reconnect.js").ReconnectOptions;
+export type ReconnectingClient = import("./rpc/reconnect.js").ReconnectingClient;
+export type ReconnectState = import("./rpc/reconnect.js").ReconnectState;
+export type Backoff = import("./rpc/reconnect.js").Backoff;
+export { PROTOCOL_VERSION, MAX_FRAME, AlpRpcError, ERROR } from "@anhlp/alp-protocol";
+export { AlpRpcClient, DEFAULT_MAX_PENDING } from "./rpc/client.js";
+export { AlpClientError, CLIENT_ERROR, isAlpClientError } from "./rpc/errors.js";
+export { createLineDecoder, utf8Length } from "./rpc/framing.js";
+export { MAX_TIMER_MS, timerDelay } from "./rpc/timers.js";
+export { backoffDelay, createReconnectingClient, retryable } from "./rpc/reconnect.js";
+export { attachments, base64Encode, conversation, sha256Hex, workspaceRegistry } from "./rpc/registry.js";

package/dist/portable.js

@@ -0,0 +1,33 @@
+// packages/client/src/portable.js
+import { PROTOCOL_VERSION, MAX_FRAME, AlpRpcError, ERROR } from "@anhlp/alp-protocol";
+import { AlpRpcClient, DEFAULT_MAX_PENDING } from "./rpc/client.js";
+import { AlpClientError, CLIENT_ERROR, isAlpClientError } from "./rpc/errors.js";
+import { createLineDecoder, utf8Length } from "./rpc/framing.js";
+import { MAX_TIMER_MS, timerDelay } from "./rpc/timers.js";
+import { hello } from "./rpc/handshake.js";
+import { backoffDelay, createReconnectingClient, retryable } from "./rpc/reconnect.js";
+import { attachments, base64Encode, conversation, sha256Hex, workspaceRegistry } from "./rpc/registry.js";
+export {
+  AlpClientError,
+  AlpRpcClient,
+  AlpRpcError,
+  CLIENT_ERROR,
+  DEFAULT_MAX_PENDING,
+  ERROR,
+  MAX_FRAME,
+  MAX_TIMER_MS,
+  PROTOCOL_VERSION,
+  attachments,
+  backoffDelay,
+  base64Encode,
+  conversation,
+  createLineDecoder,
+  createReconnectingClient,
+  hello,
+  isAlpClientError,
+  retryable,
+  sha256Hex,
+  timerDelay,
+  utf8Length,
+  workspaceRegistry
+};