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

package/dist/electron/bridge.js

@@ -0,0 +1,105 @@
+// One table of method names serves the Electron preload, the main process and a web page's calls to its server alike.
+export function define_bridge(api_name, method_names) {
+    const channel = (method) => `${api_name}:${method}`;
+    const is_method = (method) => method_names.includes(method);
+    function client_through(call) {
+        return Object.fromEntries(method_names.map((method) => [method, (...args) => call(method, args)]));
+    }
+    async function dispatch(implementation, method, args) {
+        if (!is_method(method))
+            throw new Error(`${api_name} has no method ${method}`);
+        const answer = implementation[method];
+        return answer.apply(implementation, args);
+    }
+    const ipc_client = (ipc_renderer, options = {}) => {
+        const invoke = options.envelopes ? unwrapping_invoker(ipc_renderer) : clean_invoker(ipc_renderer);
+        return client_through((method, args) => invoke.invoke(channel(method), ...args));
+    };
+    return {
+        api_name,
+        method_names,
+        channel,
+        dispatch,
+        ipc_client,
+        expose: (context_bridge, ipc_renderer, options) => {
+            context_bridge.exposeInMainWorld(api_name, ipc_client(ipc_renderer, options));
+        },
+        handle: (ipc_main, implementation, options = {}) => {
+            for (const method of method_names) {
+                ipc_main.handle(channel(method), (event, ...args) => {
+                    const answer = () => {
+                        if (options.trusted && !options.trusted((event ?? {})))
+                            throw new Error("Untrusted sender.");
+                        return dispatch(implementation, method, args);
+                    };
+                    return options.envelopes ? to_envelope(answer) : answer();
+                });
+            }
+            return () => { for (const method of method_names)
+                ipc_main.removeHandler(channel(method)); };
+        },
+        web_rpc: client_through,
+    };
+}
+// ── Envelopes and errors ─────────────────────────────────────────────────────
+// Runs the work and puts its result or its failure's words in an envelope.
+export async function to_envelope(work) {
+    try {
+        return { ok: true, result: await work() };
+    }
+    catch (error) {
+        return { ok: false, error: error instanceof Error ? error.message : String(error) };
+    }
+}
+const REMOTE_ERROR_PREFIX = /^Error invoking remote method '[^']*': (?:\w*Error: )?/;
+// Electron reports a rejected handler as "Error invoking remote method 'x': Error: words", which the page shows as the words alone.
+export function clean_error_message(message) {
+    return message.replace(REMOTE_ERROR_PREFIX, "");
+}
+// An ipcRenderer whose rejections carry clean messages.
+export function clean_invoker(ipc_renderer) {
+    return {
+        invoke: async (channel, ...args) => {
+            try {
+                return await ipc_renderer.invoke(channel, ...args);
+            }
+            catch (error) {
+                if (error instanceof Error)
+                    throw new Error(clean_error_message(error.message));
+                throw error;
+            }
+        },
+    };
+}
+// An ipcRenderer that opens envelope replies, throwing a failure as an Error with its message.
+export function unwrapping_invoker(ipc_renderer) {
+    return {
+        invoke: async (channel, ...args) => {
+            const envelope = (await ipc_renderer.invoke(channel, ...args));
+            if (!envelope.ok)
+                throw new Error(envelope.error);
+            return envelope.result;
+        },
+    };
+}
+// ── Cloning ──────────────────────────────────────────────────────────────────
+// A value that survives structured clone passes as it is, and anything else, such as a Proxy, crosses as plain JSON.
+export function to_cloneable(value) {
+    if (value === null || typeof value !== "object")
+        return value;
+    try {
+        structuredClone(value);
+        return value;
+    }
+    catch {
+        return JSON.parse(JSON.stringify(value));
+    }
+}
+// The same client with every argument made cloneable first, since Electron clones arguments before the preload sees them.
+export function with_cloneable_arguments(client) {
+    const wrapped = {};
+    for (const [name, method] of Object.entries(client)) {
+        wrapped[name] = (...args) => method(...args.map(to_cloneable));
+    }
+    return wrapped;
+}

package/dist/electron/events.d.ts

