@poe-platform/safe-js 0.1.0

package/dist/tiny-stdio-mcp-server/content/file.d.ts

@@ -0,0 +1,28 @@
+import { type FromUrlOptions } from "./remote.js";
+export interface TextResourceContents {
+    uri: string;
+    mimeType: string;
+    text: string;
+}
+export interface BlobResourceContents {
+    uri: string;
+    mimeType: string;
+    blob: string;
+}
+export interface EmbeddedResource {
+    type: "resource";
+    resource: TextResourceContents | BlobResourceContents;
+}
+export declare class File {
+    private readonly data;
+    private readonly mimeType;
+    private readonly isText;
+    private readonly name?;
+    private readonly charset;
+    private constructor();
+    static fromUrl(url: string, options?: FromUrlOptions): Promise<File>;
+    static fromBytes(data: Uint8Array, mimeType: string): File;
+    static fromText(text: string, mimeType?: string): File;
+    static fromBase64(base64: string, mimeType: string): File;
+    toContentBlock(): EmbeddedResource;
+}

package/dist/tiny-stdio-mcp-server/content/image.d.ts

@@ -0,0 +1,15 @@
+import { type FromUrlOptions } from "./remote.js";
+export interface ImageContent {
+    type: "image";
+    data: string;
+    mimeType: string;
+}
+export declare class Image {
+    private readonly base64Data;
+    private readonly mimeType;
+    private constructor();
+    static fromUrl(url: string, options?: FromUrlOptions): Promise<Image>;
+    static fromBytes(data: Uint8Array, format?: string): Image;
+    static fromBase64(base64: string, mimeType: string): Image;
+    toContentBlock(): ImageContent;
+}

package/dist/tiny-stdio-mcp-server/content/index.d.ts

@@ -0,0 +1,7 @@
+export { fileTypeFromBuffer, type FileTypeResult } from "./mime.js";
+export { DEFAULT_FROM_URL_MAX_BYTES } from "./remote.js";
+export type { FromUrlOptions } from "./remote.js";
+export { Image, type ImageContent } from "./image.js";
+export { Audio, type AudioContent } from "./audio.js";
+export { File, type EmbeddedResource, type TextResourceContents, type BlobResourceContents, } from "./file.js";
+export { toContentBlocks, type ContentBlock, type TextContent, type ToolReturn, } from "./convert.js";

package/dist/tiny-stdio-mcp-server/content/mime.d.ts

@@ -0,0 +1,7 @@
+export { fileTypeFromBuffer, type FileTypeResult } from "./file-type.js";
+export declare function parseContentType(value: string | null): {
+    mimeType?: string;
+    charset?: string;
+};
+export declare function assertBase64(value: string): void;
+export declare function safeRemoteLabel(url: string): string;

package/dist/tiny-stdio-mcp-server/content/remote.d.ts

@@ -0,0 +1,5 @@
+export declare const DEFAULT_FROM_URL_MAX_BYTES: number;
+export interface FromUrlOptions {
+    maxBytes?: number;
+}
+export declare function readRemoteBytes(response: Response, kind: string, url: string, options?: FromUrlOptions): Promise<Uint8Array>;

package/dist/tiny-stdio-mcp-server/index.d.ts

@@ -0,0 +1,9 @@
+export { createServer } from "./server.js";
+export type { CustomMethodHandler, MessageHandler, MessageSession, MessageSessionContext, Server } from "./server.js";
+export { defineSchema } from "./schema.js";
+export type { TypedSchema } from "./schema.js";
+export { Image, Audio, File, toContentBlocks, fileTypeFromBuffer, DEFAULT_FROM_URL_MAX_BYTES, } from "./content/index.js";
+export type { ImageContent, AudioContent, EmbeddedResource, TextResourceContents, BlobResourceContents, ContentBlock, TextContent, FileTypeResult, FromUrlOptions, } from "./content/index.js";
+export type { ToolReturn } from "./content/index.js";
+export type { ServerOptions, ToolHandler, ToolDefinition, Tool, ToolAnnotations, ToolExecution, Icon, ContentAnnotations, ResourceLink, CallToolResult, PromptContentItem, PromptArgument, Prompt, PromptMessage, GetPromptResult, PromptHandler, PromptDefinition, Resource, ResourceTemplate, ResourceContents, ReadResourceResult, ResourceHandler, ResourceDefinition, ResourceTemplateDefinition, HandleResult, ContentItem, JSONSchema, JSONSchemaProperty, Transport, SDKTransport, JSONRPCRequest, JSONRPCResponse, JSONRPCError, JSONRPCMessage, JSONRPCNotification, InitializeResult, } from "./types.js";
+export { JSON_RPC_ERROR_CODES, ToolError } from "./types.js";

