skykoi 2026.3.21 → 2026.3.23

package/dist/plugin-sdk/line/send.d.ts

@@ -0,0 +1,118 @@
+import { messagingApi } from "@line/bot-sdk";
+import type { LineSendResult } from "./types.js";
+type Message = messagingApi.Message;
+type TextMessage = messagingApi.TextMessage;
+type ImageMessage = messagingApi.ImageMessage;
+type LocationMessage = messagingApi.LocationMessage;
+type FlexContainer = messagingApi.FlexContainer;
+type TemplateMessage = messagingApi.TemplateMessage;
+type QuickReply = messagingApi.QuickReply;
+interface LineSendOpts {
+    channelAccessToken?: string;
+    accountId?: string;
+    verbose?: boolean;
+    mediaUrl?: string;
+    replyToken?: string;
+}
+export declare function createImageMessage(originalContentUrl: string, previewImageUrl?: string): ImageMessage;
+export declare function createLocationMessage(location: {
+    title: string;
+    address: string;
+    latitude: number;
+    longitude: number;
+}): LocationMessage;
+export declare function sendMessageLine(to: string, text: string, opts?: LineSendOpts): Promise<LineSendResult>;
+export declare function pushMessageLine(to: string, text: string, opts?: LineSendOpts): Promise<LineSendResult>;
+export declare function replyMessageLine(replyToken: string, messages: Message[], opts?: {
+    channelAccessToken?: string;
+    accountId?: string;
+    verbose?: boolean;
+}): Promise<void>;
+export declare function pushMessagesLine(to: string, messages: Message[], opts?: {
+    channelAccessToken?: string;
+    accountId?: string;
+    verbose?: boolean;
+}): Promise<LineSendResult>;
+export declare function createFlexMessage(altText: string, contents: messagingApi.FlexContainer): messagingApi.FlexMessage;
+/**
+ * Push an image message to a user/group
+ */
+export declare function pushImageMessage(to: string, originalContentUrl: string, previewImageUrl?: string, opts?: {
+    channelAccessToken?: string;
+    accountId?: string;
+    verbose?: boolean;
+}): Promise<LineSendResult>;
+/**
+ * Push a location message to a user/group
+ */
+export declare function pushLocationMessage(to: string, location: {
+    title: string;
+    address: string;
+    latitude: number;
+    longitude: number;
+}, opts?: {
+    channelAccessToken?: string;
+    accountId?: string;
+    verbose?: boolean;
+}): Promise<LineSendResult>;
+/**
+ * Push a Flex Message to a user/group
+ */
+export declare function pushFlexMessage(to: string, altText: string, contents: FlexContainer, opts?: {
+    channelAccessToken?: string;
+    accountId?: string;
+    verbose?: boolean;
+}): Promise<LineSendResult>;
+/**
+ * Push a Template Message to a user/group
+ */
+export declare function pushTemplateMessage(to: string, template: TemplateMessage, opts?: {
+    channelAccessToken?: string;
+    accountId?: string;
+    verbose?: boolean;
+}): Promise<LineSendResult>;
+/**
+ * Push a text message with quick reply buttons
+ */
+export declare function pushTextMessageWithQuickReplies(to: string, text: string, quickReplyLabels: string[], opts?: {
+    channelAccessToken?: string;
+    accountId?: string;
+    verbose?: boolean;
+}): Promise<LineSendResult>;
+/**
+ * Create quick reply buttons to attach to a message
+ */
+export declare function createQuickReplyItems(labels: string[]): QuickReply;
+/**
+ * Create a text message with quick reply buttons
+ */
+export declare function createTextMessageWithQuickReplies(text: string, quickReplyLabels: string[]): TextMessage & {
+    quickReply: QuickReply;
+};
+/**
+ * Show loading animation to user (lasts up to 20 seconds or until next message)
+ */
+export declare function showLoadingAnimation(chatId: string, opts?: {
+    channelAccessToken?: string;
+    accountId?: string;
+    loadingSeconds?: number;
+}): Promise<void>;
+/**
+ * Fetch user profile (display name, picture URL)
+ */
+export declare function getUserProfile(userId: string, opts?: {
+    channelAccessToken?: string;
+    accountId?: string;
+    useCache?: boolean;
+}): Promise<{
+    displayName: string;
+    pictureUrl?: string;
+} | null>;
+/**
+ * Get user's display name (with fallback to userId)
+ */
+export declare function getUserDisplayName(userId: string, opts?: {
+    channelAccessToken?: string;
+    accountId?: string;
+}): Promise<string>;
+export {};

