@mseep/korean-dart-mcp 0.9.3

package/build/cli.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { Command } from "commander";
+import { VERSION } from "./version.js";
+const program = new Command();
+program
+    .name("korean-dart")
+    .description("OpenDART CLI — 공시/재무/지분 조회")
+    .version(VERSION);
+program
+    .command("resolve <keyword>")
+    .description("회사명 → corp_code 조회")
+    .action(async (_keyword) => {
+    console.log("TODO: corp_code resolver 구현 예정");
+});
+program
+    .command("search <keyword>")
+    .description("공시 검색")
+    .action(async (_keyword) => {
+    console.log("TODO: search_disclosures 구현 예정");
+});
+program.parseAsync(process.argv);

package/build/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "dotenv/config";

package/build/index.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import "dotenv/config";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { createServer } from "./server/mcp-server.js";
+import { SERVER_NAME, VERSION } from "./version.js";
+async function main() {
+    const args = process.argv.slice(2);
+    // setup 서브커맨드: npx korean-dart-mcp setup
+    if (args[0] === "setup") {
+        const { runSetup } = await import("./setup.js");
+        try {
+            await runSetup();
+        }
+        catch (err) {
+            if (err?.code === "ERR_USE_AFTER_CLOSE")
+                return;
+            throw err;
+        }
+        return;
+    }
+    const apiKey = process.env.DART_API_KEY;
+    if (!apiKey) {
+        console.error(`[${SERVER_NAME}] DART_API_KEY 가 설정되지 않았습니다.\n` +
+            `발급: https://opendart.fss.or.kr/ (가입 → 인증키 신청)\n` +
+            `쉽게 설치: npx -y korean-dart-mcp setup`);
+        process.exit(1);
+    }
+    const server = createServer({ apiKey });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error(`[${SERVER_NAME}] v${VERSION} stdio 서버 시작`);
+}
+main().catch((err) => {
+    console.error(`[${SERVER_NAME}] fatal:`, err);
+    process.exit(1);
+});

package/build/lib/corp-code.d.ts

@@ -0,0 +1,53 @@
+/**
+ * corp_code 리졸버
+ *
+ * 문제: LLM은 "삼성전자" 만 아는데, 모든 OpenDART 엔드포인트는 8자리 corp_code 필수.
+ * 해결: 서버 기동 시 `corpCode.xml` 전체 덤프를 내려받아 SQLite 로 인덱싱.
+ *       첫 호출 시 한 번만 받고, 이후는 캐시 디렉터리에서 재사용 (24h TTL).
+ *
+ * 엔드포인트: /api/corpCode.xml  (ZIP → CORPCODE.xml)
+ * 레코드 형식: <list><corp_code>...</corp_code><corp_name>...</corp_name>
+ *              <corp_eng_name>...</corp_eng_name><stock_code>...</stock_code>
+ *              <modify_date>...</modify_date></list>
+ */
+import type { DartClient } from "./dart-client.js";
+export interface CorpRecord {
+    corp_code: string;
+    corp_name: string;
+    corp_eng_name?: string;
+    stock_code?: string;
+    modify_date?: string;
+}
+export interface CorpCodeResolverOptions {
+    /** 캐시 디렉터리 (기본: ~/.korean-dart-mcp) */
+    cacheDir?: string;
+    /** 디스크 캐시를 무시하고 재다운로드 */
+    forceRefresh?: boolean;
+    /** 캐시 TTL (ms, 기본 24h) */
+    ttlMs?: number;
+}
+export declare class CorpCodeResolver {
+    private readonly cacheDir;
+    private readonly dbPath;
+    private readonly forceRefresh;
+    private readonly ttlMs;
+    private db;
+    private initPromise;
+    constructor(opts?: CorpCodeResolverOptions);
+    /** 서버 기동 시 1회 호출. 캐시 유효하면 DB만 열고 끝. */
+    init(client: DartClient): Promise<void>;
+    private doInit;
+    private isCacheFresh;
+    /** 키워드로 회사 검색. alias → 상장사 → 완전일치 → 접두사 → 짧은 이름 → 낮은 종목코드 순. */
+    search(keyword: string, limit?: number): CorpRecord[];
+    byStockCode(code: string): CorpRecord | undefined;
+    byCorpCode(code: string): CorpRecord | undefined;
+    /**
+     * 입력 문자열을 단일 corp_code 로 해석.
+     *  - 8자리 숫자 → byCorpCode
+     *  - 6자리 숫자 → byStockCode
+     *  - 그 외 → search() 상위 1건
+     */
+    resolve(input: string): CorpRecord | undefined;
+    private requireDb;
+}

