@easbot/utils 0.1.7 → 0.1.12

package/dist/index.d.cts

@@ -1,6 +1,27 @@
 import z, { z as z$1 } from 'zod';
+export { z } from 'zod';
+import * as fs from 'fs';
 import { statSync } from 'fs';
+import * as stream from 'stream';
 import { Readable } from 'stream';
+import * as _hono_node_ws from '@hono/node-ws';
+export { createNodeWebSocket } from '@hono/node-ws';
+import { Context as Context$1, Next, Hono } from 'hono';
+export { Hono, Next } from 'hono';
+import { ServerType } from '@hono/node-server';
+import { cors } from 'hono/cors';
+export { cors } from 'hono/cors';
+import { ChildProcess } from 'node:child_process';
+import { EasbotShell, ShellExpression, EasbotShellPromise } from '@easbot/types';
+export { HTTPException } from 'hono/http-exception';
+export { SSEStreamingApi } from 'hono/streaming';
+export { WebSocket as WSContext } from 'ws';
+export { compress } from 'hono/compress';
+export { logger } from 'hono/logger';
+export { secureHeaders } from 'hono/secure-headers';
+export { timeout } from 'hono/timeout';
+export { validator } from 'hono/validator';
+export { zValidator } from '@hono/zod-validator';
 
 declare function findLast<T>(items: readonly T[], predicate: (item: T, index: number, items: readonly T[]) => boolean): T | undefined;
 
@@ -12,10 +33,48 @@ declare namespace Binary {
     function insert<T>(array: T[], item: T, compare: (item: T) => string): T[];
 }
 
-declare function base64Encode(value: string): string;
-declare function base64Decode(value: string): string;
-declare function hash(content: string, algorithm?: string): Promise<string>;
-declare function checksum(content: string): string | undefined;
+declare namespace Encode {
+    function base64Encode(value: string): string;
+    function base64Decode(value: string): string;
+    function hash(content: string, algorithm?: string): Promise<string>;
+    function checksum(content: string): string | undefined;
+    function sampledChecksum(content: string, limit?: number): string | undefined;
+}
+
+declare namespace TruncateContent {
+    const DIR: string;
+    const DEFAULT_MAX_CHARS = 4000;
+    const DIRECTION: "head";
+    type Result = {
+        content: string;
+        truncated: false;
+    } | {
+        content: string;
+        truncated: true;
+        outputPath: string;
+        originalLength: number;
+        removedLength: number;
+        label: string;
+    };
+    interface Options {
+        maxChars?: number;
+        direction?: 'head' | 'tail';
+        label?: string;
+        dir?: string;
+        sourcePath?: string;
+    }
+    function truncate(content: string, options?: Options): Result;
+    function truncateAndSave(content: string, options?: Options): Promise<Result>;
+    function formatHint(result: Result): string;
+}
+
+declare function formatLocalISO(date: Date | number, includeMilliseconds?: boolean): string;
+declare function formatLocalISOCompact(date: Date | number): string;
+declare function now(): number;
+declare function nowLocalISO(includeMilliseconds?: boolean): string;
+declare function parseLocalISO(isoString: string): Date;
+declare function formatLogTime(date: Date | number): string;
+declare function getTimezoneOffset(date?: Date): string;
 
 declare abstract class NamedError extends Error {
     abstract schema(): z.core.$ZodType;
@@ -208,7 +267,11 @@ declare namespace Filesystem {
     function writeJson(p: string, data: unknown, mode?: number): Promise<void>;
     function writeStream(p: string, stream: ReadableStream<Uint8Array> | Readable, mode?: number): Promise<void>;
     function mimeType(p: string): string;
-    function normalizePath(p: string): string;
+    function toUnixPath(p: string): string;
+    function normalize(p: string): string;
+    const normalizePath: typeof normalize;
+    function resolve(p: string): string;
+    function windowsPath(p: string): string;
     function overlaps(a: string, b: string): boolean;
     function contains(parent: string, child: string): boolean;
     function findUp(target: string, start: string, stop?: string): Promise<string[]>;
@@ -216,15 +279,22 @@ declare namespace Filesystem {
         targets: string[];
         start: string;
         stop?: string;
-    }): AsyncGenerator<string, void, unknown>;
+    }): AsyncGenerator<string>;
     function globUp(pattern: string, start: string, stop?: string): Promise<string[]>;
 }
 
