@easbot/utils 0.3.11 → 0.3.12

package/dist/index.d.ts

@@ -1,11 +1,11 @@
 import { ChildProcess } from 'node:child_process';
 import z, { z as z$1 } from 'zod';
-import { statSync } from 'node:fs';
-import * as stream from 'stream';
-import { Readable } from 'stream';
+import { Stats } from 'node:fs';
+import { Readable } from 'node:stream';
 import * as _hono_node_ws from '@hono/node-ws';
 export { createNodeWebSocket } from '@hono/node-ws';
 import * as fs from 'fs';
+import * as stream from 'stream';
 import { Hono, Context as Context$1, Next } from 'hono';
 export { Hono, Next } from 'hono';
 import { ServerType } from '@hono/node-server';
@@ -401,12 +401,17 @@ declare namespace Filesystem {
     function mkdir(p: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
+    function cp(src: string, dest: string, options?: {
+        recursive?: boolean;
+        dereference?: boolean;
+        force?: boolean;
+    }): Promise<void>;
     function exists(p: string): Promise<boolean>;
-    function isDir(p: string): Promise<boolean>;
-    function stat(p: string): ReturnType<typeof statSync> | undefined;
+    function isDir(p: string): boolean;
+    function stat(p: string): Stats | undefined;
     function size(p: string): Promise<number>;
     function readText(p: string): Promise<string>;
-    function readJson<T = any>(p: string): Promise<T>;
+    function readJson<T = unknown>(p: string): Promise<T>;
     function readBytes(p: string): Promise<Buffer>;
     function readArrayBuffer(p: string): Promise<ArrayBuffer>;
     function write(p: string, content: string | Buffer | Uint8Array, mode?: number): Promise<void>;
@@ -419,13 +424,14 @@ declare namespace Filesystem {
     function basename(p: string, ext?: string): string;
     function extname(p: string): string;
     function toUnixPath(p: string): string;
-    function normalize(p: string): string;
-    function resolve(p: string): string;
+    function relative(from: string, to: string): string;
+    function normalize(p: string, home?: string): string;
+    function resolve(p: string, home?: string): string;
     function isAbsolute(p: string): boolean;
     function join(base: string, ...paths: string[]): string;
     function windowsPath(p: string): string;
-    function overlaps(a: string, b: string): boolean;
     function contains(parent: string, child: string): boolean;
+    function overlaps(a: string, b: string): boolean;
     function findUp(target: string, start: string, stop?: string): Promise<string[]>;
     function up(options: {
         targets: string[];
@@ -521,206 +527,258 @@ declare namespace Lazy {
     const lazyAsync: typeof createLazyAsync;
 }
 
-declare const MarkdownStyleSchema: z$1.ZodEnum<{
-    bold: "bold";
-    code: "code";
-    italic: "italic";
-    strikethrough: "strikethrough";
-    code_block: "code_block";
-    spoiler: "spoiler";
-    blockquote: "blockquote";
-}>;
-type MarkdownStyle = z$1.infer<typeof MarkdownStyleSchema>;
-declare const MarkdownStyleSpanSchema: z$1.ZodObject<{
-    start: z$1.ZodNumber;
-    end: z$1.ZodNumber;
-    style: z$1.ZodEnum<{
-        bold: "bold";
-        code: "code";
-        italic: "italic";
-        strikethrough: "strikethrough";
-        code_block: "code_block";
-        spoiler: "spoiler";
-        blockquote: "blockquote";
-    }>;
-}, z$1.core.$strict>;
-type MarkdownStyleSpan = z$1.infer<typeof MarkdownStyleSpanSchema>;
-declare const MarkdownLinkSpanSchema: z$1.ZodObject<{
-    start: z$1.ZodNumber;
-    end: z$1.ZodNumber;
-    href: z$1.ZodString;
-}, z$1.core.$strict>;
-type MarkdownLinkSpan = z$1.infer<typeof MarkdownLinkSpanSchema>;
-declare const MarkdownIRSchema: z$1.ZodObject<{
-    text: z$1.ZodString;
-    styles: z$1.ZodArray<z$1.ZodObject<{
-        start: z$1.ZodNumber;
-        end: z$1.ZodNumber;
-        style: z$1.ZodEnum<{
-            bold: "bold";
-            code: "code";
-            italic: "italic";
-            strikethrough: "strikethrough";
-            code_block: "code_block";
-            spoiler: "spoiler";
-            blockquote: "blockquote";
-        }>;
-    }, z$1.core.$strict>>;
-    links: z$1.ZodArray<z$1.ZodObject<{
-        start: z$1.ZodNumber;
-        end: z$1.ZodNumber;
-        href: z$1.ZodString;
-    }, z$1.core.$strict>>;
-}, z$1.core.$strict>;
-type MarkdownIR = z$1.infer<typeof MarkdownIRSchema>;
-declare const MarkdownTableModeSchema: z$1.ZodEnum<{
-    code: "code";
-    off: "off";
-    bullets: "bullets";
-}>;
-type MarkdownTableMode = z$1.infer<typeof MarkdownTableModeSchema>;
-declare const MarkdownParseOptionsSchema: z$1.ZodDefault<z$1.ZodObject<{
-    linkify: z$1.ZodOptional<z$1.ZodDefault<z$1.ZodBoolean>>;
-    enableSpoilers: z$1.ZodOptional<z$1.ZodDefault<z$1.ZodBoolean>>;
-    headingStyle: z$1.ZodOptional<z$1.ZodDefault<z$1.ZodEnum<{
-        bold: "bold";
-        none: "none";
-    }>>>;
-    blockquotePrefix: z$1.ZodOptional<z$1.ZodDefault<z$1.ZodString>>;
-    autolink: z$1.ZodOptional<z$1.ZodDefault<z$1.ZodBoolean>>;
-    tableMode: z$1.ZodOptional<z$1.ZodDefault<z$1.ZodEnum<{
-        code: "code";
-        off: "off";
-        bullets: "bullets";
-    }>>>;
-}, z$1.core.$strip>>;
-type MarkdownParseOptions = z$1.infer<typeof MarkdownParseOptionsSchema>;
-declare const StyleMarkerSchema: z$1.ZodObject<{
-    open: z$1.ZodString;
-    close: z$1.ZodString;
-}, z$1.core.$strict>;
-type StyleMarker = z$1.infer<typeof StyleMarkerSchema>;
-type RenderOptions = {
-    styleMarkers?: Record<MarkdownStyle, StyleMarker>;
-    escapeText?: (text: string) => string;
-    buildLink?: (link: MarkdownLinkSpan, text: string) => RenderLink | null;
-};
-declare const RenderLinkSchema: z$1.ZodObject<{
-    start: z$1.ZodNumber;
-    end: z$1.ZodNumber;
-    open: z$1.ZodString;
-    close: z$1.ZodString;
-}, z$1.core.$strict>;
-type RenderLink = z$1.infer<typeof RenderLinkSchema>;
-declare const FormatOptionsSchema: z$1.ZodObject<{
-    indentSize: z$1.ZodDefault<z$1.ZodNumber>;
-    listMarker: z$1.ZodDefault<z$1.ZodEnum<{
-        "-": "-";
-        "*": "*";
-        "\u2022": "•";
-    }>>;
-    codeBlockMarker: z$1.ZodDefault<z$1.ZodEnum<{
-        "```": "```";
-        "~~~": "~~~";
-    }>>;
-    preserveFrontmatter: z$1.ZodDefault<z$1.ZodBoolean>;
-}, z$1.core.$strict>;
-type FormatOptions = z$1.infer<typeof FormatOptionsSchema>;
-declare const ParsedFrontmatterSchema: z$1.ZodRecord<z$1.ZodString, z$1.ZodString>;
-type ParsedFrontmatter = z$1.infer<typeof ParsedFrontmatterSchema>;
-declare const InlineCodeStateSchema: z$1.ZodObject<{
-    open: z$1.ZodBoolean;
-    ticks: z$1.ZodNumber;
-}, z$1.core.$strict>;
-type InlineCodeState$1 = z$1.infer<typeof InlineCodeStateSchema>;
-type CodeSpanIndex$1 = {
-    inlineState: InlineCodeState$1;
-    isInside: (offset: number) => boolean;
-};
-declare const FenceSpanSchema: z$1.ZodObject<{
-    start: z$1.ZodNumber;
-    end: z$1.ZodNumber;
-    openLine: z$1.ZodString;
-    marker: z$1.ZodString;
-    indent: z$1.ZodString;
-}, z$1.core.$strict>;
-type FenceSpan$1 = z$1.infer<typeof FenceSpanSchema>;
-declare const MarkdownConfigSchema: z$1.ZodObject<{
-    tables: z$1.ZodOptional<z$1.ZodEnum<{
-        code: "code";
-        off: "off";
-        bullets: "bullets";
-    }>>;
-}, z$1.core.$strict>;
-type MarkdownConfig = z$1.infer<typeof MarkdownConfigSchema>;
-
-declare function markdownToIR(markdown: string, options?: MarkdownParseOptions): MarkdownIR;
-declare function markdownToIRWithMeta(markdown: string, options?: MarkdownParseOptions): {
-    ir: MarkdownIR;
-    hasTables: boolean;
-};
-declare function chunkMarkdownIR(ir: MarkdownIR, limit: number): MarkdownIR[];
-
-declare function renderMarkdownWithMarkers(ir: MarkdownIR, options?: RenderOptions): string;
-declare function renderMarkdown(ir: MarkdownIR, options?: RenderOptions): string;
-
-declare function formatMarkdown(markdown: string, options?: FormatOptions): string;
-
-declare function parseFrontmatterBlock(content: string): ParsedFrontmatter;
-declare function serializeFrontmatter(data: ParsedFrontmatter): string;
-declare function extractFrontmatter(content: string): {
-    frontmatter: ParsedFrontmatter;
-    content: string;
-};
-
-declare function scanParenAwareBreakpoints(text: string, start: number, end: number, isAllowed?: (index: number) => boolean): {
-    lastNewline: number;
-    lastWhitespace: number;
-};
-declare function chunkText(text: string, limit: number, options?: {
-    minLength?: number;
-}): string[];
-declare function chunkTextByBreakResolver(text: string, limit: number, resolveBreakIndex: (window: string) => number): string[];
-
-type InlineCodeState = {
-    open: boolean;
-    ticks: number;
-};
-declare function createInlineCodeState(): InlineCodeState;
-type CodeSpanIndex = {
-    inlineState: InlineCodeState;
-    isInside: (index: number) => boolean;
-};
-declare function buildCodeSpanIndex(text: string, inlineState?: InlineCodeState): CodeSpanIndex;
-
-type FenceSpan = {
-    start: number;
-    end: number;
-    openLine: string;
-    marker: string;
-    indent: string;
-};
-declare function parseFenceSpans(buffer: string): FenceSpan[];
-declare function findFenceSpanAt(spans: FenceSpan[], index: number): FenceSpan | undefined;
-declare function isSafeFenceBreak(spans: FenceSpan[], index: number): boolean;
-
-declare function convertMarkdownTables(markdown: string, mode: MarkdownTableMode): string;
-
 declare namespace Markdown {
-    function parse(markdown: string, options?: MarkdownParseOptions): MarkdownIR;
-    function render(ir: MarkdownIR, options?: RenderOptions): string;
-    function format(markdown: string, options?: FormatOptions): string;
-    function parseFrontmatter(content: string): ParsedFrontmatter;
-    function serializeFrontmatter(data: ParsedFrontmatter): string;
-    function extractFrontmatter(content: string): {
-        frontmatter: ParsedFrontmatter;
+    const FILE_REGEX: RegExp;
+    const SHELL_REGEX: RegExp;
+    function files(template: string): RegExpExecArray[];
+    function shell(template: string): RegExpExecArray[];
+    function fallbackSanitization(content: string): string;
+    function parse(filePath: string): Promise<{
+        data: Record<string, unknown>;
+        content: string;
+    }>;
+    function extractFrontmatter(rawInput: string): {
+        frontmatter: Record<string, unknown>;
         content: string;
     };
-    function chunk(text: string, limit: number, options?: {
-        minLength?: number;
-    }): string[];
-    function buildCodeIndex(text: string, inlineState?: InlineCodeState$1): CodeSpanIndex$1;
-    function convertTables(markdown: string, tableMode: MarkdownTableMode): string;
+    function format(content: string, data?: Record<string, unknown>): string;
+    const FrontmatterError: {
+        new (data: {
+            path: string;
+            message: string;
+        }, options?: ErrorOptions): {
+            readonly name: "ConfigFrontmatterError";
+            readonly data: {
+                path: string;
+                message: string;
+            };
+            schema(): z$1.ZodObject<{
+                name: z$1.ZodLiteral<"ConfigFrontmatterError">;
+                data: z$1.ZodObject<{
+                    path: z$1.ZodString;
+                    message: z$1.ZodString;
+                }, z$1.core.$strip>;
+            }, z$1.core.$strip>;
+            toObject(): {
+                name: "ConfigFrontmatterError";
+                data: {
+                    path: string;
+                    message: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        readonly Schema: z$1.ZodObject<{
+            name: z$1.ZodLiteral<"ConfigFrontmatterError">;
+            data: z$1.ZodObject<{
+                path: z$1.ZodString;
+                message: z$1.ZodString;
+            }, z$1.core.$strip>;
+        }, z$1.core.$strip>;
+        isInstance(input: any): input is {
+            readonly name: "ConfigFrontmatterError";
+            readonly data: {
+                path: string;
+                message: string;
+            };
+            schema(): z$1.ZodObject<{
+                name: z$1.ZodLiteral<"ConfigFrontmatterError">;
+                data: z$1.ZodObject<{
+                    path: z$1.ZodString;
+                    message: z$1.ZodString;
+                }, z$1.core.$strip>;
+            }, z$1.core.$strip>;
+            toObject(): {
+                name: "ConfigFrontmatterError";
+                data: {
+                    path: string;
+                    message: string;
+                };
+            };
+            message: string;
+            stack?: string;
+            cause?: unknown;
+        };
+        create<Name extends string, Data extends z$1.core.$ZodType>(name: Name, data: Data): {
+            new (data: z$1.input<Data>, options?: ErrorOptions): {
+                readonly name: Name;
+                readonly data: z$1.core.input<Data>;
+                schema(): z$1.ZodObject<{
+                    name: z$1.ZodLiteral<Name>;
+                    data: Data;
+                }, z$1.core.$strip>;
+                toObject(): {
+                    name: Name;
+                    data: z$1.core.input<Data>;
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z$1.ZodObject<{
+                name: z$1.ZodLiteral<Name>;
+                data: Data;
+            }, z$1.core.$strip>;
+            isInstance(input: any): input is InstanceType<any>;
+            create<Name extends string, Data extends z$1.core.$ZodType>(name: Name, data: Data): any;
+            readonly Unknown: {
+                new (data: {
+                    message: string;
+                }, options?: ErrorOptions): {
+                    readonly name: "UnknownError";
+                    readonly data: {
+                        message: string;
+                    };
+                    schema(): z$1.ZodObject<{
+                        name: z$1.ZodLiteral<"UnknownError">;
+                        data: z$1.ZodObject<{
+                            message: z$1.ZodString;
+                        }, z$1.core.$strip>;
+                    }, z$1.core.$strip>;
+                    toObject(): {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                readonly Schema: z$1.ZodObject<{
+                    name: z$1.ZodLiteral<"UnknownError">;
+                    data: z$1.ZodObject<{
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+                isInstance(input: any): input is {
+                    readonly name: "UnknownError";
+                    readonly data: {
+                        message: string;
+                    };
+                    schema(): z$1.ZodObject<{
+                        name: z$1.ZodLiteral<"UnknownError">;
+                        data: z$1.ZodObject<{
+                            message: z$1.ZodString;
+                        }, z$1.core.$strip>;
+                    }, z$1.core.$strip>;
+                    toObject(): {
+                        name: "UnknownError";
+                        data: {
+                            message: string;
+                        };
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                create<Name extends string, Data extends z$1.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$1.ZodObject<{
+                    name: z$1.ZodLiteral<"UnknownError">;
+                    data: z$1.ZodObject<{
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            readonly Schema: z$1.ZodObject<{
+                name: z$1.ZodLiteral<"UnknownError">;
+                data: z$1.ZodObject<{
+                    message: z$1.ZodString;
+                }, z$1.core.$strip>;
+            }, z$1.core.$strip>;
+            isInstance(input: any): input is {
+                readonly name: "UnknownError";
+                readonly data: {
+                    message: string;
+                };
+                schema(): z$1.ZodObject<{
+                    name: z$1.ZodLiteral<"UnknownError">;
+                    data: z$1.ZodObject<{
+                        message: z$1.ZodString;
+                    }, z$1.core.$strip>;
+                }, z$1.core.$strip>;
+                toObject(): {
+                    name: "UnknownError";
+                    data: {
+                        message: string;
+                    };
+                };
+                message: string;
+                stack?: string;
+                cause?: unknown;
+            };
+            create<Name extends string, Data extends z$1.core.$ZodType>(name: Name, data: Data): {
+                new (data: z$1.input<Data>, options?: ErrorOptions): {
+                    readonly name: Name;
+                    readonly data: z$1.core.input<Data>;
+                    schema(): z$1.ZodObject<{
+                        name: z$1.ZodLiteral<Name>;
+                        data: Data;
+                    }, z$1.core.$strip>;
+                    toObject(): {
+                        name: Name;
+                        data: z$1.core.input<Data>;
+                    };
+                    message: string;
+                    stack?: string;
+                    cause?: unknown;
+                };
+                readonly Schema: z$1.ZodObject<{
+                    name: z$1.ZodLiteral<Name>;
+                    data: Data;
+                }, z$1.core.$strip>;
+                isInstance(input: any): input is InstanceType<any>;
+                create<Name extends string, Data extends z$1.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 replaceVariables(template: string, variables: Record<string, unknown>): string;
+    function renderTemplate(template: string, variables: Record<string, unknown>): string;
+    function formatVariableValue(value: unknown): string;
 }
 
 declare function getFilename(path: string | undefined): string;
@@ -1422,30 +1480,4 @@ declare namespace Log {
     function create(tags?: Record<string, any>): Logger;
 }
 
-declare namespace CliSearch {
-    interface Item<T> {
-        value: T;
-        label: string;
-        hint?: string;
-    }
-    interface LockedSection<T> {
-        title: string;
-        items: Item<T>[];
-        hiddenCount?: number;
-    }
-    interface MultiselectOptions<T> {
-        message: string;
-        items: Item<T>[];
-        maxVisible?: number;
-        initialSelected?: T[];
-        required?: boolean;
-        lockedSection?: LockedSection<T>;
-    }
-    const cancelSymbol: unique symbol;
-    function approxStringWidth(plain: string): number;
-    function visualRowsForLine(line: string, columns: number): number;
-    function countVisualRowsForLines(lines: string[], columns: number | undefined): number;
-    function multiselect<T>(options: MultiselectOptions<T>): Promise<T[] | typeof cancelSymbol>;
-}
-
-export { $, Archive, AsyncQueue, Binary, CliSearch, type CodeSpanIndex$1 as CodeSpanIndex, Color, Context, DEFAULT_LANG, type EasServer, Encode, EventLoop, type FenceSpan$1 as FenceSpan, Fetch, type FetchResponse, Filesystem, Fn, type FormatOptions, type GitResult, Glob, Grep, Identifier, Ignore, type InlineCodeState$1 as InlineCodeState, Keybind, type Lang, Lazy, Locale, Lock, Log, MIME_TYPES, 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, PackageRegistry, type ParseCommandResult, type ParsedFrontmatter, type ParsedVersion, PkgShell, type ProxyOptions, type RPCMethod, type RenderLink, type RenderOptions, type RequestOptions, type RouteDefinition, type SSEHandler, SUPPORTED_LANGS, Semver, type ServerOptions, SessionTitle, Shell, Slug, type StreamHandler, type StyleMarker, type TimezoneDateParts, Token, TruncateContent, type WebSocketHandler, type WebSocketRouteDefinition, Wildcard, abortAfter, abortAfterAny, addMinutesInTimezone, buildCodeSpanIndex, chunkMarkdownIR, chunkText, chunkTextByBreakResolver, convertMarkdownTables, createInlineCodeState, createPkgShell, createRESTServer, createRPCServer, createServer, createStreamingServer, createWebSocketServer, defer, detectPlatform, escapeCommandArg, escapeCommandArgSafe, extractFrontmatter, findFenceSpanAt, findLast, fn, formatDuration, formatLocalISO, formatLocalISOCompact, formatLogTime, formatLogTimeMs, formatMarkdown, getDirectory, getFileExtension, getFilename, getFilenameTruncated, getProxyConfig, getProxyUrl, getTimezoneOffset, getTimezoneParts, git, iife, isSafeFenceBreak, isValidTimezone, joinCommandArgs, lazy, lazyAsync, loadEnv, loadTextFile, loadTextFileAsync, markdownToIR, markdownToIRWithMeta, needsShellExecution, normalizeTimezone, now, nowLocalISO, parseCommand, parseCommandWithOptions, parseFenceSpans, parseFrontmatterBlock, parseLocalISO, parseModelId, proxied, readableStreamToText, renderMarkdown, renderMarkdownWithMarkers, resolveLocaleLang, retry, scanParenAwareBreakpoints, serializeFrontmatter, shell, signal, startServer, truncateMiddle, updateSchema, whichSync, withTimeout, work };
+export { $, Archive, AsyncQueue, Binary, Color, Context, DEFAULT_LANG, type EasServer, Encode, EventLoop, Fetch, type FetchResponse, Filesystem, Fn, type GitResult, Glob, Grep, Identifier, Ignore, Keybind, type Lang, Lazy, Locale, Lock, Log, MIME_TYPES, Markdown, type MiddlewareDefinition, NamedError, type NodeSpawnObjectArgs, type NodeSpawnOptions, type NodeSpawnResult, type NodeWhichOptions, PKG, PackageRegistry, type ParseCommandResult, type ParsedVersion, PkgShell, type ProxyOptions, type RPCMethod, type RequestOptions, type RouteDefinition, type SSEHandler, SUPPORTED_LANGS, Semver, type ServerOptions, SessionTitle, Shell, Slug, type StreamHandler, type TimezoneDateParts, Token, TruncateContent, type WebSocketHandler, type WebSocketRouteDefinition, Wildcard, abortAfter, abortAfterAny, addMinutesInTimezone, createPkgShell, createRESTServer, createRPCServer, createServer, createStreamingServer, createWebSocketServer, defer, detectPlatform, escapeCommandArg, escapeCommandArgSafe, findLast, fn, formatDuration, formatLocalISO, formatLocalISOCompact, formatLogTime, formatLogTimeMs, getDirectory, getFileExtension, getFilename, getFilenameTruncated, getProxyConfig, getProxyUrl, getTimezoneOffset, getTimezoneParts, git, iife, isValidTimezone, joinCommandArgs, lazy, lazyAsync, loadEnv, loadTextFile, loadTextFileAsync, needsShellExecution, normalizeTimezone, now, nowLocalISO, parseCommand, parseCommandWithOptions, parseLocalISO, parseModelId, proxied, readableStreamToText, resolveLocaleLang, retry, shell, signal, startServer, truncateMiddle, updateSchema, whichSync, withTimeout, work };