@x-tech-laboratories/x-libs 0.14.0 → 0.14.1

package/dist/agent/session.js

@@ -1,225 +0,0 @@
-// One connection to the server: says hello, with its signature of the server's challenge when it logs in with a key,
-// answers each request, and sends streamed output only as far as the server's credit allows. Closing it stops the
-// streams it was sending; long runs carry on.
-import { sign_challenge } from "./keys.js";
-import { encode_chunk, encode_message, is_server_message, parse_server_message, } from "./protocol.js";
-const socket_open = 1;
-// ── Output ───────────────────────────────────────────────────────────────────
-// Sends a stream's stdout as binary frames within the credit granted, then its end once all of it has gone.
-class OutputPump {
-    id;
-    stream;
-    session;
-    credit;
-    pending = [];
-    stdout_ended = false;
-    result = null;
-    finished = false;
-    constructor(id, stream, window, session) {
-        this.id = id;
-        this.stream = stream;
-        this.credit = window;
-        this.session = session;
-        stream.stdout.on("data", (chunk) => {
-            this.pending.push(chunk);
-            this.flush();
-        });
-        stream.stdout.on("error", () => { });
-        stream.stdout.on("close", () => {
-            this.stdout_ended = true;
-            this.finish_when_done();
-        });
-        void stream.done.then((result) => {
-            this.result = result;
-            this.finish_when_done();
-        });
-    }
-    grant(bytes) {
-        this.credit += Math.max(0, bytes);
-        this.flush();
-    }
-    // Stops the command and drops what it had yet to send.
-    cancel() {
-        this.pending.length = 0;
-        this.stream.stop();
-        this.stream.stdout.resume();
-    }
-    flush() {
-        while (this.credit > 0 && this.pending.length > 0) {
-            const chunk = this.pending[0];
-            const piece = chunk.length > this.credit ? chunk.subarray(0, this.credit) : chunk;
-            if (piece === chunk)
-                this.pending.shift();
-            else
-                this.pending[0] = chunk.subarray(piece.length);
-            this.credit -= piece.length;
-            this.session.send_chunk(this.id, piece);
-        }
-        if (this.pending.length > 0)
-            this.stream.stdout.pause();
-        else if (!this.stdout_ended)
-            this.stream.stdout.resume();
-        this.finish_when_done();
-    }
-    finish_when_done() {
-        if (this.finished || !this.stdout_ended || this.result === null || this.pending.length > 0)
-            return;
-        this.finished = true;
-        this.session.end_stream(this.id, this.result);
-    }
-}
-// ── Session ──────────────────────────────────────────────────────────────────
-export class AgentSession {
-    socket;
-    runs;
-    options;
-    pumps = new Map();
-    last_heard = Date.now();
-    heartbeat;
-    closed = false;
-    greeted = false;
-    constructor(socket, runs, options) {
-        this.socket = socket;
-        this.runs = runs;
-        this.options = options;
-        this.heartbeat = setInterval(() => this.beat(), options.heartbeat_in_milliseconds);
-        this.heartbeat.unref();
-        if (!options.key)
-            this.say_hello();
-    }
-    say_hello(signature) {
-        this.greeted = true;
-        const hello = { type: "hello", protocol: this.options.app.protocol_version, host: this.options.host, agent_version: this.options.agent_version, runs: this.runs.list() };
-        this.send(signature === undefined ? hello : { ...hello, signature });
-        this.options.on_hello?.(this);
-    }
-    // Handles one text frame from the server; anything that is not a message is ignored.
-    receive(text) {
-        this.last_heard = Date.now();
-        const message = parse_server_message(text, this.options.app);
-        if (message === null)
-            return;
-        if (is_server_message(message))
-            this.handle(message);
-        else
-            this.handle_app(message);
-    }
-    // The connection has gone: stops the streams that were being sent, since nobody reads them now.
-    close() {
-        if (this.closed)
-            return;
-        this.closed = true;
-        clearInterval(this.heartbeat);
-        for (const pump of this.pumps.values())
-            pump.cancel();
-        this.pumps.clear();
-    }
-    // ── Sending ──────────────────────────────────────────────────────────────
-    send(message) {
-        if (!this.closed && this.socket.readyState === socket_open)
-            this.socket.send(encode_message(message, this.options.app));
-    }
-    send_chunk(id, data) {
-        if (!this.closed && this.socket.readyState === socket_open)
-            this.socket.send(encode_chunk(id, data));
-    }
-    end_stream(id, result) {
-        this.pumps.delete(id);
-        this.send({ type: "stream_end", id, exit_code: result.exit_code, stderr: result.stderr });
-    }
-    // ── Handling ─────────────────────────────────────────────────────────────
-    handle(message) {
-        switch (message.type) {
-            case "ping":
-                this.send({ type: "pong", epoch_ms: message.epoch_ms });
-                return;
-            case "pong":
-                return;
-            case "challenge":
-                if (this.options.key && !this.greeted)
-                    this.say_hello(sign_challenge(this.options.key, this.options.app.name, this.options.host, message.nonce));
-                return;
-            case "credit":
-                this.pumps.get(message.id)?.grant(message.bytes);
-                return;
-            case "cancel":
-                this.pumps.get(message.id)?.cancel();
-                return;
-            case "stream":
-                this.start_pump(message.id, () => this.open_stream(message.task, message.stdin), message.window);
-                return;
-            case "attach":
-                this.start_pump(message.id, () => this.runs.tail(message.run_id, message.offset), message.window);
-                return;
-            default:
-                void this.answer(message.id, () => this.value_for(message));
-        }
-    }
-    // A message carrying an id is a request the app answers; anything else goes to the app as it is.
-    handle_app(message) {
-        if (typeof message.id !== "string") {
-            this.options.on_message?.(message, this);
-            return;
-        }
-        const requests = this.options.requests ?? {};
-        const handler = Object.hasOwn(requests, message.type) ? requests[message.type] : undefined;
-        if (handler === undefined) {
-            this.send({ type: "failed", id: message.id, error: `This agent does not know the request '${message.type}'.` });
-            return;
-        }
-        void this.answer(message.id, () => handler(message));
-    }
-    start_pump(id, open, window) {
-        if (this.pumps.has(id))
-            return;
-        let stream;
-        try {
-            stream = open();
-        }
-        catch (error) {
-            this.send({ type: "stream_end", id, exit_code: -1, stderr: error.message });
-            return;
-        }
-        this.pumps.set(id, new OutputPump(id, stream, window, this));
-    }
-    async answer(id, work) {
-        try {
-            const value = await work();
-            this.send({ type: "reply", id, value: value ?? null });
-        }
-        catch (error) {
-            this.send({ type: "failed", id, error: error.message });
-        }
-    }
-    open_stream(task, stdin) {
-        if (this.options.runner.stream === undefined)
-            throw new Error("This agent does not stream its tasks.");
-        return this.options.runner.stream(task, { stdin });
-    }
-    async value_for(message) {
-        switch (message.type) {
-            case "run":
-                return this.options.runner.run(message.task, { timeout_in_seconds: message.timeout_in_seconds, stdin: message.stdin });
-            case "start":
-                return this.runs.start(message.run_id, message.task, message.stdin);
-            case "poll":
-                return this.runs.poll(message.run_id, message.offset);
-            case "stop":
-                return this.runs.stop(message.run_id);
-            case "forget":
-                this.runs.forget(message.run_id);
-                return null;
-            case "runs":
-                return this.runs.list();
-        }
-    }
-    // Pings the server, or gives up on one that has been silent for three beats.
-    beat() {
-        if (Date.now() - this.last_heard > 3 * this.options.heartbeat_in_milliseconds) {
-            this.socket.close(4008, "The server stopped answering.");
-            this.close();
-            return;
-        }
-        this.send({ type: "ping", epoch_ms: Date.now() });
-    }
-}