package/build/lib/corp-code.js

@@ -0,0 +1,235 @@
+/**
+ * corp_code 리졸버
+ *
+ * 문제: LLM은 "삼성전자" 만 아는데, 모든 OpenDART 엔드포인트는 8자리 corp_code 필수.
+ * 해결: 서버 기동 시 `corpCode.xml` 전체 덤프를 내려받아 SQLite 로 인덱싱.
+ *       첫 호출 시 한 번만 받고, 이후는 캐시 디렉터리에서 재사용 (24h TTL).
+ *
+ * 엔드포인트: /api/corpCode.xml  (ZIP → CORPCODE.xml)
+ * 레코드 형식: <list><corp_code>...</corp_code><corp_name>...</corp_name>
+ *              <corp_eng_name>...</corp_eng_name><stock_code>...</stock_code>
+ *              <modify_date>...</modify_date></list>
+ */
+import { mkdirSync, existsSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import Database from "better-sqlite3";
+import { DOMParser } from "@xmldom/xmldom";
+import { safeUnzipToMemory } from "../utils/safe-zip.js";
+const DEFAULT_TTL_MS = 24 * 60 * 60 * 1000;
+const CORP_CODE_RE = /^\d{8}$/;
+const STOCK_CODE_RE = /^\d{6}$/;
+// 영문 corp_name 으로 등록된 한국 상장사 — 한글 query 로 LIKE 매칭이 안 되어
+// 자회사로 잘못 resolve 되는 케이스 방어. corp_code 는 OpenDART corpCode.xml 검증 필요.
+// "현대차" 같은 약어도 자회사 우선 정렬되는 케이스라 alias 에 포함.
+const KOREAN_ALIAS = {
+    네이버: "00266961", // NAVER
+    현대차: "00164742", // 현대자동차
+};
+export class CorpCodeResolver {
+    constructor(opts = {}) {
+        this.db = null;
+        this.initPromise = null;
+        this.cacheDir = opts.cacheDir ?? join(homedir(), ".korean-dart-mcp");
+        this.dbPath = join(this.cacheDir, "corp_code.sqlite");
+        this.forceRefresh = opts.forceRefresh ?? false;
+        this.ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+    }
+    /** 서버 기동 시 1회 호출. 캐시 유효하면 DB만 열고 끝. */
+    async init(client) {
+        if (this.initPromise)
+            return this.initPromise;
+        this.initPromise = this.doInit(client);
+        return this.initPromise;
+    }
+    async doInit(client) {
+        if (!existsSync(this.cacheDir)) {
+            mkdirSync(this.cacheDir, { recursive: true });
+        }
+        const cacheFresh = !this.forceRefresh && this.isCacheFresh();
+        if (cacheFresh) {
+            this.db = new Database(this.dbPath, { readonly: false });
+            return;
+        }
+        console.error("[corp-code] 덤프 다운로드 중... (수 초 소요)");
+        const zipBuf = await client.getZip("corpCode.xml");
+        const xml = await extractCorpCodeXml(zipBuf);
+        const records = parseCorpCodeXml(xml);
+        console.error(`[corp-code] ${records.length}개 회사 적재 중...`);
+        this.db = buildDatabase(this.dbPath, records);
+        console.error("[corp-code] 준비 완료");
+    }
+    isCacheFresh() {
+        if (!existsSync(this.dbPath))
+            return false;
+        try {
+            const db = new Database(this.dbPath, { readonly: true });
+            const row = db
+                .prepare("SELECT value FROM meta WHERE key = 'updated_at'")
+                .get();
+            db.close();
+            if (!row)
+                return false;
+            const age = Date.now() - Number(row.value);
+            return age < this.ttlMs;
+        }
+        catch {
+            return false;
+        }
+    }
+    /** 키워드로 회사 검색. alias → 상장사 → 완전일치 → 접두사 → 짧은 이름 → 낮은 종목코드 순. */
+    search(keyword, limit = 10) {
+        const db = this.requireDb();
+        const k = keyword.trim();
+        if (!k)
+            return [];
+        // 1. 한글 alias 우선: 영문등록 한국 상장사가 LIKE 매칭에서 누락되는 케이스 방어
+        const aliasCode = KOREAN_ALIAS[k];
+        let aliased;
+        if (aliasCode)
+            aliased = this.byCorpCode(aliasCode);
+        // 2. 일반 LIKE 검색. 동률 정렬 시 stock_code ASC 추가 (낮은 종목코드 = 오래된 대형사 휴리스틱).
+        const like = `%${k}%`;
+        const rows = db
+            .prepare(`SELECT corp_code, corp_name, corp_eng_name, stock_code, modify_date
+         FROM corps
+         WHERE corp_name LIKE ?
+            OR corp_eng_name LIKE ?
+         ORDER BY
+           (stock_code IS NULL OR stock_code = '') ASC,
+           CASE WHEN corp_name = ? THEN 0
+                WHEN corp_name LIKE ? THEN 1
+                ELSE 2 END,
+           length(corp_name) ASC,
+           CASE WHEN stock_code IS NULL OR stock_code = '' THEN 1 ELSE 0 END,
+           stock_code ASC
+         LIMIT ?`)
+            .all(like, like, k, `${k}%`, limit);
+        const normalized = rows.map(normalize);
+        // alias 결과를 1위로 prepend (중복 제거)
+        if (aliased) {
+            const others = normalized.filter((r) => r.corp_code !== aliased.corp_code);
+            return [aliased, ...others].slice(0, limit);
+        }
+        return normalized;
+    }
+    byStockCode(code) {
+        const db = this.requireDb();
+        const row = db
+            .prepare(`SELECT corp_code, corp_name, corp_eng_name, stock_code, modify_date
+         FROM corps WHERE stock_code = ? LIMIT 1`)
+            .get(code);
+        return row ? normalize(row) : undefined;
+    }
+    byCorpCode(code) {
+        const db = this.requireDb();
+        const row = db
+            .prepare(`SELECT corp_code, corp_name, corp_eng_name, stock_code, modify_date
+         FROM corps WHERE corp_code = ? LIMIT 1`)
+            .get(code);
+        return row ? normalize(row) : undefined;
+    }
+    /**
+     * 입력 문자열을 단일 corp_code 로 해석.
+     *  - 8자리 숫자 → byCorpCode
+     *  - 6자리 숫자 → byStockCode
+     *  - 그 외 → search() 상위 1건
+     */
+    resolve(input) {
+        const s = input.trim();
+        if (CORP_CODE_RE.test(s))
+            return this.byCorpCode(s);
+        if (STOCK_CODE_RE.test(s))
+            return this.byStockCode(s);
+        return this.search(s, 1)[0];
+    }
+    requireDb() {
+        if (!this.db) {
+            throw new Error("CorpCodeResolver.init() 을 먼저 호출하세요.");
+        }
+        return this.db;
+    }
+}
+function normalize(row) {
+    return {
+        corp_code: row.corp_code,
+        corp_name: row.corp_name,
+        corp_eng_name: row.corp_eng_name || undefined,
+        stock_code: row.stock_code && row.stock_code.trim() !== "" ? row.stock_code : undefined,
+        modify_date: row.modify_date || undefined,
+    };
+}
+async function extractCorpCodeXml(zipBuf) {
+    // corp_code 전량 덤프는 현재 ~30MB 수준. 장기 성장 대비 총 300MB · 단일 300MB 허용.
+    const entries = await safeUnzipToMemory(zipBuf, {
+        maxTotalBytes: 300 * 1024 * 1024,
+        maxEntryBytes: 300 * 1024 * 1024,
+        maxEntries: 16,
+        filter: (name) => /CORPCODE\.xml$/i.test(name),
+    });
+    const hit = entries[0];
+    if (!hit)
+        throw new Error("CORPCODE.xml not found in zip");
+    return hit.data.toString("utf8");
+}
+function parseCorpCodeXml(xml) {
+    const doc = new DOMParser().parseFromString(xml, "text/xml");
+    const listEls = doc.getElementsByTagName("list");
+    const out = [];
+    for (let i = 0; i < listEls.length; i++) {
+        const el = listEls[i];
+        const code = text(el, "corp_code");
+        const name = text(el, "corp_name");
+        if (!code || !name)
+            continue;
+        out.push({
+            corp_code: code,
+            corp_name: name,
+            corp_eng_name: text(el, "corp_eng_name") || undefined,
+            stock_code: text(el, "stock_code") || undefined,
+            modify_date: text(el, "modify_date") || undefined,
+        });
+    }
+    return out;
+}
+// xmldom 의 Element 타입을 직접 쓰지 않고 duck-typing 으로 접근.
+// DOM lib 을 tsconfig 에 포함시키지 않아 전역 Element 가 없음.
+function text(parent, tag) {
+    const t = parent.getElementsByTagName(tag)[0]?.textContent ?? "";
+    return t.trim();
+}
+function buildDatabase(path, records) {
+    if (existsSync(path)) {
+        try {
+            unlinkSync(path);
+        }
+        catch {
+            /* ignore — 새 DB 생성 시 덮어써짐 */
+        }
+    }
+    const db = new Database(path);
+    db.pragma("journal_mode = WAL");
+    db.exec(`
+    CREATE TABLE corps (
+      corp_code TEXT PRIMARY KEY,
+      corp_name TEXT NOT NULL,
+      corp_eng_name TEXT,
+      stock_code TEXT,
+      modify_date TEXT
+    );
+    CREATE INDEX idx_corps_name ON corps(corp_name);
+    CREATE INDEX idx_corps_stock ON corps(stock_code) WHERE stock_code IS NOT NULL AND stock_code != '';
+    CREATE TABLE meta (key TEXT PRIMARY KEY, value TEXT NOT NULL);
+  `);
+    const insert = db.prepare(`INSERT OR REPLACE INTO corps (corp_code, corp_name, corp_eng_name, stock_code, modify_date)
+     VALUES (?, ?, ?, ?, ?)`);
+    const tx = db.transaction((items) => {
+        for (const r of items) {
+            insert.run(r.corp_code, r.corp_name, r.corp_eng_name ?? null, r.stock_code ?? null, r.modify_date ?? null);
+        }
+    });
+    tx(records);
+    db.prepare("INSERT OR REPLACE INTO meta(key, value) VALUES('updated_at', ?)").run(String(Date.now()));
+    db.prepare("INSERT OR REPLACE INTO meta(key, value) VALUES('count', ?)").run(String(records.length));
+    return db;
+}

package/build/lib/dart-client.d.ts

@@ -0,0 +1,25 @@
+/**
+ * OpenDART HTTP 클라이언트
+ *
+ * Base: https://opendart.fss.or.kr/api/
+ * 인증: 모든 요청에 `crtfc_key` 쿼리파라미터 필수
+ * 응답: JSON (대부분) / ZIP (원문·corp_code·XBRL)
+ * 요율: 일 20,000건 (키 단위 합산)
+ */
+export interface DartClientOptions {
+    apiKey: string;
+    /** 요청 타임아웃 (ms), 기본 30s */
+    timeout?: number;
+}
+export declare class DartClient {
+    private readonly apiKey;
+    private readonly timeout;
+    constructor(opts: DartClientOptions);
+    /** JSON 엔드포인트 호출 */
+    getJson<T = unknown>(path: string, params?: Record<string, string | number | undefined>): Promise<T>;
+    /** ZIP 엔드포인트 호출 (corp_code 덤프, 원문 XML, XBRL 등).
+     *  DART 는 에러 시 Content-Type 은 zip 이지만 바디는 {"status":"013",...} JSON 을 돌려준다. */
+    getZip(path: string, params?: Record<string, string | number | undefined>): Promise<Buffer>;
+    private buildUrl;
+    private fetch;
+}

package/build/lib/dart-client.js

@@ -0,0 +1,71 @@
+/**
+ * OpenDART HTTP 클라이언트
+ *
+ * Base: https://opendart.fss.or.kr/api/
+ * 인증: 모든 요청에 `crtfc_key` 쿼리파라미터 필수
+ * 응답: JSON (대부분) / ZIP (원문·corp_code·XBRL)
+ * 요율: 일 20,000건 (키 단위 합산)
+ */
+const DART_BASE_URL = "https://opendart.fss.or.kr/api";
+export class DartClient {
+    constructor(opts) {
+        this.apiKey = opts.apiKey;
+        this.timeout = opts.timeout ?? 30000;
+    }
+    /** JSON 엔드포인트 호출 */
+    async getJson(path, params = {}) {
+        const url = this.buildUrl(path, params);
+        const res = await this.fetch(url);
+        if (!res.ok) {
+            throw new Error(`DART ${path} → HTTP ${res.status}`);
+        }
+        return (await res.json());
+    }
+    /** ZIP 엔드포인트 호출 (corp_code 덤프, 원문 XML, XBRL 등).
+     *  DART 는 에러 시 Content-Type 은 zip 이지만 바디는 {"status":"013",...} JSON 을 돌려준다. */
+    async getZip(path, params = {}) {
+        const url = this.buildUrl(path, params);
+        const res = await this.fetch(url);
+        if (!res.ok) {
+            throw new Error(`DART ${path} → HTTP ${res.status}`);
+        }
+        const ab = await res.arrayBuffer();
+        const buf = Buffer.from(ab);
+        // PK\x03\x04 (zip local file header) 또는 PK\x05\x06 (empty zip) 으로 시작해야 정상
+        if (buf.length >= 2 && buf[0] === 0x50 && buf[1] === 0x4b)
+            return buf;
+        // JSON 에러 응답 감지
+        const head = buf.subarray(0, Math.min(512, buf.length)).toString("utf8");
+        if (head.trimStart().startsWith("{")) {
+            try {
+                const err = JSON.parse(head);
+                throw new Error(`DART ${path} → [${err.status ?? "?"}] ${err.message ?? head}`);
+            }
+            catch (e) {
+                if (e instanceof Error && e.message.startsWith("DART "))
+                    throw e;
+            }
+        }
+        throw new Error(`DART ${path} → 비-ZIP 응답 (${buf.length}B): ${head.slice(0, 200)}`);
+    }
+    buildUrl(path, params) {
+        const u = new URL(`${DART_BASE_URL}/${path}`);
+        u.searchParams.set("crtfc_key", this.apiKey);
+        for (const [k, v] of Object.entries(params)) {
+            if (v === undefined || v === "")
+                continue;
+            u.searchParams.set(k, String(v));
+        }
+        return u.toString();
+    }
+    async fetch(url) {
+        const ctrl = new AbortController();
+        const timer = setTimeout(() => ctrl.abort(), this.timeout);
+        try {
+            return await fetch(url, { signal: ctrl.signal });
+        }
+        finally {
+            clearTimeout(timer);
+        }
+    }
+}

package/build/lib/dart-xml.d.ts

@@ -0,0 +1,26 @@
+/**
+ * DART 원문 XML → 마크다운 변환기
+ *
+ * DART 전용 마크업(`dart4.xsd`) 은 공개 표준이 아니지만 구조가 단순해서
+ * 주요 태그만 대응해도 LLM 이 읽을 수 있는 수준의 마크다운을 만들 수 있다.
+ *
+ * 지원 태그:
+ *   DOCUMENT / BODY                       → 루트
+ *   COVER-TITLE / DOCUMENT-NAME           → # 제목
+ *   SECTION-1/2/3                         → 하위 TITLE 의 heading level 제어
+ *   TITLE                                 → ##/###/#### (상위 SECTION 깊이에 따라)
+ *   TABLE, THEAD, TBODY, TR, TH, TD, TU  → 마크다운 테이블
+ *   P                                     → 단락
+ *   PGBRK                                 → 수평선
+ *   A                                     → 인라인 텍스트 (href 없음)
+ *   IMAGE/IMG/LIBRARY                     → 제거
+ *   SUMMARY/EXTRACTION                    → 메타 제거
+ *   COLGROUP/COL                          → 제거 (스타일 전용)
+ *   나머지 (SPAN, COMPANY-NAME 등)         → 텍스트만 유지
+ *
+ * 병합 셀(COLSPAN/ROWSPAN) 은 마크다운 자체가 지원하지 않으므로 무시.
+ *
+ * 타입 주석: 본 프로젝트 tsconfig 에 DOM lib 이 없어 xmldom 의 Node/Element 전역이 없다.
+ *            duck-typing 으로 any 처리.
+ */
+export declare function dartXmlToMarkdown(xml: string): string;

package/build/lib/dart-xml.js

@@ -0,0 +1,187 @@
+/**
+ * DART 원문 XML → 마크다운 변환기
+ *
+ * DART 전용 마크업(`dart4.xsd`) 은 공개 표준이 아니지만 구조가 단순해서
+ * 주요 태그만 대응해도 LLM 이 읽을 수 있는 수준의 마크다운을 만들 수 있다.
+ *
+ * 지원 태그:
+ *   DOCUMENT / BODY                       → 루트
+ *   COVER-TITLE / DOCUMENT-NAME           → # 제목
+ *   SECTION-1/2/3                         → 하위 TITLE 의 heading level 제어
+ *   TITLE                                 → ##/###/#### (상위 SECTION 깊이에 따라)
+ *   TABLE, THEAD, TBODY, TR, TH, TD, TU  → 마크다운 테이블
+ *   P                                     → 단락
+ *   PGBRK                                 → 수평선
+ *   A                                     → 인라인 텍스트 (href 없음)
+ *   IMAGE/IMG/LIBRARY                     → 제거
+ *   SUMMARY/EXTRACTION                    → 메타 제거
+ *   COLGROUP/COL                          → 제거 (스타일 전용)
+ *   나머지 (SPAN, COMPANY-NAME 등)         → 텍스트만 유지
+ *
+ * 병합 셀(COLSPAN/ROWSPAN) 은 마크다운 자체가 지원하지 않으므로 무시.
+ *
+ * 타입 주석: 본 프로젝트 tsconfig 에 DOM lib 이 없어 xmldom 의 Node/Element 전역이 없다.
+ *            duck-typing 으로 any 처리.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import { DOMParser } from "@xmldom/xmldom";
+const SKIP_TAGS = new Set([
+    "SUMMARY",
+    "EXTRACTION",
+    "COLGROUP",
+    "COL",
+    "IMAGE",
+    "IMG",
+    "IMG-CAPTION",
+    "LIBRARY",
+    "FORMULA-VERSION",
+]);
+const SECTION_DEPTH = {
+    "SECTION-1": 2,
+    "SECTION-2": 3,
+    "SECTION-3": 4,
+    "SECTION-4": 5,
+};
+export function dartXmlToMarkdown(xml) {
+    // DART XML 은 일부 엔트리에 한글 태그(`<이사ㆍ감사>`) 가 텍스트가 아닌 마크업으로
+    // 들어가 있어 xmldom 의 well-formedness 검사가 ParseError 로 fatal-throw 한다.
+    // xmldom errorHandler 옵션은 warning/error 만 silence 가능하고 fatalError 는 throw 됨.
+    // → 비-ASCII 로 시작하는 태그는 모두 entity escape 해서 텍스트로 강등시킨다.
+    const sanitized = sanitizeNonAsciiTags(xml);
+    const silentHandler = () => { };
+    let doc;
+    try {
+        doc = new DOMParser({ errorHandler: silentHandler }).parseFromString(sanitized, "text/xml");
+    }
+    catch {
+        // 그래도 실패 시 text/html 모드 (xmldom 이 더 관대)
+        try {
+            doc = new DOMParser({ errorHandler: silentHandler }).parseFromString(sanitized, "text/html");
+        }
+        catch {
+            return "";
+        }
+    }
+    const root = doc?.documentElement;
+    if (!root)
+        return "";
+    return convertNode(root, 1).replace(/\n{3,}/g, "\n\n").trim();
+}
+/**
+ * `<한글태그>...</한글태그>` 같은 비-ASCII 태그를 entity escape 해서 텍스트로 만든다.
+ * XML 표준 NameStartChar 는 유니코드를 허용하지만 DART 의 한글 태그는 닫는 태그가
+ * 누락된 경우가 있어 well-formedness 가 깨진다.
+ */
+function sanitizeNonAsciiTags(xml) {
+    // 1. CDATA 섹션은 보호 (변환 대상 아님)
+    // 2. `<` 다음 첫 문자가 ASCII letter / `?` / `!` / `/` 가 아니면 entity escape
+    return xml.replace(/<\/?[^\x00-\x7F][^<>]*>/g, (m) => m.replace(/</g, "&lt;").replace(/>/g, "&gt;"));
+}
+function convertNode(node, titleDepth) {
+    if (!node)
+        return "";
+    if (node.nodeType === 3) {
+        // Text node
+        return (node.nodeValue ?? "").replace(/[ \t]+/g, " ").replace(/\n+/g, " ");
+    }
+    if (node.nodeType !== 1)
+        return ""; // Element 아니면 스킵 (comment 등)
+    const tag = String(node.nodeName ?? "").toUpperCase();
+    if (SKIP_TAGS.has(tag))
+        return "";
+    if (tag === "COVER-TITLE" || tag === "DOCUMENT-NAME") {
+        const t = inlineText(node);
+        return t ? `\n# ${t}\n\n` : "";
+    }
+    if (tag === "TITLE") {
+        const level = Math.min(6, Math.max(2, titleDepth));
+        const t = inlineText(node);
+        return t ? `\n${"#".repeat(level)} ${t}\n\n` : "";
+    }
+    if (SECTION_DEPTH[tag] !== undefined) {
+        return renderChildren(node, SECTION_DEPTH[tag]);
+    }
+    if (tag === "P") {
+        const t = inlineText(node);
+        return t ? `${t}\n\n` : "";
+    }
+    if (tag === "PGBRK") {
+        return "\n---\n\n";
+    }
+    if (tag === "TABLE") {
+        return renderTable(node) + "\n";
+    }
+    if (tag === "TABLE-GROUP") {
+        return renderChildren(node, titleDepth);
+    }
+    if (tag === "BR") {
+        return "\n";
+    }
+    return renderChildren(node, titleDepth);
+}
+function renderChildren(el, titleDepth) {
+    let out = "";
+    const children = el.childNodes;
+    if (!children)
+        return "";
+    for (let i = 0; i < children.length; i++) {
+        out += convertNode(children[i], titleDepth);
+    }
+    return out;
+}
+function inlineText(el) {
+    return String(el?.textContent ?? "").replace(/\s+/g, " ").trim();
+}
+function renderTable(table) {
+    const trs = collectByTag(table, "TR");
+    if (!trs.length)
+        return "";
+    const rowTexts = [];
+    let headerSize = 0;
+    for (const tr of trs) {
+        const kids = tr.childNodes;
+        if (!kids)
+            continue;
+        const cells = [];
+        for (let i = 0; i < kids.length; i++) {
+            const c = kids[i];
+            if (c.nodeType === 1 && /^(TD|TH|TU)$/i.test(String(c.nodeName)))
+                cells.push(c);
+        }
+        if (!cells.length)
+            continue;
+        const row = cells.map((c) => escapeCell(inlineText(c))).join(" | ");
+        rowTexts.push(row);
+        if (headerSize === 0)
+            headerSize = cells.length;
+    }
+    if (!rowTexts.length)
+        return "";
+    const separator = Array(headerSize).fill("---").join(" | ");
+    return [
+        `\n| ${rowTexts[0]} |`,
+        `| ${separator} |`,
+        ...rowTexts.slice(1).map((r) => `| ${r} |`),
+    ].join("\n");
+}
+function collectByTag(parent, tag) {
+    const out = [];
+    const walker = (el) => {
+        const kids = el.childNodes;
+        if (!kids)
+            return;
+        for (let i = 0; i < kids.length; i++) {
+            const c = kids[i];
+            if (c.nodeType === 1) {
+                if (String(c.nodeName).toUpperCase() === tag)
+                    out.push(c);
+                walker(c);
+            }
+        }
+    };
+    walker(parent);
+    return out;
+}
+function escapeCell(s) {
+    return s.replace(/\|/g, "\\|").replace(/\n/g, " ");
+}