package/dist/tiny-stdio-mcp-server/schema.d.ts

@@ -0,0 +1,20 @@
+import type { JSONSchema } from "./types.js";
+type SchemaPropertyType = "string" | "number" | "integer" | "boolean" | "object" | "array";
+interface SchemaPropertyDef {
+    type: SchemaPropertyType;
+    description?: string;
+    optional?: boolean;
+    [keyword: string]: unknown;
+}
+type SchemaDefinition = Record<string, SchemaPropertyDef>;
+type InferType<T extends SchemaPropertyType> = T extends "string" ? string : T extends "number" | "integer" ? number : T extends "boolean" ? boolean : T extends "object" ? Record<string, unknown> : T extends "array" ? unknown[] : never;
+type InferSchema<T extends SchemaDefinition> = {
+    [K in keyof T as T[K]["optional"] extends true ? never : K]: InferType<T[K]["type"]>;
+} & {
+    [K in keyof T as T[K]["optional"] extends true ? K : never]?: InferType<T[K]["type"]>;
+};
+export interface TypedSchema<T> extends JSONSchema {
+    __type?: T;
+}
+export declare function defineSchema<T extends SchemaDefinition>(definition: T): TypedSchema<InferSchema<T>>;
+export {};

package/dist/tiny-stdio-mcp-server/server.d.ts

@@ -0,0 +1,35 @@
+import type { ServerOptions, ToolDefinition, ToolHandler, HandleResult, Prompt, PromptHandler, Resource, ResourceHandler, ResourceTemplate, Transport, SDKTransport, JSONRPCNotification } from "./types.js";
+import type { TypedSchema } from "./schema.js";
+export interface Server {
+    tool<TIn, TOut = never>(name: string, description: string, inputSchema: TypedSchema<TIn>, handler: ToolHandler<TIn, TOut>, outputSchema?: TypedSchema<TOut>): Server;
+    registerTool<TIn, TOut = never>(definition: Omit<ToolDefinition<TIn, TOut>, "handler">, handler: ToolHandler<TIn, TOut>): Server;
+    prompt(definition: Prompt, handler: PromptHandler): Server;
+    resource(definition: Resource, handler: ResourceHandler): Server;
+    resourceTemplate(definition: ResourceTemplate, handler: ResourceHandler): Server;
+    method(name: string, handler: CustomMethodHandler): Server;
+    onNotification(listener: (notification: JSONRPCNotification) => void): () => void;
+    removeTool(name: string): boolean;
+    removePrompt(name: string): boolean;
+    removeResource(uri: string): boolean;
+    removeResourceTemplate(uriTemplate: string): boolean;
+    notifyToolsChanged(): Promise<void>;
+    notifyPromptsChanged(): Promise<void>;
+    notifyResourcesChanged(): Promise<void>;
+    notifyResourceUpdated(uri: string): Promise<void>;
+    createMessageSession(listener?: (notification: JSONRPCNotification) => void | Promise<void>): MessageSession;
+    handleMessage(method: string, params?: Record<string, unknown>): Promise<HandleResult>;
+    listen(): Promise<void>;
+    connect(transport: Transport): Promise<void>;
+    connectSDK(transport: SDKTransport): Promise<void>;
+}
+export interface MessageSessionContext {
+    readonly signal: AbortSignal;
+    notify(method: string, params?: Record<string, unknown>): Promise<void>;
+}
+export type CustomMethodHandler = (params: Record<string, unknown> | undefined, session: MessageSessionContext) => unknown | Promise<unknown>;
+export type MessageHandler = (method: string, params?: Record<string, unknown>) => Promise<HandleResult>;
+export interface MessageSession {
+    handleMessage: MessageHandler;
+    close(): void;
+}
+export declare function createServer(options: ServerOptions): Server;

package/dist/tiny-stdio-mcp-server/types.d.ts