@@ -0,0 +1,21 @@
+import type { ContextBridgeLike } from "./bridge.ts";
+export interface IpcRendererEventsLike {
+    on(channel: string, listener: (event: unknown, message: unknown) => void): unknown;
+    removeListener(channel: string, listener: (event: unknown, message: unknown) => void): unknown;
+}
+export interface WindowLike {
+    webContents: {
+        send(channel: string, message: unknown): void;
+    };
+}
+export interface EventsClient<Events extends Record<string, unknown>> {
+    on<Name extends keyof Events & string>(name: Name, handler: (payload: Events[Name]) => void): () => void;
+}
+export interface EventsBridge<Events extends Record<string, unknown>> {
+    api_name: string;
+    channel: string;
+    ipc_client: (ipc_renderer: IpcRendererEventsLike) => EventsClient<Events>;
+    expose: (context_bridge: ContextBridgeLike, ipc_renderer: IpcRendererEventsLike) => void;
+    emit: <Name extends keyof Events & string>(windows: Iterable<WindowLike>, name: Name, payload: Events[Name]) => void;
+}
+export declare function define_events<Events extends Record<string, unknown>>(api_name: string): EventsBridge<Events>;

package/dist/electron/events.js

@@ -0,0 +1,25 @@
+// Messages the main process pushes to its pages, such as progress, on one channel and subscribed to by name.
+export function define_events(api_name) {
+    const channel = `${api_name}:event`;
+    const ipc_client = (ipc_renderer) => ({
+        on: (name, handler) => {
+            const listener = (_event, message) => {
+                const { name: sent_name, payload } = message;
+                if (sent_name === name)
+                    handler(payload);
+            };
+            ipc_renderer.on(channel, listener);
+            return () => void ipc_renderer.removeListener(channel, listener);
+        },
+    });
+    return {
+        api_name,
+        channel,
+        ipc_client,
+        expose: (context_bridge, ipc_renderer) => context_bridge.exposeInMainWorld(api_name, ipc_client(ipc_renderer)),
+        emit: (windows, name, payload) => {
+            for (const window of windows)
+                window.webContents.send(channel, { name, payload });
+        },
+    };
+}

package/dist/electron/fetch.d.ts

@@ -0,0 +1,52 @@
+export type HeaderList = [string, string][];
+export interface FetchRequest {
+    url: string;
+    method: string;
+    headers: HeaderList;
+    body?: Uint8Array<ArrayBuffer>;
+}
+export interface FetchAnswer {
+    status: number;
+    status_text: string;
+    headers: HeaderList;
+    body: Uint8Array<ArrayBuffer> | null;
+}
+export type FetchMethod = (request: FetchRequest) => FetchAnswer;
+export interface StreamRequest extends FetchRequest {
+    stream_id: string;
+}
+export type StreamHead = Omit<FetchAnswer, "body">;
+export type StreamChunk = {
+    stream_id: string;
+    bytes: Uint8Array<ArrayBuffer>;
+} | {
+    stream_id: string;
+    done: true;
+} | {
+    stream_id: string;
+    error: string;
+};
+export type StreamStartMethod = (request: StreamRequest) => StreamHead;
+export type StreamCancelMethod = (stream_id: string) => void;
+export interface FetchPolicy {
+    hosts: readonly string[];
+    allow_http?: boolean;
+}
+export declare function is_allowed_url(url: string, policy: FetchPolicy): boolean;
+export declare function create_main_fetch(policy: FetchPolicy, send?: typeof fetch): (request: FetchRequest) => Promise<FetchAnswer>;
+export interface MainStreamFetch {
+    start: (request: StreamRequest) => Promise<StreamHead>;
+    cancel: (stream_id: string) => void;
+}
+export declare function create_main_stream_fetch(policy: FetchPolicy, emit: (chunk: StreamChunk) => void, send?: typeof fetch): MainStreamFetch;
+export interface PageFetchOptions {
+    pinned_headers?: Record<string, string>;
+}
+export declare function to_response(answer: FetchAnswer): Response;
+export declare function create_page_fetch(send: (request: FetchRequest) => Promise<FetchAnswer>, options?: PageFetchOptions): (input: string | URL | Request, init?: RequestInit) => Promise<Response>;
+export interface PageStreamBridge {
+    start: (request: StreamRequest) => Promise<StreamHead>;
+    cancel?: (stream_id: string) => Promise<void> | void;
+    on_chunk: (handler: (chunk: StreamChunk) => void) => () => void;
+}
+export declare function create_page_stream_fetch(bridge: PageStreamBridge, options?: PageFetchOptions): (input: string | URL | Request, init?: RequestInit) => Promise<Response>;