package/dist/plugin-sdk/line/signature.d.ts

@@ -0,0 +1 @@
+export declare function validateLineSignature(body: string, signature: string, channelSecret: string): boolean;

package/dist/plugin-sdk/line/template-messages.d.ts

@@ -0,0 +1,119 @@
+import type { messagingApi } from "@line/bot-sdk";
+type TemplateMessage = messagingApi.TemplateMessage;
+type ConfirmTemplate = messagingApi.ConfirmTemplate;
+type ButtonsTemplate = messagingApi.ButtonsTemplate;
+type CarouselTemplate = messagingApi.CarouselTemplate;
+type CarouselColumn = messagingApi.CarouselColumn;
+type ImageCarouselTemplate = messagingApi.ImageCarouselTemplate;
+type ImageCarouselColumn = messagingApi.ImageCarouselColumn;
+type Action = messagingApi.Action;
+/**
+ * Create a confirm template (yes/no style dialog)
+ */
+export declare function createConfirmTemplate(text: string, confirmAction: Action, cancelAction: Action, altText?: string): TemplateMessage;
+/**
+ * Create a button template with title, text, and action buttons
+ */
+export declare function createButtonTemplate(title: string, text: string, actions: Action[], options?: {
+    thumbnailImageUrl?: string;
+    imageAspectRatio?: "rectangle" | "square";
+    imageSize?: "cover" | "contain";
+    imageBackgroundColor?: string;
+    defaultAction?: Action;
+    altText?: string;
+}): TemplateMessage;
+/**
+ * Create a carousel template with multiple columns
+ */
+export declare function createTemplateCarousel(columns: CarouselColumn[], options?: {
+    imageAspectRatio?: "rectangle" | "square";
+    imageSize?: "cover" | "contain";
+    altText?: string;
+}): TemplateMessage;
+/**
+ * Create a carousel column for use with createTemplateCarousel
+ */
+export declare function createCarouselColumn(params: {
+    title?: string;
+    text: string;
+    actions: Action[];
+    thumbnailImageUrl?: string;
+    imageBackgroundColor?: string;
+    defaultAction?: Action;
+}): CarouselColumn;
+/**
+ * Create an image carousel template (simpler, image-focused carousel)
+ */
+export declare function createImageCarousel(columns: ImageCarouselColumn[], altText?: string): TemplateMessage;
+/**
+ * Create an image carousel column for use with createImageCarousel
+ */
+export declare function createImageCarouselColumn(imageUrl: string, action: Action): ImageCarouselColumn;
+/**
+ * Create a message action (sends text when tapped)
+ */
+export declare function messageAction(label: string, text?: string): Action;
+/**
+ * Create a URI action (opens a URL when tapped)
+ */
+export declare function uriAction(label: string, uri: string): Action;
+/**
+ * Create a postback action (sends data to webhook when tapped)
+ */
+export declare function postbackAction(label: string, data: string, displayText?: string): Action;
+/**
+ * Create a datetime picker action
+ */
+export declare function datetimePickerAction(label: string, data: string, mode: "date" | "time" | "datetime", options?: {
+    initial?: string;
+    max?: string;
+    min?: string;
+}): Action;
+/**
+ * Create a simple yes/no confirmation dialog
+ */
+export declare function createYesNoConfirm(question: string, options?: {
+    yesText?: string;
+    noText?: string;
+    yesData?: string;
+    noData?: string;
+    altText?: string;
+}): TemplateMessage;
+/**
+ * Create a button menu with simple text buttons
+ */
+export declare function createButtonMenu(title: string, text: string, buttons: Array<{
+    label: string;
+    text?: string;
+}>, options?: {
+    thumbnailImageUrl?: string;
+    altText?: string;
+}): TemplateMessage;
+/**
+ * Create a button menu with URL links
+ */
+export declare function createLinkMenu(title: string, text: string, links: Array<{
+    label: string;
+    url: string;
+}>, options?: {
+    thumbnailImageUrl?: string;
+    altText?: string;
+}): TemplateMessage;
+/**
+ * Create a simple product/item carousel
+ */
+export declare function createProductCarousel(products: Array<{
+    title: string;
+    description: string;
+    imageUrl?: string;
+    price?: string;
+    actionLabel?: string;
+    actionUrl?: string;
+    actionData?: string;
+}>, altText?: string): TemplateMessage;
+import type { LineTemplateMessagePayload } from "./types.js";
+/**
+ * Convert a TemplateMessagePayload from ReplyPayload to a LINE TemplateMessage
+ */
+export declare function buildTemplateMessageFromPayload(payload: LineTemplateMessagePayload): TemplateMessage | null;
+export type { TemplateMessage, ConfirmTemplate, ButtonsTemplate, CarouselTemplate, CarouselColumn, ImageCarouselTemplate, ImageCarouselColumn, Action, };