@@ -0,0 +1,247 @@
+export interface JSONRPCRequest {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    method: string;
+    params?: Record<string, unknown>;
+}
+export interface JSONRPCResponse {
+    jsonrpc: "2.0";
+    id: string | number | null;
+    result?: unknown;
+    error?: JSONRPCError;
+}
+export interface JSONRPCError {
+    code: number;
+    message: string;
+    data?: unknown;
+}
+export declare const JSON_RPC_ERROR_CODES: Readonly<{
+    readonly PARSE_ERROR: -32700;
+    readonly INVALID_REQUEST: -32600;
+    readonly METHOD_NOT_FOUND: -32601;
+    readonly INVALID_PARAMS: -32602;
+    readonly INTERNAL_ERROR: -32603;
+    readonly RESOURCE_NOT_FOUND: -32002;
+}>;
+export declare class ToolError extends Error {
+    readonly code: number;
+    readonly data?: unknown | undefined;
+    constructor(code: number, message: string, data?: unknown | undefined);
+}
+export interface ToolsCapability {
+    listChanged?: boolean;
+}
+export interface PromptsCapability {
+    listChanged?: boolean;
+}
+export interface ResourcesCapability {
+    subscribe?: boolean;
+    listChanged?: boolean;
+}
+export interface InitializeResult {
+    protocolVersion: string;
+    capabilities: {
+        tools?: ToolsCapability;
+        prompts?: PromptsCapability;
+        resources?: ResourcesCapability;
+    };
+    serverInfo: {
+        name: string;
+        version: string;
+    };
+}
+export interface Tool {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: JSONSchema;
+    outputSchema?: JSONSchema;
+    annotations?: ToolAnnotations;
+    execution?: ToolExecution;
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+}
+export interface CallToolResult {
+    content: ContentItem[];
+    structuredContent?: Record<string, unknown>;
+    isError?: boolean;
+}
+export interface ToolAnnotations {
+    title?: string;
+    readOnlyHint?: boolean;
+    destructiveHint?: boolean;
+    idempotentHint?: boolean;
+    openWorldHint?: boolean;
+}
+export interface ToolExecution {
+    taskSupport?: "optional" | "required" | "forbidden";
+}
+export interface Icon {
+    src: string;
+    mimeType?: string;
+    sizes?: string[];
+    theme?: "light" | "dark";
+}
+export interface ContentAnnotations {
+    audience?: Array<"user" | "assistant">;
+    priority?: number;
+    lastModified?: string;
+}
+export interface ResourceLink {
+    type: "resource_link";
+    uri: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    size?: number;
+    annotations?: ContentAnnotations;
+}
+export interface PromptArgument {
+    name: string;
+    description?: string;
+    required?: boolean;
+}
+export interface Prompt {
+    name: string;
+    title?: string;
+    description?: string;
+    arguments?: PromptArgument[];
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+}
+export interface PromptMessage {
+    role: "user" | "assistant";
+    content: PromptContentItem;
+}
+export interface GetPromptResult {
+    description?: string;
+    messages: PromptMessage[];
+}
+export type PromptHandler = (args: Record<string, string>) => Promise<GetPromptResult> | GetPromptResult;
+export interface PromptDefinition extends Prompt {
+    handler: PromptHandler;
+}
+export interface Resource {
+    uri: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    size?: number;
+    annotations?: ContentAnnotations;
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+}
+export interface ResourceTemplate {
+    uriTemplate: string;
+    name: string;
+    title?: string;
+    description?: string;
+    mimeType?: string;
+    annotations?: ContentAnnotations;
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+}
+export type ResourceContents = {
+    uri: string;
+    mimeType?: string;
+    text: string;
+} | {
+    uri: string;
+    mimeType?: string;
+    blob: string;
+};
+export interface ReadResourceResult {
+    contents: ResourceContents[];
+}
+export type ResourceHandler = (uri: string) => Promise<ReadResourceResult> | ReadResourceResult;
+export interface ResourceDefinition extends Resource {
+    handler: ResourceHandler;
+}
+export interface ResourceTemplateDefinition extends ResourceTemplate {
+    handler: ResourceHandler;
+}
+export interface HandleResult {
+    result?: unknown;
+    error?: JSONRPCError;
+}
+export type PromptContentItem = {
+    type: "text";
+    text: string;
+    annotations?: ContentAnnotations;
+} | {
+    type: "image";
+    data: string;
+    mimeType: string;
+    annotations?: ContentAnnotations;
+} | {
+    type: "audio";
+    data: string;
+    mimeType: string;
+    annotations?: ContentAnnotations;
+} | {
+    type: "resource";
+    annotations?: ContentAnnotations;
+    resource: {
+        uri: string;
+        mimeType?: string;
+        text: string;
+    } | {
+        uri: string;
+        mimeType?: string;
+        blob: string;
+    };
+};
+export type ContentItem = PromptContentItem | ResourceLink;
+export interface JSONSchema {
+    type: "object";
+    properties?: Record<string, JSONSchemaProperty>;
+    required?: string[];
+    [keyword: string]: unknown;
+}
+export interface JSONSchemaProperty extends Record<string, unknown> {
+    type?: string | string[];
+    description?: string;
+    [keyword: string]: unknown;
+}
+export interface ServerOptions {
+    name: string;
+    version: string;
+    toolCallTimeoutMs?: number;
+    validateToolArguments?: boolean;
+    supportNotifications?: boolean;
+    supportResourceSubscriptions?: boolean;
+}
+import type { ToolReturn } from "./content/index.js";
+export type ToolHandler<T = Record<string, unknown>, TOut = ToolReturn> = (args: T) => Promise<TOut | CallToolResult> | TOut | CallToolResult;
+export interface ToolDefinition<T = Record<string, unknown>, TOut = ToolReturn> {
+    name: string;
+    title?: string;
+    description?: string;
+    inputSchema: JSONSchema;
+    outputSchema?: JSONSchema;
+    annotations?: ToolAnnotations;
+    execution?: ToolExecution;
+    icons?: Icon[];
+    _meta?: Record<string, unknown>;
+    handler: ToolHandler<T, TOut>;
+}
+export interface Transport {
+    readable: NodeJS.ReadableStream;
+    writable: NodeJS.WritableStream;
+}
+export interface SDKTransport {
+    onmessage?: (message: JSONRPCMessage) => void;
+    onclose?: () => void;
+    onerror?: (error: Error) => void;
+    start: () => Promise<void>;
+    close: () => Promise<void>;
+    send: (message: JSONRPCMessage) => Promise<void>;
+}
+export type JSONRPCMessage = JSONRPCRequest | JSONRPCResponse | JSONRPCNotification;
+export interface JSONRPCNotification {
+    jsonrpc: "2.0";
+    method: string;
+    params?: Record<string, unknown>;
+}