package/dist/electron/fetch.js

@@ -0,0 +1,175 @@
+// Fetching from Electron's main process for a page whose own requests the browser's cross-origin rules would block, with the body whole or streamed in chunks.
+const NULL_BODY_STATUSES = new Set([101, 204, 205, 304]);
+export function is_allowed_url(url, policy) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return false;
+    }
+    if (parsed.protocol !== "https:" && !(policy.allow_http && parsed.protocol === "http:"))
+        return false;
+    return policy.hosts.some((host) => host.startsWith("*.") ? parsed.hostname.endsWith(host.slice(1)) : parsed.host === host || parsed.hostname === host);
+}
+// The body arrives already unpacked, so the headers describing the packed body are dropped.
+const DROPPED_ANSWER_HEADERS = new Set(["content-encoding", "content-length"]);
+// The main process's half: sends the page's request with Node's fetch, refusing any URL outside the policy.
+export function create_main_fetch(policy, send = fetch) {
+    return async (request) => {
+        if (!is_allowed_url(request.url, policy))
+            throw new Error(`fetching ${request.url} is not allowed`);
+        const response = await send(request.url, { method: request.method, headers: request.headers, body: request.body });
+        const headers = [];
+        response.headers.forEach((value, name) => {
+            if (!DROPPED_ANSWER_HEADERS.has(name))
+                headers.push([name, value]);
+        });
+        const has_body = !NULL_BODY_STATUSES.has(response.status) && request.method !== "HEAD";
+        return {
+            status: response.status,
+            status_text: response.statusText,
+            headers,
+            body: has_body ? new Uint8Array(await response.arrayBuffer()) : null,
+        };
+    };
+}
+// The main process's half of a streamed fetch: answers with the head and sends each chunk of the body through emit as it arrives.
+export function create_main_stream_fetch(policy, emit, send = fetch) {
+    const open = new Map();
+    async function pump(stream_id, body, controller) {
+        const reader = body.getReader();
+        try {
+            while (!controller.signal.aborted) {
+                const { done, value } = await reader.read();
+                if (done)
+                    break;
+                emit({ stream_id, bytes: new Uint8Array(value) });
+            }
+            if (!controller.signal.aborted)
+                emit({ stream_id, done: true });
+        }
+        catch (error) {
+            if (!controller.signal.aborted)
+                emit({ stream_id, error: error instanceof Error ? error.message : String(error) });
+        }
+        finally {
+            open.delete(stream_id);
+        }
+    }
+    return {
+        start: async (request) => {
+            if (!is_allowed_url(request.url, policy))
+                throw new Error(`fetching ${request.url} is not allowed`);
+            const controller = new AbortController();
+            open.set(request.stream_id, controller);
+            const response = await send(request.url, { method: request.method, headers: request.headers, body: request.body, signal: controller.signal });
+            const headers = [];
+            response.headers.forEach((value, name) => {
+                if (!DROPPED_ANSWER_HEADERS.has(name))
+                    headers.push([name, value]);
+            });
+            const has_body = response.body !== null && !NULL_BODY_STATUSES.has(response.status) && request.method !== "HEAD";
+            if (has_body)
+                void pump(request.stream_id, response.body, controller);
+            else {
+                open.delete(request.stream_id);
+                emit({ stream_id: request.stream_id, done: true });
+            }
+            return { status: response.status, status_text: response.statusText, headers };
+        },
+        cancel: (stream_id) => {
+            open.get(stream_id)?.abort();
+            open.delete(stream_id);
+        },
+    };
+}
+function abort_error() {
+    return new DOMException("The request was aborted", "AbortError");
+}
+// Rejects once the signal aborts, though the main process still finishes the request.
+function until_aborted(promise, signal) {
+    if (!signal)
+        return promise;
+    if (signal.aborted)
+        return Promise.reject(abort_error());
+    return new Promise((resolve, reject) => {
+        signal.addEventListener("abort", () => reject(abort_error()), { once: true });
+        promise.then(resolve, reject);
+    });
+}
+export function to_response(answer) {
+    const body = NULL_BODY_STATUSES.has(answer.status) ? null : answer.body;
+    return new Response(body, { status: answer.status, statusText: answer.status_text, headers: answer.headers });
+}
+// The page's half: a fetch that sends each request through the bridge method, for libraries that take a fetch.
+export function create_page_fetch(send, options = {}) {
+    return async (input, init) => {
+        const request = new Request(input, init);
+        // A plain Headers keeps names a Request would drop, such as Origin and Referer.
+        const headers = new Headers(request.headers);
+        for (const [name, value] of Object.entries(options.pinned_headers ?? {}))
+            headers.set(name, value);
+        const body = request.method === "GET" || request.method === "HEAD" ? undefined : new Uint8Array(await request.arrayBuffer());
+        const answer = await until_aborted(send({ url: request.url, method: request.method, headers: [...headers.entries()], body }), init?.signal ?? request.signal);
+        return to_response(answer);
+    };
+}
+let next_stream_number = 0;
+const new_stream_id = () => `${Date.now().toString(36)}-${(next_stream_number++).toString(36)}`;
+// The page's half of a streamed fetch: a fetch whose Response body is a ReadableStream fed by the chunks, so a player reads them as they land.
+export function create_page_stream_fetch(bridge, options = {}) {
+    return async (input, init) => {
+        const request = new Request(input, init);
+        const signal = init?.signal ?? request.signal;
+        const stream_id = new_stream_id();
+        const headers = new Headers(request.headers);
+        for (const [name, value] of Object.entries(options.pinned_headers ?? {}))
+            headers.set(name, value);
+        const body = request.method === "GET" || request.method === "HEAD" ? undefined : new Uint8Array(await request.arrayBuffer());
+        // Chunks may land before the head answers, so the listener is in place first and the stream holds them.
+        let stop_listening = () => { };
+        const stream = new ReadableStream({
+            start(controller) {
+                const finish = () => { stop_listening(); signal?.removeEventListener("abort", on_abort); };
+                const on_abort = () => {
+                    finish();
+                    void bridge.cancel?.(stream_id);
+                    try {
+                        controller.error(abort_error());
+                    }
+                    catch { /* already closed */ }
+                };
+                stop_listening = bridge.on_chunk((chunk) => {
+                    if (chunk.stream_id !== stream_id)
+                        return;
+                    if ("bytes" in chunk)
+                        controller.enqueue(chunk.bytes);
+                    else {
+                        finish();
+                        if ("error" in chunk)
+                            controller.error(new TypeError(chunk.error));
+                        else
+                            controller.close();
+                    }
+                });
+                signal?.addEventListener("abort", on_abort, { once: true });
+            },
+            cancel() {
+                stop_listening();
+                void bridge.cancel?.(stream_id);
+            },
+        });
+        try {
+            const head = await until_aborted(bridge.start({ stream_id, url: request.url, method: request.method, headers: [...headers.entries()], body }), signal);
+            const streams = !NULL_BODY_STATUSES.has(head.status) && request.method !== "HEAD";
+            if (!streams)
+                void stream.cancel();
+            return new Response(streams ? stream : null, { status: head.status, statusText: head.status_text, headers: head.headers });
+        }
+        catch (error) {
+            stop_listening();
+            throw error;
+        }
+    };
+}