package/dist/plugin-sdk/line/types.d.ts

@@ -0,0 +1,125 @@
+import type { WebhookEvent, TextMessage, ImageMessage, VideoMessage, AudioMessage, StickerMessage, LocationMessage } from "@line/bot-sdk";
+export type LineTokenSource = "config" | "env" | "file" | "none";
+export interface LineConfig {
+    enabled?: boolean;
+    channelAccessToken?: string;
+    channelSecret?: string;
+    tokenFile?: string;
+    secretFile?: string;
+    name?: string;
+    allowFrom?: Array<string | number>;
+    groupAllowFrom?: Array<string | number>;
+    dmPolicy?: "open" | "allowlist" | "pairing" | "disabled";
+    groupPolicy?: "open" | "allowlist" | "disabled";
+    /** Outbound response prefix override for this channel/account. */
+    responsePrefix?: string;
+    mediaMaxMb?: number;
+    webhookPath?: string;
+    accounts?: Record<string, LineAccountConfig>;
+    groups?: Record<string, LineGroupConfig>;
+}
+export interface LineAccountConfig {
+    enabled?: boolean;
+    channelAccessToken?: string;
+    channelSecret?: string;
+    tokenFile?: string;
+    secretFile?: string;
+    name?: string;
+    allowFrom?: Array<string | number>;
+    groupAllowFrom?: Array<string | number>;
+    dmPolicy?: "open" | "allowlist" | "pairing" | "disabled";
+    groupPolicy?: "open" | "allowlist" | "disabled";
+    /** Outbound response prefix override for this account. */
+    responsePrefix?: string;
+    mediaMaxMb?: number;
+    webhookPath?: string;
+    groups?: Record<string, LineGroupConfig>;
+}
+export interface LineGroupConfig {
+    enabled?: boolean;
+    allowFrom?: Array<string | number>;
+    requireMention?: boolean;
+    systemPrompt?: string;
+    skills?: string[];
+}
+export interface ResolvedLineAccount {
+    accountId: string;
+    name?: string;
+    enabled: boolean;
+    channelAccessToken: string;
+    channelSecret: string;
+    tokenSource: LineTokenSource;
+    config: LineConfig & LineAccountConfig;
+}
+export type LineMessageType = TextMessage | ImageMessage | VideoMessage | AudioMessage | StickerMessage | LocationMessage;
+export interface LineWebhookContext {
+    event: WebhookEvent;
+    replyToken?: string;
+    userId?: string;
+    groupId?: string;
+    roomId?: string;
+}
+export interface LineSendResult {
+    messageId: string;
+    chatId: string;
+}
+export interface LineProbeResult {
+    ok: boolean;
+    bot?: {
+        displayName?: string;
+        userId?: string;
+        basicId?: string;
+        pictureUrl?: string;
+    };
+    error?: string;
+}
+export type LineFlexMessagePayload = {
+    altText: string;
+    contents: unknown;
+};
+export type LineTemplateMessagePayload = {
+    type: "confirm";
+    text: string;
+    confirmLabel: string;
+    confirmData: string;
+    cancelLabel: string;
+    cancelData: string;
+    altText?: string;
+} | {
+    type: "buttons";
+    title: string;
+    text: string;
+    actions: Array<{
+        type: "message" | "uri" | "postback";
+        label: string;
+        data?: string;
+        uri?: string;
+    }>;
+    thumbnailImageUrl?: string;
+    altText?: string;
+} | {
+    type: "carousel";
+    columns: Array<{
+        title?: string;
+        text: string;
+        thumbnailImageUrl?: string;
+        actions: Array<{
+            type: "message" | "uri" | "postback";
+            label: string;
+            data?: string;
+            uri?: string;
+        }>;
+    }>;
+    altText?: string;
+};
+export type LineChannelData = {
+    quickReplies?: string[];
+    location?: {
+        title: string;
+        address: string;
+        latitude: number;
+        longitude: number;
+    };
+    flexMessage?: LineFlexMessagePayload;
+    templateMessage?: LineTemplateMessagePayload;
+};