package/dist/toolcraft-design/acp/components.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Status of the agent output being rendered.
+ *
+ * `streaming` covers partial/in-progress content, which has not reached any outcome yet and so must not
+ * claim success. `success`/`error` are terminal outcomes known to the caller.
+ */
+export type AcpOutputState = "streaming" | "success" | "error";
+export declare function renderAgentMessage(text: string, state?: AcpOutputState): void;
+export declare function renderToolStart(kind: string, title: string): void;
+export declare function renderToolComplete(kind: string): void;
+export declare function renderReasoning(text: string): void;
+export declare function renderUsage(tokens: {
+    input: number;
+    output: number;
+    cached?: number;
+    costUsd?: number;
+}): void;
+export declare function renderPermissionRejected(title: string): void;
+export declare function renderError(message: string): void;

package/dist/toolcraft-design/acp/index.d.ts

@@ -0,0 +1,4 @@
+export { renderAgentMessage, renderToolStart, renderToolComplete, renderReasoning, renderUsage, renderError, renderPermissionRejected } from "./components.js";
+export type { AcpOutputState } from "./components.js";
+export { getAcpWriter, withAcpWriter } from "./writer.js";
+export type { AcpLineWriter } from "./writer.js";

package/dist/toolcraft-design/acp/writer.d.ts

@@ -0,0 +1,13 @@
+export type AcpLineWriter = (line: string) => void;
+/**
+ * Return the writer active in the current async context, or the default
+ * stdout writer if none is bound.
+ */
+export declare function getAcpWriter(): AcpLineWriter;
+/**
+ * Run `fn` with `writer` bound as the active ACP line writer. All calls to
+ * `renderAgentMessage`, `renderToolStart`, `renderAcpEvent`, etc. made inside
+ * `fn` (or async work awaited from `fn`) will go through `writer` instead of
+ * writing to `process.stdout`.
+ */
+export declare function withAcpWriter<T>(writer: AcpLineWriter, fn: () => Promise<T>): Promise<T>;

package/dist/toolcraft-design/components/browser.d.ts

