@kamilio/wire 0.1.0

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/interactive/pagination.js

@@ -0,0 +1,52 @@
+import { color } from "../../components/color.js";
+import { GLYPHS } from "./glyphs.js";
+import { getColumns, getRows } from "./wrap.js";
+import { wrapAnsi } from "fast-wrap-ansi";
+function countLines(values) {
+    return values.reduce((sum, value) => sum + value.split("\n").length, 0);
+}
+function trimToRows(values, cursorOffset, rows, hasTop, hasBottom) {
+    const output = [...values];
+    while (countLines(output) > rows && output.length > 1) {
+        const removeFromTop = hasTop && cursorOffset > 0;
+        const removeFromBottom = hasBottom && cursorOffset < output.length - 1;
+        if (removeFromTop) {
+            output.shift();
+            cursorOffset -= 1;
+        }
+        else if (removeFromBottom) {
+            output.pop();
+        }
+        else {
+            output.pop();
+        }
+    }
+    return output;
+}
+export function limitOptions(opts) {
+    const { cursor, options, style, output, maxItems = Number.POSITIVE_INFINITY, columnPadding = 0, rowPadding = 4 } = opts;
+    if (options.length === 0) {
+        return [];
+    }
+    const columns = Math.max(1, getColumns(output) - columnPadding);
+    const rowBudget = Math.max(getRows(output) - rowPadding, 0);
+    const visibleCount = Math.max(Math.min(maxItems, rowBudget), 5);
+    const cappedVisibleCount = Math.min(visibleCount, options.length);
+    let start = 0;
+    if (cursor >= cappedVisibleCount - 3) {
+        start = Math.max(Math.min(cursor - cappedVisibleCount + 3, options.length - cappedVisibleCount), 0);
+    }
+    const hasTopMarker = cappedVisibleCount < options.length && start > 0;
+    const hasBottomMarker = cappedVisibleCount < options.length && start + cappedVisibleCount < options.length;
+    const visible = options
+        .slice(start, start + cappedVisibleCount)
+        .map((option, index) => wrapAnsi(style(option, start + index === cursor), columns, { hard: true, trim: false }));
+    const trimmed = trimToRows(visible, Math.max(cursor - start, 0), Math.max(rowBudget - Number(hasTopMarker) - Number(hasBottomMarker), 1), hasTopMarker, hasBottomMarker);
+    if (hasTopMarker) {
+        trimmed.unshift(color.dim(GLYPHS.ellipsis));
+    }
+    if (hasBottomMarker) {
+        trimmed.push(color.dim(GLYPHS.ellipsis));
+    }
+    return trimmed;
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/interactive/password.d.ts

@@ -0,0 +1,10 @@
+import { CANCEL } from "./cancel-symbol.js";
+export interface PasswordOptions {
+    message: string;
+    mask?: string;
+    validate?: (value: string) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function passwordPrompt(opts: PasswordOptions): Promise<string | typeof CANCEL>;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/interactive/password.js

@@ -0,0 +1,55 @@
+import { color } from "../../components/color.js";
+import { GLYPHS, symbol, symbolBar } from "./glyphs.js";
+import { Prompt } from "./core.js";
+class PasswordPrompt extends Prompt {
+    mask;
+    constructor(opts) {
+        super({
+            ...opts,
+            initialValue: "",
+            initialUserInput: "",
+            render: (prompt) => renderPasswordPrompt(prompt, opts),
+            validate: opts.validate
+        });
+        this.mask = opts.mask ?? GLYPHS.passwordMask;
+        this.on("userInput", (value) => this.setValue(value));
+    }
+    get masked() {
+        return this.mask.repeat(this.userInput.length);
+    }
+    get userInputWithCursor() {
+        if (this.state === "submit") {
+            return this.masked;
+        }
+        const masked = this.masked;
+        const before = masked.slice(0, this.cursor);
+        const current = masked[this.cursor];
+        const after = masked.slice(this.cursor + 1);
+        if (current) {
+            return `${before}${color.inverse(current)}${after}`;
+        }
+        return `${before}${color.inverse("█")}`;
+    }
+    promptNonTty() {
+        return this.readNonTtyLine();
+    }
+}
+function renderHeader(prompt, message) {
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${message}`;
+}
+function renderPasswordPrompt(prompt, opts) {
+    const value = prompt.masked;
+    if (prompt.state === "submit") {
+        return `${renderHeader(prompt, opts.message)}\n${color.gray(GLYPHS.bar)}  ${color.dim(value)}\n${color.green(GLYPHS.barEnd)}`;
+    }
+    if (prompt.state === "cancel") {
+        return `${renderHeader(prompt, opts.message)}\n${color.gray(GLYPHS.bar)}  ${color.dim.strikethrough(value)}\n${color.red(GLYPHS.barEnd)}`;
+    }
+    if (prompt.state === "error") {
+        return `${renderHeader(prompt, opts.message)}\n${symbolBar(prompt.state)}  ${prompt.userInputWithCursor}\n${color.yellow(GLYPHS.barEnd)}  ${color.yellow(prompt.error)}`;
+    }
+    return `${renderHeader(prompt, opts.message)}\n${symbolBar(prompt.state)}  ${prompt.userInputWithCursor}\n${color.cyan(GLYPHS.barEnd)}`;
+}
+export function passwordPrompt(opts) {
+    return new PasswordPrompt(opts).prompt();
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/interactive/select.d.ts

@@ -0,0 +1,18 @@
+import { CANCEL } from "./cancel-symbol.js";
+export interface SelectOption<Value> {
+    value: Value;
+    label: string;
+    hint?: string;
+    disabled?: boolean;
+}
+export interface SelectOptions<Value> {
+    message: string;
+    options: Array<SelectOption<Value>>;
+    initialValue?: Value;
+    maxItems?: number;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function findNonDisabled<Value>(start: number, direction: 1 | -1, options: Array<SelectOption<Value>>): number;
+export declare function selectPrompt<Value>(opts: SelectOptions<Value>): Promise<Value | typeof CANCEL>;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/interactive/select.js

@@ -0,0 +1,89 @@
+import { color } from "../../components/color.js";
+import { GLYPHS, symbol } from "./glyphs.js";
+import { Prompt } from "./core.js";
+import { limitOptions } from "./pagination.js";
+class SelectPrompt extends Prompt {
+    options;
+    constructor(opts) {
+        if (opts.options.length === 0) {
+            throw new Error("Select prompt requires at least one option.");
+        }
+        if (opts.options.every((option) => option.disabled)) {
+            throw new Error("Select prompt requires at least one enabled option.");
+        }
+        const initialIndex = Math.max(opts.options.findIndex((option) => option.value === opts.initialValue), 0);
+        const cursor = findNonDisabled(initialIndex, 1, opts.options);
+        super({
+            ...opts,
+            initialValue: opts.options[cursor]?.value,
+            render: (prompt) => renderSelectPrompt(prompt, opts)
+        }, false);
+        this.options = opts.options;
+        this._cursor = cursor;
+        this.setValue(this.options[this._cursor]?.value);
+        this.on("cursor", (action) => {
+            if (action === "up" || action === "left") {
+                this._cursor = findNonDisabled(this._cursor - 1, -1, this.options);
+            }
+            else if (action === "down" || action === "right") {
+                this._cursor = findNonDisabled(this._cursor + 1, 1, this.options);
+            }
+            this.setValue(this.options[this._cursor]?.value);
+        });
+    }
+    get visibleOptions() {
+        return this.options;
+    }
+    promptNonTty() {
+        if (process.env.POE_NO_PROMPT === "1") {
+            return Promise.resolve(this.value);
+        }
+        return super.promptNonTty();
+    }
+}
+export function findNonDisabled(start, direction, options) {
+    if (options.every((option) => option.disabled)) {
+        return start;
+    }
+    let index = start;
+    for (let checked = 0; checked < options.length; checked += 1) {
+        index = (index + options.length) % options.length;
+        if (!options[index]?.disabled) {
+            return index;
+        }
+        index += direction;
+    }
+    return start;
+}
+function renderOption(option, active, submitted, cancelled) {
+    const hint = option.hint ? color.dim(` (${option.hint})`) : "";
+    if (submitted)
+        return color.dim(option.label);
+    if (cancelled)
+        return color.dim.strikethrough(option.label);
+    if (option.disabled)
+        return `${color.gray(GLYPHS.radioInactive)} ${color.gray.strikethrough(option.label)}${hint}`;
+    if (active)
+        return `${color.green(GLYPHS.radioActive)} ${option.label}${hint}`;
+    return `${color.dim(GLYPHS.radioInactive)} ${color.dim(option.label)}${hint}`;
+}
+function renderSelectPrompt(prompt, opts) {
+    if (prompt.state === "submit" || prompt.state === "cancel") {
+        const option = prompt.visibleOptions[prompt.cursor];
+        const rendered = option ? renderOption(option, false, prompt.state === "submit", prompt.state === "cancel") : "";
+        const end = prompt.state === "submit" ? color.green(GLYPHS.barEnd) : color.red(GLYPHS.barEnd);
+        return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${color.gray(GLYPHS.bar)}  ${rendered}\n${end}`;
+    }
+    const lines = limitOptions({
+        cursor: prompt.cursor,
+        options: prompt.visibleOptions,
+        output: opts.output ?? process.stdout,
+        maxItems: opts.maxItems,
+        columnPadding: 3,
+        style: (option, active) => renderOption(option, active, false, false)
+    }).map((line) => `${color.cyan(GLYPHS.bar)}  ${line}`);
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${opts.message}\n${lines.join("\n")}\n${color.cyan(GLYPHS.barEnd)}`;
+}
+export function selectPrompt(opts) {
+    return new SelectPrompt(opts).prompt();
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/interactive/test-helpers.d.ts

@@ -0,0 +1,21 @@
+import { PassThrough, Writable } from "node:stream";
+export interface PromptHarness {
+    input: PassThrough & {
+        isTTY?: boolean;
+        setRawMode?: (enabled: boolean) => void;
+    };
+    output: Writable & {
+        columns?: number;
+        rows?: number;
+        isTTY?: boolean;
+        frames: string[];
+    };
+    rawModes: boolean[];
+    getOutput: () => string;
+}
+export declare function createPromptHarness(options?: {
+    tty?: boolean;
+    columns?: number;
+    rows?: number;
+}): PromptHarness;
+export declare function tick(): Promise<void>;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/interactive/test-helpers.js

@@ -0,0 +1,32 @@
+import { PassThrough, Writable } from "node:stream";
+export function createPromptHarness(options = {}) {
+    const chunks = [];
+    const frames = [];
+    const rawModes = [];
+    const input = new PassThrough();
+    const output = new Writable({
+        write(chunk, _encoding, callback) {
+            const value = String(chunk);
+            chunks.push(value);
+            frames.push(value);
+            callback();
+        }
+    });
+    input.isTTY = options.tty ?? true;
+    input.setRawMode = (enabled) => {
+        rawModes.push(enabled);
+    };
+    output.isTTY = options.tty ?? true;
+    output.columns = options.columns ?? 80;
+    output.rows = options.rows ?? 20;
+    output.frames = frames;
+    return {
+        input,
+        output,
+        rawModes,
+        getOutput: () => chunks.join("")
+    };
+}
+export async function tick() {
+    await new Promise((resolve) => setImmediate(resolve));
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/interactive/text.d.ts

@@ -0,0 +1,12 @@
+import { CANCEL } from "./cancel-symbol.js";
+export interface TextOptions {
+    message: string;
+    placeholder?: string;
+    defaultValue?: string;
+    initialValue?: string;
+    validate?: (value: string) => string | Error | undefined;
+    signal?: AbortSignal;
+    input?: NodeJS.ReadableStream;
+    output?: NodeJS.WritableStream;
+}
+export declare function textPrompt(opts: TextOptions): Promise<string | typeof CANCEL>;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/interactive/text.js

@@ -0,0 +1,60 @@
+import { color } from "../../components/color.js";
+import { GLYPHS, symbol, symbolBar } from "./glyphs.js";
+import { Prompt } from "./core.js";
+class TextPrompt extends Prompt {
+    constructor(opts) {
+        const initialUserInput = opts.initialValue ?? "";
+        super({
+            ...opts,
+            initialValue: initialUserInput,
+            initialUserInput,
+            render: (prompt) => renderTextPrompt(prompt, opts),
+            validate: opts.validate
+        });
+        this.on("userInput", (value) => this.setValue(value));
+        this.on("finalize", () => {
+            if (this.state === "submit") {
+                this.setValue(this.value || opts.defaultValue || "");
+            }
+        });
+    }
+    get userInputWithCursor() {
+        if (this.state === "submit") {
+            return this.userInput;
+        }
+        const before = this.userInput.slice(0, this.cursor);
+        const current = this.userInput[this.cursor];
+        const after = this.userInput.slice(this.cursor + 1);
+        if (current) {
+            return `${before}${color.inverse(current)}${after}`;
+        }
+        return `${before}${color.inverse("█")}`;
+    }
+    promptNonTty() {
+        return this.readNonTtyLine();
+    }
+}
+function renderHeader(prompt, message) {
+    return `${color.gray(GLYPHS.barStart)} ${symbol(prompt.state)} ${message}`;
+}
+function renderTextPrompt(prompt, opts) {
+    const value = prompt.value ?? "";
+    if (prompt.state === "submit") {
+        return `${renderHeader(prompt, opts.message)}\n${color.gray(GLYPHS.bar)}  ${color.dim(value)}\n${color.green(GLYPHS.barEnd)}`;
+    }
+    if (prompt.state === "cancel") {
+        return `${renderHeader(prompt, opts.message)}\n${color.gray(GLYPHS.bar)}  ${color.dim.strikethrough(value)}\n${color.red(GLYPHS.barEnd)}`;
+    }
+    const input = prompt.userInput.length > 0
+        ? prompt.userInputWithCursor
+        : opts.placeholder
+            ? `${color.inverse(opts.placeholder[0] ?? " ")}${color.dim(opts.placeholder.slice(1))}`
+            : color.inverse("_");
+    if (prompt.state === "error") {
+        return `${renderHeader(prompt, opts.message)}\n${symbolBar(prompt.state)}  ${input}\n${color.yellow(GLYPHS.barEnd)}  ${color.yellow(prompt.error)}`;
+    }
+    return `${renderHeader(prompt, opts.message)}\n${symbolBar(prompt.state)}  ${input}\n${color.cyan(GLYPHS.barEnd)}`;
+}
+export function textPrompt(opts) {
+    return new TextPrompt(opts).prompt();
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/interactive/wrap.d.ts

@@ -0,0 +1,4 @@
+export declare function getColumns(output: NodeJS.WritableStream): number;
+export declare function getRows(output: NodeJS.WritableStream): number;
+export declare function wrapTextWithPrefix(output: NodeJS.WritableStream, text: string, prefix: string, startPrefix?: string): string;
+export declare function wrapFrame(output: NodeJS.WritableStream, frame: string): string;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/interactive/wrap.js

@@ -0,0 +1,18 @@
+import { wrapAnsi } from "fast-wrap-ansi";
+import stringWidth from "fast-string-width";
+export function getColumns(output) {
+    return Math.max(1, output.columns ?? 80);
+}
+export function getRows(output) {
+    return Math.max(1, output.rows ?? 20);
+}
+export function wrapTextWithPrefix(output, text, prefix, startPrefix = prefix) {
+    const width = Math.max(1, getColumns(output) - stringWidth(prefix));
+    return wrapAnsi(text, width, { hard: true, trim: false })
+        .split("\n")
+        .map((line, index) => `${index === 0 ? startPrefix : prefix}${line}`)
+        .join("\n");
+}
+export function wrapFrame(output, frame) {
+    return wrapAnsi(frame, getColumns(output), { hard: true, trim: false });
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/primitives/cancel.d.ts

@@ -0,0 +1,2 @@
+export { isCancel } from "../interactive/cancel-symbol.js";
+export declare function cancel(msg?: string): void;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/primitives/cancel.js

@@ -0,0 +1,9 @@
+import { color } from "../../components/color.js";
+export { isCancel } from "../interactive/cancel-symbol.js";
+import { resolveOutputFormat } from "../../internal/output-format.js";
+export function cancel(msg = "") {
+    if (resolveOutputFormat() !== "terminal") {
+        return;
+    }
+    process.stdout.write(`${color.gray("└")}  ${color.red(msg)}\n\n`);
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/primitives/intro.d.ts

@@ -0,0 +1 @@
+export declare function intro(title: string): void;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/primitives/intro.js

@@ -0,0 +1,16 @@
+import { color } from "../../components/color.js";
+import { text } from "../../components/text.js";
+import { resolveOutputFormat } from "../../internal/output-format.js";
+import { stripAnsi } from "../../internal/strip-ansi.js";
+export function intro(title) {
+    const format = resolveOutputFormat();
+    if (format === "json") {
+        return;
+    }
+    if (format === "markdown") {
+        const safeTitle = stripAnsi(title).replaceAll("\r\n", " ").replaceAll("\n", " ").replaceAll("\r", " ");
+        process.stdout.write(`# ${safeTitle}\n\n`);
+        return;
+    }
+    process.stdout.write(`${color.gray("┌")}  ${text.intro(title)}\n`);
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/primitives/log.d.ts

@@ -0,0 +1,18 @@
+export interface LogMessageOptions {
+    symbol?: string;
+    secondarySymbol?: string;
+    spacing?: number;
+    withGuide?: boolean;
+}
+export declare function message(msg: string, options?: LogMessageOptions): void;
+export declare function info(msg: string): void;
+export declare function success(msg: string): void;
+export declare function warn(msg: string): void;
+export declare function error(msg: string): void;
+export declare const log: {
+    info: typeof info;
+    success: typeof success;
+    message: typeof message;
+    warn: typeof warn;
+    error: typeof error;
+};

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/primitives/log.js

@@ -0,0 +1,104 @@
+import { color } from "../../components/color.js";
+import { symbols } from "../../components/symbols.js";
+import { resolveOutputFormat } from "../../internal/output-format.js";
+import { stripAnsi } from "../../internal/strip-ansi.js";
+function renderMarkdownInline(value) {
+    return stripAnsi(value).replaceAll("\r\n", " ").replaceAll("\n", " ").replaceAll("\r", " ");
+}
+function writeTerminalMessage(msg, { symbol = color.gray("│"), secondarySymbol = color.gray("│"), spacing = 1, withGuide = true } = {}) {
+    const lines = [];
+    const showGuide = withGuide !== false;
+    const contentLines = msg.split("\n");
+    const prefix = showGuide ? `${symbol}  ` : "";
+    const continuationPrefix = showGuide ? `${secondarySymbol}  ` : "";
+    const emptyGuide = showGuide ? secondarySymbol : "";
+    for (let index = 0; index < spacing; index += 1) {
+        lines.push(emptyGuide);
+    }
+    if (contentLines.length === 0) {
+        process.stdout.write("\n");
+        return;
+    }
+    const [firstLine = "", ...continuationLines] = contentLines;
+    if (firstLine.length > 0) {
+        lines.push(`${prefix}${firstLine}`);
+    }
+    else {
+        lines.push(showGuide ? symbol : "");
+    }
+    for (const line of continuationLines) {
+        if (line.length > 0) {
+            lines.push(`${continuationPrefix}${line}`);
+            continue;
+        }
+        lines.push(emptyGuide);
+    }
+    process.stdout.write(`${lines.join("\n")}\n`);
+}
+export function message(msg, options) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        process.stdout.write(`- ${renderMarkdownInline(msg)}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({ level: "message", message: stripAnsi(msg) })}\n`);
+        return;
+    }
+    writeTerminalMessage(msg, options);
+}
+export function info(msg) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        process.stdout.write(`- **info:** ${renderMarkdownInline(msg)}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({ level: "info", message: stripAnsi(msg) })}\n`);
+        return;
+    }
+    message(msg, { symbol: symbols.info });
+}
+export function success(msg) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        process.stdout.write(`- **success:** ${renderMarkdownInline(msg)}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({ level: "success", message: stripAnsi(msg) })}\n`);
+        return;
+    }
+    message(msg, { symbol: symbols.success });
+}
+export function warn(msg) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        process.stdout.write(`- **warning:** ${renderMarkdownInline(msg)}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({ level: "warn", message: stripAnsi(msg) })}\n`);
+        return;
+    }
+    message(msg, { symbol: color.yellow("▲") });
+}
+export function error(msg) {
+    const format = resolveOutputFormat();
+    if (format === "markdown") {
+        process.stdout.write(`- **error:** ${renderMarkdownInline(msg)}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({ level: "error", message: stripAnsi(msg) })}\n`);
+        return;
+    }
+    message(msg, { symbol: color.red("■") });
+}
+export const log = {
+    info,
+    success,
+    message,
+    warn,
+    error
+};

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/primitives/note.d.ts