package/dist/plugin-sdk/line/webhook.d.ts

@@ -0,0 +1,19 @@
+import type { WebhookRequestBody } from "@line/bot-sdk";
+import type { Request, Response, NextFunction } from "express";
+import type { RuntimeEnv } from "../runtime.js";
+export interface LineWebhookOptions {
+    channelSecret: string;
+    onEvents: (body: WebhookRequestBody) => Promise<void>;
+    runtime?: RuntimeEnv;
+}
+export declare function createLineWebhookMiddleware(options: LineWebhookOptions): (req: Request, res: Response, _next: NextFunction) => Promise<void>;
+export interface StartLineWebhookOptions {
+    channelSecret: string;
+    onEvents: (body: WebhookRequestBody) => Promise<void>;
+    runtime?: RuntimeEnv;
+    path?: string;
+}
+export declare function startLineWebhook(options: StartLineWebhookOptions): {
+    path: string;
+    handler: (req: Request, res: Response, _next: NextFunction) => Promise<void>;
+};

package/dist/plugin-sdk/link-understanding/apply.d.ts

@@ -0,0 +1,10 @@
+import type { MsgContext } from "../auto-reply/templating.js";
+import type { SKYKOIConfig } from "../config/config.js";
+export type ApplyLinkUnderstandingResult = {
+    outputs: string[];
+    urls: string[];
+};
+export declare function applyLinkUnderstanding(params: {
+    ctx: MsgContext;
+    cfg: SKYKOIConfig;
+}): Promise<ApplyLinkUnderstandingResult>;

package/dist/plugin-sdk/link-understanding/defaults.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_LINK_TIMEOUT_SECONDS = 30;
+export declare const DEFAULT_MAX_LINKS = 3;

package/dist/plugin-sdk/link-understanding/detect.d.ts

@@ -0,0 +1,3 @@
+export declare function extractLinksFromMessage(message: string, opts?: {
+    maxLinks?: number;
+}): string[];

package/dist/plugin-sdk/link-understanding/format.d.ts

@@ -0,0 +1,4 @@
+export declare function formatLinkUnderstandingBody(params: {
+    body?: string;
+    outputs: string[];
+}): string;

package/dist/plugin-sdk/link-understanding/runner.d.ts

@@ -0,0 +1,11 @@
+import type { MsgContext } from "../auto-reply/templating.js";
+import type { SKYKOIConfig } from "../config/config.js";
+export type LinkUnderstandingResult = {
+    urls: string[];
+    outputs: string[];
+};
+export declare function runLinkUnderstanding(params: {
+    cfg: SKYKOIConfig;
+    ctx: MsgContext;
+    message?: string;
+}): Promise<LinkUnderstandingResult>;

package/dist/plugin-sdk/logger.d.ts

