@kamilio/wire 0.1.9 → 0.1.10

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/render-performance.d.ts

@@ -0,0 +1,33 @@
+export interface RenderPercentiles {
+    p50: number;
+    p95: number;
+    max: number;
+}
+export interface RenderPerformanceSnapshot {
+    /** Rolling one-second repaint dispatch rate, with 10ms bucket resolution. */
+    fps: number;
+    frames: number;
+    renders: number;
+    requests: number;
+    coalesced: number;
+    changedCells: number;
+    sampleCount: number;
+    /** Paints exceeding the 60Hz frame budget (16.67ms), cumulative. */
+    slowFrames: number;
+    longestRenderMs: number;
+    renderMs: RenderPercentiles;
+    /** Time from oldest pending input to flush enqueue; terminal presentation is not observable. */
+    inputMs: RenderPercentiles;
+}
+export declare function createRenderPerformanceMonitor(options?: {
+    now?: () => number;
+    sampleSize?: number;
+}): {
+    request(kind: "input" | "update" | "resize"): void;
+    begin(): number;
+    end(startedAt: number, frame: {
+        changedCells: number;
+    }): void;
+    snapshot(): RenderPerformanceSnapshot;
+};
+export declare function formatRenderPerformance(stats: RenderPerformanceSnapshot, width: number): string;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/render-performance.js