package/dist/electron/window.d.ts

@@ -0,0 +1,96 @@
+export interface Rectangle {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+export interface BrowserWindowOptionsLike {
+    title: string;
+    icon?: string;
+    x?: number;
+    y?: number;
+    width: number;
+    height: number;
+    minWidth?: number;
+    minHeight?: number;
+    show: boolean;
+    backgroundColor: string;
+    titleBarStyle?: "default" | "hidden" | "hiddenInset";
+    webPreferences: {
+        preload?: string;
+        sandbox: boolean;
+        contextIsolation: boolean;
+        nodeIntegration: boolean;
+        backgroundThrottling: boolean;
+    };
+}
+export interface NavigationEventLike {
+    preventDefault(): void;
+}
+export interface BrowserWindowLike {
+    webContents: {
+        setWindowOpenHandler(handler: (details: {
+            url: string;
+        }) => {
+            action: "deny";
+        }): void;
+        on(event: "will-navigate", listener: (event: NavigationEventLike, url: string) => void): unknown;
+    };
+    on(event: string, listener: () => void): unknown;
+    once(event: string, listener: () => void): unknown;
+    show(): void;
+    maximize(): void;
+    isMaximized(): boolean;
+    getNormalBounds(): Rectangle;
+    setBackgroundColor(color: string): void;
+    loadURL(url: string): Promise<void>;
+    loadFile(path: string): Promise<void>;
+}
+export interface NativeThemeLike {
+    shouldUseDarkColors: boolean;
+    on(event: "updated", listener: () => void): unknown;
+    removeListener(event: "updated", listener: () => void): unknown;
+}
+export interface ShellLike {
+    openExternal(url: string): Promise<void>;
+}
+export interface ScreenLike {
+    getAllDisplays(): {
+        workArea: Rectangle;
+    }[];
+}
+export interface Size {
+    width: number;
+    height: number;
+}
+export interface WindowOptions {
+    title: string;
+    icon?: string;
+    preload?: string;
+    dev_url?: string;
+    file: string;
+    default_size: Size;
+    min_size?: Size;
+    state_file?: string;
+    native_theme: NativeThemeLike;
+    shell: ShellLike;
+    screen?: ScreenLike;
+    background?: {
+        light: string;
+        dark: string;
+    };
+    sandbox?: boolean;
+    background_throttling?: boolean;
+    title_bar_style?: "default" | "hidden" | "hiddenInset";
+    before_write?: (path: string) => void;
+    save_delay_ms?: number;
+}
+export interface WindowState {
+    bounds: Rectangle;
+    is_maximized: boolean;
+}
+export declare function read_window_state(state_file: string): WindowState | null;
+export declare function write_window_state(state_file: string, state: WindowState): void;
+export declare function is_external_link(url: string): boolean;
+export declare function is_app_page(url: string, options: Pick<WindowOptions, "dev_url" | "file">): boolean;
+export declare function create_window<Window extends BrowserWindowLike>(BrowserWindow: new (options: BrowserWindowOptionsLike) => Window, options: WindowOptions): Window;

package/dist/electron/window.js

@@ -0,0 +1,128 @@
+// An Electron app's main window: links and pages of other sites open in the browser, the background follows the system theme, and its size and place are remembered.
+import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname } from "node:path";
+import { pathToFileURL } from "node:url";
+const DEFAULT_BACKGROUND = { light: "#f5f6f8", dark: "#0f1115" };
+const DEFAULT_SAVE_DELAY_MS = 500;
+// ── State file ───────────────────────────────────────────────────────────────
+// A missing, unreadable or malformed file reads as no saved state.
+export function read_window_state(state_file) {
+    try {
+        const state = JSON.parse(readFileSync(state_file, "utf8"));
+        const bounds = state.bounds;
+        const is_whole = (value) => Number.isInteger(value);
+        if (!bounds || ![bounds.x, bounds.y, bounds.width, bounds.height].every(is_whole) || bounds.width <= 0 || bounds.height <= 0)
+            return null;
+        return { bounds, is_maximized: state.is_maximized === true };
+    }
+    catch {
+        return null;
+    }
+}
+// Writes beside the file and renames over it, so a crash mid-write never leaves half a file.
+export function write_window_state(state_file, state) {
+    mkdirSync(dirname(state_file), { recursive: true });
+    const temporary_file = `${state_file}.tmp`;
+    writeFileSync(temporary_file, JSON.stringify(state));
+    renameSync(temporary_file, state_file);
+}
+function overlaps(first, second) {
+    return first.x < second.x + second.width && second.x < first.x + first.width && first.y < second.y + second.height && second.y < first.y + first.height;
+}
+// ── Links ────────────────────────────────────────────────────────────────────
+const EXTERNAL_SCHEMES = new Set(["http:", "https:", "mailto:"]);
+// Only web and mail links reach the browser, never a file or another app's scheme.
+export function is_external_link(url) {
+    try {
+        return EXTERNAL_SCHEMES.has(new URL(url).protocol);
+    }
+    catch {
+        return false;
+    }
+}
+// True for the app's own pages: the dev server's origin, or files beside the built page.
+export function is_app_page(url, options) {
+    try {
+        const target = new URL(url);
+        if (options.dev_url)
+            return target.origin === new URL(options.dev_url).origin;
+        const page_folder = new URL(".", pathToFileURL(options.file)).href;
+        return target.protocol === "file:" && target.href.startsWith(page_folder);
+    }
+    catch {
+        return false;
+    }
+}
+function open_outside(shell, url) {
+    if (is_external_link(url))
+        void shell.openExternal(url);
+}
+// ── Window ───────────────────────────────────────────────────────────────────
+export function create_window(BrowserWindow, options) {
+    const background = options.background ?? DEFAULT_BACKGROUND;
+    const background_color = () => options.native_theme.shouldUseDarkColors ? background.dark : background.light;
+    const saved = options.state_file ? read_window_state(options.state_file) : null;
+    const on_a_screen = saved && (!options.screen || options.screen.getAllDisplays().some((display) => overlaps(saved.bounds, display.workArea)));
+    const size = saved?.bounds ?? options.default_size;
+    const window = new BrowserWindow({
+        title: options.title,
+        icon: options.icon,
+        ...(on_a_screen ? { x: saved.bounds.x, y: saved.bounds.y } : {}),
+        width: size.width,
+        height: size.height,
+        minWidth: options.min_size?.width,
+        minHeight: options.min_size?.height,
+        show: false,
+        backgroundColor: background_color(),
+        ...(options.title_bar_style ? { titleBarStyle: options.title_bar_style } : {}),
+        webPreferences: { preload: options.preload, sandbox: options.sandbox ?? false, contextIsolation: true, nodeIntegration: false, backgroundThrottling: options.background_throttling ?? true },
+    });
+    window.once("ready-to-show", () => {
+        if (saved?.is_maximized)
+            window.maximize();
+        window.show();
+    });
+    window.webContents.setWindowOpenHandler(({ url }) => {
+        open_outside(options.shell, url);
+        return { action: "deny" };
+    });
+    // A link that would load another site in the window opens in the browser instead.
+    window.webContents.on("will-navigate", (event, url) => {
+        if (is_app_page(url, options))
+            return;
+        event.preventDefault();
+        open_outside(options.shell, url);
+    });
+    const follow_theme = () => window.setBackgroundColor(background_color());
+    options.native_theme.on("updated", follow_theme);
+    window.on("closed", () => options.native_theme.removeListener("updated", follow_theme));
+    if (options.state_file)
+        remember_state(window, options.state_file, options.save_delay_ms ?? DEFAULT_SAVE_DELAY_MS, options.before_write);
+    if (options.dev_url)
+        void window.loadURL(options.dev_url);
+    else
+        void window.loadFile(options.file);
+    return window;
+}
+// Saves a moment after the last move or resize, and at once when the window closes.
+function remember_state(window, state_file, save_delay_ms, before_write) {
+    let timer;
+    const save_now = () => {
+        clearTimeout(timer);
+        timer = undefined;
+        try {
+            before_write?.(state_file);
+            write_window_state(state_file, { bounds: window.getNormalBounds(), is_maximized: window.isMaximized() });
+        }
+        catch {
+            // A refused or failed save keeps the last one, and the window carries on.
+        }
+    };
+    const save_soon = () => {
+        clearTimeout(timer);
+        timer = setTimeout(save_now, save_delay_ms);
+    };
+    for (const event of ["resize", "move", "maximize", "unmaximize"])
+        window.on(event, save_soon);
+    window.on("close", save_now);
+}