@@ -0,0 +1,6 @@
+import { type RuntimeEnv } from "./runtime.js";
+export declare function logInfo(message: string, runtime?: RuntimeEnv): void;
+export declare function logWarn(message: string, runtime?: RuntimeEnv): void;
+export declare function logSuccess(message: string, runtime?: RuntimeEnv): void;
+export declare function logError(message: string, runtime?: RuntimeEnv): void;
+export declare function logDebug(message: string): void;

package/dist/plugin-sdk/logging/config.d.ts

@@ -0,0 +1,4 @@
+import type { SKYKOIConfig } from "../config/types.js";
+type LoggingConfig = SKYKOIConfig["logging"];
+export declare function readLoggingConfig(): LoggingConfig | undefined;
+export {};

package/dist/plugin-sdk/logging/console.d.ts

@@ -0,0 +1,19 @@
+import { type LogLevel } from "./levels.js";
+export type ConsoleStyle = "pretty" | "compact" | "json";
+type ConsoleSettings = {
+    level: LogLevel;
+    style: ConsoleStyle;
+};
+export type ConsoleLoggerSettings = ConsoleSettings;
+export declare function getConsoleSettings(): ConsoleLoggerSettings;
+export declare function getResolvedConsoleSettings(): ConsoleLoggerSettings;
+export declare function routeLogsToStderr(): void;
+export declare function setConsoleSubsystemFilter(filters?: string[] | null): void;
+export declare function setConsoleTimestampPrefix(enabled: boolean): void;
+export declare function shouldLogSubsystemToConsole(subsystem: string): boolean;
+/**
+ * Route console.* calls through file logging while still emitting to stdout/stderr.
+ * This keeps user-facing output unchanged but guarantees every console call is captured in log files.
+ */
+export declare function enableConsoleCapture(): void;
+export {};

package/dist/plugin-sdk/logging/diagnostic.d.ts

@@ -0,0 +1,58 @@
+declare const diag: import("./subsystem.js").SubsystemLogger;
+type SessionStateValue = "idle" | "processing" | "waiting";
+type SessionRef = {
+    sessionId?: string;
+    sessionKey?: string;
+};
+export declare function logWebhookReceived(params: {
+    channel: string;
+    updateType?: string;
+    chatId?: number | string;
+}): void;
+export declare function logWebhookProcessed(params: {
+    channel: string;
+    updateType?: string;
+    chatId?: number | string;
+    durationMs?: number;
+}): void;
+export declare function logWebhookError(params: {
+    channel: string;
+    updateType?: string;
+    chatId?: number | string;
+    error: string;
+}): void;
+export declare function logMessageQueued(params: {
+    sessionId?: string;
+    sessionKey?: string;
+    channel?: string;
+    source: string;
+}): void;
+export declare function logMessageProcessed(params: {
+    channel: string;
+    messageId?: number | string;
+    chatId?: number | string;
+    sessionId?: string;
+    sessionKey?: string;
+    durationMs?: number;
+    outcome: "completed" | "skipped" | "error";
+    reason?: string;
+    error?: string;
+}): void;
+export declare function logSessionStateChange(params: SessionRef & {
+    state: SessionStateValue;
+    reason?: string;
+}): void;
+export declare function logSessionStuck(params: SessionRef & {
+    state: SessionStateValue;
+    ageMs: number;
+}): void;
+export declare function logLaneEnqueue(lane: string, queueSize: number): void;
+export declare function logLaneDequeue(lane: string, waitMs: number, queueSize: number): void;
+export declare function logRunAttempt(params: SessionRef & {
+    runId: string;
+    attempt: number;
+}): void;
+export declare function logActiveRuns(): void;
+export declare function startDiagnosticHeartbeat(): void;
+export declare function stopDiagnosticHeartbeat(): void;
+export { diag as diagnosticLogger };

package/dist/plugin-sdk/logging/levels.d.ts

@@ -0,0 +1,4 @@
+export declare const ALLOWED_LOG_LEVELS: readonly ["silent", "fatal", "error", "warn", "info", "debug", "trace"];
+export type LogLevel = (typeof ALLOWED_LOG_LEVELS)[number];
+export declare function normalizeLogLevel(level?: string, fallback?: LogLevel): "silent" | "fatal" | "error" | "warn" | "info" | "debug" | "trace";
+export declare function levelToMinLevel(level: LogLevel): number;