-declare function fn<T extends z$1.ZodType, Result>(schema: T, cb: (input: z$1.infer<T>) => Result): {
+declare function createFn<T extends z$1.ZodType, Result>(schema: T, cb: (input: z$1.infer<T>) => Result): {
     (input: z$1.infer<T>): Result;
     force(input: z$1.infer<T>): Result;
     schema: T;
 };
+declare const fn: typeof createFn;
+type Fn = typeof createFn;
+declare namespace Fn {
+    const fn: typeof createFn;
+}
+
+declare function loadEnv(): void;
 
 declare namespace Identifier {
     function ascending(): string;
@@ -232,8 +302,19 @@ declare namespace Identifier {
     function create(descending: boolean, timestamp?: number): string;
 }
 
+interface GitResult {
+    exitCode: number;
+    text(): string | Promise<string>;
+    stdout: any;
+    stderr: any;
+}
+declare function git(args: string[], opts: {
+    cwd: string;
+    env?: Record<string, string>;
+}): Promise<GitResult>;
+
 declare function loadTextFile(relativePath: string, importMetaUrl?: string): {
-    (): Promise<string>;
+    (): string;
     reset(): void;
 };
 declare function loadTextFileAsync(relativePath: string, importMetaUrl?: string): {
@@ -243,10 +324,26 @@ declare function loadTextFileAsync(relativePath: string, importMetaUrl?: string)
 
 declare function iife<T>(fn: () => T): T;
 
-declare function lazy<T>(fn: () => T): {
+declare function parseModelId(modelId: string): {
+    provider: string;
+    model: string;
+};
+
+declare function createLazy<T>(fn: () => T): {
     (): T;
     reset(): void;
 };
+declare const lazy: typeof createLazy;
+declare function createLazyAsync<T>(fn: () => Promise<T>): {
+    (): Promise<T>;
+    reset(): void;
+};
+declare const lazyAsync: typeof createLazyAsync;
+type Lazy = typeof createLazy;
+declare namespace Lazy {
+    const lazy: typeof createLazy;
+    const lazyAsync: typeof createLazyAsync;
+}
 
 declare const MarkdownStyleSchema: z$1.ZodEnum<{
     bold: "bold";
@@ -343,8 +440,8 @@ declare const FormatOptionsSchema: z$1.ZodObject<{
     indentSize: z$1.ZodDefault<z$1.ZodNumber>;
     listMarker: z$1.ZodDefault<z$1.ZodEnum<{
         "-": "-";
-        "\u2022": "•";
         "*": "*";
+        "\u2022": "•";
     }>>;
     codeBlockMarker: z$1.ZodDefault<z$1.ZodEnum<{
         "```": "```";
@@ -465,4 +562,745 @@ declare namespace Slug {
     function create(): string;
 }
 
-export { Binary, type CodeSpanIndex$1 as CodeSpanIndex, type FenceSpan$1 as FenceSpan, Filesystem, type FormatOptions, Identifier, type InlineCodeState$1 as InlineCodeState, Markdown, type MarkdownConfig, type MarkdownIR, type MarkdownLinkSpan, type MarkdownParseOptions, type MarkdownStyle, type MarkdownStyleSpan, type MarkdownTableMode, NamedError, type ParsedFrontmatter, type RenderLink, type RenderOptions, Slug, type StyleMarker, base64Decode, base64Encode, buildCodeSpanIndex, checksum, chunkMarkdownIR, chunkText, chunkTextByBreakResolver, convertMarkdownTables, createInlineCodeState, extractFrontmatter, findFenceSpanAt, findLast, fn, formatMarkdown, getDirectory, getFileExtension, getFilename, getFilenameTruncated, hash, iife, isSafeFenceBreak, lazy, loadTextFile, loadTextFileAsync, markdownToIR, markdownToIRWithMeta, parseFenceSpans, parseFrontmatterBlock, renderMarkdown, renderMarkdownWithMarkers, retry, scanParenAwareBreakpoints, serializeFrontmatter, truncateMiddle };
+type BunBuildTarget = 'bun-darwin-x64' | 'bun-darwin-x64-baseline' | 'bun-darwin-arm64' | 'bun-linux-x64' | 'bun-linux-x64-baseline' | 'bun-linux-x64-modern' | 'bun-linux-arm64' | 'bun-linux-x64-musl' | 'bun-linux-arm64-musl' | 'bun-windows-x64' | 'bun-windows-x64-baseline' | 'bun-windows-x64-modern';
+interface BunCompileOptions {
+    target?: BunBuildTarget | string;
+    outfile?: string;
+    execArgv?: string[];
+    autoloadTsconfig?: boolean;
+    autoloadPackageJson?: boolean;
+    autoloadDotenv?: boolean;
+    autoloadBunfig?: boolean;
+    windows?: {
+        icon?: string;
+        hideConsole?: boolean;
+        title?: string;
+        publisher?: string;
+        version?: string;
+        description?: string;
+        copyright?: string;
+    };
+    codesign?: {
+        identity?: string;
+    };
+}
+interface BunBuildOptions {
+    entrypoints: string[];
+    outdir?: string;
+    target?: 'browser' | 'node' | 'bun';
+    minify?: boolean;
+    sourcemap?: 'inline' | 'external' | 'none' | 'linked';
+    splitting?: boolean;
+    plugins?: any[];
+    define?: Record<string, string>;
+    conditions?: string[];
+    tsconfig?: string;
+    external?: string[];
+    format?: 'esm' | 'cjs' | 'iife';
+    platform?: 'browser' | 'node' | 'neutral';
+    bundle?: boolean;
+    compile?: boolean | BunBuildTarget | BunCompileOptions;
+    bytecode?: boolean;
+    assets?: string[];
+    loader?: Record<string, string>;
+    write?: boolean;
+    entryNames?: string;
+    chunkNames?: string;
+    assetNames?: string;
+    publicPath?: string;
+    paths?: Record<string, string[]>;
+    inject?: string[];
+}
+interface BunBuildOutput {
+    path: string;
+    size: number;
+}
+interface BunBuildLog {
+    level: 'error' | 'warning' | 'info';
+    message: string;
+    path?: string;
+    position?: {
+        line: number;
+        column: number;
+    };
+}
+interface BunBuildResult {
+    outputs: BunBuildOutput[];
+    success: boolean;
+    logs: BunBuildLog[];
+    metafile?: any;
+}
+declare function build(options: BunBuildOptions): Promise<BunBuildResult>;
+
+interface WebSocketHandler {
+    onMessage?: (event: MessageEvent, ws: any) => void | Promise<void>;
+    onClose?: (event: CloseEvent, ws: any) => void | Promise<void>;
+    onError?: (event: Event, ws: any) => void | Promise<void>;
+    onOpen?: (event: Event, ws: any) => void | Promise<void>;
+}
+type StreamHandler = (stream: ReadableStream) => Response | Promise<Response>;
+type SSEHandler = (c: Context$1) => AsyncGenerator<{
+    data: string;
+    event?: string;
+    id?: string;
+}, void, unknown>;
+type RPCMethod<T = unknown> = (params: T, c: Context$1) => unknown | Promise<unknown>;
+interface ServerOptions {
+    port?: number;
+    hostname?: string;
+    fetch?: (req: Request) => Response | Promise<Response>;
+    routes?: RouteDefinition[];
+    middlewares?: MiddlewareDefinition[];
+    websockets?: WebSocketRouteDefinition[];
+    rpc?: Record<string, RPCMethod>;
+    streaming?: boolean;
+    compression?: boolean;
+    cors?: boolean | Parameters<typeof cors>[0];
+    secureHeaders?: boolean;
+    timeout?: number;
+    onError?: (err: Error, c: Context$1) => Response | Promise<Response>;
+    onNotFound?: (c: Context$1) => Response | Promise<Response>;
+}
+interface RouteDefinition {
+    method: 'get' | 'post' | 'put' | 'delete' | 'patch' | 'head' | 'options';
+    path: string;
+    handler: (c: Context$1) => Response | Promise<Response>;
+    middlewares?: ((c: Context$1, next: Next) => Promise<void> | void)[];
+    validation?: z$1.ZodSchema;
+}
+interface MiddlewareDefinition {
+    path?: string;
+    handler: (c: Context$1, next: Next) => Promise<void> | void;
+}
+interface WebSocketRouteDefinition {
+    path: string;
+    handler: WebSocketHandler;
+}
+interface EasServer {
+    url: URL;
+    port: number;
+    hostname: string;
+    hono: Hono;
+    stop(closeActiveConnections?: boolean): Promise<void>;
+    raw?: ServerType;
+}
+declare function createServer(options?: ServerOptions): EasServer;
+declare function createRPCServer(methods: Record<string, RPCMethod>): EasServer;
+declare function startServer(fetch: (req: Request) => Response | Promise<Response>, port?: number, hostname?: string): EasServer;
+declare function createRESTServer(routes: RouteDefinition[], options?: Omit<ServerOptions, 'routes'>): EasServer;
+declare function createWebSocketServer(websockets: WebSocketRouteDefinition[], options?: Omit<ServerOptions, 'websockets'>): EasServer;
+declare function createStreamingServer(sseHandlers: Record<string, (c: Context$1) => AsyncIterable<{
+    data: string;
+    event?: string;
+    id?: string;
+}>>, options?: Omit<ServerOptions, 'routes'>): EasServer;
+
+interface ShellOptions {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    quiet?: boolean;
+    nothrow?: boolean;
+}
+declare class PkgShell {
+    private options;
+    constructor(options?: ShellOptions);
+    call(strings: TemplateStringsArray, ...expressions: ShellExpression[]): EasbotShellPromise;
+    braces(pattern: string): string[];
+    escape(input: string): string;
+    env(newEnv?: Record<string, string | undefined>): EasbotShell;
+    cwd(newCwd?: string): EasbotShell;
+    nothrow(): EasbotShell;
+    throws(shouldThrow: boolean): EasbotShell;
+}
+declare function createPkgShell(options?: ShellOptions): EasbotShell;
+declare const $$1: EasbotShell;
+
+interface NodeWhichOptions {
+    PATH?: string;
+}
+interface NodeSpawnOptions {
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    stdout?: 'pipe' | 'inherit' | 'null';
+    stderr?: 'pipe' | 'inherit' | 'null';
+    stdin?: 'pipe' | 'inherit' | 'null';
+    signal?: AbortSignal;
+    timeout?: number | false;
+}
+interface NodeSpawnObjectArgs {
+    cmd: string[];
+    cwd?: string;
+    env?: Record<string, string | undefined>;
+    stdout?: 'pipe' | 'inherit' | 'null';
+    stderr?: 'pipe' | 'inherit' | 'null';
+    stdin?: 'pipe' | 'inherit' | 'null';
+    signal?: AbortSignal;
+    timeout?: number | false;
+}
+interface NodeSpawnResult {
+    stdout: stream.Readable;
+    stderr: stream.Readable;
+    stdin: stream.Writable;
+    pid: number;
+    exited: Promise<number>;
+    kill: (signal?: string | number) => boolean;
+    exitCode?: number;
+}
+declare namespace PKG {
+    function which(command?: string, options?: NodeWhichOptions): Promise<string | null>;
+    function whichSync(command?: string, options?: NodeWhichOptions): string | null;
+    function clearWhichCache(): void;
+    function resolve(module: string, base?: string): Promise<string>;
+    function file(filePath: string): {
+        readonly name: string;
+        exists(): Promise<boolean>;
+        getSize(): Promise<number | undefined>;
+        text(): Promise<string>;
+        textSync(): string;
+        jsonSync(): unknown;
+        bytes(): Promise<Uint8Array>;
+        arrayBuffer(): Promise<ArrayBuffer>;
+        readonly type: string;
+        write(data: string | Buffer | Uint8Array | Response): Promise<void>;
+        json(): Promise<unknown>;
+        stat(): Promise<fs.Stats>;
+    };
+    function write(filePath: string, data: string | Buffer | Uint8Array | Response, options?: {
+        mode?: number;
+    }): Promise<void>;
+    function writeSync(filePath: string, data: string | Buffer | Uint8Array, options?: {
+        mode?: number;
+    }): void;
+    function readSync(filePath: string, encoding?: BufferEncoding): string;
+    function spawn(command: string | string[], options?: NodeSpawnOptions): NodeSpawnResult;
+    function spawn(args: NodeSpawnObjectArgs): NodeSpawnResult;
+    function run(cmd: string[], options?: {
+        cwd?: string;
+        env?: Record<string, string | undefined>;
+        timeout?: number;
+    }): Promise<{
+        code: number;
+        stdout: string;
+        stderr: string;
+    }>;
+    function runWithStream(cmd: string[], options?: {
+        cwd?: string;
+        env?: Record<string, string | undefined>;
+        timeout?: number;
+    }, callbacks?: {
+        onStdout?: (chunk: string) => void;
+        onStderr?: (chunk: string) => void;
+        onExit?: (code: number) => void;
+    }): Promise<{
+        code: number;
+        stdout: string;
+        stderr: string;
+    }>;
+    function $(strings: TemplateStringsArray, ...values: unknown[]): {
+        quiet: () => any;
+        nothrow: () => any;
+        cwd: (dir: string) => any;
+        env: (env: Record<string, string | undefined>) => any;
+        text: () => Promise<string>;
+        lines: () => Promise<string[]>;
+        then: (onfulfilled: (result: {
+            exitCode: number;
+            stdout: Uint8Array;
+            stderr: Uint8Array;
+            text: () => string;
+            lines: () => string[];
+        }) => void, onrejected?: (error: Error) => void) => Promise<void>;
+    };
+    function readableStreamToText(stream: ReadableStream<Uint8Array>): Promise<string>;
+    function nodeReadableStreamToText(stream: NodeJS.ReadableStream): Promise<string>;
+    function xxHash32(str: string, seed?: number): number;
+    function stringWidth(str: string): number;
+    class Glob {
+        private pattern;
+        constructor(pattern: string);
+        scan(options?: {
+            cwd?: string;
+            absolute?: boolean;
+            followSymlinks?: boolean;
+            dot?: boolean;
+            onlyFiles?: boolean;
+        }): AsyncIterable<string>;
+        scanSync(options?: {
+            cwd?: string;
+            absolute?: boolean;
+            followSymlinks?: boolean;
+            dot?: boolean;
+            onlyFiles?: boolean;
+        }): Generator<string>;
+        match(filepath: string): boolean;
+    }
+    const InstallFailedError: {
+        new (data: {
+            message: string;
+            pkg: string;
+            version: string;
+            originalError?: string | undefined;
+        }, options?: ErrorOptions): {
+            readonly name: "PKGInstallFailedError";
+            readonly data: {
+                message: string;
+                pkg: string;
+                version: string;
+                originalError?: string | undefined;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"PKGInstallFailedError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                    pkg: z.ZodString;
+                    version: z.ZodString;
+                    originalError: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            toObject(): {
+                name: "PKGInstallFailedError";
+                data: {
+                    message: string;
+                    pkg: string;
+                    version: string;
+                    originalError?: string | undefined;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z.ZodObject<{
+            name: z.ZodLiteral<"PKGInstallFailedError">;
+            data: z.ZodObject<{
+                message: z.ZodString;
+                pkg: z.ZodString;
+                version: z.ZodString;
+                originalError: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+        isInstance(input: any): input is {
+            readonly name: "PKGInstallFailedError";
+            readonly data: {
+                message: string;
+                pkg: string;
+                version: string;
+                originalError?: string | undefined;
+            };
+            schema(): z.ZodObject<{
+                name: z.ZodLiteral<"PKGInstallFailedError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                    pkg: z.ZodString;
+                    version: z.ZodString;
+                    originalError: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            toObject(): {
+                name: "PKGInstallFailedError";
+                data: {
+                    message: string;
+                    pkg: string;
+                    version: string;
+                    originalError?: string | undefined;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): {
+            new (data: z.input<Data>, options?: ErrorOptions): {
+                readonly name: Name;
+                readonly data: z.core.input<Data>;
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: Name;
+                    data: z.core.input<Data>;
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<Name>;
+                data: Data;
+            }, z.core.$strip>;
+            isInstance(input: any): input is InstanceType<any>;
+            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+            readonly Unknown: {
+                new (data: {
+                    message: string;
+                }, options?: ErrorOptions): {
+                    readonly name: "UnknownError";
+                    readonly data: {
+                        message: string;
+                    };
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<"UnknownError">;
+                        data: z.ZodObject<{
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                    toObject(): {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                readonly Schema: z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                isInstance(input: any): input is {
+                    readonly name: "UnknownError";
+                    readonly data: {
+                        message: string;
+                    };
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<"UnknownError">;
+                        data: z.ZodObject<{
+                            message: z.ZodString;
+                        }, z.core.$strip>;
+                    }, z.core.$strip>;
+                    toObject(): {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+                readonly Unknown: any;
+                isError(error: unknown): error is Error;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+                stackTraceLimit: number;
+            };
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        readonly Unknown: {
+            new (data: {
+                message: string;
+            }, options?: ErrorOptions): {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z.ZodObject<{
+                name: z.ZodLiteral<"UnknownError">;
+                data: z.ZodObject<{
+                    message: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>;
+            isInstance(input: any): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z.ZodObject<{
+                    name: z.ZodLiteral<"UnknownError">;
+                    data: z.ZodObject<{
+                        message: z.ZodString;
+                    }, z.core.$strip>;
+                }, z.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): {
+                new (data: z.input<Data>, options?: ErrorOptions): {
+                    readonly name: Name;
+                    readonly data: z.core.input<Data>;
+                    schema(): z.ZodObject<{
+                        name: z.ZodLiteral<Name>;
+                        data: Data;
+                    }, z.core.$strip>;
+                    toObject(): {
+                        name: Name;
+                        data: z.core.input<Data>;
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                readonly Schema: z.ZodObject<{
+                    name: z.ZodLiteral<Name>;
+                    data: Data;
+                }, z.core.$strip>;
+                isInstance(input: any): input is InstanceType<any>;
+                create<Name extends string, Data extends z.core.$ZodType>(name: Name, data: Data): any;
+                readonly Unknown: any;
+                isError(error: unknown): error is Error;
+                captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+                prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+                stackTraceLimit: number;
+            };
+            readonly Unknown: any;
+            isError(error: unknown): error is Error;
+            captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+            prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+            stackTraceLimit: number;
+        };
+        isError(error: unknown): error is Error;
+        captureStackTrace(targetObject: object, constructorOpt?: Function): void;
+        prepareStackTrace(err: Error, stackTraces: NodeJS.CallSite[]): any;
+        stackTraceLimit: number;
+    };
+    function install(pkg: string, version?: string, installPath?: string): Promise<string>;
+    const stdin: NodeJS.ReadStream & {
+        fd: 0;
+    };
+    const stdout: NodeJS.WriteStream & {
+        fd: 1;
+    };
+    const stderr: NodeJS.WriteStream & {
+        fd: 2;
+    };
+    const sleep: (ms: number) => Promise<unknown>;
+    const color: (color: string, format: "ansi") => string | null;
+    const hash: {
+        xxHash32: typeof xxHash32;
+    };
+    const build: typeof build;
+    const server: typeof createServer;
+    const nodeWebSocket: (init: _hono_node_ws.NodeWebSocketInit) => _hono_node_ws.NodeWebSocket;
+    const restServer: typeof createRESTServer;
+    const rpcServer: typeof createRPCServer;
+    const streamingServer: typeof createStreamingServer;
+    const webSocketServer: typeof createWebSocketServer;
+}
+declare const $: typeof PKG.$;
+declare const readableStreamToText: typeof PKG.readableStreamToText;
+declare const whichSync: typeof PKG.whichSync;
+
+declare function abortAfter(ms: number): {
+    controller: AbortController;
+    signal: AbortSignal;
+    clearTimeout: () => void;
+};
+declare function abortAfterAny(ms: number, ...signals: AbortSignal[]): {
+    signal: AbortSignal;
+    clearTimeout: () => void;
+};
+
+declare namespace Archive {
+    function extractZip(zipPath: string, destDir: string): Promise<void>;
+}
+
+declare namespace Color {
+    function isValidHex(hex?: string): hex is string;
+    function hexToRgb(hex: string): {
+        r: number;
+        g: number;
+        b: number;
+    };
+    function hexToAnsiBold(hex?: string): string | undefined;
+}
+
+declare namespace Context {
+    class NotFound extends Error {
+        readonly name: string;
+        constructor(name: string);
+    }
+    function create<T>(name: string): {
+        use(): NonNullable<T>;
+        provide<R>(value: T, fn: () => R): R;
+    };
+}
+
+declare function defer<T extends () => void | Promise<void>>(fn: T): T extends () => Promise<void> ? {
+    [Symbol.asyncDispose]: () => Promise<void>;
+} : {
+    [Symbol.dispose]: () => void;
+};
+
+declare namespace EventLoop {
+    function wait(): Promise<void>;
+}
+
+declare function formatDuration(secs: number): string;
+
+declare namespace Glob {
+    interface Options {
+        cwd?: string;
+        absolute?: boolean;
+        include?: 'file' | 'all';
+        dot?: boolean;
+        symlink?: boolean;
+    }
+    function scan(pattern: string, options?: Options): Promise<string[]>;
+    function scanSync(pattern: string, options?: Options): string[];
+    function match(pattern: string, filepath: string): boolean;
+}
+
+declare namespace Keybind {
+    type Info = {
+        name: string;
+        ctrl: boolean;
+        meta: boolean;
+        shift: boolean;
+        super: boolean;
+        leader: boolean;
+    };
+    function match(a: Info | undefined, b: Info): boolean;
+    function fromParsedKey(key: {
+        name: string;
+        ctrl: boolean;
+        meta: boolean;
+        shift: boolean;
+        super?: boolean;
+    }, leader?: boolean): Info;
+    function keyToString(info: Info | undefined): string;
+    function parse(key: string): Info[];
+}
+
+declare namespace Locale {
+    function titlecase(str: string): string;
+    function time(input: number): string;
+    function datetime(input: number): string;
+    function todayTimeOrDateTime(input: number): string;
+    function number(num: number): string;
+    function duration(input: number): string;
+    function truncate(str: string, len: number): string;
+    function truncateMiddle(str: string, maxLength?: number): string;
+    function pluralize(count: number, singular: string, plural: string): string;
+}
+
+declare namespace Lock {
+    function read(key: string): Promise<Disposable>;
+    function write(key: string): Promise<Disposable>;
+}
+
+declare namespace Process {
+    type Stdio = 'inherit' | 'pipe' | 'ignore';
+    type Shell = boolean | string;
+    interface Options {
+        cwd?: string;
+        env?: NodeJS.ProcessEnv | null;
+        stdin?: Stdio;
+        stdout?: Stdio;
+        stderr?: Stdio;
+        shell?: Shell;
+        abort?: AbortSignal;
+        kill?: NodeJS.Signals | number;
+        timeout?: number;
+    }
+    interface RunOptions extends Omit<Options, 'stdout' | 'stderr'> {
+        nothrow?: boolean;
+    }
+    interface Result {
+        code: number;
+        stdout: Buffer;
+        stderr: Buffer;
+    }
+    interface TextResult extends Result {
+        text: string;
+    }
+    class RunFailedError extends Error {
+        readonly cmd: string[];
+        readonly code: number;
+        readonly stdout: Buffer;
+        readonly stderr: Buffer;
+        constructor(cmd: string[], code: number, stdout: Buffer, stderr: Buffer);
+    }
+    type Child = ChildProcess & {
+        exited: Promise<number>;
+    };
+    function spawn(cmd: string[], opts?: Options): Child;
+    function run(cmd: string[], opts?: RunOptions): Promise<Result>;
+    function stop(proc: ChildProcess): Promise<void>;
+    function text(cmd: string[], opts?: RunOptions): Promise<TextResult>;
+    function lines(cmd: string[], opts?: RunOptions): Promise<string[]>;
+}
+
+declare function proxied(): boolean;
+
+declare class AsyncQueue<T> implements AsyncIterable<T> {
+    private queue;
+    private resolvers;
+    push(item: T): void;
+    next(): Promise<T>;
+    [Symbol.asyncIterator](): AsyncGenerator<Awaited<T>, void, unknown>;
+}
+declare function work<T>(concurrency: number, items: T[], fn: (item: T) => Promise<void>): Promise<void>;
+
+declare function signal(): {
+    trigger(): any;
+    wait(): Promise<unknown>;
+};
+
+declare function withTimeout<T>(promise: Promise<T>, ms: number): Promise<T>;
+
+declare namespace Token {
+    function estimate(input: string | null | undefined): number;
+    function estimateObject(obj: unknown): number;
+    function total(tokens: {
+        total?: number;
+        input?: number;
+        output?: number;
+        reasoning?: number;
+        cache?: {
+            read?: number;
+            write?: number;
+        };
+    }): number;
+}
+
+declare function updateSchema<T extends z.ZodRawShape>(schema: z.ZodObject<T>): z.ZodObject<{ -readonly [P in keyof { [K in keyof T]: z.ZodOptional<z.ZodNullable<T[K]>>; }]: { [K in keyof T]: z.ZodOptional<z.ZodNullable<T[K]>>; }[P]; }, z.core.$strip>;
+
+declare namespace Wildcard {
+    function match(str: string, pattern: string): boolean;
+    function all(input: string, patterns: Record<string, unknown>): unknown;
+    function allStructured(input: {
+        head: string;
+        tail: string[];
+    }, patterns: Record<string, unknown>): unknown;
+}
+
+declare function initLog(options: {
+    print: boolean;
+    logDir: string;
+    logFile?: string;
+    dev?: boolean;
+    level?: 'DEBUG' | 'INFO' | 'WARN' | 'ERROR';
+}): Promise<void>;
+
+export { $, Archive, AsyncQueue, Binary, type CodeSpanIndex$1 as CodeSpanIndex, Color, Context, type EasServer, $$1 as EasbotShell, Encode, EventLoop, type FenceSpan$1 as FenceSpan, Filesystem, Fn, type FormatOptions, type GitResult, Glob, Identifier, type InlineCodeState$1 as InlineCodeState, Keybind, Lazy, Locale, Lock, Markdown, type MarkdownConfig, type MarkdownIR, type MarkdownLinkSpan, type MarkdownParseOptions, type MarkdownStyle, type MarkdownStyleSpan, type MarkdownTableMode, type MiddlewareDefinition, NamedError, type NodeSpawnObjectArgs, type NodeSpawnOptions, type NodeSpawnResult, type NodeWhichOptions, PKG, type ParsedFrontmatter, PkgShell, Process, type RPCMethod, type RenderLink, type RenderOptions, type RouteDefinition, type SSEHandler, type ServerOptions, Slug, type StreamHandler, type StyleMarker, Token, TruncateContent, type WebSocketHandler, type WebSocketRouteDefinition, Wildcard, abortAfter, abortAfterAny, buildCodeSpanIndex, chunkMarkdownIR, chunkText, chunkTextByBreakResolver, convertMarkdownTables, createInlineCodeState, createPkgShell, createRESTServer, createRPCServer, createServer, createStreamingServer, createWebSocketServer, defer, extractFrontmatter, findFenceSpanAt, findLast, fn, formatDuration, formatLocalISO, formatLocalISOCompact, formatLogTime, formatMarkdown, getDirectory, getFileExtension, getFilename, getFilenameTruncated, getTimezoneOffset, git, iife, initLog, isSafeFenceBreak, lazy, lazyAsync, loadEnv, loadTextFile, loadTextFileAsync, markdownToIR, markdownToIRWithMeta, now, nowLocalISO, parseFenceSpans, parseFrontmatterBlock, parseLocalISO, parseModelId, proxied, readableStreamToText, renderMarkdown, renderMarkdownWithMarkers, retry, scanParenAwareBreakpoints, serializeFrontmatter, signal, startServer, truncateMiddle, updateSchema, whichSync, withTimeout, work };