package/dist/log.d.ts

@@ -0,0 +1,30 @@
+export type Level = "critical" | "error" | "warn" | "info" | "debug";
+export declare const levels: Level[];
+export declare const default_level: Level;
+export interface LevelSpec {
+    default: Level;
+    scopes: Record<string, Level>;
+}
+export declare function parse_level_spec(spec: string | undefined, fallback?: Level): LevelSpec;
+export declare function level_for(spec: LevelSpec, scope: string): Level;
+export declare function is_enabled(spec: LevelSpec, scope: string, level: Level): boolean;
+export interface LogRecord {
+    at: number;
+    level: Level;
+    scope: string;
+    message: string;
+    data?: unknown;
+}
+export type LogSink = (record: LogRecord) => void;
+export declare function format_record(record: LogRecord): string;
+export interface Logger {
+    critical(message: string, data?: unknown): void;
+    error(message: string, data?: unknown): void;
+    warn(message: string, data?: unknown): void;
+    info(message: string, data?: unknown): void;
+    debug(message: string, data?: unknown): void;
+    enabled(level: Level): boolean;
+    child(scope: string): Logger;
+}
+export type SpecSource = LevelSpec | (() => LevelSpec);
+export declare function create_logger(scope: string, spec: SpecSource, sink: LogSink): Logger;