package/dist/plugin-sdk/logging/logger.d.ts

@@ -0,0 +1,42 @@
+import { Logger as TsLogger } from "tslog";
+import type { ConsoleStyle } from "./console.js";
+import { type LogLevel } from "./levels.js";
+export declare const DEFAULT_LOG_DIR = "/tmp/SKYKOI";
+export declare const DEFAULT_LOG_FILE: string;
+export type LoggerSettings = {
+    level?: LogLevel;
+    file?: string;
+    consoleLevel?: LogLevel;
+    consoleStyle?: ConsoleStyle;
+};
+type LogObj = {
+    date?: Date;
+} & Record<string, unknown>;
+type ResolvedSettings = {
+    level: LogLevel;
+    file: string;
+};
+export type LoggerResolvedSettings = ResolvedSettings;
+export type LogTransportRecord = Record<string, unknown>;
+export type LogTransport = (logObj: LogTransportRecord) => void;
+export declare function isFileLogLevelEnabled(level: LogLevel): boolean;
+export declare function getLogger(): TsLogger<LogObj>;
+export declare function getChildLogger(bindings?: Record<string, unknown>, opts?: {
+    level?: LogLevel;
+}): TsLogger<LogObj>;
+export declare function toPinoLikeLogger(logger: TsLogger<LogObj>, level: LogLevel): PinoLikeLogger;
+export type PinoLikeLogger = {
+    level: string;
+    child: (bindings?: Record<string, unknown>) => PinoLikeLogger;
+    trace: (...args: unknown[]) => void;
+    debug: (...args: unknown[]) => void;
+    info: (...args: unknown[]) => void;
+    warn: (...args: unknown[]) => void;
+    error: (...args: unknown[]) => void;
+    fatal: (...args: unknown[]) => void;
+};
+export declare function getResolvedLoggerSettings(): LoggerResolvedSettings;
+export declare function setLoggerOverride(settings: LoggerSettings | null): void;
+export declare function resetLogger(): void;
+export declare function registerLogTransport(transport: LogTransport): () => void;
+export {};

package/dist/plugin-sdk/logging/redact-identifier.d.ts

@@ -0,0 +1,4 @@
+export declare function sha256HexPrefix(value: string, len?: number): string;
+export declare function redactIdentifier(value: string | undefined, opts?: {
+    len?: number;
+}): string;

package/dist/plugin-sdk/logging/redact.d.ts

@@ -0,0 +1,9 @@
+export type RedactSensitiveMode = "off" | "tools";
+type RedactOptions = {
+    mode?: RedactSensitiveMode;
+    patterns?: string[];
+};
+export declare function redactSensitiveText(text: string, options?: RedactOptions): string;
+export declare function redactToolDetail(detail: string): string;
+export declare function getDefaultRedactPatterns(): string[];
+export {};

package/dist/plugin-sdk/logging/state.d.ts

@@ -0,0 +1,17 @@
+export declare const loggingState: {
+    cachedLogger: unknown;
+    cachedSettings: unknown;
+    cachedConsoleSettings: unknown;
+    overrideSettings: unknown;
+    consolePatched: boolean;
+    forceConsoleToStderr: boolean;
+    consoleTimestampPrefix: boolean;
+    consoleSubsystemFilter: string[] | null;
+    resolvingConsoleSettings: boolean;
+    rawConsole: {
+        log: typeof console.log;
+        info: typeof console.info;
+        warn: typeof console.warn;
+        error: typeof console.error;
+    } | null;
+};

package/dist/plugin-sdk/logging/subsystem.d.ts