package/dist/agent/tasks.d.ts

@@ -1,17 +0,0 @@
-import { type CommandStream } from "./commands.ts";
-import type { RunResult } from "./protocol.ts";
-export interface LongRunLaunch {
-    program: string;
-    args: string[];
-}
-export interface TaskRunner<Task> {
-    run(task: Task, options: {
-        timeout_in_seconds: number;
-        stdin?: string | null;
-    }): Promise<RunResult>;
-    stream?(task: Task, options: {
-        stdin?: string | null;
-    }): CommandStream;
-    launch(task: Task, folder: string, has_stdin: boolean): LongRunLaunch;
-}
-export declare function shell_runner(process_name: string): TaskRunner<string>;

package/dist/agent/tasks.js

@@ -1,15 +0,0 @@
-// How an agent carries out the app's tasks: to their end, as a stream, or as a long run's own process. Shell tasks, a
-// command line run by sh, come built in; an app with typed operations gives its own.
-// ── Imports ──────────────────────────────────────────────────────────────────
-import { run_command, stream_command } from "./commands.js";
-// ── Shell ────────────────────────────────────────────────────────────────────
-// The outer shell runs the command with its output in the run's folder, then writes the exit code in one rename.
-const wrapper = 'sh -c "$2" > "$1/out" 2>&1; echo $? > "$1/exit.part"; mv -f "$1/exit.part" "$1/exit"';
-// Runs each task as a command line under sh; `process_name`, such as "x-backups-run", is what ps shows for a long run.
-export function shell_runner(process_name) {
-    return {
-        run: (command, options) => run_command(command, options),
-        stream: (command, options) => stream_command(command, options),
-        launch: (command, folder) => ({ program: "sh", args: ["-c", wrapper, process_name, folder, command] }),
-    };
-}