@@ -0,0 +1,71 @@
+import { fitToWidth } from "./explorer/render/text.js";
+export function createRenderPerformanceMonitor(options = {}) {
+    const now = options.now ?? (() => performance.now());
+    const capacity = options.sampleSize ?? 256;
+    if (!Number.isInteger(capacity) || capacity < 1 || capacity > 4096)
+        throw new Error("sampleSize must be an integer between 1 and 4096");
+    const durations = new Float64Array(capacity);
+    const inputs = new Float64Array(capacity);
+    const buckets = new Float64Array(101).fill(-Infinity);
+    const counts = new Uint32Array(101);
+    let renders = 0, frames = 0, requests = 0, pending = 0, coalesced = 0, changedCells = 0;
+    let inputCount = 0;
+    let slowFrames = 0, longestRenderMs = 0;
+    let firstInput;
+    return {
+        request(kind) {
+            requests++;
+            pending++;
+            if (kind === "input")
+                firstInput ??= now();
+        },
+        begin() { return now(); },
+        end(startedAt, frame) {
+            const finished = now();
+            const duration = Math.max(0, finished - startedAt);
+            durations[renders % capacity] = duration;
+            longestRenderMs = Math.max(longestRenderMs, duration);
+            if (frame.changedCells > 0 && duration > 1000 / 60)
+                slowFrames++;
+            renders++;
+            coalesced += Math.max(0, pending - 1);
+            pending = 0;
+            if (firstInput !== undefined) {
+                inputs[inputCount++ % capacity] = Math.max(0, finished - firstInput);
+                firstInput = undefined;
+            }
+            if (frame.changedCells > 0) {
+                frames++;
+                changedCells += frame.changedCells;
+                const bucket = Math.floor(finished / 10);
+                const index = bucket % buckets.length;
+                if (buckets[index] !== bucket) {
+                    buckets[index] = bucket;
+                    counts[index] = 0;
+                }
+                counts[index] = counts[index] + 1;
+            }
+        },
+        snapshot() {
+            const time = now();
+            let fps = 0;
+            for (let index = 0; index < buckets.length; index++) {
+                if (buckets[index] * 10 >= time - 1000 && buckets[index] * 10 <= time)
+                    fps += counts[index];
+            }
+            return { fps, frames, renders, requests, coalesced, changedCells, slowFrames, longestRenderMs,
+                sampleCount: Math.min(renders, capacity), renderMs: percentiles(durations, Math.min(renders, capacity)),
+                inputMs: percentiles(inputs, Math.min(inputCount, capacity)) };
+        }
+    };
+}
+function percentiles(samples, count) {
+    if (count === 0)
+        return { p50: 0, p95: 0, max: 0 };
+    const sorted = samples.slice(0, count).sort();
+    return { p50: sorted[Math.ceil(count * .5) - 1], p95: sorted[Math.ceil(count * .95) - 1], max: sorted[count - 1] };
+}
+export function formatRenderPerformance(stats, width) {
+    const value = `FPS ${stats.fps} · paint p95 ${stats.renderMs.p95.toFixed(1)}ms · input p95 ${stats.inputMs.p95.toFixed(1)}ms · slow ${stats.slowFrames} · merged ${stats.coalesced}`;
+    return fitToWidth(value, width);
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/screen/ansi-text.d.ts

@@ -0,0 +1,2 @@
+import type { Cell } from "./screen.js";
+export declare function ansiToCells(text: string): Cell[];

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/screen/ansi-text.js

@@ -0,0 +1,35 @@
+import { parseAnsi } from "../dashboard/ansi.js";
+import { graphemes, graphemeWidth } from "../dashboard/terminal-width.js";
+import { packStyle } from "./style.js";
+const COLORS = new Map([
+    ["black", 1], ["red", 1], ["green", 2], ["yellow", 3], ["blue", 4],
+    ["magenta", 5], ["cyan", 6], ["white", 7], ["gray", 8]
+]);
+export function ansiToCells(text) {
+    const output = [];
+    const lines = parseAnsi(text);
+    for (let lineIndex = 0; lineIndex < lines.length; lineIndex += 1) {
+        if (lineIndex > 0)
+            output.push(cell("\n", 1, 0));
+        for (const segment of lines[lineIndex].segments) {
+            const style = packed(segment.style);
+            for (const grapheme of graphemes(segment.text))
+                output.push(cell(grapheme, graphemeWidth(grapheme) > 1 ? 2 : 1, style));
+        }
+    }
+    return output;
+}
+function packed(style) {
+    return packStyle({
+        bold: style.bold,
+        dim: style.dim,
+        underline: style.underline,
+        inverse: style.inverse,
+        fg: colorNumber(style.fg),
+        bg: colorNumber(style.bg)
+    });
+}
+function colorNumber(value) { return value === undefined ? 0 : (COLORS.get(value) ?? 0); }
+function cell(ch, width, style) {
+    return { ch, width, style, fg: (style >> 8) & 0xff, bg: (style >> 16) & 0xff };
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/screen/screen.d.ts

@@ -0,0 +1,40 @@
+import type { CellStyle, Rect } from "../dashboard/types.js";
+import { type PackedStyle } from "./style.js";
+export interface Cell {
+    ch: string;
+    width: 1 | 2;
+    style: PackedStyle;
+    fg: number;
+    bg: number;
+}
+export interface ScreenSize {
+    cols: number;
+    rows: number;
+}
+export interface ScreenSurface {
+    readonly width: number;
+    readonly height: number;
+    put(x: number, y: number, text: string, style?: CellStyle | PackedStyle): void;
+    clearRect(rect: Rect, style?: CellStyle | PackedStyle): void;
+}
+export declare class Screen {
+    private cols;
+    private rows;
+    private front;
+    private back;
+    private outputStyle;
+    private readonly colors;
+    constructor(size?: ScreenSize, options?: {
+        colors?: boolean;
+    });
+    get width(): number;
+    get height(): number;
+    resize(size: ScreenSize): void;
+    cell(x: number, y: number, ch: string, style?: PackedStyle): void;
+    text(x: number, y: number, text: string, style?: PackedStyle): void;
+    put(x: number, y: number, text: string, style?: CellStyle | PackedStyle): void;
+    clearRect(rect: Rect, style?: CellStyle | PackedStyle): void;
+    flush(): string;
+    private index;
+    private inBounds;
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/screen/screen.js

@@ -0,0 +1,122 @@
+import { graphemes, graphemeWidth } from "../dashboard/terminal-width.js";
+import { background, foreground, styleToSgrDelta } from "./style.js";
+const EMPTY = { ch: " ", width: 1, style: 0, fg: 0, bg: 0 };
+export class Screen {
+    cols = 0;
+    rows = 0;
+    front = [];
+    back = [];
+    outputStyle = 0;
+    colors;
+    constructor(size = { cols: 0, rows: 0 }, options = {}) {
+        this.colors = options.colors ?? (process.env.NO_COLOR === undefined && process.env.TERM !== "dumb");
+        this.resize(size);
+    }
+    get width() { return this.cols; }
+    get height() { return this.rows; }
+    resize(size) {
+        this.cols = normalize(size.cols);
+        this.rows = normalize(size.rows);
+        this.front = cells(this.cols * this.rows);
+        this.back = cells(this.cols * this.rows);
+    }
+    cell(x, y, ch, style = 0) {
+        if (!this.inBounds(x, y) || ch.length === 0)
+            return;
+        const segment = graphemes(ch)[0];
+        if (segment === undefined)
+            return;
+        const measured = graphemeWidth(segment);
+        const width = measured > 1 ? 2 : 1;
+        this.back[this.index(x, y)] = makeCell(segment, width, style);
+        if (width === 2 && this.inBounds(x + 1, y))
+            this.back[this.index(x + 1, y)] = makeCell("", 1, style);
+    }
+    text(x, y, text, style = 0) {
+        let offset = 0;
+        for (const segment of graphemes(text)) {
+            const width = Math.max(0, graphemeWidth(segment));
+            if (width > 0)
+                this.cell(x + offset, y, segment, style);
+            offset += width;
+        }
+    }
+    put(x, y, text, style = 0) {
+        this.text(x, y, text, typeof style === "number" ? style : packLegacyStyle(style));
+    }
+    clearRect(rect, style = 0) {
+        const packed = typeof style === "number" ? style : packLegacyStyle(style);
+        const startX = Math.max(0, rect.x);
+        const startY = Math.max(0, rect.y);
+        const endX = Math.min(this.cols, rect.x + Math.max(0, rect.width));
+        const endY = Math.min(this.rows, rect.y + Math.max(0, rect.height));
+        for (let y = startY; y < endY; y += 1)
+            for (let x = startX; x < endX; x += 1)
+                this.cell(x, y, " ", packed);
+    }
+    flush() {
+        const changed = new Set();
+        for (let index = 0; index < this.back.length; index += 1) {
+            if (!equal(this.front[index], this.back[index])) {
+                changed.add(index);
+                const old = this.front[index];
+                const next = this.back[index];
+                if ((old.width === 2 || next.width === 2) && (index % this.cols) + 1 < this.cols)
+                    changed.add(index + 1);
+                if (old.ch === "" && index % this.cols > 0)
+                    changed.add(index - 1);
+            }
+        }
+        let output = "";
+        let currentStyle = this.outputStyle;
+        const ordered = [...changed].sort((left, right) => left - right);
+        let cursor = 0;
+        while (cursor < ordered.length) {
+            const start = ordered[cursor];
+            const y = Math.floor(start / this.cols);
+            let end = start;
+            while (cursor + 1 < ordered.length && ordered[cursor + 1] === end + 1 && Math.floor(ordered[cursor + 1] / this.cols) === y) {
+                cursor += 1;
+                end += 1;
+            }
+            output += `\u001b[${y + 1};${(start % this.cols) + 1}H`;
+            for (let index = start; index <= end; index += 1) {
+                const cell = this.back[index];
+                const delta = styleToSgrDelta(currentStyle, cell.style, this.colors);
+                output += delta;
+                currentStyle = cell.style;
+                output += cell.ch.length === 0 ? "" : cell.ch;
+            }
+            cursor += 1;
+        }
+        this.front = this.back;
+        this.back = cells(this.cols * this.rows);
+        this.outputStyle = currentStyle;
+        return output;
+    }
+    index(x, y) { return y * this.cols + x; }
+    inBounds(x, y) { return x >= 0 && y >= 0 && x < this.cols && y < this.rows; }
+}
+function makeCell(ch, width, style) {
+    return { ch, width, style, fg: foreground(style), bg: background(style) };
+}
+function cells(length) { return Array.from({ length }, () => ({ ...EMPTY })); }
+function equal(left, right) { return left.ch === right.ch && left.width === right.width && left.style === right.style; }
+function normalize(value) { return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0; }
+function packLegacyStyle(style) {
+    return (style.bold ? 1 : 0)
+        | (style.dim ? 2 : 0)
+        | (style.underline ? 4 : 0)
+        | (style.inverse ? 8 : 0)
+        | (legacyColor(style.fg) << 8)
+        | (legacyColor(style.bg) << 16);
+}
+function legacyColor(value) {
+    if (value === undefined)
+        return 0;
+    const names = ["", "red", "green", "yellow", "blue", "magenta", "cyan", "white", "gray"];
+    const exact = names.indexOf(value);
+    if (exact >= 0)
+        return exact;
+    return value.startsWith("#") ? 7 : 0;
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/screen/style.d.ts

@@ -0,0 +1,16 @@
+export declare const STYLE_BOLD: number;
+export declare const STYLE_DIM: number;
+export declare const STYLE_UNDERLINE: number;
+export declare const STYLE_INVERSE: number;
+export type PackedStyle = number;
+export declare function packStyle(style: {
+    bold?: boolean;
+    dim?: boolean;
+    underline?: boolean;
+    inverse?: boolean;
+    fg?: number;
+    bg?: number;
+}): PackedStyle;
+export declare function foreground(style: PackedStyle): number;
+export declare function background(style: PackedStyle): number;
+export declare function styleToSgrDelta(previous: PackedStyle, next: PackedStyle, colors?: boolean): string;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/screen/style.js

@@ -0,0 +1,55 @@
+export const STYLE_BOLD = 1 << 0;
+export const STYLE_DIM = 1 << 1;
+export const STYLE_UNDERLINE = 1 << 2;
+export const STYLE_INVERSE = 1 << 3;
+const FG_SHIFT = 8;
+const BG_SHIFT = 16;
+const COLOR_MASK = 0xff;
+export function packStyle(style) {
+    let packed = 0;
+    if (style.bold)
+        packed |= STYLE_BOLD;
+    if (style.dim)
+        packed |= STYLE_DIM;
+    if (style.underline)
+        packed |= STYLE_UNDERLINE;
+    if (style.inverse)
+        packed |= STYLE_INVERSE;
+    packed |= ((style.fg ?? 0) & COLOR_MASK) << FG_SHIFT;
+    packed |= ((style.bg ?? 0) & COLOR_MASK) << BG_SHIFT;
+    return packed;
+}
+export function foreground(style) { return (style >> FG_SHIFT) & COLOR_MASK; }
+export function background(style) { return (style >> BG_SHIFT) & COLOR_MASK; }
+export function styleToSgrDelta(previous, next, colors = process.env.NO_COLOR === undefined && process.env.TERM !== "dumb") {
+    if (!colors)
+        return "";
+    if (previous === next)
+        return "";
+    const codes = [];
+    const previousIntensity = previous & (STYLE_BOLD | STYLE_DIM);
+    const nextIntensity = next & (STYLE_BOLD | STYLE_DIM);
+    if (previousIntensity !== nextIntensity) {
+        if ((previousIntensity & ~nextIntensity) !== 0)
+            codes.push(22);
+        if ((nextIntensity & STYLE_BOLD) !== 0 && ((previousIntensity & ~nextIntensity) !== 0 || (previousIntensity & STYLE_BOLD) === 0))
+            codes.push(1);
+        if ((nextIntensity & STYLE_DIM) !== 0 && ((previousIntensity & ~nextIntensity) !== 0 || (previousIntensity & STYLE_DIM) === 0))
+            codes.push(2);
+    }
+    flagDelta(codes, previous, next, STYLE_UNDERLINE, 4, 24);
+    flagDelta(codes, previous, next, STYLE_INVERSE, 7, 27);
+    const previousFg = foreground(previous);
+    const nextFg = foreground(next);
+    if (previousFg !== nextFg)
+        codes.push(nextFg === 0 ? 39 : 30 + nextFg);
+    const previousBg = background(previous);
+    const nextBg = background(next);
+    if (previousBg !== nextBg)
+        codes.push(nextBg === 0 ? 49 : 40 + nextBg);
+    return codes.length === 0 ? "" : `\u001b[${[...new Set(codes)].join(";")}m`;
+}
+function flagDelta(codes, previous, next, flag, on, off) {
+    if ((previous & flag) !== (next & flag))
+        codes.push((next & flag) === 0 ? off : on);
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/task-tree.d.ts

@@ -0,0 +1,22 @@
+export interface TaskNode {
+    id: string;
+    parentId?: string;
+    label: string;
+    status: "pending" | "running" | "success" | "error";
+    durationMs?: number;
+}
+export declare function createTaskTree({ capacity }?: {
+    capacity?: number;
+}): {
+    upsert(node: TaskNode): void;
+    remove(id: string): void;
+    toggle(id: string): void;
+    rows(offset: number, height: number): (TaskNode & {
+        depth: number;
+        collapsed: boolean;
+    })[];
+};
+export declare function renderTaskRows(rows: readonly (TaskNode & {
+    depth: number;
+    collapsed: boolean;
+})[], width: number): string[];

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/task-tree.js

@@ -0,0 +1,79 @@
+import { plainTerminalText } from "./dashboard/ansi.js";
+import { fitToWidth } from "./explorer/render/text.js";
+export function createTaskTree({ capacity = 10000 } = {}) {
+    if (!Number.isInteger(capacity) || capacity < 1)
+        throw new RangeError("positive capacity required");
+    const nodes = new Map();
+    const children = new Map();
+    const collapsed = new Set();
+    return {
+        upsert(node) {
+            if (!nodes.has(node.id) && nodes.size >= capacity)
+                throw new RangeError("Task capacity exceeded");
+            let parent = node.parentId;
+            const seen = new Set([node.id]);
+            while (parent !== undefined) {
+                if (seen.has(parent))
+                    throw new Error("Task cycle");
+                seen.add(parent);
+                parent = nodes.get(parent)?.parentId;
+            }
+            const previous = nodes.get(node.id);
+            if (previous)
+                children.get(previous.parentId)?.delete(node.id);
+            nodes.set(node.id, { ...node });
+            let siblings = children.get(node.parentId);
+            if (!siblings) {
+                siblings = new Set();
+                children.set(node.parentId, siblings);
+            }
+            siblings.add(node.id);
+        },
+        remove(id) {
+            const node = nodes.get(id);
+            if (!node)
+                return;
+            children.get(node.parentId)?.delete(id);
+            const pending = [id];
+            while (pending.length) {
+                const current = pending.pop();
+                for (const child of children.get(current) ?? [])
+                    pending.push(child);
+                children.delete(current);
+                nodes.delete(current);
+                collapsed.delete(current);
+            }
+        },
+        toggle(id) { if (collapsed.has(id))
+            collapsed.delete(id);
+        else
+            collapsed.add(id); },
+        rows(offset, height) {
+            const result = [];
+            const stack = [{ iterator: (children.get(undefined) ?? new Set()).values(), depth: 0 }];
+            let index = 0;
+            while (stack.length && result.length < height) {
+                const frame = stack[stack.length - 1];
+                const next = frame.iterator.next();
+                if (next.done) {
+                    stack.pop();
+                    continue;
+                }
+                const node = nodes.get(next.value);
+                if (index++ >= offset)
+                    result.push({ ...node, depth: frame.depth, collapsed: collapsed.has(node.id) });
+                if (!collapsed.has(node.id) && children.has(node.id))
+                    stack.push({ iterator: children.get(node.id).values(), depth: frame.depth + 1 });
+            }
+            return result;
+        }
+    };
+}
+export function renderTaskRows(rows, width) {
+    const markers = { pending: "○", running: "●", success: "✓", error: "■" };
+    return rows.map(row => {
+        const indent = " ".repeat(Math.min(Math.max(0, width), Math.max(0, row.depth) * 2));
+        const duration = row.durationMs !== undefined && Number.isFinite(row.durationMs) ? ` · ${Math.max(0, Math.round(row.durationMs))}ms` : "";
+        return fitToWidth(`${indent}${row.collapsed ? "▸" : "▾"} ${markers[row.status]} ${plainTerminalText(row.label)}${duration}`, width);
+    });
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal/driver.d.ts

@@ -0,0 +1,34 @@
+import { type TerminalInputEvent } from "./input.js";
+export interface Size {
+    cols: number;
+    rows: number;
+}
+export interface TerminalDriver {
+    start(): void;
+    stop(): void;
+    onEvent(fn: (event: TerminalInputEvent) => void): () => void;
+    onResize(fn: (size: Size) => void): () => void;
+    getSize(): Size;
+    writeFrame(ansi: string): void;
+}
+interface InputStream {
+    setRawMode?: (enabled: boolean) => void;
+    resume(): void;
+    pause(): void;
+    on(event: "data", listener: (chunk: Buffer | string) => void): unknown;
+    off(event: "data", listener: (chunk: Buffer | string) => void): unknown;
+}
+interface OutputStream {
+    columns?: number;
+    rows?: number;
+    write(value: string): boolean;
+    on(event: "resize", listener: () => void): unknown;
+    off(event: "resize", listener: () => void): unknown;
+}
+export declare function createTerminalDriver(options?: {
+    input?: InputStream;
+    output?: OutputStream;
+    escTimeoutMs?: number;
+    mouse?: boolean;
+}): TerminalDriver;
+export type { TerminalInputEvent } from "./input.js";

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal/driver.js

@@ -0,0 +1,65 @@
+import { createInputParser } from "./input.js";
+import { createFrameWriter } from "./output.js";
+export function createTerminalDriver(options = {}) {
+    const input = options.input ?? process.stdin;
+    const output = options.output ?? process.stdout;
+    const eventListeners = new Set();
+    const resizeListeners = new Set();
+    const emit = (event) => {
+        for (const listener of eventListeners)
+            listener(event);
+    };
+    const parser = createInputParser({ escTimeoutMs: options.escTimeoutMs, onEvent: emit });
+    const writer = createFrameWriter(output, { mouse: options.mouse });
+    let started = false;
+    const onData = (chunk) => {
+        for (const event of parser.feed(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk)))
+            emit(event);
+    };
+    const getSize = () => ({ cols: dimension(output.columns), rows: dimension(output.rows) });
+    const onTerminalResize = () => {
+        const size = getSize();
+        for (const listener of resizeListeners)
+            listener(size);
+    };
+    return {
+        start() {
+            if (started)
+                return;
+            started = true;
+            input.setRawMode?.(true);
+            input.resume();
+            input.on("data", onData);
+            output.on("resize", onTerminalResize);
+            writer.open();
+        },
+        stop() {
+            if (!started)
+                return;
+            started = false;
+            input.off("data", onData);
+            output.off("resize", onTerminalResize);
+            parser.destroy();
+            writer.close();
+            input.setRawMode?.(false);
+            input.pause();
+        },
+        onEvent(fn) {
+            eventListeners.add(fn);
+            return () => {
+                eventListeners.delete(fn);
+            };
+        },
+        onResize(fn) {
+            resizeListeners.add(fn);
+            return () => {
+                resizeListeners.delete(fn);
+            };
+        },
+        getSize,
+        writeFrame: writer.writeFrame
+    };
+}
+function dimension(value) {
+    return Number.isFinite(value) ? Math.max(0, Math.floor(value)) : 0;
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/terminal/input.d.ts

@@ -0,0 +1,25 @@
+export type TerminalInputEvent = {
+    type: "key";
+    name: string;
+    ch?: string;
+    ctrl: boolean;
+    alt: boolean;
+    shift: boolean;
+} | {
+    type: "paste";
+    text: string;
+} | {
+    type: "wheel";
+    direction: "up" | "down";
+    x: number;
+    y: number;
+};
+export interface InputParser {
+    feed(chunk: Buffer): TerminalInputEvent[];
+    flush(): TerminalInputEvent[];
+    destroy(): void;
+}
+export declare function createInputParser(options?: {
+    escTimeoutMs?: number;
+    onEvent?: (event: TerminalInputEvent) => void;
+}): InputParser;