@jacobbubu/md-to-lark 1.0.0

package/dist/publish/last-normalize.js

@@ -0,0 +1,327 @@
+import { isTextualBlock, extractTextFromInlines, toPlainTextFromInlineList } from './common.js';
+const TABLE_DEFAULT_PAGE_WIDTH_PX = 1024;
+const TABLE_FONT_SIZE_PX = 14;
+const TABLE_CELL_HORIZONTAL_PADDING_PX = 24;
+const TABLE_TEXT_COLUMN_MIN_WIDTH_PX = 96;
+const TABLE_TEXT_COLUMN_MAX_WIDTH_PX = 360;
+const TABLE_NUMERIC_COLUMN_MIN_WIDTH_PX = 72;
+const TABLE_NUMERIC_COLUMN_MAX_WIDTH_PX = 240;
+const INVALID_NUMERIC_TOKENS = new Set([
+    'inf',
+    '+inf',
+    '-inf',
+    'infinity',
+    '+infinity',
+    '-infinity',
+    'na',
+    'n/a',
+    'nan',
+    'null',
+    'nil',
+    '--',
+    '-',
+]);
+const CURRENCY_PREFIX_RE = /^(?:[$€£¥₹]|cny|rmb|usd|eur|gbp|jpy|hkd|cad|aud)\s*/i;
+const NUMBER_WITH_OPTIONAL_UNIT_RE = /^([+-]?(?:(?:\d{1,3}(?:,\d{3})+)|\d+)(?:\.\d+)?|[+-]?\.\d+)(?:\s*(%|[a-zA-Z\u4e00-\u9fff]{1,12}))?$/;
+function isMermaidLanguage(language) {
+    if (typeof language !== 'string')
+        return false;
+    const normalized = language.trim().toLowerCase();
+    if (normalized === 'mermaid')
+        return true;
+    if (normalized.startsWith('mermaid '))
+        return true;
+    return normalized.split(/[,\s{}[\]()]+/).includes('mermaid');
+}
+function clamp(value, min, max) {
+    return Math.min(max, Math.max(min, value));
+}
+function charWidthPx(ch) {
+    if (/\s/.test(ch))
+        return TABLE_FONT_SIZE_PX * 0.33;
+    if (/[0-9]/.test(ch))
+        return TABLE_FONT_SIZE_PX * 0.56;
+    if (/[A-Z]/.test(ch))
+        return TABLE_FONT_SIZE_PX * 0.62;
+    if (/[a-z]/.test(ch))
+        return TABLE_FONT_SIZE_PX * 0.54;
+    if (/[\u4e00-\u9fff\u3040-\u30ff\uac00-\ud7af]/.test(ch))
+        return TABLE_FONT_SIZE_PX * 1.0;
+    if (/[.,:;'"`|]/.test(ch))
+        return TABLE_FONT_SIZE_PX * 0.32;
+    if (/[(){}\[\]<>]/.test(ch))
+        return TABLE_FONT_SIZE_PX * 0.4;
+    if (/[!@#$%^&*+=?/\\~-]/.test(ch))
+        return TABLE_FONT_SIZE_PX * 0.48;
+    return TABLE_FONT_SIZE_PX * 0.56;
+}
+function estimateLineWidthPx(line) {
+    let width = 0;
+    for (const ch of Array.from(line)) {
+        width += charWidthPx(ch);
+    }
+    return width;
+}
+function estimateCellTextWidthPx(text) {
+    if (text.trim().length === 0)
+        return 0;
+    const lines = text.split(/\r?\n/);
+    const maxWidth = lines.reduce((acc, line) => Math.max(acc, estimateLineWidthPx(line)), 0);
+    return Math.ceil(maxWidth + TABLE_CELL_HORIZONTAL_PADDING_PX);
+}
+function isEmptyLikeNumericValue(value) {
+    const compact = value.trim().toLowerCase().replace(/\s+/g, '');
+    return compact.length === 0 || INVALID_NUMERIC_TOKENS.has(compact);
+}
+function isNumericLikeValue(value) {
+    let text = value.trim();
+    if (text.length === 0)
+        return false;
+    if (isEmptyLikeNumericValue(text))
+        return false;
+    text = text.replace(CURRENCY_PREFIX_RE, '');
+    if (text.length === 0)
+        return false;
+    const matched = text.match(NUMBER_WITH_OPTIONAL_UNIT_RE);
+    if (!matched)
+        return false;
+    const numberToken = matched[1];
+    if (!numberToken)
+        return false;
+    const numberPart = numberToken.replace(/,/g, '');
+    const parsed = Number(numberPart);
+    return Number.isFinite(parsed);
+}
+function classifyCellValue(value) {
+    if (isEmptyLikeNumericValue(value))
+        return 'empty';
+    return isNumericLikeValue(value) ? 'numeric' : 'text';
+}
+function isRightAlignedAlready(align) {
+    return align === 'right' || align === 3;
+}
+function normalizeDeclaredColumnAlign(raw, columnSize) {
+    if (!Array.isArray(raw) || columnSize <= 0) {
+        return Array.from({ length: Math.max(0, columnSize) }, () => undefined);
+    }
+    const normalized = Array.from({ length: columnSize }, () => undefined);
+    for (let col = 0; col < columnSize; col += 1) {
+        const value = raw[col];
+        if (value === 'left' || value === 'center' || value === 'right') {
+            normalized[col] = value;
+        }
+        else if (value === 1) {
+            normalized[col] = 'left';
+        }
+        else if (value === 2) {
+            normalized[col] = 'center';
+        }
+        else if (value === 3) {
+            normalized[col] = 'right';
+        }
+    }
+    return normalized;
+}
+function allocateTableColumnWidths(rows, richCells, hasHeaderRow, pageWidthPx = TABLE_DEFAULT_PAGE_WIDTH_PX) {
+    if (rows.length === 0)
+        return [];
+    const columnCount = rows[0]?.length ?? 0;
+    if (columnCount === 0)
+        return [];
+    const dataRowStart = hasHeaderRow ? 1 : 0;
+    const preferred = [];
+    const minWidths = [];
+    for (let col = 0; col < columnCount; col += 1) {
+        let numeric = true;
+        for (let row = dataRowStart; row < rows.length; row += 1) {
+            if (richCells[row]?.[col]) {
+                numeric = false;
+                break;
+            }
+        }
+        for (let row = dataRowStart; row < rows.length; row += 1) {
+            if (!numeric)
+                break;
+            const value = rows[row]?.[col] ?? '';
+            if (classifyCellValue(value) === 'text') {
+                numeric = false;
+                break;
+            }
+        }
+        const minWidth = numeric ? TABLE_NUMERIC_COLUMN_MIN_WIDTH_PX : TABLE_TEXT_COLUMN_MIN_WIDTH_PX;
+        const maxWidth = numeric ? TABLE_NUMERIC_COLUMN_MAX_WIDTH_PX : TABLE_TEXT_COLUMN_MAX_WIDTH_PX;
+        const widths = [];
+        for (let row = 0; row < rows.length; row += 1) {
+            widths.push(estimateCellTextWidthPx(rows[row]?.[col] ?? ''));
+        }
+        const sorted = [...widths].sort((a, b) => a - b);
+        const p95Idx = Math.max(0, Math.min(sorted.length - 1, Math.ceil(sorted.length * 0.95) - 1));
+        const p95 = sorted[p95Idx] ?? 0;
+        const preferredWidth = clamp(p95 > 0 ? p95 : minWidth, minWidth, maxWidth);
+        preferred.push(preferredWidth);
+        minWidths.push(minWidth);
+    }
+    const preferredSum = preferred.reduce((sum, item) => sum + item, 0);
+    if (preferredSum <= pageWidthPx) {
+        return preferred.map((item) => Math.round(item));
+    }
+    const minSum = minWidths.reduce((sum, item) => sum + item, 0);
+    if (minSum >= pageWidthPx) {
+        const ratio = pageWidthPx / minSum;
+        return minWidths.map((item) => Math.max(50, Math.round(item * ratio)));
+    }
+    const flex = preferred.map((item, idx) => Math.max(item - (minWidths[idx] ?? 0), 0));
+    const flexSum = flex.reduce((sum, item) => sum + item, 0);
+    const ratio = flexSum > 0 ? (pageWidthPx - minSum) / flexSum : 0;
+    return preferred.map((item, idx) => Math.round((minWidths[idx] ?? 0) + (item - (minWidths[idx] ?? 0)) * ratio));
+}
+function applyNumericColumnRightAlignment(rows, textBlocks, richCells, hasHeaderRow) {
+    const rowCount = rows.length;
+    if (rowCount === 0)
+        return;
+    const columnCount = rows[0]?.length ?? 0;
+    if (columnCount === 0)
+        return;
+    const dataRowStart = hasHeaderRow ? 1 : 0;
+    if (dataRowStart >= rowCount)
+        return;
+    for (let col = 0; col < columnCount; col += 1) {
+        let numericColumn = true;
+        for (let row = dataRowStart; row < rowCount; row += 1) {
+            if (richCells[row]?.[col]) {
+                numericColumn = false;
+                break;
+            }
+            if (classifyCellValue(rows[row]?.[col] ?? '') === 'text') {
+                numericColumn = false;
+                break;
+            }
+        }
+        if (!numericColumn)
+            continue;
+        for (let row = dataRowStart; row < rowCount; row += 1) {
+            const textBlock = textBlocks[row]?.[col];
+            if (!textBlock)
+                continue;
+            if (isRightAlignedAlready(textBlock.payload.style.align))
+                continue;
+            textBlock.payload.style.align = 'right';
+        }
+    }
+}
+function applyDefaultHeaderCenterAlignment(textBlocks, hasHeaderRow) {
+    if (!hasHeaderRow)
+        return;
+    const headerRow = textBlocks[0];
+    if (!headerRow || headerRow.length === 0)
+        return;
+    for (const textBlock of headerRow) {
+        if (!textBlock)
+            continue;
+        textBlock.payload.style.align = 'center';
+    }
+}
+function applyDeclaredColumnAlignment(textBlocks, columnAlign) {
+    if (columnAlign.length === 0)
+        return;
+    for (let row = 0; row < textBlocks.length; row += 1) {
+        for (let col = 0; col < columnAlign.length; col += 1) {
+            const align = columnAlign[col];
+            if (align === undefined)
+                continue;
+            const textBlock = textBlocks[row]?.[col];
+            if (!textBlock)
+                continue;
+            textBlock.payload.style.align = align;
+        }
+    }
+}
+export function ensureLastBlockBttIds(last) {
+    for (const block of Object.values(last.blocks)) {
+        block.bttId = block.id;
+    }
+}
+export function collectMermaidPatches(last) {
+    const patches = new Map();
+    for (const block of Object.values(last.blocks)) {
+        if (block.type !== 'code')
+            continue;
+        if (!isMermaidLanguage(block.payload.style.language))
+            continue;
+        const code = extractTextFromInlines(block.payload.inlines);
+        patches.set(block.id, { code });
+    }
+    return patches;
+}
+export function applyTableColumnWidthHeuristics(last) {
+    for (const block of Object.values(last.blocks)) {
+        if (block.type !== 'table')
+            continue;
+        const rowSize = Math.max(1, block.payload.rowSize ?? 0);
+        const columnSize = Math.max(1, block.payload.columnSize ?? 0);
+        if (rowSize <= 0 || columnSize <= 0)
+            continue;
+        const cells = block.payload.cells && block.payload.cells.length > 0 ? block.payload.cells : block.children;
+        if (!cells || cells.length === 0)
+            continue;
+        const rows = [];
+        const textBlocks = [];
+        const richCells = [];
+        for (let r = 0; r < rowSize; r += 1) {
+            const row = [];
+            const rowTextBlocks = [];
+            const rowRichCells = [];
+            for (let c = 0; c < columnSize; c += 1) {
+                const idx = r * columnSize + c;
+                const cellId = cells[idx];
+                if (!cellId) {
+                    row.push('');
+                    rowTextBlocks.push(null);
+                    rowRichCells.push(false);
+                    continue;
+                }
+                const cell = last.blocks[cellId];
+                if (!cell || cell.type !== 'table_cell') {
+                    row.push('');
+                    rowTextBlocks.push(null);
+                    rowRichCells.push(false);
+                    continue;
+                }
+                const childBlocks = cell.children.map((id) => last.blocks[id]).filter(Boolean);
+                const textChild = childBlocks.find((candidate) => {
+                    return Boolean(candidate && isTextualBlock(candidate) && candidate.type === 'text');
+                }) ?? null;
+                const hasRichContent = childBlocks.length > 1 ||
+                    childBlocks.some((candidate) => {
+                        return !candidate || !isTextualBlock(candidate) || candidate.type !== 'text';
+                    });
+                if (!textChild) {
+                    row.push('');
+                    rowTextBlocks.push(null);
+                    rowRichCells.push(hasRichContent);
+                    continue;
+                }
+                row.push(toPlainTextFromInlineList(textChild.payload.inlines).replace(/\s+/g, ' ').trim());
+                rowTextBlocks.push(textChild);
+                rowRichCells.push(hasRichContent);
+            }
+            rows.push(row);
+            textBlocks.push(rowTextBlocks);
+            richCells.push(rowRichCells);
+        }
+        const hasHeaderRow = block.payload.headerRow ?? rowSize > 1;
+        const declaredColumnAlign = normalizeDeclaredColumnAlign(block.payload.columnAlign, columnSize);
+        const hasDeclaredColumnAlign = declaredColumnAlign.some((item) => item !== undefined);
+        if (hasDeclaredColumnAlign) {
+            applyDeclaredColumnAlignment(textBlocks, declaredColumnAlign);
+        }
+        else {
+            applyDefaultHeaderCenterAlignment(textBlocks, hasHeaderRow);
+            applyNumericColumnRightAlignment(rows, textBlocks, richCells, hasHeaderRow);
+        }
+        const widths = allocateTableColumnWidths(rows, richCells, hasHeaderRow);
+        if (widths.length > 0) {
+            block.payload.columnWidth = widths;
+        }
+    }
+}

package/dist/publish/process-file.js

@@ -0,0 +1,228 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { convertLASTToBTT } from '../interop/index.js';
+import { clearDocumentContent, normalizeDocumentId } from '../lark/docx/ops.js';
+import { renderBTTToDocument, } from '../lark/docx/render-btt.js';
+import { hastToLAST, markdownToHast, prepareMarkdownBeforePublish } from '../pipeline/index.js';
+import { applySingleH1TitleRule, buildTitleForMarkdown } from '../commands/publish-md/title-policy.js';
+import { applyStandaloneAttachmentTransforms } from './asset-adapter.js';
+import { patchBTTForMermaidAndAssets } from './btt-patch.js';
+import { buildPipelineDocumentId } from './ids.js';
+import { applyTableColumnWidthHeuristics, collectMermaidPatches, ensureLastBlockBttIds } from './last-normalize.js';
+import { buildPipelineStagePaths, writeBttStage, writeHastStage, writeLastStage, writePrepareStage, writePublishStageArtifact, writeSourceStage, } from './stage-cache.js';
+function stringifyConsoleArg(arg) {
+    if (typeof arg === 'string')
+        return arg;
+    try {
+        return JSON.stringify(arg);
+    }
+    catch {
+        return String(arg);
+    }
+}
+async function withCapturedRetryLogs(run) {
+    const originalWarn = console.warn;
+    const retryLogs = [];
+    let result;
+    let caughtError;
+    console.warn = (...args) => {
+        const line = args.map((arg) => stringifyConsoleArg(arg)).join(' ');
+        if (line.includes('[retry]')) {
+            retryLogs.push(line);
+        }
+        originalWarn(...args);
+    };
+    try {
+        result = await run();
+    }
+    catch (error) {
+        caughtError = error;
+    }
+    finally {
+        console.warn = originalWarn;
+    }
+    if (caughtError !== undefined) {
+        return { retryLogs, error: caughtError };
+    }
+    if (result !== undefined) {
+        return { result, retryLogs };
+    }
+    return { retryLogs };
+}
+function inferFailedBlocksFromError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    const sourceMatch = /source=([^\s]+)\s+type=(\d+)/.exec(message);
+    if (!sourceMatch || !sourceMatch[1] || !sourceMatch[2]) {
+        return [];
+    }
+    return [
+        {
+            sourceBlockId: sourceMatch[1],
+            blockType: Number.parseInt(sourceMatch[2], 10),
+            parentBlockId: '',
+            error: message,
+        },
+    ];
+}
+export async function processSingleMarkdownFile(params) {
+    const { runtime, inputSet, options, markdownPath, index, resolveTargetDocumentId } = params;
+    const stagePaths = buildPipelineStagePaths(runtime.pipelineCacheRootDir, markdownPath);
+    const startedAt = new Date().toISOString();
+    const sourceMarkdown = await readFile(markdownPath, 'utf8');
+    let markdown = sourceMarkdown;
+    if (runtime.markdownPreset) {
+        markdown = await runtime.markdownPreset.transform(markdown, {
+            inputPath: markdownPath,
+            index,
+            total: inputSet.markdownFiles.length,
+            env: runtime.env,
+            log: (...args) => console.log(`[preset ${index + 1}/${inputSet.markdownFiles.length}]`, ...args.map((arg) => String(arg))),
+        });
+    }
+    await writeSourceStage(stagePaths, sourceMarkdown, markdown, {
+        sourcePath: path.resolve(markdownPath),
+        preset: runtime.markdownPreset ? runtime.markdownPreset.displayPath : null,
+        startedAt,
+    });
+    const prepareResult = await prepareMarkdownBeforePublish(markdownPath, markdown, {
+        ...runtime.prepareConfig,
+        prepareDir: stagePaths.prepareDir,
+    });
+    markdown = prepareResult.preparedContent;
+    await writePrepareStage(stagePaths, markdown, prepareResult);
+    console.log(`[prepare ${index + 1}/${inputSet.markdownFiles.length}] rewritten=${prepareResult.rewrittenCount} downloaded=${prepareResult.downloadedCount} failed=${prepareResult.failedCount} log=${prepareResult.logFilePath}`);
+    const hast = await markdownToHast(markdown);
+    await writeHastStage(stagePaths, hast);
+    const h1RuleResult = options.title ? {} : applySingleH1TitleRule(hast);
+    const title = buildTitleForMarkdown(markdownPath, inputSet, options.title, h1RuleResult.derivedTitle, {
+        datePrefix: runtime.titleDatePrefix,
+    });
+    const documentKey = buildPipelineDocumentId(markdownPath);
+    const last = hastToLAST(hast, {
+        documentId: documentKey,
+        mode: 'fragment',
+    });
+    await writeLastStage(stagePaths, last);
+    ensureLastBlockBttIds(last);
+    const baseDir = path.dirname(markdownPath);
+    const localAssetByBlockId = applyStandaloneAttachmentTransforms(last, baseDir);
+    applyTableColumnWidthHeuristics(last);
+    const mermaidByBlockId = collectMermaidPatches(last);
+    const btt = convertLASTToBTT(last, {
+        documentId: documentKey,
+    });
+    patchBTTForMermaidAndAssets(btt, mermaidByBlockId, localAssetByBlockId, {
+        mermaidRender: runtime.mermaidRenderConfig,
+    });
+    await writeBttStage(stagePaths, btt, {
+        mermaidPatchCount: mermaidByBlockId.size,
+        mermaidTarget: runtime.mermaidRenderConfig.target,
+        mermaidBoard: runtime.mermaidRenderConfig.board,
+        localAssetCount: localAssetByBlockId.size,
+    });
+    if (options.dryRun) {
+        const dryRunArtifact = {
+            status: 'dry-run',
+            sourcePath: path.resolve(markdownPath),
+            title,
+            documentId: null,
+            rootBlockId: null,
+            createdAt: startedAt,
+            finishedAt: new Date().toISOString(),
+            failedBlocks: [],
+            retryLogs: [],
+            mediaTokenMappings: [],
+        };
+        await writePublishStageArtifact(stagePaths, dryRunArtifact);
+        console.log(`[dry-run ${index + 1}/${inputSet.markdownFiles.length}] input: ${markdownPath}`);
+        console.log(`[dry-run ${index + 1}/${inputSet.markdownFiles.length}] title: ${title}`);
+        console.log(`[dry-run ${index + 1}/${inputSet.markdownFiles.length}] blocks: ${Object.keys(last.blocks).length}`);
+        console.log(`[dry-run ${index + 1}/${inputSet.markdownFiles.length}] btt blocks: ${Object.keys(btt.flatBlocks).length}`);
+        console.log(`[dry-run ${index + 1}/${inputSet.markdownFiles.length}] mermaid patches: ${mermaidByBlockId.size}`);
+        console.log(`[dry-run ${index + 1}/${inputSet.markdownFiles.length}] mermaid target: ${runtime.mermaidRenderConfig.target}`);
+        console.log(`[dry-run ${index + 1}/${inputSet.markdownFiles.length}] local assets: ${localAssetByBlockId.size}`);
+        return {
+            stagePaths,
+            title,
+            documentId: null,
+            status: 'dry-run',
+        };
+    }
+    let documentId = options.documentId ? normalizeDocumentId(options.documentId) : '';
+    let rootBlockId = null;
+    let failedBlocks = [];
+    let mediaTokenMappings = [];
+    let retryLogs = [];
+    try {
+        const captured = await withCapturedRetryLogs(async () => {
+            if (!documentId) {
+                if (!resolveTargetDocumentId) {
+                    throw new Error('Failed to resolve target document id.');
+                }
+                documentId = await resolveTargetDocumentId(title);
+            }
+            if (!documentId) {
+                throw new Error('Failed to resolve target document id.');
+            }
+            rootBlockId = await clearDocumentContent(runtime.sdkClient, documentId, runtime.authOptions, runtime.docxLimiter);
+            const renderReport = await renderBTTToDocument(runtime.sdkClient, documentId, rootBlockId, btt.root, runtime.authOptions, runtime.docxLimiter, runtime.mediaLimiter, {
+                continueOnError: true,
+                mermaidByBlockId,
+                mermaidRender: runtime.mermaidRenderConfig,
+            });
+            failedBlocks = renderReport.failedNodes;
+            mediaTokenMappings = renderReport.mediaTokenMappings;
+            if (renderReport.failedNodes.length > 0) {
+                const first = renderReport.failedNodes[0];
+                throw new Error(`renderBTTToDocument has ${renderReport.failedNodes.length} failed block(s), first source=${first.sourceBlockId} type=${first.blockType}`);
+            }
+        });
+        retryLogs = captured.retryLogs;
+        if (captured.error !== undefined) {
+            throw captured.error;
+        }
+    }
+    catch (error) {
+        if (failedBlocks.length === 0) {
+            failedBlocks = inferFailedBlocksFromError(error);
+        }
+        const failedArtifact = {
+            status: 'failed',
+            sourcePath: path.resolve(markdownPath),
+            title,
+            documentId: documentId || null,
+            rootBlockId,
+            createdAt: startedAt,
+            finishedAt: new Date().toISOString(),
+            failedBlocks,
+            retryLogs,
+            mediaTokenMappings,
+            error: error instanceof Error ? error.message : String(error),
+        };
+        await writePublishStageArtifact(stagePaths, failedArtifact);
+        throw error;
+    }
+    const successArtifact = {
+        status: 'published',
+        sourcePath: path.resolve(markdownPath),
+        title,
+        documentId,
+        rootBlockId,
+        createdAt: startedAt,
+        finishedAt: new Date().toISOString(),
+        failedBlocks,
+        retryLogs,
+        mediaTokenMappings,
+    };
+    await writePublishStageArtifact(stagePaths, successArtifact);
+    console.log(`[${index + 1}/${inputSet.markdownFiles.length}] Published markdown: ${markdownPath}`);
+    console.log(`[${index + 1}/${inputSet.markdownFiles.length}] Document ID: ${documentId}`);
+    console.log(`[${index + 1}/${inputSet.markdownFiles.length}] Title: ${title}`);
+    console.log(`[${index + 1}/${inputSet.markdownFiles.length}] stage-cache: ${stagePaths.rootDir} (00-source..05-publish)`);
+    return {
+        stagePaths,
+        title,
+        documentId,
+        status: 'published',
+    };
+}

package/dist/publish/runtime.js

@@ -0,0 +1,133 @@
+import path from 'node:path';
+import * as lark from '@larksuiteoapi/node-sdk';
+import { DEFAULT_MERMAID_BOARD_SYNTAX_TYPE, normalizeMermaidRenderTarget, } from '../commands/publish-md/mermaid-render.js';
+import { createLarkClientConfigFromEnv } from '../lark/index.js';
+import { RateLimiter } from '../shared/rate-limiter.js';
+function getSdkDomain(baseUrl) {
+    const lower = baseUrl.toLowerCase();
+    if (lower.includes('open.larksuite.com'))
+        return lark.Domain.Lark;
+    if (lower.includes('open.feishu.cn'))
+        return lark.Domain.Feishu;
+    return baseUrl;
+}
+function toPositiveInt(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value <= 0)
+        return undefined;
+    return Math.round(value);
+}
+function toNonNegativeInt(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value) || value < 0)
+        return undefined;
+    return Math.round(value);
+}
+function parseOptionalEnvNonNegativeInt(raw) {
+    if (raw === undefined)
+        return undefined;
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return undefined;
+    return toNonNegativeInt(Number(trimmed));
+}
+function parseBoolean(value, fallback) {
+    if (value === undefined || value.trim().length === 0)
+        return fallback;
+    const normalized = value.trim().toLowerCase();
+    if (['1', 'true', 'yes', 'on'].includes(normalized))
+        return true;
+    if (['0', 'false', 'no', 'off'].includes(normalized))
+        return false;
+    return fallback;
+}
+function normalizeOptionalPath(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    if (!trimmed)
+        return undefined;
+    if (trimmed === '~')
+        return process.env.HOME;
+    if (trimmed.startsWith('~/')) {
+        const home = process.env.HOME;
+        return home ? path.join(home, trimmed.slice(2)) : trimmed;
+    }
+    return trimmed;
+}
+export function buildPublishRuntime(options, env, markdownPreset) {
+    const config = createLarkClientConfigFromEnv(env);
+    const sdkClient = new lark.Client({
+        appId: config.appId,
+        appSecret: config.appSecret,
+        domain: getSdkDomain(config.baseUrl),
+        loggerLevel: lark.LoggerLevel.warn,
+        disableTokenCache: false,
+    });
+    const authOptions = config.tokenType === 'user' ? lark.withUserAccessToken(config.userAccessToken) : undefined;
+    const docxLimiterIntervalMs = toPositiveInt(Number((env.LARK_DOCX_MIN_INTERVAL_MS ?? '').trim())) ?? 260;
+    const mediaLimiterIntervalMs = toPositiveInt(Number((env.LARK_MEDIA_MIN_INTERVAL_MS ?? '').trim())) ?? 450;
+    const publishCooldownMs = toPositiveInt(Number((env.LARK_PUBLISH_COOLDOWN_MS ?? '').trim())) ?? 600;
+    const downloadRemoteImages = options.downloadRemoteImages ?? parseBoolean(env.DOWNLOAD_REMOTE_IMAGES, true);
+    const titleDatePrefix = options.titleDatePrefix ?? parseBoolean(env.LARK_TITLE_DATE_PREFIX, true);
+    const ytDlpPath = normalizeOptionalPath(options.ytDlpPath ?? env.YT_DLP_PATH);
+    const ytDlpCookiesPath = normalizeOptionalPath(options.ytDlpCookiesPath ?? env.YT_DLP_COOKIES_PATH);
+    const pipelineCacheRootDir = path.resolve(options.pipelineCacheDir ?? env.PIPELINE_CACHE_DIR ?? './out/pipeline-cache');
+    const prepareTimeoutMs = toPositiveInt(Number((env.PREPARE_TIMEOUT_MS ?? '').trim())) ?? 15_000;
+    const prepareMaxRetries = toNonNegativeInt(Number((env.PREPARE_MAX_RETRIES ?? '').trim())) ?? 3;
+    const prepareBackoffBaseMs = toPositiveInt(Number((env.PREPARE_BACKOFF_BASE_MS ?? '').trim())) ?? 500;
+    const prepareBackoffMaxMs = toPositiveInt(Number((env.PREPARE_BACKOFF_MAX_MS ?? '').trim())) ?? 5_000;
+    const prepareBackoffJitterRatio = Number((env.PREPARE_BACKOFF_JITTER_RATIO ?? '').trim());
+    const prepareJitter = Number.isFinite(prepareBackoffJitterRatio) && prepareBackoffJitterRatio >= 0 ? prepareBackoffJitterRatio : 0.2;
+    const ytDlpTimeoutMs = toPositiveInt(Number((env.YT_DLP_TIMEOUT_MS ?? '').trim())) ?? 600_000;
+    const mermaidTarget = normalizeMermaidRenderTarget(options.mermaidTarget ?? env.LARK_MERMAID_TARGET);
+    const mermaidBoardSyntaxType = options.mermaidBoardSyntaxType ??
+        parseOptionalEnvNonNegativeInt(env.LARK_MERMAID_BOARD_SYNTAX_TYPE) ??
+        DEFAULT_MERMAID_BOARD_SYNTAX_TYPE;
+    const mermaidBoardStyleType = options.mermaidBoardStyleType ?? parseOptionalEnvNonNegativeInt(env.LARK_MERMAID_BOARD_STYLE_TYPE);
+    const mermaidBoardDiagramType = options.mermaidBoardDiagramType ?? parseOptionalEnvNonNegativeInt(env.LARK_MERMAID_BOARD_DIAGRAM_TYPE);
+    const mermaidRenderConfig = {
+        target: mermaidTarget,
+        board: {
+            syntaxType: mermaidBoardSyntaxType,
+            ...(mermaidBoardStyleType === undefined ? {} : { styleType: mermaidBoardStyleType }),
+            ...(mermaidBoardDiagramType === undefined ? {} : { diagramType: mermaidBoardDiagramType }),
+        },
+    };
+    return {
+        env,
+        markdownPreset,
+        authOptions,
+        sdkClient,
+        docxLimiter: new RateLimiter(docxLimiterIntervalMs),
+        mediaLimiter: new RateLimiter(mediaLimiterIntervalMs),
+        docxLimiterIntervalMs,
+        mediaLimiterIntervalMs,
+        publishCooldownMs,
+        pipelineCacheRootDir,
+        titleDatePrefix,
+        downloadRemoteImages,
+        ...(ytDlpPath ? { ytDlpPath } : {}),
+        mermaidRenderConfig,
+        prepareConfig: {
+            enabled: downloadRemoteImages,
+            timeoutMs: prepareTimeoutMs,
+            maxRetries: prepareMaxRetries,
+            backoffBaseMs: prepareBackoffBaseMs,
+            backoffMaxMs: prepareBackoffMaxMs,
+            backoffJitterRatio: prepareJitter,
+            ytDlpTimeoutMs,
+            ...(ytDlpPath ? { ytDlpPath } : {}),
+            ...(ytDlpCookiesPath ? { ytDlpCookiesPath } : {}),
+        },
+    };
+}
+export function logPublishRuntimeSummary(runtime, inputCount, inputMode) {
+    console.log(`Resolved markdown files: ${inputCount} (${inputMode === 'single' ? 'single' : 'directory'})`);
+    console.log(`Rate limits: docx=${runtime.docxLimiterIntervalMs}ms media=${runtime.mediaLimiterIntervalMs}ms cooldown=${runtime.publishCooldownMs}ms`);
+    console.log(`Prepare: download_remote_images=${String(runtime.downloadRemoteImages)} yt_dlp=${runtime.ytDlpPath ? 'enabled' : 'disabled'}`);
+    console.log(runtime.mermaidRenderConfig.target === 'board'
+        ? `Mermaid: target=board syntax_type=${String(runtime.mermaidRenderConfig.board.syntaxType)} style_type=${String(runtime.mermaidRenderConfig.board.styleType ?? '(default)')} diagram_type=${String(runtime.mermaidRenderConfig.board.diagramType ?? '(default)')}`
+        : 'Mermaid: target=text-drawing');
+    if (runtime.markdownPreset) {
+        console.log(`Preset: ${runtime.markdownPreset.displayPath}`);
+    }
+}