package/dist/backups.d.ts

@@ -1,31 +0,0 @@
-export interface Backup {
-    name: string;
-    taken_at: string;
-    is_automatic: boolean;
-    size_bytes: number;
-}
-export interface BackupNaming {
-    pattern: RegExp;
-    name_for: (taken_at: Date, is_automatic: boolean) => string;
-    describe: (name: string, size_bytes: number) => Backup;
-}
-export declare function backup_naming(prefix: string, extension: string): BackupNaming;
-export interface BackupStore {
-    list: () => Promise<{
-        name: string;
-        size_bytes: number;
-    }[]> | {
-        name: string;
-        size_bytes: number;
-    }[];
-    take: (name: string) => Promise<number> | number;
-    remove: (name: string) => Promise<void> | void;
-}
-export interface Backups {
-    naming: BackupNaming;
-    list: () => Promise<Backup[]>;
-    create: (is_automatic?: boolean) => Promise<Backup>;
-    remove: (name: string) => Promise<void>;
-    keep_automatic: (to_keep: number, interval_in_milliseconds?: number, now?: Date) => Promise<void>;
-}
-export declare function backups(naming: BackupNaming, store: BackupStore): Backups;

package/dist/backups.js

@@ -1,43 +0,0 @@
-// Named backups of an app's data: the name says when each was taken and whether it was automatic, and daily ones keep a set number.
-const escaped = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-// Names such as tasks-2026-06-10T09-30-00Z-auto.db for the prefix "tasks" and the extension ".db".
-export function backup_naming(prefix, extension) {
-    const pattern = new RegExp(`^${escaped(prefix)}-(\\d{4}-\\d{2}-\\d{2})T(\\d{2})-(\\d{2})-(\\d{2})Z(-auto)?${escaped(extension)}$`);
-    return {
-        pattern,
-        name_for: (taken_at, is_automatic) => `${prefix}-${taken_at.toISOString().slice(0, 19).replaceAll(":", "-")}Z${is_automatic ? "-auto" : ""}${extension}`,
-        describe: (name, size_bytes) => {
-            const match = pattern.exec(name);
-            if (!match)
-                throw new Error(`not a backup name: ${name}`);
-            const [, date, hours, minutes, seconds, automatic] = match;
-            return { name, taken_at: `${date}T${hours}:${minutes}:${seconds}Z`, is_automatic: automatic !== undefined, size_bytes };
-        },
-    };
-}
-const day_in_milliseconds = 24 * 60 * 60 * 1000;
-export function backups(naming, store) {
-    const list = async () => (await store.list())
-        .filter((file) => naming.pattern.test(file.name))
-        .map((file) => naming.describe(file.name, file.size_bytes))
-        .sort((first, second) => second.taken_at.localeCompare(first.taken_at));
-    const remove = async (name) => {
-        if (!naming.pattern.test(name))
-            throw new Error(`not a backup name: ${name}`);
-        await store.remove(name);
-    };
-    const create = async (is_automatic = false, now = new Date()) => {
-        const name = naming.name_for(now, is_automatic);
-        const existing = (await list()).find((backup) => backup.name === name);
-        return existing ?? naming.describe(name, await store.take(name));
-    };
-    const keep_automatic = async (to_keep, interval_in_milliseconds = day_in_milliseconds, now = new Date()) => {
-        const newest = (await list()).find((backup) => backup.is_automatic);
-        if (!newest || now.getTime() - Date.parse(newest.taken_at) >= interval_in_milliseconds)
-            await create(true, now);
-        const automatic = (await list()).filter((backup) => backup.is_automatic);
-        for (const backup of automatic.slice(Math.max(0, to_keep)))
-            await remove(backup.name);
-    };
-    return { naming, list, create: (is_automatic) => create(is_automatic), remove, keep_automatic };
-}