@@ -0,0 +1,16 @@
+import { type RuntimeEnv } from "../runtime.js";
+export type SubsystemLogger = {
+    subsystem: string;
+    trace: (message: string, meta?: Record<string, unknown>) => void;
+    debug: (message: string, meta?: Record<string, unknown>) => void;
+    info: (message: string, meta?: Record<string, unknown>) => void;
+    warn: (message: string, meta?: Record<string, unknown>) => void;
+    error: (message: string, meta?: Record<string, unknown>) => void;
+    fatal: (message: string, meta?: Record<string, unknown>) => void;
+    raw: (message: string) => void;
+    child: (name: string) => SubsystemLogger;
+};
+export declare function stripRedundantSubsystemPrefixForConsole(message: string, displaySubsystem: string): string;
+export declare function createSubsystemLogger(subsystem: string): SubsystemLogger;
+export declare function runtimeForLogger(logger: SubsystemLogger, exit?: RuntimeEnv["exit"]): RuntimeEnv;
+export declare function createSubsystemRuntime(subsystem: string, exit?: RuntimeEnv["exit"]): RuntimeEnv;

package/dist/plugin-sdk/logging.d.ts

@@ -0,0 +1,10 @@
+import type { ConsoleLoggerSettings, ConsoleStyle } from "./logging/console.js";
+import type { LogLevel } from "./logging/levels.js";
+import type { LoggerResolvedSettings, LoggerSettings, PinoLikeLogger } from "./logging/logger.js";
+import type { SubsystemLogger } from "./logging/subsystem.js";
+import { enableConsoleCapture, getConsoleSettings, getResolvedConsoleSettings, routeLogsToStderr, setConsoleSubsystemFilter, setConsoleTimestampPrefix, shouldLogSubsystemToConsole } from "./logging/console.js";
+import { ALLOWED_LOG_LEVELS, levelToMinLevel, normalizeLogLevel } from "./logging/levels.js";
+import { DEFAULT_LOG_DIR, DEFAULT_LOG_FILE, getChildLogger, getLogger, getResolvedLoggerSettings, isFileLogLevelEnabled, resetLogger, setLoggerOverride, toPinoLikeLogger } from "./logging/logger.js";
+import { createSubsystemLogger, createSubsystemRuntime, runtimeForLogger, stripRedundantSubsystemPrefixForConsole } from "./logging/subsystem.js";
+export { enableConsoleCapture, getConsoleSettings, getResolvedConsoleSettings, routeLogsToStderr, setConsoleSubsystemFilter, setConsoleTimestampPrefix, shouldLogSubsystemToConsole, ALLOWED_LOG_LEVELS, levelToMinLevel, normalizeLogLevel, DEFAULT_LOG_DIR, DEFAULT_LOG_FILE, getChildLogger, getLogger, getResolvedLoggerSettings, isFileLogLevelEnabled, resetLogger, setLoggerOverride, toPinoLikeLogger, createSubsystemLogger, createSubsystemRuntime, runtimeForLogger, stripRedundantSubsystemPrefixForConsole, };
+export type { ConsoleLoggerSettings, ConsoleStyle, LogLevel, LoggerResolvedSettings, LoggerSettings, PinoLikeLogger, SubsystemLogger, };

package/dist/plugin-sdk/markdown/code-spans.d.ts

@@ -0,0 +1,10 @@
+export type InlineCodeState = {
+    open: boolean;
+    ticks: number;
+};
+export declare function createInlineCodeState(): InlineCodeState;
+export type CodeSpanIndex = {
+    inlineState: InlineCodeState;
+    isInside: (index: number) => boolean;
+};
+export declare function buildCodeSpanIndex(text: string, inlineState?: InlineCodeState): CodeSpanIndex;

package/dist/plugin-sdk/markdown/fences.d.ts

@@ -0,0 +1,10 @@
+export type FenceSpan = {
+    start: number;
+    end: number;
+    openLine: string;
+    marker: string;
+    indent: string;
+};
+export declare function parseFenceSpans(buffer: string): FenceSpan[];
+export declare function findFenceSpanAt(spans: FenceSpan[], index: number): FenceSpan | undefined;
+export declare function isSafeFenceBreak(spans: FenceSpan[], index: number): boolean;

package/dist/plugin-sdk/markdown/frontmatter.d.ts

@@ -0,0 +1,2 @@
+export type ParsedFrontmatter = Record<string, string>;
+export declare function parseFrontmatterBlock(content: string): ParsedFrontmatter;