@@ -0,0 +1 @@
+export declare function note(message: string, title?: string): void;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/primitives/note.js

@@ -0,0 +1,39 @@
+import { color } from "../../components/color.js";
+import { resolveOutputFormat } from "../../internal/output-format.js";
+import { stripAnsi } from "../../internal/strip-ansi.js";
+function getVisibleWidth(value) {
+    return stripAnsi(value).length;
+}
+function renderTerminalNote(message, title) {
+    const contentLines = ["", ...message.split("\n"), ""];
+    const visibleTitle = stripAnsi(title ?? "");
+    const contentWidth = Math.max(visibleTitle.length, ...contentLines.map((line) => getVisibleWidth(line))) + 2;
+    const titleLine = `${color.green("◇")}  ${color.reset(title ?? "")} ${color.gray(`${"─".repeat(Math.max(contentWidth - visibleTitle.length - 1, 1))}╮`)}`;
+    const content = contentLines.map((line) => {
+        const padding = " ".repeat(contentWidth - getVisibleWidth(line));
+        return `${color.gray("│")}  ${line}${padding}${color.gray("│")}`;
+    });
+    const bottom = color.gray(`├${"─".repeat(contentWidth + 2)}╯`);
+    return [color.gray("│"), titleLine, ...content, bottom].join("\n");
+}
+export function note(message, title) {
+    const format = resolveOutputFormat();
+    const strippedMessage = stripAnsi(message);
+    const strippedTitle = stripAnsi(title ?? "").replaceAll("\r\n", " ").replaceAll("\n", " ").replaceAll("\r", " ");
+    if (format === "markdown") {
+        const lines = strippedMessage.split("\n");
+        const heading = strippedTitle ? `> **${strippedTitle}**\n` : "";
+        const body = lines.map((line) => `> ${line}`).join("\n");
+        process.stdout.write(`${heading}${body}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({
+            type: "note",
+            title: strippedTitle,
+            message: strippedMessage
+        })}\n`);
+        return;
+    }
+    process.stdout.write(`${renderTerminalNote(message, title)}\n`);
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/primitives/outro.d.ts

@@ -0,0 +1 @@
+export declare function outro(message: string): void;

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/primitives/outro.js

@@ -0,0 +1,16 @@
+import { color } from "../../components/color.js";
+import { resolveOutputFormat } from "../../internal/output-format.js";
+import { stripAnsi } from "../../internal/strip-ansi.js";
+export function outro(message) {
+    const format = resolveOutputFormat();
+    const stripped = stripAnsi(message);
+    if (format === "markdown") {
+        process.stdout.write(`---\n${stripped}\n`);
+        return;
+    }
+    if (format === "json") {
+        process.stdout.write(`${JSON.stringify({ type: "outro", message: stripped })}\n`);
+        return;
+    }
+    process.stdout.write(`${color.gray("│")}\n${color.gray("└")}  ${message}\n\n`);
+}

package/node_modules/toolcraft/node_modules/toolcraft-design/dist/prompts/primitives/spinner.d.ts

@@ -0,0 +1,6 @@
+export interface SpinnerOptions {
+    start: (message?: string) => void;
+    stop: (message?: string, code?: number) => void;
+    message: (message?: string) => void;
+}
+export declare function spinner(): SpinnerOptions;