package/dist/dates.d.ts

@@ -1,9 +0,0 @@
-export declare function has_time(local_date: string): boolean;
-export declare function parse_local(local_date: string): Date;
-export declare function format_local(date: Date, with_time: boolean): string;
-export declare function start_of_day(date: Date): Date;
-export declare function days_between(first: Date, second: Date): number;
-export declare function add_days(date: Date, days: number): Date;
-export declare function add_months(date: Date, months: number): Date;
-export declare function is_overdue(local_date: string, now?: Date): boolean;
-export declare function relative_day_label(local_date: string, now?: Date, locale?: string): string;

package/dist/dates.js

@@ -1,60 +0,0 @@
-// Local calendar dates written as "YYYY-MM-DD" or "YYYY-MM-DDTHH:MM", read and written in the device's own time zone.
-const DAY_IN_MILLISECONDS = 24 * 60 * 60 * 1000;
-// ── Text and dates ───────────────────────────────────────────────────────────
-export function has_time(local_date) {
-    return local_date.includes("T");
-}
-// A date without a time stands for midnight at the start of its day.
-export function parse_local(local_date) {
-    const [day = "", time = "00:00"] = local_date.split("T");
-    const [year = 0, month = 1, day_of_month = 1] = day.split("-").map(Number);
-    const [hours = 0, minutes = 0] = time.split(":").map(Number);
-    return new Date(year, month - 1, day_of_month, hours, minutes);
-}
-export function format_local(date, with_time) {
-    const pad = (number) => String(number).padStart(2, "0");
-    const day = `${date.getFullYear()}-${pad(date.getMonth() + 1)}-${pad(date.getDate())}`;
-    return with_time ? `${day}T${pad(date.getHours())}:${pad(date.getMinutes())}` : day;
-}
-// ── Arithmetic ───────────────────────────────────────────────────────────────
-export function start_of_day(date) {
-    return new Date(date.getFullYear(), date.getMonth(), date.getDate());
-}
-// Whole calendar days from the first date to the second, so a clock change in between still counts as one day.
-export function days_between(first, second) {
-    return Math.round((start_of_day(second).getTime() - start_of_day(first).getTime()) / DAY_IN_MILLISECONDS);
-}
-export function add_days(date, days) {
-    const moved = new Date(date);
-    moved.setDate(moved.getDate() + days);
-    return moved;
-}
-// A day past the end of the target month falls back to its last day, so Jan 31 plus a month is Feb 28.
-export function add_months(date, months) {
-    const last_day = new Date(date.getFullYear(), date.getMonth() + months + 1, 0).getDate();
-    return new Date(date.getFullYear(), date.getMonth() + months, Math.min(date.getDate(), last_day), date.getHours(), date.getMinutes(), date.getSeconds(), date.getMilliseconds());
-}
-// ── Labels ───────────────────────────────────────────────────────────────────
-// A date without a time is overdue only once its day has passed.
-export function is_overdue(local_date, now = new Date()) {
-    const date = parse_local(local_date);
-    return has_time(local_date) ? date < now : date < start_of_day(now);
-}
-// Yesterday, Today or Tomorrow in the reader's language, else a short date with the year only when it is not this year, then the time if there is one.
-export function relative_day_label(local_date, now = new Date(), locale) {
-    const date = parse_local(local_date);
-    const day_offset = days_between(now, date);
-    const day_label = Math.abs(day_offset) <= 1
-        ? capitalised(new Intl.RelativeTimeFormat(locale, { numeric: "auto" }).format(day_offset, "day"), locale)
-        : date.toLocaleDateString(locale, {
-            month: "short",
-            day: "numeric",
-            year: date.getFullYear() === now.getFullYear() ? undefined : "numeric",
-        });
-    if (!has_time(local_date))
-        return day_label;
-    return `${day_label} ${date.toLocaleTimeString(locale, { hour: "numeric", minute: "2-digit" })}`;
-}
-function capitalised(text, locale) {
-    return text.charAt(0).toLocaleUpperCase(locale) + text.slice(1);
-}

