somark-js 0.1.0

package/dist/cli.mjs

@@ -0,0 +1,1503 @@
+#!/usr/bin/env node
+import {
+  getConfigValue,
+  listResolvedConfig,
+  maskConfigValue,
+  resolveConfig,
+  saveConfig
+} from "./chunk-RWOUZTFQ.mjs";
+
+// src/cli/index.ts
+import { Command } from "commander";
+
+// package.json
+var package_default = {
+  name: "somark-js",
+  version: "0.1.0",
+  description: "SoMark SDK + CLI \u2014 Document parsing, PDF processing, and SoMarkDown preview",
+  type: "module",
+  main: "./dist/index.cjs",
+  module: "./dist/index.mjs",
+  types: "./dist/index.d.ts",
+  files: [
+    "dist",
+    "vendor/somarkdown-viewer/index.html",
+    "vendor/somarkdown-viewer/lib",
+    "vendor/somarkdown-viewer/style",
+    "README.md",
+    "README_CN.md",
+    "LICENSE"
+  ],
+  exports: {
+    ".": {
+      types: "./dist/index.d.ts",
+      import: "./dist/index.mjs",
+      require: "./dist/index.cjs"
+    }
+  },
+  bin: {
+    somark: "./dist/cli.mjs"
+  },
+  engines: {
+    node: ">=18"
+  },
+  scripts: {
+    build: "tsup",
+    test: "npm run build && vitest run",
+    "test:watch": "vitest"
+  },
+  keywords: [
+    "somark",
+    "pdf",
+    "document",
+    "parsing",
+    "cli",
+    "sdk"
+  ],
+  author: "SoMark",
+  license: "Apache-2.0",
+  homepage: "https://somark.tech",
+  repository: {
+    type: "git",
+    url: "https://github.com/SoMarkAI/somark-js"
+  },
+  dependencies: {
+    "@hyzyla/pdfium": "^2.1.12",
+    "@types/pngjs": "^6.0.5",
+    chalk: "^5.3.0",
+    commander: "^12.0.0",
+    open: "^10.1.0",
+    ora: "^8.1.0",
+    pngjs: "^7.0.0"
+  },
+  devDependencies: {
+    "@types/node": "^20.0.0",
+    tsup: "^8.0.0",
+    typescript: "^5.4.0",
+    vitest: "^1.6.0"
+  }
+};
+
+// src/cli/commands/parse.ts
+import chalk from "chalk";
+import ora from "ora";
+
+// src/errors.ts
+var SoMarkError = class extends Error {
+  code;
+  constructor(message = "", code = -1) {
+    super(message);
+    this.name = "SoMarkError";
+    this.code = code;
+  }
+};
+var AuthenticationError = class extends SoMarkError {
+  constructor(message = "Authentication failed", code = -1) {
+    super(message, code);
+    this.name = "AuthenticationError";
+  }
+};
+var InsufficientBalanceError = class extends SoMarkError {
+  constructor(message = "Insufficient balance", code = -1) {
+    super(message, code);
+    this.name = "InsufficientBalanceError";
+  }
+};
+var RateLimitError = class extends SoMarkError {
+  constructor(message = "Rate limit exceeded", code = -1) {
+    super(message, code);
+    this.name = "RateLimitError";
+  }
+};
+var UnsupportedFileError = class extends SoMarkError {
+  constructor(message = "Unsupported file type", code = -1) {
+    super(message, code);
+    this.name = "UnsupportedFileError";
+  }
+};
+var FileTooLargeError = class extends SoMarkError {
+  constructor(message = "File too large", code = -1) {
+    super(message, code);
+    this.name = "FileTooLargeError";
+  }
+};
+var ParseTimeoutError = class extends SoMarkError {
+  constructor(message = "Parse timed out", code = -1) {
+    super(message, code);
+    this.name = "ParseTimeoutError";
+  }
+};
+var ParseFailedError = class extends SoMarkError {
+  constructor(message = "Parse failed", code = -1) {
+    super(message, code);
+    this.name = "ParseFailedError";
+  }
+};
+var InvalidParamError = class extends SoMarkError {
+  constructor(message = "Invalid parameter", code = -1) {
+    super(message, code);
+    this.name = "InvalidParamError";
+  }
+};
+var APIError = class extends SoMarkError {
+  constructor(message = "API error", code = -1) {
+    super(message, code);
+    this.name = "APIError";
+  }
+};
+var ConnectionError = class extends SoMarkError {
+  constructor(message = "Connection failed", code = -1) {
+    super(message, code);
+    this.name = "ConnectionError";
+  }
+};
+var RequestTimeoutError = class extends SoMarkError {
+  constructor(message = "Request timed out", code = -1) {
+    super(message, code);
+    this.name = "RequestTimeoutError";
+  }
+};
+var CODE_TO_ERROR = {
+  1101: RateLimitError,
+  1102: ParseTimeoutError,
+  1104: UnsupportedFileError,
+  1105: InvalidParamError,
+  1106: InvalidParamError,
+  1107: AuthenticationError,
+  1108: InsufficientBalanceError,
+  1111: APIError,
+  1118: FileTooLargeError,
+  1120: APIError,
+  1123: InsufficientBalanceError,
+  1124: RateLimitError,
+  1132: FileTooLargeError,
+  1133: InvalidParamError,
+  1137: ParseFailedError,
+  1138: APIError
+};
+function raiseForCode(code, message = "") {
+  const ErrorClass = CODE_TO_ERROR[code] ?? APIError;
+  throw new ErrorClass(message || `API error (code=${code})`, code);
+}
+
+// src/http.ts
+var RETRY_CODES = /* @__PURE__ */ new Set([1101, 1124]);
+var RETRY_HTTP_STATUSES = /* @__PURE__ */ new Set([500, 502, 503, 504]);
+var HttpClient = class {
+  apiKey;
+  baseUrl;
+  timeoutMs;
+  maxRetries;
+  constructor(opts) {
+    this.apiKey = opts.apiKey;
+    this.baseUrl = opts.baseUrl.replace(/\/$/, "");
+    this.timeoutMs = opts.timeout * 1e3;
+    this.maxRetries = opts.maxRetries;
+  }
+  getApiKey() {
+    return this.apiKey;
+  }
+  buildFormData(data) {
+    const form = new FormData();
+    if (this.apiKey) form.append("api_key", this.apiKey);
+    for (const [k, v] of Object.entries(data)) {
+      if (v === void 0) continue;
+      if (Array.isArray(v)) {
+        for (const item of v) form.append(k, item);
+      } else {
+        form.append(k, v);
+      }
+    }
+    return form;
+  }
+  async post(path7, data = {}, file) {
+    const url = this.baseUrl + path7;
+    let lastError;
+    for (let attempt = 0; attempt <= this.maxRetries; attempt++) {
+      try {
+        const form = this.buildFormData(data);
+        if (file) {
+          const blob = new Blob([file.buffer], { type: file.mimeType });
+          form.append("file", blob, file.name);
+        }
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        let response;
+        try {
+          response = await fetch(url, { method: "POST", body: form, signal: controller.signal });
+        } finally {
+          clearTimeout(timer);
+        }
+        if (RETRY_HTTP_STATUSES.has(response.status) && attempt < this.maxRetries) {
+          await sleep(Math.pow(2, attempt) * 1e3);
+          continue;
+        }
+        if (!response.ok) {
+          throw new APIError(`HTTP ${response.status}: ${response.statusText}`);
+        }
+        const result = await response.json();
+        const code = result.code ?? -1;
+        if (code !== 0) {
+          if (RETRY_CODES.has(code) && attempt < this.maxRetries) {
+            await sleep(Math.pow(2, attempt) * 1e3);
+            continue;
+          }
+          raiseForCode(code, (result.message ?? result.msg) || "");
+        }
+        return result;
+      } catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+          lastError = new RequestTimeoutError("Request timed out");
+        } else if (err instanceof TypeError && err.message.includes("fetch")) {
+          lastError = new ConnectionError(err.message);
+        } else if (err instanceof Error && err.code === "ECONNREFUSED") {
+          lastError = new ConnectionError(err.message);
+        } else {
+          throw err;
+        }
+        if (attempt < this.maxRetries) await sleep(Math.pow(2, attempt) * 1e3);
+      }
+    }
+    throw lastError ?? new APIError("Request failed after retries");
+  }
+};
+function sleep(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+
+// src/resources/parser.ts
+import * as fs3 from "fs";
+import * as path3 from "path";
+
+// src/models.ts
+import * as fs from "fs";
+import * as path from "path";
+
+// src/warnings.ts
+var warningsSuppressed = false;
+function dedupe(messages) {
+  const seen = /* @__PURE__ */ new Set();
+  const result = [];
+  for (const message of messages) {
+    if (seen.has(message)) continue;
+    seen.add(message);
+    result.push(message);
+  }
+  return result;
+}
+function setWarningsSuppressed(suppressed) {
+  warningsSuppressed = suppressed;
+}
+function collectApiWarnings(data) {
+  const raw = data.warnings;
+  if (!Array.isArray(raw)) return [];
+  return dedupe(raw.filter((item) => typeof item === "string").map((item) => item.trim()).filter(Boolean));
+}
+function emitWarnings(warnings) {
+  if (warningsSuppressed) return;
+  for (const warning of dedupe(warnings)) {
+    process.emitWarning(warning, { type: "SoMarkWarning" });
+  }
+}
+function parseMaxConcurrency(raw) {
+  const value = raw?.trim() ?? "";
+  if (!value) return { value: 1, warnings: [] };
+  const parsed = Number.parseInt(value, 10);
+  if (!Number.isFinite(parsed) || parsed < 1) {
+    return {
+      value: 1,
+      warnings: [`Invalid SOMARK_PARSE_MAX_CONCURRENCY="${value}"; using 1.`]
+    };
+  }
+  if (parsed >= 2) {
+    return {
+      value: parsed,
+      warnings: [
+        `SOMARK_PARSE_MAX_CONCURRENCY is set to ${parsed}. The official default quota is 1 for everyone; only users explicitly approved for higher concurrency should use 2 or above.`
+      ]
+    };
+  }
+  return { value: parsed, warnings: [] };
+}
+
+// src/models.ts
+var ParseResponse = class _ParseResponse {
+  ok;
+  code;
+  message;
+  warnings;
+  taskId;
+  pages;
+  fileType;
+  imgs;
+  md;
+  jsonOutput;
+  zipUrl;
+  sourceFileName;
+  constructor(data) {
+    this.ok = data.ok;
+    this.code = data.code;
+    this.message = data.message;
+    this.warnings = data.warnings ?? [];
+    this.taskId = data.taskId;
+    this.pages = data.pages;
+    this.fileType = data.fileType;
+    this.imgs = data.imgs;
+    this.md = data.md;
+    this.jsonOutput = data.jsonOutput;
+    this.zipUrl = data.zipUrl;
+    this.sourceFileName = data.sourceFileName;
+  }
+  async save(targetPath, format) {
+    const plan = planOutput(this.sourceFileName, targetPath, format, { allowStdout: false });
+    for (const target of plan.targets) {
+      if (target.stdout || !target.path) throw new Error("save path is required");
+      await this.saveFormat(target.path, target.format);
+    }
+  }
+  contentForFormat(format) {
+    const fmt = normalizeOutputFormat(format);
+    if (fmt === "json") return JSON.stringify(this.jsonOutput ?? {}, null, 2);
+    if (fmt === "md") return this.md ?? "";
+    if (fmt === "zip") {
+      if (!this.zipUrl) throw new Error("ZIP output URL was not returned by the API.");
+      return this.zipUrl;
+    }
+    throw new Error(`Unsupported output format: ${fmt}. Valid formats: md, markdown, json, zip.`);
+  }
+  async saveFormat(targetPath, format) {
+    const fmt = normalizeOutputFormat(format);
+    if (fmt === "zip") {
+      if (!this.zipUrl) throw new Error("ZIP output URL was not returned by the API.");
+      await downloadOutputFile(targetPath, this.zipUrl);
+      return;
+    }
+    fs.writeFileSync(targetPath, this.contentForFormat(fmt), "utf-8");
+  }
+  toJSON() {
+    return {
+      ok: this.ok,
+      code: this.code,
+      message: this.message,
+      warnings: this.warnings,
+      taskId: this.taskId,
+      pages: this.pages,
+      fileType: this.fileType,
+      imgs: this.imgs,
+      md: this.md,
+      jsonOutput: this.jsonOutput,
+      zipUrl: this.zipUrl,
+      sourceFileName: this.sourceFileName
+    };
+  }
+  static fromApi(data) {
+    const apiData = data.data ?? {};
+    const metadata = apiData.metadata ?? {};
+    const result = apiData.result ?? {};
+    const outputs = result.outputs ?? {};
+    const warnings = collectApiWarnings(data);
+    return new _ParseResponse({
+      ok: data.code === 0,
+      code: data.code ?? -1,
+      message: data.message ?? data.msg ?? "",
+      warnings,
+      taskId: apiData.task_id ?? "",
+      pages: metadata.page_num ?? 0,
+      fileType: metadata.file_type ?? "",
+      imgs: result.imgs ?? [],
+      md: outputs.markdown,
+      jsonOutput: outputs.json,
+      zipUrl: outputs.zip,
+      sourceFileName: result.file_name ?? apiData.file_name
+    });
+  }
+};
+function normalizeOutputFormat(format) {
+  const fmt = format.trim().toLowerCase();
+  return { markdown: "md" }[fmt] ?? fmt;
+}
+function normalizeSaveFormats(format, targetPath) {
+  const rawFormats = Array.isArray(format) ? format : typeof format === "string" ? format.split(",").map((item) => item.trim()) : [path.extname(targetPath ?? "").replace(/^\./, "") || "md"];
+  const formats = rawFormats.map(normalizeOutputFormat).filter(Boolean);
+  const normalized = formats.length ? formats : ["md"];
+  const invalid = normalized.filter((fmt) => !["md", "json", "zip"].includes(fmt));
+  if (invalid.length) {
+    throw new Error(`Unsupported output format: ${invalid.join(", ")}. Valid formats: md, markdown, json, zip.`);
+  }
+  return normalized;
+}
+function planOutput(sourceFileName, out, format, opts = {}) {
+  const formats = normalizeSaveFormats(format, out);
+  if (opts.batch) {
+    if (!out || !isExistingDirectory(out)) {
+      throw new Error("batch parse requires --out to be an existing directory");
+    }
+    return directoryOutputPlan(sourceFileName, out, formats);
+  }
+  if (!out) {
+    if (formats.length > 1) throw new Error("multiple formats require --out to be an existing directory");
+    if (!opts.allowStdout) throw new Error("output path is required");
+    return { formats, targets: [{ format: formats[0], stdout: true }], stdout: true };
+  }
+  if (isExistingDirectory(out)) return directoryOutputPlan(sourceFileName, out, formats);
+  if (formats.length > 1) throw new Error("multiple formats require --out to be an existing directory");
+  if (looksLikeDirectoryPath(out)) throw new Error(`output directory does not exist: ${out}`);
+  const parent = path.dirname(path.resolve(out));
+  if (!isExistingDirectory(parent)) throw new Error(`output parent directory does not exist: ${parent}`);
+  return { formats, targets: [{ format: formats[0], path: out, stdout: false }], stdout: false };
+}
+function directoryOutputPlan(sourceFileName, directory, formats) {
+  const stem = sourceStem(sourceFileName);
+  if (!stem) throw new Error("saving to a directory requires a source file name");
+  return {
+    formats,
+    targets: formats.map((fmt) => ({
+      format: fmt,
+      path: path.join(directory, `${stem}.${formatExt(fmt)}`),
+      stdout: false
+    })),
+    stdout: false
+  };
+}
+function formatExt(format) {
+  return normalizeOutputFormat(format) === "md" ? "md" : normalizeOutputFormat(format);
+}
+function sourceStem(fileName) {
+  if (!fileName) return void 0;
+  return path.basename(fileName, path.extname(fileName));
+}
+function isExistingDirectory(target) {
+  return fs.existsSync(target) && fs.statSync(target).isDirectory();
+}
+function looksLikeDirectoryPath(target) {
+  return target.endsWith(path.sep) || target.endsWith("/");
+}
+async function downloadOutputFile(targetPath, url) {
+  let response;
+  try {
+    response = await fetch(url, { redirect: "follow", signal: AbortSignal.timeout(6e4) });
+  } catch (err) {
+    throw new Error(`failed to download ZIP output: ${err.message}`);
+  }
+  if (!response.ok) {
+    throw new Error(`failed to download ZIP output: HTTP ${response.status}: ${response.statusText}`);
+  }
+  const bytes = Buffer.from(await response.arrayBuffer());
+  fs.writeFileSync(targetPath, bytes);
+}
+var Usage = class _Usage {
+  ok;
+  code;
+  message;
+  warnings;
+  remainingPaidPages;
+  remainingFreePagesToday;
+  remainingFreePagesThisMonth;
+  dashboardUrl;
+  constructor(data) {
+    this.ok = data.ok;
+    this.code = data.code;
+    this.message = data.message;
+    this.warnings = data.warnings ?? [];
+    this.remainingPaidPages = data.remainingPaidPages;
+    this.remainingFreePagesToday = data.remainingFreePagesToday;
+    this.remainingFreePagesThisMonth = data.remainingFreePagesThisMonth;
+    this.dashboardUrl = data.dashboardUrl;
+  }
+  toJSON() {
+    return {
+      ok: this.ok,
+      code: this.code,
+      message: this.message,
+      warnings: this.warnings,
+      remainingPaidPages: this.remainingPaidPages,
+      remainingFreePagesToday: this.remainingFreePagesToday,
+      remainingFreePagesThisMonth: this.remainingFreePagesThisMonth,
+      dashboardUrl: this.dashboardUrl
+    };
+  }
+  static fromApi(data) {
+    const apiData = data.data ?? {};
+    const warnings = collectApiWarnings(data);
+    return new _Usage({
+      ok: data.code === 0,
+      code: data.code ?? -1,
+      message: data.message ?? data.msg ?? "",
+      warnings,
+      remainingPaidPages: apiData.remaining_paid_pages ?? 0,
+      remainingFreePagesToday: apiData.remaining_free_pages_today ?? 0,
+      remainingFreePagesThisMonth: apiData.remaining_free_pages_this_month ?? 0,
+      dashboardUrl: apiData.dashboard_url ?? "https://somark.tech/workbench"
+    });
+  }
+};
+var Task = class {
+  id;
+  completed = false;
+  status = "queuing";
+  recordId;
+  fileName;
+  pages;
+  warnings;
+  refreshHandler;
+  _result;
+  constructor(taskId, refreshHandler, warnings = []) {
+    this.id = taskId;
+    this.refreshHandler = refreshHandler;
+    this.warnings = warnings;
+  }
+  async refresh() {
+    if (!this.refreshHandler) {
+      throw new Error("Task cannot refresh without a parser resource. Use client.parser.task(taskId).");
+    }
+    const data = await this.refreshHandler(this.id);
+    this.applyApi(data);
+  }
+  applyApi(data) {
+    this.warnings = collectApiWarnings(data);
+    const apiData = data.data ?? {};
+    const rawStatus = apiData.status ?? this.status;
+    this.status = rawStatus.toLowerCase();
+    this.recordId = apiData.record_id;
+    this.fileName = apiData.file_name;
+    const metadata = apiData.metadata ?? {};
+    this.pages = metadata.page_num;
+    if (this.status === "success" || this.status === "failed") {
+      this.completed = true;
+      if (this.status === "success") {
+        this._result = ParseResponse.fromApi(data);
+      }
+    }
+  }
+  async wait(opts = {}) {
+    const pollInterval = (opts.pollInterval ?? 3) * 1e3;
+    const timeout = (opts.timeout ?? 120) * 1e3;
+    const start = Date.now();
+    while (!this.completed) {
+      if (Date.now() - start >= timeout) {
+        throw new ParseTimeoutError(`Task ${this.id} timed out`);
+      }
+      await sleep2(pollInterval);
+      await this.refresh();
+    }
+    if (this.status === "failed") throw new ParseFailedError(`Task ${this.id} failed`);
+    return this._result;
+  }
+  result() {
+    if (!this._result) throw new Error("Task not completed. Call wait() first.");
+    return this._result;
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve5) => setTimeout(resolve5, ms));
+}
+
+// src/resources/parse-core.ts
+import * as fs2 from "fs";
+import * as path2 from "path";
+var FMT_MAP = { md: "markdown", zip: "zip", json: "json" };
+var VALID_API_FORMATS = /* @__PURE__ */ new Set(["markdown", "json", "zip"]);
+var VALID_FORMAT_HINT = "md, markdown, json, zip";
+function buildParseData(opts) {
+  const data = {};
+  if (opts.formats?.length) {
+    const mapped = opts.formats.map((f) => {
+      const normalized = normalizeOutputFormat(f);
+      return FMT_MAP[normalized] ?? normalized;
+    });
+    const invalid = mapped.filter((f) => !VALID_API_FORMATS.has(f));
+    if (invalid.length) {
+      throw new InvalidParamError(`Unsupported output format: ${invalid.join(", ")}. Valid formats: ${VALID_FORMAT_HINT}.`);
+    }
+    data.output_formats = mapped;
+  }
+  if (opts.elementFormats) {
+    const ef = opts.elementFormats;
+    const efObj = {};
+    if (ef.image) efObj.image = ef.image;
+    if (ef.formula) efObj.formula = ef.formula;
+    if (ef.table) efObj.table = ef.table;
+    if (ef.cs) efObj.cs = ef.cs;
+    if (Object.keys(efObj).length) data.element_formats = JSON.stringify(efObj);
+  }
+  if (opts.extractConfig) {
+    const ec = opts.extractConfig;
+    const fcObj = {};
+    if (ec.enableTextCrossPage !== void 0) fcObj.enable_text_cross_page = ec.enableTextCrossPage;
+    if (ec.enableTableCrossPage !== void 0) fcObj.enable_table_cross_page = ec.enableTableCrossPage;
+    if (ec.enableTitleLevelRecognition !== void 0) fcObj.enable_title_level_recognition = ec.enableTitleLevelRecognition;
+    if (ec.enableInlineImage !== void 0) fcObj.enable_inline_image = ec.enableInlineImage;
+    if (ec.enableTableImage !== void 0) fcObj.enable_table_image = ec.enableTableImage;
+    if (ec.enableImageUnderstanding !== void 0) fcObj.enable_image_understanding = ec.enableImageUnderstanding;
+    if (ec.keepHeaderFooter !== void 0) fcObj.keep_header_footer = ec.keepHeaderFooter;
+    if (Object.keys(fcObj).length) data.feature_config = JSON.stringify(fcObj);
+  }
+  return data;
+}
+function readFileList(file) {
+  if (!fs2.existsSync(file)) throw new InvalidParamError(`File list not found: ${file}`);
+  return fs2.readFileSync(file, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((item) => path2.isAbsolute(item) ? item : path2.resolve(item));
+}
+function resolveFileInputs(file, fileList = false) {
+  if (fileList) {
+    const manifests = Array.isArray(file) ? file : [file];
+    return { files: manifests.flatMap(readFileList), isBatch: true };
+  }
+  if (Array.isArray(file)) return { files: file, isBatch: true };
+  return { files: [file], isBatch: false };
+}
+function resolveCliFileInputs(files, fileList) {
+  const resolved = [...files];
+  if (fileList) resolved.push(...readFileList(fileList));
+  return { files: resolved, isBatch: resolved.length > 1 || fileList !== void 0 };
+}
+function ensureFilesExist(files) {
+  const missing = files.filter((file) => !fs2.existsSync(file) || !fs2.statSync(file).isFile());
+  if (missing.length) throw new InvalidParamError(`File not found: ${missing.join(", ")}`);
+}
+function parseBatchSettings(itemCount) {
+  const { value, warnings } = parseMaxConcurrency(process.env.SOMARK_PARSE_MAX_CONCURRENCY);
+  return { concurrency: Math.min(value, itemCount) || 1, warnings };
+}
+async function runLimited(files, worker, onResult) {
+  const { concurrency, warnings } = parseBatchSettings(files.length);
+  const results = new Array(files.length);
+  let next = 0;
+  async function runWorker() {
+    while (next < files.length) {
+      const index = next++;
+      const result = await worker(files[index]);
+      results[index] = result;
+      onResult?.(index, result);
+    }
+  }
+  await Promise.all(Array.from({ length: concurrency }, () => runWorker()));
+  return { results, warnings, concurrency };
+}
+function attachWarnings(items, warnings) {
+  if (!warnings.length) return;
+  for (const item of items) {
+    item.warnings = [...item.warnings ?? [], ...warnings];
+  }
+}
+
+// src/resources/parser.ts
+var DocumentParser = class {
+  _http;
+  constructor(http2) {
+    this._http = http2;
+  }
+  checkApiKey() {
+    if (!this._http.getApiKey()) {
+      throw new AuthenticationError("apiKey is required for parser operations.");
+    }
+  }
+  async pollTask(taskId) {
+    this.checkApiKey();
+    const data = await this._http.post("/parse/async_check", { task_id: taskId });
+    emitWarnings(collectApiWarnings(data));
+    return data;
+  }
+  task(taskId) {
+    return new Task(taskId, (id) => this.pollTask(id));
+  }
+  async parseOne(opts) {
+    this.checkApiKey();
+    const data = buildParseData({ formats: opts.formats ?? ["md"], elementFormats: opts.elementFormats, extractConfig: opts.extractConfig });
+    const buffer = fs3.readFileSync(opts.file);
+    const fileName = path3.basename(opts.file);
+    const result = await this._http.post("/parse/sync", data, { name: fileName, buffer, mimeType: "application/octet-stream" });
+    const response = ParseResponse.fromApi(result);
+    emitWarnings(response.warnings);
+    response.sourceFileName = fileName;
+    return response;
+  }
+  async parse(opts) {
+    this.checkApiKey();
+    const { files, isBatch } = resolveFileInputs(opts.file, opts.fileList);
+    ensureFilesExist(files);
+    const { results: responses, warnings } = await runLimited(files, (file) => this.parseOne({ ...opts, file }));
+    if (isBatch) {
+      emitWarnings(warnings);
+      attachWarnings(responses, warnings);
+    }
+    return isBatch ? responses : responses[0];
+  }
+  async createOne(opts) {
+    this.checkApiKey();
+    const data = buildParseData({ formats: opts.formats ?? ["md"], elementFormats: opts.elementFormats, extractConfig: opts.extractConfig });
+    const buffer = fs3.readFileSync(opts.file);
+    const fileName = path3.basename(opts.file);
+    const result = await this._http.post("/parse/async", data, { name: fileName, buffer, mimeType: "application/octet-stream" });
+    const taskId = result.data?.task_id ?? "";
+    const warnings = collectApiWarnings(result);
+    emitWarnings(warnings);
+    return new Task(taskId, (id) => this.pollTask(id), warnings);
+  }
+  async create(opts) {
+    this.checkApiKey();
+    const { files, isBatch } = resolveFileInputs(opts.file, opts.fileList);
+    ensureFilesExist(files);
+    const { results: tasks, warnings } = await runLimited(files, (file) => this.createOne({ ...opts, file }));
+    if (isBatch) {
+      emitWarnings(warnings);
+      attachWarnings(tasks, warnings);
+    }
+    return isBatch ? tasks : tasks[0];
+  }
+};
+
+// src/resources/usage.ts
+var UsageClient = class {
+  _http;
+  constructor(http2) {
+    this._http = http2;
+  }
+  async get() {
+    if (!this._http.getApiKey()) {
+      throw new AuthenticationError("apiKey is required for usage queries.");
+    }
+    const result = await this._http.post("/usage", {});
+    const usage = Usage.fromApi(result);
+    emitWarnings(usage.warnings);
+    return usage;
+  }
+};
+
+// src/resources/pdf.ts
+import * as fs4 from "fs";
+import * as path4 from "path";
+var PDFProcessor = class {
+  async toImages(opts) {
+    let pdfiumMod = null;
+    try {
+      pdfiumMod = await import("@hyzyla/pdfium");
+    } catch {
+      return { ok: false, files: [], error: "@hyzyla/pdfium is not installed. Run: npm install somark-js" };
+    }
+    let PNG = null;
+    try {
+      const pngjsMod = await import("pngjs");
+      PNG = pngjsMod.PNG;
+    } catch {
+      return { ok: false, files: [], error: "pngjs is not installed. Run: npm install pngjs" };
+    }
+    try {
+      const outDir = opts.out ?? "./";
+      if (!fs4.existsSync(outDir)) fs4.mkdirSync(outDir, { recursive: true });
+      const baseName = path4.basename(opts.file, path4.extname(opts.file));
+      const fmt = opts.filenameFormat ?? "{name}.page-{n}.png";
+      const dpi = opts.dpi ?? 150;
+      const scale = dpi / 72;
+      const pdfBuffer = fs4.readFileSync(opts.file);
+      const library = await pdfiumMod.PDFiumLibrary.init();
+      const document = await library.loadDocument(pdfBuffer);
+      const files = [];
+      const pageCount = document.getPageCount();
+      for (let i = 0; i < pageCount; i++) {
+        const page = document.getPage(i);
+        const image = await page.render({
+          scale,
+          render: async (renderOpts) => {
+            const png = new PNG({ width: renderOpts.width, height: renderOpts.height });
+            const src = renderOpts.data;
+            for (let j = 0; j < src.length; j += 4) {
+              png.data[j] = src[j + 2];
+              png.data[j + 1] = src[j + 1];
+              png.data[j + 2] = src[j];
+              png.data[j + 3] = src[j + 3];
+            }
+            return Buffer.from(PNG.sync.write(png));
+          }
+        });
+        const outName = fmt.replace("{name}", baseName).replace("{n}", String(i + 1));
+        const outPath = path4.join(outDir, outName);
+        fs4.writeFileSync(outPath, Buffer.from(image.data));
+        files.push(outPath);
+      }
+      document.destroy();
+      library.destroy();
+      return { ok: true, files };
+    } catch (err) {
+      return { ok: false, files: [], error: String(err) };
+    }
+  }
+};
+
+// src/resources/preview.ts
+import * as fs5 from "fs";
+import * as http from "http";
+import * as path5 from "path";
+import { fileURLToPath } from "url";
+var SUPPORTED_PREVIEW_EXTS = /* @__PURE__ */ new Set([".md", ".smd"]);
+var VENDOR_FIX_HINT = "Run: git submodule update --init --recursive or somark doctor fix";
+var previewHttp = {
+  createServer: http.createServer
+};
+var previewFs = {
+  createReadStream: fs5.createReadStream,
+  existsSync: fs5.existsSync,
+  statSync: fs5.statSync
+};
+var MIME_TYPES = {
+  ".css": "text/css; charset=utf-8",
+  ".gif": "image/gif",
+  ".html": "text/html; charset=utf-8",
+  ".jpeg": "image/jpeg",
+  ".jpg": "image/jpeg",
+  ".js": "application/javascript; charset=utf-8",
+  ".json": "application/json; charset=utf-8",
+  ".map": "application/json; charset=utf-8",
+  ".md": "text/markdown; charset=utf-8",
+  ".png": "image/png",
+  ".smd": "text/plain; charset=utf-8",
+  ".svg": "image/svg+xml",
+  ".txt": "text/plain; charset=utf-8",
+  ".wasm": "application/wasm",
+  ".webp": "image/webp"
+};
+function currentModuleDir() {
+  if (typeof __dirname !== "undefined") return __dirname;
+  return path5.dirname(fileURLToPath(import.meta.url));
+}
+var previewVendorPaths = {
+  packageVendorDir() {
+    return path5.resolve(currentModuleDir(), "../vendor/somarkdown-viewer");
+  },
+  developmentVendorDir() {
+    return path5.resolve(process.cwd(), "vendor/somarkdown-viewer");
+  }
+};
+function vendorCandidates() {
+  const candidates = [
+    { dir: previewVendorPaths.packageVendorDir(), source: "package" },
+    { dir: previewVendorPaths.developmentVendorDir(), source: "development" }
+  ];
+  const seen = /* @__PURE__ */ new Set();
+  return candidates.map((candidate) => ({ ...candidate, dir: path5.resolve(candidate.dir) })).filter((candidate) => {
+    if (seen.has(candidate.dir)) return false;
+    seen.add(candidate.dir);
+    return true;
+  });
+}
+function describeVendorSource(source) {
+  return source === "package" ? "package assets" : "development checkout";
+}
+function findVendorLocation() {
+  for (const candidate of vendorCandidates()) {
+    if (previewFs.existsSync(candidate.dir) && previewFs.statSync(candidate.dir).isDirectory()) return candidate;
+  }
+  return null;
+}
+function missingVendorEntries(vendorDir) {
+  const required = [
+    path5.join(vendorDir, "index.html"),
+    path5.join(vendorDir, "lib")
+  ];
+  return required.filter((candidate) => !previewFs.existsSync(candidate)).map((item) => path5.basename(item));
+}
+function validateVendorLocation(vendorLocation) {
+  if (!vendorLocation) {
+    throw new Error(`vendor/somarkdown-viewer not found. ${VENDOR_FIX_HINT}`);
+  }
+  const missing = missingVendorEntries(vendorLocation.dir);
+  if (missing.length > 0) {
+    if (vendorLocation.source === "package") {
+      throw new Error(`Installed preview assets are incomplete. Missing ${missing.join(", ")}. Reinstall the package or rebuild it with bundled viewer assets.`);
+    }
+    throw new Error(`vendor/somarkdown-viewer is incomplete. Missing ${missing.join(", ")}. ${VENDOR_FIX_HINT}`);
+  }
+  return vendorLocation;
+}
+function validatePreviewFile(file) {
+  const absolutePath = path5.resolve(file);
+  if (!previewFs.existsSync(absolutePath) || !previewFs.statSync(absolutePath).isFile()) {
+    throw new Error(`Preview file not found: ${absolutePath}`);
+  }
+  const ext = path5.extname(absolutePath).toLowerCase();
+  if (!SUPPORTED_PREVIEW_EXTS.has(ext)) {
+    throw new Error(`Unsupported preview file type: ${ext || "(no extension)"}. Use .md or .smd.`);
+  }
+  return {
+    absolutePath,
+    rootDir: path5.dirname(absolutePath),
+    routePath: `/_preview/file/${encodeURIComponent(path5.basename(absolutePath))}`
+  };
+}
+function normalizeRelativeRoute(routePathname) {
+  const prefix = "/_preview/file/";
+  if (!routePathname.startsWith(prefix)) return null;
+  const raw = routePathname.slice(prefix.length);
+  if (!raw) return null;
+  const decodedSegments = raw.split("/").filter(Boolean).map((segment) => {
+    try {
+      return decodeURIComponent(segment);
+    } catch {
+      return null;
+    }
+  });
+  if (decodedSegments.some((segment) => !segment || segment === "." || segment === "..")) {
+    return null;
+  }
+  return decodedSegments.join(path5.sep);
+}
+function isPathInside(rootDir, candidatePath) {
+  const relativePath = path5.relative(rootDir, candidatePath);
+  return relativePath !== "" && !relativePath.startsWith("..") && !path5.isAbsolute(relativePath);
+}
+function sendFile(res, filePath) {
+  const ext = path5.extname(filePath).toLowerCase();
+  res.writeHead(200, { "Content-Type": MIME_TYPES[ext] ?? "application/octet-stream" });
+  previewFs.createReadStream(filePath).pipe(res);
+}
+function sendText(res, status, body) {
+  res.writeHead(status, { "Content-Type": "text/plain; charset=utf-8" });
+  res.end(body);
+}
+var SoMarkDownPreview = class {
+  async start(opts = {}) {
+    const host = opts.host ?? "127.0.0.1";
+    const port = opts.port ?? 7878;
+    const openBrowser = opts.openBrowser ?? true;
+    const vendorLocation = validateVendorLocation(findVendorLocation());
+    const vendorDir = vendorLocation.dir;
+    const previewFile = opts.file ? validatePreviewFile(opts.file) : null;
+    const server = previewHttp.createServer((req, res) => {
+      const pathname = (req.url ?? "/").split("?")[0] || "/";
+      if (pathname === "/") {
+        sendFile(res, path5.join(vendorDir, "index.html"));
+        return;
+      }
+      const relativePreviewPath = normalizeRelativeRoute(pathname);
+      if (pathname.startsWith("/_preview/file/")) {
+        if (!previewFile) {
+          sendText(res, 404, "No preview file loaded.");
+          return;
+        }
+        if (!relativePreviewPath) {
+          sendText(res, 403, "Preview access denied.");
+          return;
+        }
+        const candidatePath = path5.resolve(previewFile.rootDir, relativePreviewPath);
+        if (candidatePath !== previewFile.absolutePath && !isPathInside(previewFile.rootDir, candidatePath)) {
+          sendText(res, 403, "Preview access denied.");
+          return;
+        }
+        if (!previewFs.existsSync(candidatePath) || !previewFs.statSync(candidatePath).isFile()) {
+          sendText(res, 404, "Preview file not found.");
+          return;
+        }
+        sendFile(res, candidatePath);
+        return;
+      }
+      const vendorPath = path5.resolve(vendorDir, `.${pathname}`);
+      const relativeVendorPath = path5.relative(vendorDir, vendorPath);
+      if (relativeVendorPath.startsWith("..") || path5.isAbsolute(relativeVendorPath) || !previewFs.existsSync(vendorPath) || !previewFs.statSync(vendorPath).isFile()) {
+        sendText(res, 404, "Not found");
+        return;
+      }
+      sendFile(res, vendorPath);
+    });
+    server.on("clientError", (_err, socket) => {
+      socket.end("HTTP/1.1 400 Bad Request\r\n\r\n");
+    });
+    await new Promise((resolve5, reject) => {
+      server.listen(port, host, () => resolve5());
+      server.once("error", (err) => {
+        if (err.code === "EADDRINUSE") {
+          reject(new Error(`Port ${port} is already in use on ${host}.`));
+          return;
+        }
+        reject(err);
+      });
+    });
+    const boundAddress = server.address();
+    const boundPort = typeof boundAddress === "object" && boundAddress ? boundAddress.port : port;
+    const serverUrl = `http://${host}:${boundPort}`;
+    const fileUrl = previewFile ? `${serverUrl}?file=${encodeURIComponent(`${serverUrl}${previewFile.routePath}`)}` : serverUrl;
+    if (openBrowser) {
+      const open = await import("open").catch(() => null);
+      if (open) await open.default(fileUrl);
+    }
+    let stopped = false;
+    return {
+      url: serverUrl,
+      fileUrl,
+      host,
+      port: boundPort,
+      stop: () => new Promise((resolve5, reject) => {
+        if (stopped) {
+          resolve5();
+          return;
+        }
+        stopped = true;
+        server.close((err) => err ? reject(err) : resolve5());
+      })
+    };
+  }
+};
+
+// src/client.ts
+var SoMark = class {
+  parser;
+  usage;
+  pdf;
+  preview;
+  _http;
+  constructor(opts = {}) {
+    const cfg = resolveConfig(opts);
+    this._http = new HttpClient({
+      apiKey: cfg.apiKey,
+      baseUrl: cfg.baseUrl,
+      timeout: cfg.timeout,
+      maxRetries: cfg.maxRetries
+    });
+    this.parser = new DocumentParser(this._http);
+    this.usage = new UsageClient(this._http);
+    this.pdf = new PDFProcessor();
+    this.preview = new SoMarkDownPreview();
+  }
+  toString() {
+    const key = this._http.getApiKey();
+    const masked = key && key.length > 8 ? `${key.slice(0, 4)}...${key.slice(-4)}` : key ? "set" : "not set";
+    return `SoMark(apiKey=${masked})`;
+  }
+};
+
+// src/cli/help.ts
+function examples(...commands) {
+  return `
+Examples:
+${commands.map((command) => `  ${command}`).join("\n")}`;
+}
+
+// src/cli/commands/parse.ts
+function registerParseCommand(program2) {
+  program2.command("parse [files...]").description("Parse a document").option("--formats <formats>", "Output formats (comma-separated): md,markdown,json,zip", "md").option("--out <path>", "Output file path").option("--file-list <path>", "Text file with one document path per line").option("--image-fmt <mode>", "Image return mode: url|base64|file|none", "url").option("--formula-fmt <fmt>", "Formula format: latex|mathml|ascii").option("--table-fmt <fmt>", "Table format: markdown|html|image").option("--cs-fmt <fmt>", "Chemical structure format: image").option("--title-levels", "Enable title level recognition").option("--cross-page-text", "Enable text cross-page merge").option("--cross-page-table", "Enable table cross-page merge").option("--no-inline-image", "Disable inline images").option("--no-table-image", "Disable table images").option("--no-image-understanding", "Disable image understanding").option("--keep-header-footer", "Keep headers and footers").option("--async", "Submit async task only").option("--task-id <id>", "Query/wait for existing task").option("--wait", "Wait for async task (use with --task-id)").option("--verbose", "Verbose output").addHelpText("after", examples(
+    "somark parse document.pdf --formats md,json --out parsed/",
+    "somark parse a.pdf b.pdf --out parsed/",
+    "somark parse --file-list files.txt --out parsed/",
+    "somark parse document.pdf --async",
+    "somark parse --task-id TASK_ID --wait"
+  )).action(async (filesArg, opts, cmd) => {
+    const parentOpts = cmd.parent?.opts() ?? {};
+    const client = new SoMark({
+      apiKey: parentOpts["apiKey"],
+      baseUrl: parentOpts["baseUrl"],
+      timeout: parentOpts["timeout"] ? Number(parentOpts["timeout"]) : void 0
+    });
+    const formats = normalizeSaveFormats(opts.formats);
+    const extractConfig = {
+      enableTitleLevelRecognition: !!opts.titleLevels,
+      enableTextCrossPage: !!opts.crossPageText,
+      enableTableCrossPage: !!opts.crossPageTable,
+      enableInlineImage: opts.inlineImage !== false,
+      enableTableImage: opts.tableImage !== false,
+      enableImageUnderstanding: opts.imageUnderstanding !== false,
+      keepHeaderFooter: !!opts.keepHeaderFooter
+    };
+    const elementFormats = {
+      image: opts.imageFmt,
+      formula: opts.formulaFmt,
+      table: opts.tableFmt,
+      cs: opts.csFmt
+    };
+    const files = collectInputFiles(filesArg ?? [], opts.fileList);
+    const isBatch = files.length > 1 || opts.fileList !== void 0;
+    try {
+      if (opts.taskId) {
+        const task = client.parser.task(opts.taskId);
+        if (opts.wait) {
+          const stdoutMode = opts.out === void 0 && formats.length === 1;
+          let response2;
+          if (stdoutMode) {
+            response2 = await task.wait();
+          } else {
+            const spinner2 = ora(`Waiting for task ${opts.taskId}...`).start();
+            response2 = await task.wait();
+            spinner2.succeed("Done");
+          }
+          response2.sourceFileName = response2.sourceFileName ?? task.fileName;
+          const outputPlan2 = planOutput(response2.sourceFileName ?? "output", opts.out, formats, { allowStdout: true });
+          if (outputPlan2.stdout) {
+            process.stdout.write(response2.contentForFormat(formats[0]));
+            return;
+          }
+          await saveOutputPlan(response2, outputPlan2);
+          for (const output of planPaths(outputPlan2)) console.log(`Output saved: ${output}`);
+          console.log(`Task ID: ${response2.taskId}, Pages: ${response2.pages}`);
+        } else {
+          await task.refresh();
+          console.log(`Task ${opts.taskId}: status=${task.status}`);
+        }
+        return;
+      }
+      if (opts.async) {
+        if (!files.length) {
+          console.error(chalk.red("File argument required for async mode"));
+          process.exit(3);
+        }
+        if (isBatch) {
+          const spinner2 = ora("Submitting tasks...").start();
+          const tasks = await client.parser.create({ file: files, formats, elementFormats, extractConfig });
+          spinner2.succeed("Done");
+          renderBatchResults(files, tasks, { asyncMode: true, formats, out: opts.out, verbose: !!opts.verbose });
+          return;
+        }
+        const file2 = files[0];
+        const task = await client.parser.create({ file: file2, formats, elementFormats, extractConfig });
+        console.log(`Task submitted: ${task.id}`);
+        console.log(`Status: ${task.status}`);
+        console.log(`
+To retrieve results later:`);
+        console.log(`  somark parse --task-id ${task.id} --wait`);
+        return;
+      }
+      if (!files.length) {
+        console.error(chalk.red("File argument required"));
+        process.exit(3);
+      }
+      if (isBatch) {
+        validateBatchOutput(opts.out, formats);
+        const spinner2 = ora("Parsing files...").start();
+        const responses = await client.parser.parse({ file: files, formats, elementFormats, extractConfig });
+        spinner2.succeed("Done");
+        await saveBatchOutputs(files, responses, opts.out, formats);
+        renderBatchResults(files, responses, { asyncMode: false, formats, out: opts.out, verbose: !!opts.verbose });
+        return;
+      }
+      const file = files[0];
+      const outputPlan = planOutput(file, opts.out, formats, { allowStdout: true });
+      if (outputPlan.stdout) {
+        const response2 = await client.parser.parse({ file, formats, elementFormats, extractConfig });
+        process.stdout.write(response2.contentForFormat(formats[0]));
+        return;
+      }
+      const spinner = ora(`Parsing ${file}...`).start();
+      const response = await client.parser.parse({ file, formats, elementFormats, extractConfig });
+      spinner.succeed(chalk.green(`Done in ${response.pages} pages`));
+      await saveOutputPlan(response, outputPlan);
+      for (const output of planPaths(outputPlan)) console.log(`Output saved: ${output}`);
+      if (opts.verbose) console.log(`Task ID: ${response.taskId}`);
+    } catch (err) {
+      const e = err;
+      console.error(chalk.red(`\u2717 ${e.message}`));
+      process.exit(e.constructor.name.includes("Auth") || e.constructor.name.includes("Connection") ? 2 : 1);
+    }
+  });
+}
+function collectInputFiles(files, fileList) {
+  try {
+    return resolveCliFileInputs(files, fileList).files;
+  } catch (err) {
+    console.error(chalk.red(`\u2717 ${err.message}`));
+    process.exit(3);
+  }
+}
+function validateBatchOutput(out, formats = ["md"]) {
+  planOutput("output", out, formats, { batch: true });
+}
+function planPaths(plan) {
+  return plan.targets.flatMap((target) => target.path ? [target.path] : []);
+}
+async function saveOutputPlan(response, plan) {
+  for (const target of plan.targets) {
+    if (!target.stdout && target.path) await response.save(target.path, target.format);
+  }
+}
+async function saveBatchOutputs(files, responses, out, formats) {
+  await Promise.all(responses.map((response, index) => saveOutputPlan(response, planOutput(files[index], out, formats, { batch: true }))));
+}
+function renderBatchResults(files, items, opts) {
+  console.log(`Files: ${files.length}`);
+  console.table(items.map((item, index) => {
+    const file = files[index];
+    const outputOrTask = opts.asyncMode ? item.id : outputLabel(file, item, opts);
+    return {
+      "#": index + 1,
+      file,
+      exists: "yes",
+      status: opts.asyncMode ? "submitted" : "success",
+      outputOrTask,
+      error: ""
+    };
+  }));
+  console.log(`Summary: total=${items.length} success=${items.length} failed=0`);
+}
+function outputLabel(file, response, opts) {
+  const output = planPaths(planOutput(file, opts.out, opts.formats, { batch: true })).join(", ");
+  return opts.verbose && response.taskId ? `${output} task=${response.taskId}` : output;
+}
+
+// src/cli/commands/usage.ts
+import chalk2 from "chalk";
+function registerUsageCommand(program2) {
+  program2.command("usage").description("Query API usage").option("--format <fmt>", "Output format: text|json|table", "table").addHelpText("after", examples("somark usage --format table")).action(async (opts, cmd) => {
+    const parentOpts = cmd.parent?.opts() ?? {};
+    const client = new SoMark({
+      apiKey: parentOpts["apiKey"],
+      baseUrl: parentOpts["baseUrl"],
+      timeout: parentOpts["timeout"] ? Number(parentOpts["timeout"]) : void 0
+    });
+    try {
+      const usage = await client.usage.get();
+      if (opts.format === "json") {
+        console.log(JSON.stringify(usage.toJSON(), null, 2));
+      } else if (opts.format === "text") {
+        console.log(`Paid Pages Remaining:  ${usage.remainingPaidPages.toLocaleString()}`);
+        console.log(`Free Pages Today:      ${usage.remainingFreePagesToday.toLocaleString()}`);
+        console.log(`Free Pages This Month: ${usage.remainingFreePagesThisMonth.toLocaleString()}`);
+        console.log(`Dashboard: ${usage.dashboardUrl}`);
+      } else {
+        console.log("\u250C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510");
+        console.log("\u2502 SoMark Usage              \u2502                     \u2502");
+        console.log("\u251C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253C\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524");
+        console.log(`\u2502 Paid Pages Remaining      \u2502 ${String(usage.remainingPaidPages.toLocaleString()).padEnd(20)}\u2502`);
+        console.log(`\u2502 Free Pages Today          \u2502 ${String(usage.remainingFreePagesToday.toLocaleString()).padEnd(20)}\u2502`);
+        console.log(`\u2502 Free Pages This Month     \u2502 ${String(usage.remainingFreePagesThisMonth.toLocaleString()).padEnd(20)}\u2502`);
+        console.log(`\u2502 Dashboard                 \u2502 ${String(usage.dashboardUrl).substring(0, 20).padEnd(20)}\u2502`);
+        console.log("\u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518");
+      }
+    } catch (err) {
+      console.error(chalk2.red(`\u2717 ${err.message}`));
+      process.exit(2);
+    }
+  });
+}
+
+// src/cli/commands/pdf.ts
+import chalk3 from "chalk";
+function registerPdfCommand(program2) {
+  const pdf = program2.command("pdf").description("PDF operations").addHelpText("after", examples("somark pdf toimg document.pdf --out ./pages"));
+  pdf.command("toimg <file>").description("Convert PDF pages to images (local, no API key needed)").option("--out <dir>", "Output directory", "./").option("--format <template>", "Filename template: {name}.page-{n}.png").option("--dpi <n>", "Resolution in DPI", "150").addHelpText("after", examples("somark pdf toimg document.pdf --out ./pages")).action(async (file, opts) => {
+    const resource = new PDFProcessor();
+    const result = await resource.toImages({
+      file,
+      out: opts.out,
+      filenameFormat: opts.format,
+      dpi: Number(opts.dpi)
+    });
+    if (result.ok) {
+      console.log(chalk3.green(`\u2713 Converted ${result.files.length} page(s) to ${opts.out}`));
+      result.files.forEach((f) => console.log(`  ${f}`));
+    } else {
+      console.error(chalk3.red(`\u2717 ${result.error}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/preview.ts
+import chalk4 from "chalk";
+function registerPreviewCommand(program2) {
+  program2.command("preview [file]").description("Start a local SoMarkDown preview server").option("--host <host>", "Host to bind", "127.0.0.1").option("--port <n>", "Port to listen on", "7878").option("--no-open", "Don't open browser").addHelpText("after", examples("somark preview output.md --port 7878")).action(async (file, opts) => {
+    const resource = new SoMarkDownPreview();
+    try {
+      const server = await resource.start({
+        file,
+        host: opts.host,
+        port: Number(opts.port),
+        openBrowser: opts.open
+      });
+      console.log(chalk4.green(`Preview server started: ${server.url}`));
+      if (file) console.log(`File URL: ${server.fileUrl}`);
+      console.log("Press Ctrl+C to stop.");
+      process.once("SIGINT", async () => {
+        await server.stop();
+        console.log("\nServer stopped.");
+        process.exit(0);
+      });
+    } catch (err) {
+      console.error(chalk4.red(`\u2717 ${err.message}`));
+      process.exit(1);
+    }
+  });
+}
+
+// src/cli/commands/doctor.ts
+import chalk5 from "chalk";
+import * as path6 from "path";
+import * as fs6 from "fs";
+
+// src/cli/output.ts
+function printWarning(message) {
+  emitWarnings([message]);
+}
+
+// src/cli/commands/doctor.ts
+var VIEWER_REPO_URL = "https://github.com/SoMarkAI/SoMarkDownViewer.git";
+function placeholderEntries(targetDir) {
+  if (!fs6.existsSync(targetDir) || !fs6.statSync(targetDir).isDirectory()) return [];
+  return fs6.readdirSync(targetDir).filter((name) => name !== ".DS_Store");
+}
+function resolveVendorInstallDir() {
+  return path6.resolve(process.cwd(), "vendor/somarkdown-viewer");
+}
+async function repairViewerInstall() {
+  const { execFileSync } = await import("child_process");
+  const targetDir = resolveVendorInstallDir();
+  const parentDir = path6.dirname(targetDir);
+  const gitDir = path6.join(targetDir, ".git");
+  const scriptPath = path6.join(targetDir, "get_latest_smd.sh");
+  fs6.mkdirSync(parentDir, { recursive: true });
+  if (fs6.existsSync(gitDir)) {
+    execFileSync("git", ["-C", targetDir, "fetch", "--depth", "1", "origin", "main"], { stdio: "inherit" });
+    execFileSync("git", ["-C", targetDir, "checkout", "main"], { stdio: "inherit" });
+    execFileSync("git", ["-C", targetDir, "pull", "--ff-only", "origin", "main"], { stdio: "inherit" });
+  } else if (!fs6.existsSync(targetDir)) {
+    execFileSync("git", ["clone", "--depth", "1", VIEWER_REPO_URL, targetDir], { stdio: "inherit" });
+  } else {
+    const entries = placeholderEntries(targetDir);
+    const isPlaceholder = entries.length === 0 || entries.length === 1 && entries[0] === ".gitkeep";
+    const hasViewerFiles = fs6.existsSync(path6.join(targetDir, "index.html")) || fs6.existsSync(scriptPath);
+    if (isPlaceholder) {
+      fs6.rmSync(targetDir, { recursive: true, force: true });
+      execFileSync("git", ["clone", "--depth", "1", VIEWER_REPO_URL, targetDir], { stdio: "inherit" });
+    } else if (!hasViewerFiles) {
+      throw new Error(`Cannot repair preview assets automatically because ${targetDir} exists but is not a SoMarkDownViewer checkout.`);
+    }
+  }
+  if (fs6.existsSync(scriptPath)) {
+    execFileSync("bash", [scriptPath], { stdio: "inherit" });
+    return;
+  }
+  throw new Error(`get_latest_smd.sh not found after repair in ${targetDir}.`);
+}
+function registerDoctorCommand(program2) {
+  const doctor = program2.command("doctor").description("Diagnose installation").addHelpText("after", examples("somark doctor", "somark doctor fix", "somark doctor ping"));
+  doctor.action(runChecks);
+  doctor.command("fix").description("Attempt to fix installation issues").addHelpText("after", examples("somark doctor fix")).action(async () => {
+    try {
+      await repairViewerInstall();
+      console.log(chalk5.green("\u2713 Preview assets repaired."));
+    } catch (e) {
+      console.error(chalk5.red(`\u2717 Failed: ${e.message}`));
+    }
+  });
+  doctor.command("ping").description("Check network connectivity").addHelpText("after", examples("somark doctor ping")).action(async () => {
+    const targets = ["https://1.1.1.1", "https://somark.tech"];
+    for (const target of targets) {
+      try {
+        const res = await fetch(target, { signal: AbortSignal.timeout(5e3) });
+        console.log(chalk5.green(`\u2713 ${target} (${res.status})`));
+      } catch (e) {
+        console.error(chalk5.red(`\u2717 ${target}: ${e.message}`));
+      }
+    }
+  });
+}
+async function runChecks() {
+  console.log(chalk5.bold("SoMark Doctor\n"));
+  const [major] = process.versions.node.split(".").map(Number);
+  if (major >= 18) {
+    console.log(chalk5.green(`\u2713 Node.js ${process.versions.node}`));
+  } else {
+    console.error(chalk5.red(`\u2717 Node.js ${process.versions.node} (>=18 required)`));
+  }
+  try {
+    await import("@hyzyla/pdfium");
+    console.log(chalk5.green("\u2713 @hyzyla/pdfium installed"));
+  } catch {
+    printWarning("@hyzyla/pdfium not installed. Run: npm install somark-js");
+  }
+  const { resolveConfig: resolveConfig2 } = await import("./config-GOZJZCRT.mjs");
+  const cfg = resolveConfig2();
+  if (cfg.apiKey) {
+    const k = cfg.apiKey;
+    const masked = k.length > 8 ? `${k.slice(0, 4)}...${k.slice(-4)}` : "***";
+    console.log(chalk5.green(`\u2713 API key configured (${masked})`));
+  } else {
+    printWarning("API key not configured. Run: somark login");
+  }
+  const vendorLocation = findVendorLocation();
+  try {
+    const resolvedVendorLocation = validateVendorLocation(vendorLocation);
+    const source = describeVendorSource(resolvedVendorLocation.source);
+    console.log(chalk5.green(`\u2713 preview assets ready (${source}: ${resolvedVendorLocation.dir})`));
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    const hasVendorDir = vendorLocation && fs6.existsSync(vendorLocation.dir);
+    if (hasVendorDir) {
+      printWarning(message);
+    } else {
+      console.error(chalk5.red(`\u2717 ${message}`));
+    }
+  }
+  try {
+    const res = await fetch("https://somark.tech", { signal: AbortSignal.timeout(5e3) });
+    console.log(chalk5.green(`\u2713 somark.tech reachable (${res.status})`));
+  } catch (e) {
+    console.error(chalk5.red(`\u2717 somark.tech unreachable: ${e.message}`));
+  }
+}
+
+// src/cli/commands/config.ts
+import chalk6 from "chalk";
+function registerConfigCommand(program2) {
+  const config = program2.command("config").description("Manage configuration").addHelpText("after", examples("somark config set api_key sk-...", "somark config get api_key", "somark config list"));
+  config.command("set <key> <value>").description("Set a config value (keys: api_key, base_url, timeout, max_retries)").option("--show", "Show secret values in output").addHelpText("after", examples("somark config set api_key sk-...")).action((key, value, opts) => {
+    try {
+      saveConfig({ [key]: value });
+      const displayValue = opts.show ? value : maskConfigValue(key, value);
+      console.log(chalk6.green(`\u2713 Set ${key} = ${displayValue}`));
+    } catch (e) {
+      console.error(chalk6.red(`\u2717 ${e.message}`));
+      process.exit(1);
+    }
+  });
+  config.command("get <key>").description("Get a config value").option("--show", "Show secret values in output").addHelpText("after", examples("somark config get api_key")).action((key, opts) => {
+    const val = getConfigValue(key);
+    if (val !== void 0) console.log(`${key} = ${opts.show ? val : maskConfigValue(key, val)}`);
+    else console.log(`${key} is not set`);
+  });
+  config.command("list").description("List all config values (effective: env > file > default)").option("--show", "Show secret values in output").addHelpText("after", examples("somark config list")).action((opts) => {
+    const cfg = listResolvedConfig();
+    const sourceLabel = (s) => s === "env" ? chalk6.cyan("[env]") : s === "file" ? chalk6.yellow("[file]") : chalk6.dim("[default]");
+    Object.entries(cfg).forEach(([k, { value, source }]) => {
+      const displayValue = opts.show ? value : maskConfigValue(k, value);
+      console.log(`${k} = ${displayValue}  ${sourceLabel(source)}`);
+    });
+  });
+}
+
+// src/cli/commands/login.ts
+import chalk7 from "chalk";
+import * as readline from "readline";
+function registerLoginCommand(program2) {
+  program2.command("login").description("Login to SoMark and save API key").option("--no-open", "Don't open browser").addHelpText("after", examples("somark login --no-open")).action(async (opts) => {
+    const apiKeyUrl = "https://somark.tech/workbench/apikey";
+    if (opts.open !== false) {
+      console.log(`Opening ${apiKeyUrl} in your browser...`);
+      const open = await import("open").catch(() => null);
+      if (open) await open.default(apiKeyUrl);
+    } else {
+      console.log(`Visit ${apiKeyUrl} to get your API key.`);
+    }
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const apiKey = await new Promise((resolve5) => rl.question("Enter your API key: ", resolve5));
+    rl.close();
+    if (!apiKey.startsWith("sk-")) {
+      console.error(chalk7.red("\u2717 Invalid API key format (should start with 'sk-')"));
+      process.exit(1);
+    }
+    saveConfig({ api_key: apiKey });
+    console.log(chalk7.green("\u2713 Authenticated. Config saved to ~/.somark/config.toml"));
+  });
+}
+
+// src/cli/index.ts
+var { version } = package_default;
+var program = new Command();
+program.name("somark").description("SoMark SDK + CLI \u2014 Document parsing, PDF processing, and SoMarkDown preview. [JS]").version(version).helpOption("-h, --help", "display help for command").option("--api-key <key>", "API key", process.env.SOMARK_API_KEY).option("--base-url <url>", "Base URL").option("--timeout <seconds>", "Request timeout in seconds", "60").option("--no-warnings", "Suppress SoMark warnings").addHelpText("after", examples("somark parse document.pdf --formats md,json --out output.md", "somark usage --format table"));
+registerParseCommand(program);
+registerUsageCommand(program);
+registerPdfCommand(program);
+registerPreviewCommand(program);
+registerDoctorCommand(program);
+registerConfigCommand(program);
+registerLoginCommand(program);
+program.hook("preAction", (_thisCommand, actionCommand) => {
+  const optsWithGlobals = actionCommand.optsWithGlobals?.() ?? program.opts();
+  setWarningsSuppressed(Boolean(optsWithGlobals.warnings === false));
+});
+program.parse();