@@ -0,0 +1,15 @@
+interface BrowserProcess {
+    once(event: "error", listener: (error: Error) => void): this;
+    once(event: "close", listener: (code: number | null, signal: NodeJS.Signals | null) => void): this;
+    unref(): void;
+}
+type SpawnBrowserProcess = (command: string, args: string[], options: {
+    detached: true;
+    stdio: "ignore";
+}) => BrowserProcess;
+export interface OpenExternalOptions {
+    platform?: NodeJS.Platform;
+    spawnProcess?: SpawnBrowserProcess;
+}
+export declare function openExternal(url: string, options?: OpenExternalOptions): Promise<void>;
+export {};

package/dist/toolcraft-design/components/catalog.d.ts

@@ -0,0 +1,26 @@
+import type { ThemePalette } from "../tokens/colors.js";
+export type CatalogTone = "accent" | "muted" | "success" | "warning" | "error" | "info";
+export interface CatalogMetric {
+    label: string;
+    value: string | number;
+    tone?: CatalogTone;
+}
+export interface CatalogItem {
+    label: string;
+    value: string;
+    detail?: string;
+    tone?: CatalogTone;
+}
+export interface CatalogGroup {
+    title: string;
+    description?: string;
+    items: CatalogItem[];
+}
+export interface RenderCatalogOptions {
+    theme: ThemePalette;
+    title: string;
+    subtitle?: string;
+    metrics?: CatalogMetric[];
+    groups: CatalogGroup[];
+}
+export declare function renderCatalog(options: RenderCatalogOptions): string;

package/dist/toolcraft-design/components/color.d.ts

@@ -0,0 +1,31 @@
+export interface Color {
+    (text: string): string;
+    reset: Color;
+    bold: Color;
+    dim: Color;
+    italic: Color;
+    underline: Color;
+    inverse: Color;
+    strikethrough: Color;
+    black: Color;
+    red: Color;
+    green: Color;
+    yellow: Color;
+    blue: Color;
+    magenta: Color;
+    cyan: Color;
+    white: Color;
+    gray: Color;
+    magentaBright: Color;
+    cyanBright: Color;
+    bgRed: Color;
+    bgGreen: Color;
+    bgYellow: Color;
+    bgBlue: Color;
+    bgMagenta: Color;
+    hex: (value: string) => Color;
+    rgb: (red: number, green: number, blue: number) => Color;
+    bgHex: (value: string) => Color;
+    bgRgb: (red: number, green: number, blue: number) => Color;
+}
+export declare const color: Color;

package/dist/toolcraft-design/components/command-errors.d.ts

@@ -0,0 +1,18 @@
+export declare function formatCommandNotFound(input: {
+    unknownCommand: string;
+    helpCommand: string;
+    suggestions?: readonly string[];
+}): {
+    label: string;
+    hint: string;
+};
+export declare function formatCommandNotFoundPanel(input: {
+    unknownCommand: string;
+    helpCommand: string;
+    suggestions?: readonly string[];
+    title?: string;
+}): {
+    title: string;
+    label: string;
+    footer: string;
+};

package/dist/toolcraft-design/components/detail-card.d.ts

@@ -0,0 +1,22 @@
+import type { ThemePalette } from "../tokens/colors.js";
+export interface DetailCardRow {
+    label: string;
+    value: string;
+}
+export interface DetailCardSection {
+    title?: string;
+    rows: DetailCardRow[];
+}
+export interface RenderDetailCardOptions {
+    theme: ThemePalette;
+    title: string;
+    subtitle?: string;
+    badges?: string[];
+    prose?: Array<{
+        title?: string;
+        value: string;
+    }>;
+    sections?: DetailCardSection[];
+    width?: number;
+}
+export declare function renderDetailCard(options: RenderDetailCardOptions): string;

package/dist/toolcraft-design/components/file-changes.d.ts

@@ -0,0 +1,16 @@
+export type FileChangeKind = "added" | "modified" | "deleted" | "renamed";
+export type FileChangeDisplayMode = "status" | "diff";
+export type FileChangeOutputFormat = "terminal" | "markdown";
+export interface FileChange {
+    path: string;
+    kind: FileChangeKind;
+    oldPath?: string;
+    conflict?: boolean;
+    oldContent?: string;
+    newContent?: string;
+}
+export interface RenderFileChangesOptions {
+    mode?: FileChangeDisplayMode;
+    format?: FileChangeOutputFormat;
+}
+export declare function renderFileChanges(changes: readonly FileChange[], options?: RenderFileChangesOptions): string;

package/dist/toolcraft-design/components/help-formatter-plain.d.ts