package/dist/durations.d.ts

@@ -1,11 +0,0 @@
-declare const unit_names: readonly [readonly ["months", 2592000], readonly ["weeks", 604800], readonly ["days", 86400], readonly ["hours", 3600], readonly ["minutes", 60], readonly ["seconds", 1]];
-export type DurationUnit = (typeof unit_names)[number][0];
-export interface DurationWording {
-    separator?: string;
-    largest_unit?: DurationUnit;
-}
-export declare function parse_duration(value: unknown, key: string): number;
-export declare function format_duration(seconds: number, wording?: DurationWording): string;
-export declare function format_age(seconds: number): string;
-export declare function format_clock(milliseconds: number | null | undefined, empty?: string): string;
-export {};

package/dist/durations.js

@@ -1,49 +0,0 @@
-// Reads durations such as "2h30m" from settings and writes them back in words, for the server and the agent alike.
-import parse from "parse-duration";
-// A month counts as 30 days.
-const unit_names = [["months", 2592000], ["weeks", 604800], ["days", 86400], ["hours", 3600], ["minutes", 60], ["seconds", 1]];
-const words = new Intl.DurationFormat("en", { style: "long" });
-// A duration in whole seconds; `key` names the setting in the error.
-export function parse_duration(value, key) {
-    if (typeof value === "number" && Number.isFinite(value) && value >= 0)
-        return Math.floor(value);
-    const text = String(value).trim();
-    // A bare number is seconds, where parse-duration would read milliseconds.
-    const seconds = /^\d+$/.test(text) ? Number(text) : parse(text, "s");
-    if (seconds === null || seconds === undefined || !Number.isFinite(seconds) || seconds < 0) {
-        throw new Error(`\`${key}\` must be a duration such as "1w", "7d", "2h30m" or "60s", not ${JSON.stringify(value)}`);
-    }
-    return Math.floor(seconds);
-}
-// The two largest whole units, such as "1 day, 2 hours" or, with a space between, "1 week 2 days".
-export function format_duration(seconds, wording = {}) {
-    if (seconds < 1)
-        return "0 seconds";
-    const first_unit = unit_names.findIndex(([name]) => name === (wording.largest_unit ?? "months"));
-    const parts = {};
-    let remaining = Math.floor(seconds);
-    for (const [name, size] of unit_names.slice(first_unit)) {
-        if (Object.keys(parts).length === 2)
-            break;
-        if (remaining < size)
-            continue;
-        parts[name] = Math.floor(remaining / size);
-        remaining %= size;
-    }
-    if (wording.separator === undefined)
-        return words.format(parts);
-    return Object.entries(parts).map(([name, count]) => words.format({ [name]: count })).join(wording.separator);
-}
-export function format_age(seconds) {
-    return seconds < 0 ? "never" : `${format_duration(seconds)} ago`;
-}
-// A playing time as a clock, such as "3:07", or "1:02:03" from an hour.
-export function format_clock(milliseconds, empty = "0:00") {
-    if (milliseconds === null || milliseconds === undefined || !Number.isFinite(milliseconds))
-        return empty;
-    const total = Math.max(0, Math.round(milliseconds / 1000));
-    const hours = Math.floor(total / 3600);
-    const minutes = Math.floor((total % 3600) / 60);
-    const seconds = String(total % 60).padStart(2, "0");
-    return hours > 0 ? `${hours}:${String(minutes).padStart(2, "0")}:${seconds}` : `${minutes}:${seconds}`;
-}

package/dist/electron/app.d.ts

@@ -1,13 +0,0 @@
-export interface AppLike {
-    requestSingleInstanceLock(): boolean;
-    quit(): void;
-    on(event: "second-instance", listener: (event: unknown, argv: string[]) => void): unknown;
-}
-export interface FocusableWindowLike {
-    isMinimized(): boolean;
-    restore(): void;
-    focus(): void;
-}
-export declare function hold_single_instance(app: AppLike, on_second_launch: (argv: string[]) => void): boolean;
-export declare function bring_to_front(window: FocusableWindowLike): void;
-export declare function first_argument<Value>(argv: readonly string[], parse: (argument: string) => Value | null): Value | null;

package/dist/electron/app.js

@@ -1,27 +0,0 @@
-// The app's place on the desktop: one copy running at a time, its window brought forward, and links handed over on the command line.
-// ── One copy ─────────────────────────────────────────────────────────────────
-// Keeps one copy running: a second launch hands its command line to the first and quits; returns false in the copy that must quit.
-export function hold_single_instance(app, on_second_launch) {
-    if (!app.requestSingleInstanceLock()) {
-        app.quit();
-        return false;
-    }
-    app.on("second-instance", (_event, argv) => on_second_launch(argv));
-    return true;
-}
-// Brings a window forward, restoring it first when minimised.
-export function bring_to_front(window) {
-    if (window.isMinimized())
-        window.restore();
-    window.focus();
-}
-// ── Command line ─────────────────────────────────────────────────────────────
-// The first command-line argument a parser accepts, such as a task link, or null.
-export function first_argument(argv, parse) {
-    for (const argument of argv) {
-        const value = parse(argument);
-        if (value !== null)
-            return value;
-    }
-    return null;
-}

package/dist/electron/bridge.d.ts

@@ -1,55 +0,0 @@
-export interface IpcMainLike {
-    handle(channel: string, listener: (event: unknown, ...args: unknown[]) => unknown): void;
-    removeHandler(channel: string): void;
-}
-export interface IpcMainEventLike {
-    senderFrame?: {
-        url: string;
-    } | null;
-}
-export interface IpcRendererLike {
-    invoke(channel: string, ...args: unknown[]): Promise<unknown>;
-}
-export interface ContextBridgeLike {
-    exposeInMainWorld(api_key: string, api: unknown): void;
-}
-type AnyMethod = (...args: never[]) => unknown;
-export type Client<Methods extends Record<keyof Methods, AnyMethod>> = {
-    [Name in keyof Methods]: (...args: Parameters<Methods[Name]>) => Promise<Awaited<ReturnType<Methods[Name]>>>;
-};
-export type Implementation<Methods extends Record<keyof Methods, AnyMethod>> = {
-    [Name in keyof Methods]: (...args: Parameters<Methods[Name]>) => Awaited<ReturnType<Methods[Name]>> | Promise<Awaited<ReturnType<Methods[Name]>>>;
-};
-export type CallRemote = (method: string, args: unknown[]) => Promise<unknown>;
-export type Envelope<Result = unknown> = {
-    ok: true;
-    result: Result;
-} | {
-    ok: false;
-    error: string;
-};
-export interface HandleOptions {
-    trusted?: (event: IpcMainEventLike) => boolean;
-    envelopes?: boolean;
-}
-export interface ClientOptions {
-    envelopes?: boolean;
-}
-export interface Bridge<Methods extends Record<keyof Methods, AnyMethod>> {
-    api_name: string;
-    method_names: readonly (keyof Methods & string)[];
-    channel: (method: keyof Methods & string) => string;
-    expose: (context_bridge: ContextBridgeLike, ipc_renderer: IpcRendererLike, options?: ClientOptions) => void;
-    ipc_client: (ipc_renderer: IpcRendererLike, options?: ClientOptions) => Client<Methods>;
-    handle: (ipc_main: IpcMainLike, implementation: Implementation<Methods>, options?: HandleOptions) => () => void;
-    web_rpc: (call_remote: CallRemote) => Client<Methods>;
-    dispatch: (implementation: Implementation<Methods>, method: string, args: unknown[]) => Promise<unknown>;
-}
-export declare function define_bridge<Methods extends Record<keyof Methods, AnyMethod>>(api_name: string, method_names: readonly (keyof Methods & string)[]): Bridge<Methods>;
-export declare function to_envelope<Result>(work: () => Result | Promise<Result>): Promise<Envelope<Awaited<Result>>>;
-export declare function clean_error_message(message: string): string;
-export declare function clean_invoker(ipc_renderer: IpcRendererLike): IpcRendererLike;
-export declare function unwrapping_invoker(ipc_renderer: IpcRendererLike): IpcRendererLike;
-export declare function to_cloneable(value: unknown): unknown;
-export declare function with_cloneable_arguments<Methods extends Record<keyof Methods, AnyMethod>>(client: Client<Methods>): Client<Methods>;
-export {};