@@ -0,0 +1,5 @@
+import type { CommandInfo, FormatColumnsOptions, OptionInfo } from "./help-formatter.js";
+export declare function stripAnsi(value: string): string;
+export declare function formatColumns(opts: FormatColumnsOptions): string;
+export declare function formatCommandList(commands: CommandInfo[]): string;
+export declare function formatOptionList(options: OptionInfo[]): string;

package/dist/toolcraft-design/components/help-formatter.d.ts

@@ -0,0 +1,50 @@
+export type HelpTokenRole = "command" | "argument" | "option" | "literal" | "dim";
+export interface HelpToken {
+    text: string;
+    role: HelpTokenRole;
+}
+export interface CommandInfo {
+    name: string;
+    /** Structured tokens for TTY/markdown styling. Plain `name` is used when absent. */
+    nameTokens?: HelpToken[];
+    description: string;
+    /** Nesting depth relative to the help target. Depth 0 is a direct child. */
+    depth?: number;
+}
+export interface OptionInfo {
+    flags: string;
+    /** Structured tokens for TTY/markdown styling. Plain `flags` is used when absent. */
+    flagTokens?: HelpToken[];
+    description: string;
+}
+export interface FormatColumnsOptions {
+    rows: Array<{
+        left: string;
+        right: string;
+    }>;
+    totalWidth?: number;
+    minLeftWidth?: number;
+    maxLeftWidth?: number;
+    gap?: number;
+    indent?: number;
+}
+export declare function formatColumns(opts: FormatColumnsOptions): string;
+export declare function styleHelpToken(token: HelpToken): string;
+export declare function joinHelpTokens(tokens: HelpToken[]): string;
+export declare function renderHelpTokens(tokens: HelpToken[]): string;
+export declare function formatCommand(name: string, description: string): string;
+export declare function formatUsage(command: string, args?: string): string;
+export declare function formatOption(flags: string, description: string): string;
+export declare function formatCommandList(commands: CommandInfo[]): string;
+export declare function formatOptionList(options: OptionInfo[]): string;
+export declare const helpFormatter: {
+    readonly formatColumns: typeof formatColumns;
+    readonly formatCommand: typeof formatCommand;
+    readonly formatUsage: typeof formatUsage;
+    readonly formatOption: typeof formatOption;
+    readonly formatCommandList: typeof formatCommandList;
+    readonly formatOptionList: typeof formatOptionList;
+    readonly styleHelpToken: typeof styleHelpToken;
+    readonly joinHelpTokens: typeof joinHelpTokens;
+    readonly renderHelpTokens: typeof renderHelpTokens;
+};

package/dist/toolcraft-design/components/inspector-card.d.ts

@@ -0,0 +1,21 @@
+import type { ThemePalette } from "../tokens/colors.js";
+export interface InspectorField {
+    label: string;
+    value: string;
+}
+export interface InspectorSection {
+    title?: string;
+    fields: InspectorField[];
+}
+export interface RenderInspectorCardOptions {
+    theme: ThemePalette;
+    title: string;
+    subtitle?: string;
+    badges?: string[];
+    preview?: string;
+    previewTitle?: string;
+    sections?: InspectorSection[];
+    width?: number;
+    maxPreviewLines?: number;
+}
+export declare function renderInspectorCard(options: RenderInspectorCardOptions): string;

package/dist/toolcraft-design/components/logger.d.ts

@@ -0,0 +1,11 @@
+export interface LoggerOutput {
+    info(message: string): void;
+    success(message: string): void;
+    warn(message: string): void;
+    error(message: string): void;
+    resolved(label: string, value: string): void;
+    errorResolved(label: string, value: string): void;
+    message(message: string, symbol?: string): void;
+}
+export declare function createLogger(emitter?: (message: string) => void): LoggerOutput;
+export declare const logger: LoggerOutput;

package/dist/toolcraft-design/components/resource-browser.d.ts

@@ -0,0 +1,21 @@
+import type { ThemePalette } from "../tokens/colors.js";
+export interface ResourceBrowserItem {
+    label: string;
+    meta?: string[];
+    preview?: string;
+    badge?: string;
+}
+export interface ResourceBrowserGroup {
+    title: string;
+    description?: string;
+    emptyHint?: string;
+    items: ResourceBrowserItem[];
+}
+export interface RenderResourceBrowserOptions {
+    theme: ThemePalette;
+    title: string;
+    subtitle?: string;
+    groups: ResourceBrowserGroup[];
+    footer?: string;
+}
+export declare function renderResourceBrowser(options: RenderResourceBrowserOptions): string;