sygal-cli 0.1.0

package/dist/index.js

@@ -0,0 +1,2858 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/index.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path9 = require("node:path");
+var import_commander = require("commander");
+var import_picocolors3 = __toESM(require("picocolors"));
+
+// ../core/src/errors.ts
+var ConversionError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ConversionError";
+  }
+};
+
+// ../core/src/mime.ts
+var MAX_FILE_SIZE_BYTES = 200 * 1024 * 1024;
+var SUPPORTED_EXTENSIONS = {
+  // MarkItDown
+  pdf: "application/pdf",
+  docx: "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+  xlsx: "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+  pptx: "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+  xls: "application/vnd.ms-excel",
+  html: "text/html",
+  htm: "text/html",
+  csv: "text/csv",
+  txt: "text/plain",
+  md: "text/markdown",
+  json: "application/json",
+  xml: "application/xml",
+  epub: "application/epub+zip",
+  msg: "application/vnd.ms-outlook",
+  eml: "message/rfc822",
+  ipynb: "application/x-ipynb+json",
+  zip: "application/zip",
+  // OCR (images) — HEIC/TIFF normalized to PNG before the API call (sharp)
+  png: "image/png",
+  jpg: "image/jpeg",
+  jpeg: "image/jpeg",
+  gif: "image/gif",
+  webp: "image/webp",
+  tiff: "image/tiff",
+  tif: "image/tiff",
+  heic: "image/heic",
+  heif: "image/heif"
+};
+function mimeForExtension(extension) {
+  return SUPPORTED_EXTENSIONS[extension.toLowerCase()] ?? null;
+}
+function pipelineForMime(mimeType) {
+  return mimeType.startsWith("image/") ? "ocr" : "markitdown";
+}
+
+// ../core/src/tokens.ts
+var import_gpt_4o = require("gpt-tokenizer/model/gpt-4o");
+function countTokens(text) {
+  if (!text) return 0;
+  try {
+    return (0, import_gpt_4o.encode)(text).length;
+  } catch {
+    return 0;
+  }
+}
+
+// ../core/src/image-normalize.ts
+var import_sharp = __toESM(require("sharp"));
+var NEEDS_PNG = /* @__PURE__ */ new Set([".heic", ".heif", ".tiff", ".tif"]);
+function needsPngNormalization(ext) {
+  return NEEDS_PNG.has(ext.toLowerCase());
+}
+async function toPngBuffer(input) {
+  return (0, import_sharp.default)(input).png().toBuffer();
+}
+async function shrinkToMaxBytes(input, maxBytes) {
+  const QUALITY = 80;
+  let output = await (0, import_sharp.default)(input).jpeg({ quality: QUALITY }).toBuffer();
+  if (output.length <= maxBytes) return output;
+  const meta = await (0, import_sharp.default)(input).metadata();
+  let width = meta.width ?? 1600;
+  while (output.length > maxBytes && width > 200) {
+    width = Math.round(width * 0.75);
+    output = await (0, import_sharp.default)(input).resize({ width }).jpeg({ quality: QUALITY }).toBuffer();
+  }
+  let quality = QUALITY;
+  while (output.length > maxBytes && quality > 20) {
+    quality -= 15;
+    output = await (0, import_sharp.default)(input).resize({ width }).jpeg({ quality }).toBuffer();
+  }
+  return output;
+}
+
+// ../core/src/ocr-models.ts
+var OCR_MODELS = {
+  openai: "gpt-4o",
+  mistral: "mistral-ocr-latest",
+  claude: "claude-sonnet-4-6",
+  // Bascule 18/07/2026 (test comparatif, validation Cyrill) : nemotron nano VL
+  // remplace meta/llama-3.2-11b-vision-instruct — 0/5 confabulation sur portrait
+  // sans texte (contre 5/5), français fidèle, plus rapide et déterministe.
+  nvidia: "nvidia/llama-3.1-nemotron-nano-vl-8b-v1",
+  gemini: "gemini-2.0-flash"
+};
+var MISTRAL_TRANSLATE_MODEL = "mistral-large-latest";
+
+// ../core/src/sidecar/manager.ts
+var import_node_child_process = require("node:child_process");
+var import_node_crypto = require("node:crypto");
+var import_node_readline = require("node:readline");
+var SidecarError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SidecarError";
+  }
+};
+var DEFAULT_TIMEOUT_MS = 12e4;
+var DEFAULT_MAX_RESPAWNS = 3;
+var SidecarManager = class {
+  command;
+  args;
+  requestTimeoutMs;
+  maxRespawns;
+  logger;
+  child = null;
+  pending = /* @__PURE__ */ new Map();
+  respawnCount = 0;
+  stopped = false;
+  constructor(options) {
+    this.command = options.command;
+    this.args = options.args ?? [];
+    this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_TIMEOUT_MS;
+    this.maxRespawns = options.maxRespawns ?? DEFAULT_MAX_RESPAWNS;
+    this.logger = options.logger ?? console;
+  }
+  get isRunning() {
+    return this.child !== null;
+  }
+  start() {
+    if (this.child) return;
+    this.stopped = false;
+    const child = (0, import_node_child_process.spawn)(this.command, this.args, {
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    this.child = child;
+    const stdout = (0, import_node_readline.createInterface)({ input: child.stdout });
+    stdout.on("line", (line) => this.handleLine(line));
+    const stderr = (0, import_node_readline.createInterface)({ input: child.stderr });
+    stderr.on("line", (line) => this.logger.info(`[sidecar:stderr] ${line}`));
+    child.stdin.on("error", (err) => {
+      this.logger.warn(`[sidecar] erreur stdin ignor\xE9e : ${err.message}`);
+    });
+    child.on("error", (err) => {
+      this.logger.error(`[sidecar] erreur de spawn : ${err.message}`);
+      this.handleExit(null);
+    });
+    child.on("exit", (code) => {
+      if (child !== this.child) return;
+      this.handleExit(code);
+    });
+  }
+  /** Arrêt propre : fin de stdin, plus aucun respawn. */
+  stop() {
+    this.stopped = true;
+    const child = this.child;
+    this.child = null;
+    if (child) {
+      child.stdin.end();
+      child.kill();
+    }
+    this.rejectAllPending("SIDECAR_DOWN", "Sidecar arr\xEAt\xE9");
+  }
+  async ping() {
+    await this.request({ id: (0, import_node_crypto.randomUUID)(), cmd: "ping" });
+  }
+  async convert(path, options = {}) {
+    const response = await this.request({ id: (0, import_node_crypto.randomUUID)(), cmd: "convert", path, options });
+    return {
+      markdown: response.markdown ?? "",
+      meta: response.meta ?? {},
+      originText: response.origin_text,
+      originPdf: response.origin_pdf,
+      originImages: response.origin_images
+    };
+  }
+  async convertUrl(url) {
+    const response = await this.request({ id: (0, import_node_crypto.randomUUID)(), cmd: "convert_url", url });
+    return {
+      markdown: response.markdown ?? "",
+      meta: response.meta ?? {},
+      originText: response.origin_text
+    };
+  }
+  async probePdf(path) {
+    const response = await this.request({ id: (0, import_node_crypto.randomUUID)(), cmd: "pdf_probe", path });
+    return {
+      pageCount: response.page_count ?? 0,
+      pagesTextLength: response.pages_text_length ?? []
+    };
+  }
+  async renderPdfPage(path, page) {
+    const response = await this.request({ id: (0, import_node_crypto.randomUUID)(), cmd: "pdf_render_page", path, page });
+    if (!response.image_path) {
+      throw new SidecarError("CONVERSION_FAILED", "Rendu de page PDF sans image_path");
+    }
+    return response.image_path;
+  }
+  request(req) {
+    const child = this.child;
+    if (!child || child.killed || child.stdin.destroyed || !child.stdin.writable) {
+      return Promise.reject(
+        new SidecarError("SIDECAR_DOWN", "Sidecar non d\xE9marr\xE9 ou d\xE9finitivement arr\xEAt\xE9")
+      );
+    }
+    return new Promise((resolve2, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(req.id);
+        reject(new SidecarError("TIMEOUT", `Timeout apr\xE8s ${this.requestTimeoutMs} ms`));
+      }, this.requestTimeoutMs);
+      this.pending.set(req.id, {
+        resolve: (response) => {
+          clearTimeout(timer);
+          if (response.status === "ok") {
+            resolve2(response);
+          } else {
+            reject(new SidecarError(response.code, response.message));
+          }
+        },
+        reject: (error) => {
+          clearTimeout(timer);
+          reject(error);
+        },
+        timer
+      });
+      try {
+        child.stdin.write(JSON.stringify(req) + "\n");
+      } catch (err) {
+        this.pending.delete(req.id);
+        clearTimeout(timer);
+        reject(
+          new SidecarError(
+            "SIDECAR_DOWN",
+            `\xC9criture stdin impossible : ${err instanceof Error ? err.message : String(err)}`
+          )
+        );
+      }
+    });
+  }
+  handleLine(line) {
+    let response;
+    try {
+      response = JSON.parse(line);
+    } catch {
+      this.logger.warn(`[sidecar] ligne stdout non-JSON ignor\xE9e : ${line}`);
+      return;
+    }
+    if (!response.id) {
+      this.logger.warn(`[sidecar] r\xE9ponse sans id : ${line}`);
+      return;
+    }
+    const pending = this.pending.get(response.id);
+    if (!pending) {
+      this.logger.warn(`[sidecar] r\xE9ponse orpheline (id=${response.id})`);
+      return;
+    }
+    this.pending.delete(response.id);
+    this.respawnCount = 0;
+    pending.resolve(response);
+  }
+  handleExit(code) {
+    this.child = null;
+    this.rejectAllPending("SIDECAR_DOWN", `Sidecar termin\xE9 (code ${code ?? "inconnu"})`);
+    if (this.stopped) return;
+    if (this.respawnCount >= this.maxRespawns) {
+      this.logger.error(`[sidecar] crash d\xE9finitif apr\xE8s ${this.maxRespawns} tentatives de respawn`);
+      return;
+    }
+    this.respawnCount += 1;
+    this.logger.warn(
+      `[sidecar] crash (code ${code ?? "inconnu"}) \u2014 respawn ${this.respawnCount}/${this.maxRespawns}`
+    );
+    this.start();
+  }
+  rejectAllPending(code, message) {
+    for (const pending of this.pending.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new SidecarError(code, message));
+    }
+    this.pending.clear();
+  }
+};
+
+// ../core/src/sidecar/pool.ts
+var DEFAULT_POOL_SIZE = 2;
+var SidecarPool = class {
+  workers;
+  inFlight;
+  constructor(options) {
+    const size = options.poolSize ?? DEFAULT_POOL_SIZE;
+    this.workers = Array.from({ length: size }, () => new SidecarManager(options));
+    this.inFlight = new Map(this.workers.map((w) => [w, 0]));
+  }
+  /** Vrai tant qu'au moins un worker est vivant */
+  get isRunning() {
+    return this.workers.some((w) => w.isRunning);
+  }
+  start() {
+    for (const worker of this.workers) worker.start();
+  }
+  stop() {
+    for (const worker of this.workers) worker.stop();
+  }
+  /** Ping de tous les workers vivants (health check au boot) */
+  async ping() {
+    const alive = this.workers.filter((w) => w.isRunning);
+    if (alive.length === 0) {
+      throw new SidecarError("SIDECAR_DOWN", "Aucun worker sidecar vivant");
+    }
+    await Promise.all(alive.map((w) => w.ping()));
+  }
+  async convert(path, options = {}) {
+    const worker = this.pickWorker();
+    this.inFlight.set(worker, (this.inFlight.get(worker) ?? 0) + 1);
+    try {
+      return await worker.convert(path, options);
+    } finally {
+      this.inFlight.set(worker, Math.max(0, (this.inFlight.get(worker) ?? 1) - 1));
+    }
+  }
+  async convertUrl(url) {
+    const worker = this.pickWorker();
+    this.inFlight.set(worker, (this.inFlight.get(worker) ?? 0) + 1);
+    try {
+      return await worker.convertUrl(url);
+    } finally {
+      this.inFlight.set(worker, Math.max(0, (this.inFlight.get(worker) ?? 1) - 1));
+    }
+  }
+  async probePdf(path) {
+    const worker = this.pickWorker();
+    this.inFlight.set(worker, (this.inFlight.get(worker) ?? 0) + 1);
+    try {
+      return await worker.probePdf(path);
+    } finally {
+      this.inFlight.set(worker, Math.max(0, (this.inFlight.get(worker) ?? 1) - 1));
+    }
+  }
+  async renderPdfPage(path, page) {
+    const worker = this.pickWorker();
+    this.inFlight.set(worker, (this.inFlight.get(worker) ?? 0) + 1);
+    try {
+      return await worker.renderPdfPage(path, page);
+    } finally {
+      this.inFlight.set(worker, Math.max(0, (this.inFlight.get(worker) ?? 1) - 1));
+    }
+  }
+  /** Worker vivant le moins chargé — les workers morts sont exclus du dispatch */
+  pickWorker() {
+    let best = null;
+    let bestLoad = Infinity;
+    for (const worker of this.workers) {
+      if (!worker.isRunning) continue;
+      const load2 = this.inFlight.get(worker) ?? 0;
+      if (load2 < bestLoad) {
+        best = worker;
+        bestLoad = load2;
+      }
+    }
+    if (!best) {
+      throw new SidecarError("SIDECAR_DOWN", "Aucun worker sidecar vivant");
+    }
+    return best;
+  }
+};
+
+// ../core/src/ocr/ocr-provider.ts
+var LOCALE_LANGUAGE = {
+  fr: "French",
+  en: "English",
+  it: "Italian",
+  de: "German",
+  es: "Spanish"
+};
+function buildOcrPrompt(labelLanguage = "French") {
+  return `Transcribe ALL visible text in this image verbatim as clean Markdown, preserving the document layout: headings, lists and tables exactly as shown. Transcribe EVERY line, row and table cell faithfully \u2014 never summarize, skip, merge, reorder, or invent rows, values, or text. If a cell is empty, leave it empty. Keep the document text in its ORIGINAL language exactly as written \u2014 do not translate it. Do NOT invent a table of contents, section titles, or any heading/structure that is not visually present in the document. If you must add a label of your own that is not in the document, write it in ${labelLanguage}. While transcribing, do NOT describe the scene, the people, or any visual elements that are not text. ONLY IF the image contains no readable text at all: instead of an empty document, describe the image in ${labelLanguage} as clean Markdown \u2014 one short paragraph covering the subject, the setting and the dominant colors, factual and concise, without inventing any text that is not visible. When describing, NEVER invent or guess names, ages, occupations, employers, biographies, locations, dates, or any information about people or organizations. Describe only what is physically visible in the image; if something is not visible, do not mention it. Output only the Markdown.`;
+}
+function buildTranslatePrompt(targetLocale) {
+  const language = LOCALE_LANGUAGE[targetLocale] ?? "English";
+  return `Translate the ENTIRE following Markdown document into ${language}, from the first line to the last, without skipping any paragraph, list item, or table cell. Every word of human-readable text must end up in ${language} \u2014 none of the original language may remain anywhere in the output. Preserve the Markdown structure exactly (headings, lists, tables, code blocks, links) and keep URLs, code, and proper nouns unchanged. Output only the fully translated Markdown, nothing else.`;
+}
+var OcrError = class extends Error {
+  constructor(code, message, retryable = false) {
+    super(message);
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "OcrError";
+  }
+};
+function httpStatusToOcrError(status, providerId) {
+  if (status === 401 || status === 403) {
+    return new OcrError("API_KEY_INVALID", `${providerId} : cl\xE9 API refus\xE9e (HTTP ${status})`);
+  }
+  if (status === 429) {
+    return new OcrError("RATE_LIMITED", `${providerId} : limite de requ\xEAtes atteinte (HTTP 429)`);
+  }
+  if (status >= 500) {
+    return new OcrError("NETWORK", `${providerId} : erreur serveur (HTTP ${status})`, true);
+  }
+  return new OcrError("UNKNOWN", `${providerId} : r\xE9ponse inattendue (HTTP ${status})`);
+}
+function toDataUrl(img, mime) {
+  return `data:${mime};base64,${img.toString("base64")}`;
+}
+async function callOpenAiCompatibleChatText(endpoint, model, apiKey, signal, prompt, text, providerId, maxTokens = 8192, frequencyPenalty) {
+  const response = await fetch(endpoint, {
+    method: "POST",
+    signal,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model,
+      max_tokens: maxTokens,
+      ...frequencyPenalty !== void 0 ? { frequency_penalty: frequencyPenalty } : {},
+      messages: [{ role: "user", content: `${prompt}
+
+${text}` }]
+    })
+  });
+  if (!response.ok) {
+    throw httpStatusToOcrError(response.status, providerId);
+  }
+  const payload = await response.json();
+  const markdown = payload.choices?.[0]?.message?.content;
+  if (typeof markdown !== "string" || markdown.length === 0) {
+    throw new OcrError("UNKNOWN", `${providerId} : r\xE9ponse sans contenu`);
+  }
+  return { markdown, raw: payload };
+}
+
+// ../core/src/ocr/ocr-runner.ts
+var import_promises = require("node:fs/promises");
+var import_node_path = require("node:path");
+
+// ../core/src/ocr/claude-provider.ts
+var CLAUDE_OCR_MODEL = OCR_MODELS.claude;
+var ENDPOINT = "https://api.anthropic.com/v1/messages";
+var claudeProvider = {
+  id: "claude",
+  model: CLAUDE_OCR_MODEL,
+  async convertImage(img, mime, apiKey, signal, prompt) {
+    const response = await fetch(ENDPOINT, {
+      method: "POST",
+      signal,
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: CLAUDE_OCR_MODEL,
+        max_tokens: 8192,
+        messages: [
+          {
+            role: "user",
+            content: [
+              {
+                type: "image",
+                source: { type: "base64", media_type: mime, data: img.toString("base64") }
+              },
+              { type: "text", text: prompt }
+            ]
+          }
+        ]
+      })
+    });
+    if (!response.ok) throw httpStatusToOcrError(response.status, "claude");
+    const payload = await response.json();
+    const markdown = (payload.content ?? []).filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("");
+    if (markdown.length === 0) {
+      throw new OcrError("UNKNOWN", "claude : r\xE9ponse sans contenu");
+    }
+    return { markdown, raw: payload };
+  },
+  async translateText(text, apiKey, signal, prompt) {
+    const response = await fetch(ENDPOINT, {
+      method: "POST",
+      signal,
+      headers: {
+        "Content-Type": "application/json",
+        "x-api-key": apiKey,
+        "anthropic-version": "2023-06-01"
+      },
+      body: JSON.stringify({
+        model: CLAUDE_OCR_MODEL,
+        max_tokens: 8192,
+        messages: [{ role: "user", content: `${prompt}
+
+${text}` }]
+      })
+    });
+    if (!response.ok) throw httpStatusToOcrError(response.status, "claude");
+    const payload = await response.json();
+    const markdown = (payload.content ?? []).filter((b) => b.type === "text" && typeof b.text === "string").map((b) => b.text).join("");
+    if (markdown.length === 0) {
+      throw new OcrError("UNKNOWN", "claude : r\xE9ponse sans contenu");
+    }
+    return { markdown, raw: payload };
+  }
+};
+
+// ../core/src/ocr/custom-provider.ts
+async function callCustomProvider(provider, img, mime, apiKey, signal, prompt) {
+  const base = provider.baseUrl.replace(/\/$/, "");
+  const endpoint = `${base}/chat/completions`;
+  const response = await fetch(endpoint, {
+    method: "POST",
+    signal,
+    headers: {
+      "Content-Type": "application/json",
+      Authorization: `Bearer ${apiKey}`
+    },
+    body: JSON.stringify({
+      model: provider.model,
+      max_tokens: 8192,
+      messages: [
+        {
+          role: "user",
+          content: [
+            { type: "text", text: prompt },
+            { type: "image_url", image_url: { url: toDataUrl(img, mime) } }
+          ]
+        }
+      ]
+    })
+  });
+  if (!response.ok) {
+    throw httpStatusToOcrError(response.status, "openai");
+  }
+  const payload = await response.json();
+  const markdown = payload.choices?.[0]?.message?.content;
+  if (typeof markdown !== "string" || markdown.length === 0) {
+    throw new OcrError("UNKNOWN", `${provider.name} : r\xE9ponse sans contenu`);
+  }
+  return { markdown };
+}
+function callCustomProviderTranslate(provider, text, apiKey, signal, prompt) {
+  const base = provider.baseUrl.replace(/\/$/, "");
+  return callOpenAiCompatibleChatText(
+    `${base}/chat/completions`,
+    provider.model,
+    apiKey,
+    signal,
+    prompt,
+    text,
+    provider.name
+  );
+}
+
+// ../core/src/ocr/gemini-provider.ts
+var MODEL = OCR_MODELS.gemini;
+var ENDPOINT2 = "https://generativelanguage.googleapis.com/v1beta/openai/chat/completions";
+var geminiProvider = {
+  id: "gemini",
+  model: MODEL,
+  async convertImage(img, mime, apiKey, signal, prompt) {
+    const response = await fetch(ENDPOINT2, {
+      method: "POST",
+      signal,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model: MODEL,
+        max_tokens: 8192,
+        messages: [
+          {
+            role: "user",
+            content: [
+              { type: "text", text: prompt },
+              { type: "image_url", image_url: { url: toDataUrl(img, mime) } }
+            ]
+          }
+        ]
+      })
+    });
+    if (!response.ok) throw httpStatusToOcrError(response.status, "gemini");
+    const payload = await response.json();
+    const markdown = payload.choices?.[0]?.message?.content;
+    if (typeof markdown !== "string" || markdown.length === 0) {
+      throw new OcrError("UNKNOWN", "gemini : r\xE9ponse sans contenu");
+    }
+    return { markdown, raw: payload };
+  },
+  translateText(text, apiKey, signal, prompt) {
+    return callOpenAiCompatibleChatText(ENDPOINT2, MODEL, apiKey, signal, prompt, text, "gemini");
+  }
+};
+
+// ../core/src/ocr/mistral-provider.ts
+var MISTRAL_OCR_MODEL = OCR_MODELS.mistral;
+var ENDPOINT3 = "https://api.mistral.ai/v1/ocr";
+var CHAT_ENDPOINT = "https://api.mistral.ai/v1/chat/completions";
+var mistralProvider = {
+  id: "mistral",
+  model: MISTRAL_OCR_MODEL,
+  async convertImage(img, mime, apiKey, signal) {
+    const response = await fetch(ENDPOINT3, {
+      method: "POST",
+      signal,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model: MISTRAL_OCR_MODEL,
+        document: { type: "image_url", image_url: toDataUrl(img, mime) }
+      })
+    });
+    if (!response.ok) throw httpStatusToOcrError(response.status, "mistral");
+    const payload = await response.json();
+    const markdown = (payload.pages ?? []).map((p) => p.markdown ?? "").filter((md) => md.length > 0).join("\n\n");
+    if (markdown.length === 0) {
+      throw new OcrError("UNKNOWN", "mistral : r\xE9ponse sans contenu");
+    }
+    return { markdown, raw: payload };
+  },
+  translateText(text, apiKey, signal, prompt) {
+    return callOpenAiCompatibleChatText(
+      CHAT_ENDPOINT,
+      MISTRAL_TRANSLATE_MODEL,
+      apiKey,
+      signal,
+      prompt,
+      text,
+      "mistral"
+    );
+  }
+};
+
+// ../core/src/ocr/nvidia-provider.ts
+var NVIDIA_OCR_MODEL = OCR_MODELS.nvidia;
+var ENDPOINT4 = "https://integrate.api.nvidia.com/v1/chat/completions";
+var NVIDIA_MAX_IMAGE_BYTES = 17e4;
+var nvidiaProvider = {
+  id: "nvidia",
+  model: NVIDIA_OCR_MODEL,
+  async convertImage(img, mime, apiKey, signal, prompt) {
+    let payloadImg = img;
+    let payloadMime = mime;
+    if (payloadImg.length > NVIDIA_MAX_IMAGE_BYTES) {
+      payloadImg = await shrinkToMaxBytes(payloadImg, NVIDIA_MAX_IMAGE_BYTES);
+      payloadMime = "image/jpeg";
+    }
+    const response = await fetch(ENDPOINT4, {
+      method: "POST",
+      signal,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model: NVIDIA_OCR_MODEL,
+        max_tokens: 4096,
+        // Llama vision peut dégénérer en boucle de répétition sans pénalité
+        // (observé en réel : même phrase répétée ~200 fois jusqu'à max_tokens).
+        frequency_penalty: 0.4,
+        // Petit modèle (11B) : sans température 0 ni cadrage renforcé, il "interprète"
+        // (résumé en anglais observé en réel 12/07/2026 au lieu d'une transcription).
+        // ATTENTION : pas de message system — le endpoint NIM llama vision rejette
+        // les requêtes system + image (constaté en réel 12/07/2026, appel en échec).
+        temperature: 0,
+        messages: [
+          {
+            role: "user",
+            content: [
+              {
+                type: "text",
+                text: "You are an OCR engine. You copy text from images character by character. You never summarize, never translate, never comment, never add steps or headings of your own. You only describe the image in the single case where it contains no readable text at all, exactly as instructed below.\n\n" + prompt
+              },
+              { type: "image_url", image_url: { url: toDataUrl(payloadImg, payloadMime) } }
+            ]
+          }
+        ]
+      })
+    });
+    if (!response.ok) throw httpStatusToOcrError(response.status, "nvidia");
+    const payload = await response.json();
+    const markdown = payload.choices?.[0]?.message?.content;
+    if (typeof markdown !== "string" || markdown.length === 0) {
+      throw new OcrError("UNKNOWN", "nvidia : r\xE9ponse sans contenu");
+    }
+    return { markdown, raw: payload };
+  },
+  translateText(text, apiKey, signal, prompt) {
+    return callOpenAiCompatibleChatText(
+      ENDPOINT4,
+      NVIDIA_OCR_MODEL,
+      apiKey,
+      signal,
+      prompt,
+      text,
+      "nvidia",
+      8192,
+      0.4
+      // même garde-fou anti-répétition que convertImage ci-dessus
+    );
+  }
+};
+
+// ../core/src/ocr/openai-provider.ts
+var OPENAI_OCR_MODEL = OCR_MODELS.openai;
+var ENDPOINT5 = "https://api.openai.com/v1/chat/completions";
+var openAiProvider = {
+  id: "openai",
+  model: OPENAI_OCR_MODEL,
+  async convertImage(img, mime, apiKey, signal, prompt) {
+    const response = await fetch(ENDPOINT5, {
+      method: "POST",
+      signal,
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`
+      },
+      body: JSON.stringify({
+        model: OPENAI_OCR_MODEL,
+        max_tokens: 8192,
+        messages: [
+          {
+            role: "user",
+            content: [
+              { type: "text", text: prompt },
+              { type: "image_url", image_url: { url: toDataUrl(img, mime) } }
+            ]
+          }
+        ]
+      })
+    });
+    if (!response.ok) throw httpStatusToOcrError(response.status, "openai");
+    const payload = await response.json();
+    const markdown = payload.choices?.[0]?.message?.content;
+    if (typeof markdown !== "string" || markdown.length === 0) {
+      throw new OcrError("UNKNOWN", "openai : r\xE9ponse sans contenu");
+    }
+    return { markdown, raw: payload };
+  },
+  translateText(text, apiKey, signal, prompt) {
+    return callOpenAiCompatibleChatText(
+      ENDPOINT5,
+      OPENAI_OCR_MODEL,
+      apiKey,
+      signal,
+      prompt,
+      text,
+      "openai"
+    );
+  }
+};
+
+// ../core/src/ocr/ocr-runner.ts
+var OCR_TIMEOUT_MS = 12e4;
+var OCR_RETRY_BACKOFF_MS = [1e3, 4e3];
+var REPEATED_LINE_LIMIT = 4;
+function collapseRepeatedLines(markdown) {
+  const lines = markdown.split("\n");
+  const kept = [];
+  let prevContent = null;
+  let streak = 0;
+  for (const line of lines) {
+    const content = line.replace(/^[#*\-\s]+/, "").trim();
+    if (content.length === 0) {
+      kept.push(line);
+      continue;
+    }
+    streak = content === prevContent ? streak + 1 : 0;
+    if (streak >= REPEATED_LINE_LIMIT) {
+      kept.push("\n*(r\xE9ponse tronqu\xE9e \u2014 r\xE9p\xE9tition d\xE9tect\xE9e)*");
+      break;
+    }
+    prevContent = content;
+    kept.push(line);
+  }
+  return kept.join("\n");
+}
+var REFUSAL_RE = /^(i['’]?m sorry|i cannot|i can['’]?t|i am (unable|not able)|sorry,|je suis désolé|désolé,|je ne peux pas|lo siento|mi dispiace|es tut mir leid|ich kann)/i;
+function isProviderRefusal(markdown) {
+  return REFUSAL_RE.test(markdown.trim().slice(0, 80));
+}
+var OCR_PROVIDERS = {
+  openai: openAiProvider,
+  mistral: mistralProvider,
+  claude: claudeProvider,
+  nvidia: nvidiaProvider,
+  gemini: geminiProvider
+};
+var IMAGE_MIME = {
+  ".png": "image/png",
+  ".jpg": "image/jpeg",
+  ".jpeg": "image/jpeg",
+  ".webp": "image/webp",
+  ".gif": "image/gif",
+  // HEIC/TIFF normalisés en PNG avant l'appel API (les API vision les refusent)
+  ".tiff": "image/tiff",
+  ".tif": "image/tiff",
+  ".heic": "image/heic",
+  ".heif": "image/heif"
+};
+var ApiOcrRunner = class {
+  constructor(settings, options = {}) {
+    this.settings = settings;
+    this.timeoutMs = options.timeoutMs ?? OCR_TIMEOUT_MS;
+    this.backoffMs = options.backoffMs ?? OCR_RETRY_BACKOFF_MS;
+  }
+  timeoutMs;
+  backoffMs;
+  async convertImage(sourcePath) {
+    const settings = this.settings.getAppSettings();
+    const prompt = buildOcrPrompt(LOCALE_LANGUAGE[settings.locale]);
+    const ext = (0, import_node_path.extname)(sourcePath).toLowerCase();
+    const mime = IMAGE_MIME[ext];
+    if (!mime) {
+      throw new ConversionError("UNSUPPORTED_FORMAT", `Image non prise en charge : ${sourcePath}`);
+    }
+    let img = await (0, import_promises.readFile)(sourcePath);
+    let sendMime = mime;
+    if (needsPngNormalization(ext)) {
+      img = await toPngBuffer(img);
+      sendMime = "image/png";
+    }
+    if (settings.customProviderId) {
+      const customs = this.settings.getCustomProviders();
+      const custom = customs.find((p) => p.id === settings.customProviderId);
+      if (!custom) {
+        throw new ConversionError(
+          "UNKNOWN",
+          `Provider personnalis\xE9 introuvable : ${settings.customProviderId}`
+        );
+      }
+      const apiKey2 = this.settings.getCustomApiKey(settings.customProviderId);
+      if (!apiKey2) {
+        throw new ConversionError("API_KEY_MISSING", `Aucune cl\xE9 API pour ${custom.name}`);
+      }
+      const result2 = await this.callCustomWithRetry(custom, img, sendMime, apiKey2, prompt);
+      if (isProviderRefusal(result2.markdown)) {
+        throw new ConversionError("OCR_REFUSED", `${custom.name} : refus du mod\xE8le`);
+      }
+      return {
+        markdown: collapseRepeatedLines(result2.markdown),
+        meta: { provider: custom.name, model: custom.model }
+      };
+    }
+    const providerId = settings.ocrProvider;
+    const provider = OCR_PROVIDERS[providerId];
+    const apiKey = this.settings.getApiKey(providerId);
+    if (!apiKey) {
+      throw new ConversionError(
+        "API_KEY_MISSING",
+        `Aucune cl\xE9 API enregistr\xE9e pour le provider ${providerId}`
+      );
+    }
+    const result = await this.callWithRetry(provider, img, sendMime, apiKey, prompt);
+    if (isProviderRefusal(result.markdown)) {
+      throw new ConversionError("OCR_REFUSED", `${provider.id} : refus du mod\xE8le`);
+    }
+    return {
+      markdown: collapseRepeatedLines(result.markdown),
+      meta: { provider: provider.id, model: provider.model }
+    };
+  }
+  /** Tentative initiale + retries backoff sur erreurs retryable uniquement */
+  async callWithRetry(provider, img, mime, apiKey, prompt) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.backoffMs.length; attempt++) {
+      if (attempt > 0) await sleep(this.backoffMs[attempt - 1]);
+      try {
+        return await this.singleAttempt(provider, img, mime, apiKey, prompt);
+      } catch (err) {
+        const converted = toConversionError(err, provider.id);
+        const retryable = err instanceof OcrError && err.retryable;
+        if (!retryable) throw converted;
+        lastError = converted;
+      }
+    }
+    throw lastError ?? new ConversionError("UNKNOWN", `${provider.id} : \xE9chec OCR`);
+  }
+  async singleAttempt(provider, img, mime, apiKey, prompt) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+    try {
+      return await provider.convertImage(img, mime, apiKey, controller.signal, prompt);
+    } catch (err) {
+      if (controller.signal.aborted) {
+        throw new ConversionError("TIMEOUT", `${provider.id} : d\xE9lai OCR d\xE9pass\xE9`);
+      }
+      if (!(err instanceof OcrError) && !(err instanceof ConversionError)) {
+        throw new OcrError("NETWORK", `${provider.id} : erreur r\xE9seau`, true);
+      }
+      throw err;
+    } finally {
+      clearTimeout(timer);
+    }
+  }
+  async callCustomWithRetry(custom, img, mime, apiKey, prompt) {
+    let lastError = null;
+    for (let attempt = 0; attempt <= this.backoffMs.length; attempt++) {
+      if (attempt > 0) await sleep(this.backoffMs[attempt - 1]);
+      try {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+        try {
+          return await callCustomProvider(custom, img, mime, apiKey, controller.signal, prompt);
+        } catch (err) {
+          if (controller.signal.aborted) {
+            throw new ConversionError("TIMEOUT", `${custom.name} : d\xE9lai OCR d\xE9pass\xE9`);
+          }
+          if (!(err instanceof OcrError) && !(err instanceof ConversionError)) {
+            throw new OcrError("NETWORK", `${custom.name} : erreur r\xE9seau`, true);
+          }
+          throw err;
+        } finally {
+          clearTimeout(timer);
+        }
+      } catch (err) {
+        const converted = toConversionErrorStr(err, custom.name);
+        const retryable = err instanceof OcrError && err.retryable;
+        if (!retryable) throw converted;
+        lastError = converted;
+      }
+    }
+    throw lastError ?? new ConversionError("UNKNOWN", `${custom.name} : \xE9chec OCR`);
+  }
+};
+function toConversionErrorStr(err, name) {
+  if (err instanceof ConversionError) return err;
+  if (err instanceof OcrError) return new ConversionError(err.code, err.message);
+  return new ConversionError("UNKNOWN", `${name} : \xE9chec OCR`);
+}
+function toConversionError(err, providerId) {
+  if (err instanceof ConversionError) return err;
+  if (err instanceof OcrError) return new ConversionError(err.code, err.message);
+  return new ConversionError("UNKNOWN", `${providerId} : \xE9chec OCR`);
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// ../core/src/ocr/locale-detect.ts
+var STOPWORDS = {
+  fr: [
+    "le",
+    "la",
+    "les",
+    "de",
+    "des",
+    "du",
+    "et",
+    "est",
+    "une",
+    "un",
+    "dans",
+    "pour",
+    "que",
+    "qui",
+    "avec",
+    "sur",
+    "pas",
+    "vous",
+    "nous",
+    "mais",
+    "ou",
+    "plus",
+    "sont",
+    "ce",
+    "cette",
+    "au",
+    "aux",
+    "leur"
+  ],
+  en: [
+    "the",
+    "and",
+    "is",
+    "of",
+    "to",
+    "in",
+    "that",
+    "for",
+    "with",
+    "on",
+    "are",
+    "was",
+    "this",
+    "but",
+    "not",
+    "you",
+    "we",
+    "or",
+    "have",
+    "as",
+    "be",
+    "it",
+    "from",
+    "by"
+  ],
+  it: [
+    "il",
+    "la",
+    "di",
+    "che",
+    "e",
+    "un",
+    "una",
+    "per",
+    "con",
+    "non",
+    "sono",
+    "gli",
+    "le",
+    "del",
+    "della",
+    "ma",
+    "anche",
+    "come",
+    "pi\xF9",
+    "questo",
+    "questa",
+    "sono"
+  ],
+  de: [
+    "der",
+    "die",
+    "das",
+    "und",
+    "ist",
+    "ein",
+    "eine",
+    "mit",
+    "f\xFCr",
+    "auf",
+    "nicht",
+    "sie",
+    "wir",
+    "aber",
+    "oder",
+    "von",
+    "zu",
+    "im",
+    "sind",
+    "auch"
+  ],
+  es: [
+    "el",
+    "la",
+    "los",
+    "las",
+    "de",
+    "y",
+    "es",
+    "un",
+    "una",
+    "para",
+    "con",
+    "no",
+    "son",
+    "pero",
+    "m\xE1s",
+    "como",
+    "este",
+    "esta",
+    "en",
+    "su"
+  ]
+};
+var LOCALES = ["fr", "en", "it", "de", "es"];
+var MIN_SCORE = 0.03;
+var MIN_MARGIN = 1.3;
+function detectLocale(text) {
+  const tokens = text.toLowerCase().normalize("NFD").replace(/[\u0300-\u036f]/g, "").match(/[a-z]+/g);
+  if (!tokens || tokens.length < 20) return null;
+  const scores = LOCALES.map((locale) => {
+    const words = new Set(STOPWORDS[locale]);
+    const hits = tokens.filter((t) => words.has(t)).length;
+    return { locale, score: hits / tokens.length };
+  }).sort((a, b) => b.score - a.score);
+  const [best, second] = scores;
+  if (best.score < MIN_SCORE) return null;
+  if (second && best.score < second.score * MIN_MARGIN) return null;
+  return best.locale;
+}
+
+// ../core/src/ocr/markdown-chunker.ts
+var CHUNK_CHAR_BUDGET = 6e3;
+function splitMarkdownIntoChunks(markdown, budget = CHUNK_CHAR_BUDGET) {
+  if (markdown.length <= budget) return [markdown];
+  const blocks = markdown.split(/\n{2,}/);
+  const chunks = [];
+  let current = "";
+  for (const block of blocks) {
+    const candidate = current ? `${current}
+
+${block}` : block;
+    if (candidate.length > budget && current) {
+      chunks.push(current);
+      current = block;
+    } else {
+      current = candidate;
+    }
+  }
+  if (current) chunks.push(current);
+  return chunks.length > 0 ? chunks : [markdown];
+}
+
+// ../core/src/ocr/translation-runner.ts
+var TranslationRunner = class {
+  constructor(settings, options = {}) {
+    this.settings = settings;
+    this.timeoutMs = options.timeoutMs ?? OCR_TIMEOUT_MS;
+    this.backoffMs = options.backoffMs ?? OCR_RETRY_BACKOFF_MS;
+  }
+  timeoutMs;
+  backoffMs;
+  async translate(markdown, targetLocale) {
+    if (detectLocale(markdown) === targetLocale) return markdown;
+    const settings = this.settings.getAppSettings();
+    const prompt = buildTranslatePrompt(targetLocale);
+    let providerLabel;
+    let call;
+    if (settings.customProviderId) {
+      const custom = this.settings.getCustomProviders().find((p) => p.id === settings.customProviderId);
+      if (!custom) {
+        throw new ConversionError(
+          "UNKNOWN",
+          `Provider personnalis\xE9 introuvable : ${settings.customProviderId}`
+        );
+      }
+      const apiKey = this.settings.getCustomApiKey(settings.customProviderId);
+      if (!apiKey) {
+        throw new ConversionError("API_KEY_MISSING", `Aucune cl\xE9 API pour ${custom.name}`);
+      }
+      providerLabel = custom.name;
+      call = (text, signal) => callCustomProviderTranslate(custom, text, apiKey, signal, prompt);
+    } else {
+      const providerId = settings.ocrProvider;
+      const provider = OCR_PROVIDERS[providerId];
+      const apiKey = this.settings.getApiKey(providerId);
+      if (!apiKey) {
+        throw new ConversionError(
+          "API_KEY_MISSING",
+          `Aucune cl\xE9 API enregistr\xE9e pour le provider ${providerId}`
+        );
+      }
+      providerLabel = provider.id;
+      call = (text, signal) => provider.translateText(text, apiKey, signal, prompt);
+    }
+    const chunks = splitMarkdownIntoChunks(markdown);
+    const translated = [];
+    for (const chunk of chunks) {
+      translated.push(await this.withRetry(providerLabel, (signal) => call(chunk, signal)));
+    }
+    return translated.join("\n\n");
+  }
+  async withRetry(providerLabel, attempt) {
+    let lastError = null;
+    for (let i = 0; i <= this.backoffMs.length; i++) {
+      if (i > 0) await sleep2(this.backoffMs[i - 1]);
+      const controller = new AbortController();
+      const timer = setTimeout(() => controller.abort(), this.timeoutMs);
+      try {
+        const result = await attempt(controller.signal);
+        return collapseRepeatedLines(result.markdown);
+      } catch (err) {
+        if (controller.signal.aborted) {
+          throw new ConversionError("TIMEOUT", `${providerLabel} : d\xE9lai de traduction d\xE9pass\xE9`);
+        }
+        const normalized = err instanceof OcrError || err instanceof ConversionError ? err : new OcrError("NETWORK", `${providerLabel} : erreur r\xE9seau`, true);
+        const retryable = normalized instanceof OcrError && normalized.retryable;
+        const converted = normalized instanceof ConversionError ? normalized : new ConversionError(normalized.code, normalized.message);
+        if (!retryable) throw converted;
+        lastError = converted;
+      } finally {
+        clearTimeout(timer);
+      }
+    }
+    throw lastError ?? new ConversionError("UNKNOWN", `${providerLabel} : \xE9chec de traduction`);
+  }
+};
+function sleep2(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+
+// ../core/src/conversion/embedded-images.ts
+var import_node_crypto2 = require("node:crypto");
+var import_promises2 = require("node:fs/promises");
+var import_node_os = require("node:os");
+var import_node_path2 = require("node:path");
+var ADVANCED_CONVERSION_EXTENSIONS = /* @__PURE__ */ new Set([
+  "docx",
+  "pptx",
+  "html",
+  "htm",
+  "eml",
+  "pdf",
+  "xlsx"
+]);
+var DATA_URI_IMAGE_RE = /!\[([^\]]*)\]\(data:([^;,)]+)(?:;[^,)]*)?,([A-Za-z0-9+/=]+)\)/g;
+var DEFAULT_EMBEDDED_OCR_CONCURRENCY = 3;
+function uniqueImageIndices(matches) {
+  const seen = /* @__PURE__ */ new Set();
+  const unique = /* @__PURE__ */ new Set();
+  matches.forEach((match, i) => {
+    if (!seen.has(match[3])) {
+      seen.add(match[3]);
+      unique.add(i);
+    }
+  });
+  return unique;
+}
+async function ocrEmbeddedImages(result, options) {
+  const matches = [...result.markdown.matchAll(DATA_URI_IMAGE_RE)];
+  if (matches.length === 0) return result;
+  const ocr = options.ocr;
+  if (!ocr) {
+    throw new ConversionError(
+      "API_KEY_MISSING",
+      `${matches.length} image(s) embarqu\xE9e(s) d\xE9tect\xE9e(s), aucun provider OCR configur\xE9`
+    );
+  }
+  const unique = uniqueImageIndices(matches);
+  const concurrency = options.concurrency ?? DEFAULT_EMBEDDED_OCR_CONCURRENCY;
+  const replacements = new Array(matches.length);
+  let succeeded = 0;
+  let failed = 0;
+  let deduplicated = 0;
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < matches.length) {
+      const i = nextIndex++;
+      if (!unique.has(i)) {
+        replacements[i] = "";
+        deduplicated += 1;
+        continue;
+      }
+      const [, alt, mimeType, base64] = matches[i];
+      try {
+        replacements[i] = await ocrDataUriImage(ocr, mimeType, base64, options.formatTranscript);
+        succeeded += 1;
+      } catch (err) {
+        const detail = err instanceof Error ? err.message : String(err);
+        options.onImageError?.(detail);
+        replacements[i] = `![${alt || "image non convertie"}]()`;
+        failed += 1;
+      }
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(concurrency, matches.length) }, worker));
+  let markdown = "";
+  let cursor = 0;
+  matches.forEach((match, i) => {
+    const start = match.index ?? 0;
+    markdown += result.markdown.slice(cursor, start);
+    markdown += replacements[i];
+    cursor = start + match[0].length;
+  });
+  markdown += result.markdown.slice(cursor);
+  return {
+    ...result,
+    markdown,
+    meta: {
+      ...result.meta,
+      embeddedImagesOcr: succeeded,
+      embeddedImagesFailed: failed,
+      ...deduplicated > 0 ? { embeddedImagesDeduplicated: deduplicated } : {}
+    }
+  };
+}
+async function ocrDataUriImage(ocr, mimeType, base64, formatTranscript) {
+  const extension = mimeType.split("/")[1]?.split("+")[0] || "png";
+  const tmpPath = (0, import_node_path2.join)((0, import_node_os.tmpdir)(), `${(0, import_node_crypto2.randomUUID)()}.${extension}`);
+  await (0, import_promises2.writeFile)(tmpPath, Buffer.from(base64, "base64"));
+  try {
+    const ocrResult = await ocr.convertImage(tmpPath);
+    const text = ocrResult.markdown.trim();
+    return `
+
+${formatTranscript ? formatTranscript(text, ocrResult.meta) : text}
+
+`;
+  } finally {
+    await (0, import_promises2.unlink)(tmpPath).catch(() => {
+    });
+  }
+}
+
+// ../core/src/conversion/pdf.ts
+var SCAN_TEXT_THRESHOLD = 20;
+function isLikelyScannedPdf(probe) {
+  return probe.pageCount > 0 && probe.pagesTextLength.every((len) => len < SCAN_TEXT_THRESHOLD);
+}
+async function ocrPdfPages(options) {
+  const { sidecar, ocr, sourcePath, mode } = options;
+  let pageCount = options.knownPageCount ?? 0;
+  if (pageCount < 1 && (mode === "all" || mode === "page")) {
+    pageCount = (await sidecar.probePdf(sourcePath)).pageCount;
+  }
+  pageCount = Math.max(pageCount, 1);
+  const pages = mode === "all" ? Array.from({ length: pageCount }, (_, i) => i + 1) : mode === "page" ? [Math.min(Math.max(1, options.page ?? 1), pageCount)] : [1];
+  const parts = [];
+  for (const page of pages) {
+    const imagePath = await sidecar.renderPdfPage(sourcePath, page);
+    const result = await ocr.convertImage(imagePath);
+    parts.push(pages.length > 1 ? `## Page ${page}
+
+${result.markdown}` : result.markdown);
+  }
+  return { markdown: parts.join("\n\n"), meta: { ocrPages: pages } };
+}
+
+// ../core/src/export.ts
+var import_promises3 = require("node:fs/promises");
+var import_node_path3 = require("node:path");
+function buildJsonEnvelope(doc) {
+  return {
+    id: doc.id,
+    name: doc.name,
+    extension: doc.extension,
+    mimeType: doc.mimeType,
+    sizeBytes: doc.sizeBytes,
+    sourcePath: doc.sourcePath,
+    pipeline: doc.pipeline,
+    ocrProvider: doc.ocrProvider ?? null,
+    status: doc.status,
+    createdAt: doc.createdAt,
+    convertedAt: doc.convertedAt ?? null,
+    meta: doc.meta ?? {},
+    markdown: doc.markdown ?? ""
+  };
+}
+function serializeJsonExport(doc) {
+  return JSON.stringify(buildJsonEnvelope(doc), null, 2);
+}
+async function resolveCollisionPath(dir, stem, ext) {
+  const candidate = (n2) => (0, import_node_path3.join)(dir, n2 === 0 ? `${stem}${ext}` : `${stem} (${n2})${ext}`);
+  let n = 0;
+  while (n < 999) {
+    try {
+      await (0, import_promises3.access)(candidate(n));
+      n++;
+    } catch {
+      return candidate(n);
+    }
+  }
+  return candidate(n);
+}
+
+// ../core/src/license.ts
+var TRIAL_DAYS = 14;
+var LS_API_BASE = "https://api.lemonsqueezy.com/v1";
+var LS_STORE_URL = "https://sygal.lemonsqueezy.com";
+var LS_STORE_ID = 419968;
+function computeLicenseStatus(data, now = Date.now()) {
+  if (data.licenseKey && data.instanceId) {
+    return { state: "active", licenseKey: data.licenseKey };
+  }
+  const firstLaunch = new Date(data.firstLaunchDate).getTime();
+  const daysSince = Math.floor((now - firstLaunch) / (1e3 * 60 * 60 * 24));
+  const daysLeft = Math.max(0, TRIAL_DAYS - daysSince);
+  if (daysLeft > 0) return { state: "trial", daysLeft };
+  return { state: "expired" };
+}
+var FORM_HEADERS = {
+  Accept: "application/json",
+  "Content-Type": "application/x-www-form-urlencoded"
+};
+async function parseJson(res) {
+  try {
+    return await res.json();
+  } catch {
+    return null;
+  }
+}
+async function lsActivate(licenseKey, instanceName, fetchImpl = fetch) {
+  const body = new URLSearchParams({ license_key: licenseKey, instance_name: instanceName });
+  let res;
+  try {
+    res = await fetchImpl(`${LS_API_BASE}/licenses/activate`, {
+      method: "POST",
+      headers: FORM_HEADERS,
+      body: body.toString()
+    });
+  } catch {
+    return {
+      ok: false,
+      error: "Impossible de joindre le serveur de licence. V\xE9rifiez votre connexion."
+    };
+  }
+  const json = await parseJson(res);
+  if (!res.ok || !json?.activated) {
+    return { ok: false, error: json?.error ?? `HTTP ${res.status}` };
+  }
+  if (LS_STORE_ID !== null && json.meta?.store_id !== void 0 && json.meta.store_id !== LS_STORE_ID) {
+    return { ok: false, error: "Cl\xE9 \xE9mise par un autre store" };
+  }
+  const instanceId = json.instance?.id;
+  if (!instanceId) {
+    return { ok: false, error: "R\xE9ponse API invalide (instance id manquant)" };
+  }
+  return { ok: true, activation: { instanceId } };
+}
+async function lsValidate(licenseKey, instanceId, fetchImpl = fetch) {
+  const body = new URLSearchParams({ license_key: licenseKey, instance_id: instanceId });
+  try {
+    const res = await fetchImpl(`${LS_API_BASE}/licenses/validate`, {
+      method: "POST",
+      headers: FORM_HEADERS,
+      body: body.toString()
+    });
+    if (!res.ok) return "unreachable";
+    const json = await parseJson(res);
+    return json?.valid === false ? "revoked" : "valid";
+  } catch {
+    return "unreachable";
+  }
+}
+async function lsDeactivate(licenseKey, instanceId, fetchImpl = fetch) {
+  const body = new URLSearchParams({ license_key: licenseKey, instance_id: instanceId });
+  try {
+    const res = await fetchImpl(`${LS_API_BASE}/licenses/deactivate`, {
+      method: "POST",
+      headers: FORM_HEADERS,
+      body: body.toString()
+    });
+    const json = await parseJson(res);
+    if (!res.ok || !json?.deactivated) {
+      return { ok: false, error: json?.error ?? `HTTP ${res.status}` };
+    }
+    return { ok: true };
+  } catch {
+    return {
+      ok: false,
+      error: "Impossible de joindre le serveur de licence. V\xE9rifiez votre connexion."
+    };
+  }
+}
+
+// src/convert.ts
+var import_node_crypto3 = require("node:crypto");
+var import_node_fs2 = require("node:fs");
+var import_node_path5 = require("node:path");
+
+// src/defer.ts
+var import_node_fs = require("node:fs");
+var import_node_path4 = require("node:path");
+function formatTranscriptBlock(text, provider) {
+  return `---
+*Transcription image OCR (IA : ${provider}) :*
+
+${text}
+
+---`;
+}
+async function deferEmbeddedImages(markdown, assetsDir) {
+  const matches = [...markdown.matchAll(DATA_URI_IMAGE_RE)];
+  if (matches.length === 0) return { markdown, images: [] };
+  await import_node_fs.promises.mkdir(assetsDir, { recursive: true });
+  const images = [];
+  const seen = /* @__PURE__ */ new Set();
+  let out = "";
+  let cursor = 0;
+  let index = 0;
+  for (const match of matches) {
+    const [, , mimeType, base64] = match;
+    const start = match.index ?? 0;
+    out += markdown.slice(cursor, start);
+    cursor = start + match[0].length;
+    if (seen.has(base64)) continue;
+    seen.add(base64);
+    index += 1;
+    const extension = mimeType.split("/")[1]?.split("+")[0] || "png";
+    const path = (0, import_node_path4.join)(assetsDir, `img-${index}.${extension}`);
+    await import_node_fs.promises.writeFile(path, Buffer.from(base64, "base64"));
+    images.push({ index, path, mimeType });
+    out += placeholder(index, (0, import_node_path4.relative)((0, import_node_path4.dirname)(assetsDir), path));
+  }
+  out += markdown.slice(cursor);
+  return { markdown: out, images };
+}
+function placeholder(index, relPath) {
+  return `![sygal:ocr:${index}](${relPath})`;
+}
+var PLACEHOLDER_RE = /!\[sygal:ocr:(\d+)\]\(([^)]*)\)/g;
+async function injectTranscripts(markdownPath, transcripts) {
+  const markdown = await import_node_fs.promises.readFile(markdownPath, "utf-8");
+  const byIndex = /* @__PURE__ */ new Map();
+  for (const t of transcripts) byIndex.set(t.index, t);
+  let injected = 0;
+  let remaining = 0;
+  const out = markdown.replace(PLACEHOLDER_RE, (whole, rawIndex) => {
+    const transcript = byIndex.get(Number(rawIndex));
+    const text = transcript?.text ?? transcript?.ocrText;
+    if (!transcript || typeof text !== "string") {
+      remaining += 1;
+      return whole;
+    }
+    injected += 1;
+    const provider = transcript.provider ?? transcript.ocrProvider ?? "externe";
+    return formatTranscriptBlock(text.trim(), provider);
+  });
+  await import_node_fs.promises.writeFile(markdownPath, out, "utf-8");
+  return { injected, remaining };
+}
+function assetsDirFor(outputDir, docName) {
+  return (0, import_node_path4.join)(outputDir, `${(0, import_node_path4.basename)(docName)}.images`);
+}
+
+// src/errors.ts
+var CONVERSION_CODE_MAP = {
+  SIDECAR_DOWN: "sidecar_down",
+  TIMEOUT: "timeout",
+  UNSUPPORTED_FORMAT: "unsupported_format",
+  API_KEY_MISSING: "api_key_missing",
+  API_KEY_INVALID: "invalid_api_key",
+  RATE_LIMITED: "rate_limited",
+  NETWORK: "network_error",
+  OCR_REFUSED: "ocr_refused",
+  URL_FORBIDDEN: "url_forbidden",
+  URL_UNREACHABLE: "url_unreachable",
+  UNKNOWN: "unknown"
+};
+var CliCodedError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "CliCodedError";
+  }
+};
+function toCliError(err) {
+  if (err instanceof CliCodedError) {
+    return { code: err.code, message: err.message };
+  }
+  if (err instanceof ConversionError) {
+    return { code: CONVERSION_CODE_MAP[err.code] ?? "unknown", message: err.message };
+  }
+  if (err instanceof SidecarError) {
+    switch (err.code) {
+      case "NOT_FOUND":
+        return { code: "file_unreadable", message: err.message };
+      case "UNSUPPORTED":
+        return { code: "unsupported_format", message: err.message };
+      case "TIMEOUT":
+        return { code: "timeout", message: err.message };
+      case "SIDECAR_DOWN":
+        return { code: "sidecar_down", message: err.message };
+      case "URL_FORBIDDEN":
+        return { code: "url_forbidden", message: err.message };
+      case "URL_UNREACHABLE":
+        return { code: "url_unreachable", message: err.message };
+      default:
+        return { code: "conversion_failed", message: err.message };
+    }
+  }
+  return { code: "unknown", message: err instanceof Error ? err.message : String(err) };
+}
+
+// src/convert.ts
+var MARKITDOWN_CONCURRENCY = 2;
+var OCR_CONCURRENCY = 3;
+var OcrBudget = class {
+  constructor(limit) {
+    this.limit = limit;
+  }
+  used = 0;
+  take(count) {
+    if (this.limit !== null && this.used + count > this.limit) {
+      throw new CliCodedError(
+        "ocr_call_limit_exceeded",
+        `Budget OCR d\xE9pass\xE9 : ${count} appel(s) demand\xE9(s), ${this.limit - this.used} restant(s) sur ${this.limit} (--max-ocr-calls ou sygal config set-max-ocr-calls)`
+      );
+    }
+    this.used += count;
+  }
+  get total() {
+    return this.used;
+  }
+};
+async function runConvert(inputs, options, deps, hooks) {
+  const jobs = await expandInputs(inputs);
+  hooks?.onExpanded?.(jobs.length);
+  const budget = new OcrBudget(options.maxOcrCalls);
+  const reports = new Array(jobs.length);
+  let nextIndex = 0;
+  const worker = async () => {
+    while (nextIndex < jobs.length) {
+      const i = nextIndex++;
+      const startedAt = Date.now();
+      reports[i] = await convertOne(jobs[i], options, deps, budget);
+      reports[i].durationMs = Date.now() - startedAt;
+      hooks?.onReport?.(reports[i]);
+    }
+  };
+  await Promise.all(Array.from({ length: Math.min(MARKITDOWN_CONCURRENCY, jobs.length) }, worker));
+  const done = reports.filter((r) => r.status === "done").length;
+  return { reports, done, failed: reports.length - done, ocrCalls: budget.total };
+}
+async function expandInputs(inputs) {
+  const jobs = [];
+  for (const raw of inputs) {
+    if (/^https?:\/\//i.test(raw.trim())) {
+      jobs.push({ input: raw.trim(), kind: "url" });
+      continue;
+    }
+    const path = (0, import_node_path5.resolve)((0, import_node_path5.normalize)(raw));
+    let stat;
+    try {
+      stat = await import_node_fs2.promises.stat(path);
+    } catch {
+      jobs.push({
+        input: raw,
+        kind: "invalid",
+        error: { code: "file_unreadable", message: `Fichier illisible ou introuvable : ${raw}` }
+      });
+      continue;
+    }
+    if (stat.isDirectory()) {
+      await collectFromDir(path, jobs);
+    } else {
+      jobs.push({ input: path, kind: "file" });
+    }
+  }
+  return jobs;
+}
+async function collectFromDir(dir, jobs) {
+  let entries;
+  try {
+    entries = await import_node_fs2.promises.readdir(dir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  entries.sort((a, b) => a.name.localeCompare(b.name));
+  for (const entry of entries) {
+    if (entry.name.startsWith(".")) continue;
+    const full = (0, import_node_path5.join)(dir, entry.name);
+    if (entry.isDirectory()) {
+      await collectFromDir(full, jobs);
+    } else if (entry.isFile() && mimeForExtension((0, import_node_path5.extname)(entry.name).slice(1))) {
+      jobs.push({ input: full, kind: "file" });
+    }
+  }
+}
+async function convertOne(job, options, deps, budget) {
+  if (job.kind === "invalid") {
+    return {
+      input: job.input,
+      name: (0, import_node_path5.basename)(job.input),
+      pipeline: null,
+      status: "error",
+      outputs: [],
+      error: job.error
+    };
+  }
+  try {
+    return job.kind === "url" ? await convertUrl(job.input, options, deps) : await convertFile(job.input, options, deps, budget);
+  } catch (err) {
+    return {
+      input: job.input,
+      name: job.kind === "url" ? job.input : (0, import_node_path5.basename)(job.input),
+      pipeline: job.kind === "url" ? "markitdown" : null,
+      status: "error",
+      outputs: [],
+      error: toCliError(err)
+    };
+  }
+}
+function requireOcr(deps) {
+  if (!deps.ocr) {
+    throw new ConversionError(
+      "API_KEY_MISSING",
+      `Aucune cl\xE9 API pour le provider ${deps.ocrProvider} (sygal config set-api-key ${deps.ocrProvider} ...)`
+    );
+  }
+  return deps.ocr;
+}
+async function convertFile(path, options, deps, budget) {
+  const name = (0, import_node_path5.basename)(path);
+  const extension = (0, import_node_path5.extname)(path).slice(1).toLowerCase();
+  const mimeType = mimeForExtension(extension);
+  if (!mimeType) {
+    return errorReport(path, name, null, {
+      code: "unsupported_extension",
+      message: `Extension non support\xE9e : .${extension || "?"}`
+    });
+  }
+  const stat = await import_node_fs2.promises.stat(path);
+  if (stat.size > MAX_FILE_SIZE_BYTES) {
+    return errorReport(path, name, null, {
+      code: "file_too_large",
+      message: `Fichier trop volumineux (max 200 Mo) : ${path}`
+    });
+  }
+  const outputDir = options.output ? (0, import_node_path5.resolve)(options.output) : (0, import_node_path5.dirname)(path);
+  const base = {
+    input: path,
+    name,
+    extension,
+    mimeType,
+    sizeBytes: stat.size,
+    sourcePath: path,
+    outputDir,
+    format: options.format
+  };
+  const pipeline = pipelineForMime(mimeType);
+  if (pipeline === "ocr") {
+    if (options.ocrMode === "defer") {
+      const markdown = placeholder(1, name);
+      return writeOutputs({
+        ...base,
+        pipeline,
+        result: { markdown, meta: { ocrDeferred: 1 } },
+        deferred: [{ index: 1, path, mimeType }]
+      });
+    }
+    const ocr = requireOcr(deps);
+    budget.take(1);
+    const result2 = await ocr.convertImage(path);
+    return writeOutputs({
+      ...base,
+      pipeline,
+      result: { markdown: result2.markdown, meta: result2.meta },
+      ocrProvider: deps.ocrProvider,
+      ocrCalls: 1,
+      translate: options.translate,
+      translator: deps.translate
+    });
+  }
+  if (extension === "pdf") {
+    if (options.pdfOcr) {
+      return convertPdfPages(path, options, deps, budget, base);
+    }
+    const probe = await deps.sidecar.probePdf(path);
+    if (isLikelyScannedPdf(probe)) {
+      return errorReport(path, name, "markitdown", {
+        code: "scanned_pdf_detected",
+        message: `PDF scann\xE9 d\xE9tect\xE9 (${probe.pageCount} page(s), pas de texte extractible) : relancez avec --pdf-ocr all|first|page [--page N]`
+      });
+    }
+  }
+  const advanced = options.advanced && ADVANCED_CONVERSION_EXTENSIONS.has(extension);
+  const result = await deps.sidecar.convert(path, advanced ? { advanced: true } : {});
+  if (!advanced) {
+    return writeOutputs({
+      ...base,
+      pipeline,
+      result,
+      translate: options.translate,
+      translator: deps.translate
+    });
+  }
+  if (options.ocrMode === "defer") {
+    const { markdown, images } = await deferEmbeddedImages(
+      result.markdown,
+      assetsDirFor(outputDir, name)
+    );
+    return writeOutputs({
+      ...base,
+      pipeline,
+      result: { ...result, markdown, meta: { ...result.meta, ocrDeferred: images.length } },
+      deferred: images
+    });
+  }
+  const embeddedCount = uniqueImageIndices([...result.markdown.matchAll(DATA_URI_IMAGE_RE)]).size;
+  if (embeddedCount > 0) {
+    requireOcr(deps);
+    budget.take(embeddedCount);
+  }
+  const converted = await ocrEmbeddedImages(result, {
+    ocr: deps.ocr,
+    concurrency: OCR_CONCURRENCY,
+    formatTranscript: (text, meta) => formatTranscriptBlock(
+      text,
+      typeof meta.provider === "string" ? meta.provider : deps.ocrProvider
+    )
+  });
+  return writeOutputs({
+    ...base,
+    pipeline,
+    result: converted,
+    ocrProvider: embeddedCount > 0 ? deps.ocrProvider : void 0,
+    ocrCalls: embeddedCount,
+    translate: options.translate,
+    translator: deps.translate
+  });
+}
+async function convertPdfPages(path, options, deps, budget, base) {
+  const mode = options.pdfOcr;
+  const pageCount = Math.max((await deps.sidecar.probePdf(path)).pageCount, 1);
+  const pages = mode === "all" ? Array.from({ length: pageCount }, (_, i) => i + 1) : mode === "page" ? [Math.min(Math.max(1, options.pdfPage ?? 1), pageCount)] : [1];
+  if (options.ocrMode === "defer") {
+    const assetsDir = assetsDirFor(base.outputDir, base.name);
+    await import_node_fs2.promises.mkdir(assetsDir, { recursive: true });
+    const deferred = [];
+    const parts = [];
+    for (let i = 0; i < pages.length; i++) {
+      const page = pages[i];
+      const rendered = await deps.sidecar.renderPdfPage(path, page);
+      const dest = (0, import_node_path5.join)(assetsDir, `img-${i + 1}.png`);
+      await import_node_fs2.promises.copyFile(rendered, dest);
+      deferred.push({ index: i + 1, path: dest, mimeType: "image/png", page });
+      const mark = placeholder(i + 1, (0, import_node_path5.join)((0, import_node_path5.basename)(assetsDir), `img-${i + 1}.png`));
+      parts.push(pages.length > 1 ? `## Page ${page}
+
+${mark}` : mark);
+    }
+    return writeOutputs({
+      ...base,
+      pipeline: "ocr",
+      result: {
+        markdown: parts.join("\n\n"),
+        meta: { ocrPages: pages, ocrDeferred: deferred.length }
+      },
+      deferred
+    });
+  }
+  const ocr = requireOcr(deps);
+  budget.take(pages.length);
+  const result = await ocrPdfPages({
+    sidecar: deps.sidecar,
+    ocr,
+    sourcePath: path,
+    mode,
+    page: options.pdfPage,
+    knownPageCount: pageCount
+  });
+  return writeOutputs({
+    ...base,
+    pipeline: "ocr",
+    result,
+    ocrProvider: deps.ocrProvider,
+    ocrCalls: pages.length,
+    translate: options.translate,
+    translator: deps.translate
+  });
+}
+async function convertUrl(rawUrl, options, deps) {
+  let parsed;
+  try {
+    parsed = new URL(rawUrl);
+  } catch {
+    return errorReport(rawUrl, rawUrl, null, { code: "invalid_url", message: "URL invalide" });
+  }
+  const result = await deps.sidecar.convertUrl(parsed.toString());
+  const provisional = (parsed.hostname + parsed.pathname).replace(/\/$/, "") || parsed.hostname;
+  const title = typeof result.meta.title === "string" && result.meta.title.trim();
+  const name = title || provisional;
+  const outputDir = options.output ? (0, import_node_path5.resolve)(options.output) : process.cwd();
+  return writeOutputs({
+    input: rawUrl,
+    name,
+    extension: "url",
+    mimeType: "text/html",
+    sizeBytes: 0,
+    sourcePath: null,
+    pipeline: "markitdown",
+    result,
+    outputDir,
+    format: options.format,
+    translate: options.translate,
+    translator: deps.translate
+  });
+}
+async function writeOutputs(params) {
+  const { result, outputDir, format } = params;
+  await import_node_fs2.promises.mkdir(outputDir, { recursive: true });
+  let markdown = result.markdown;
+  let translatedTo;
+  if (params.translate && params.translator) {
+    markdown = await params.translator(markdown, params.translate);
+    translatedTo = params.translate;
+  }
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const envelope = {
+    id: (0, import_node_crypto3.randomUUID)(),
+    name: params.name,
+    extension: params.extension,
+    mimeType: params.mimeType,
+    sizeBytes: params.sizeBytes,
+    sourcePath: params.sourcePath,
+    pipeline: params.pipeline,
+    ...params.ocrProvider ? { ocrProvider: params.ocrProvider } : {},
+    status: "done",
+    createdAt: now,
+    convertedAt: now,
+    meta: result.meta,
+    markdown
+  };
+  const json = serializeJsonExport(envelope);
+  const outputs = [];
+  if (format === "md" || format === "both") {
+    const path = await resolveCollisionPath(outputDir, params.name, ".md");
+    await import_node_fs2.promises.writeFile(path, markdown, "utf-8");
+    outputs.push(path);
+  }
+  if (format === "json" || format === "both") {
+    const path = await resolveCollisionPath(outputDir, params.name, ".json");
+    await import_node_fs2.promises.writeFile(path, json, "utf-8");
+    outputs.push(path);
+  }
+  return {
+    input: params.input,
+    name: params.name,
+    pipeline: params.pipeline,
+    status: "done",
+    outputs,
+    sizeBytes: params.sizeBytes,
+    mdTokens: countTokens(markdown),
+    jsonTokens: countTokens(json),
+    ...params.ocrProvider ? { ocrProvider: params.ocrProvider } : {},
+    ...params.ocrCalls ? { ocrCalls: params.ocrCalls } : {},
+    ...params.deferred && params.deferred.length > 0 ? { deferred: params.deferred } : {},
+    ...translatedTo ? { translatedTo } : {}
+  };
+}
+function errorReport(input, name, pipeline, error) {
+  return { input, name, pipeline, status: "error", outputs: [], error };
+}
+
+// src/license.ts
+var import_node_fs5 = require("node:fs");
+var import_node_os4 = require("node:os");
+var import_node_path7 = require("node:path");
+
+// src/machine-crypto.ts
+var import_node_crypto4 = require("node:crypto");
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs3 = require("node:fs");
+var import_node_os2 = require("node:os");
+var ALGO = "aes-256-gcm";
+var SCRYPT_SALT = "sygal-cli-v1";
+var IV_LENGTH = 12;
+var cachedKey = null;
+function machineId() {
+  try {
+    if (process.platform === "darwin") {
+      const out = (0, import_node_child_process2.execSync)("ioreg -rd1 -c IOPlatformExpertDevice", { encoding: "utf-8" });
+      const match = out.match(/"IOPlatformUUID"\s*=\s*"([^"]+)"/);
+      if (match) return match[1];
+    } else if (process.platform === "win32") {
+      const out = (0, import_node_child_process2.execSync)("reg query HKLM\\SOFTWARE\\Microsoft\\Cryptography /v MachineGuid", {
+        encoding: "utf-8"
+      });
+      const match = out.match(/MachineGuid\s+REG_SZ\s+(\S+)/);
+      if (match) return match[1];
+    } else {
+      return (0, import_node_fs3.readFileSync)("/etc/machine-id", "utf-8").trim();
+    }
+  } catch {
+  }
+  return `${(0, import_node_os2.hostname)()}|${(0, import_node_os2.homedir)()}`;
+}
+function deriveKey() {
+  if (!cachedKey) {
+    cachedKey = (0, import_node_crypto4.scryptSync)(machineId(), SCRYPT_SALT, 32);
+  }
+  return cachedKey;
+}
+function encryptString(plain) {
+  const iv = (0, import_node_crypto4.randomBytes)(IV_LENGTH);
+  const cipher = (0, import_node_crypto4.createCipheriv)(ALGO, deriveKey(), iv);
+  const encrypted = Buffer.concat([cipher.update(plain, "utf-8"), cipher.final()]);
+  return Buffer.concat([iv, cipher.getAuthTag(), encrypted]).toString("base64");
+}
+function decryptString(blob) {
+  const raw = Buffer.from(blob, "base64");
+  const iv = raw.subarray(0, IV_LENGTH);
+  const tag = raw.subarray(IV_LENGTH, IV_LENGTH + 16);
+  const data = raw.subarray(IV_LENGTH + 16);
+  const decipher = (0, import_node_crypto4.createDecipheriv)(ALGO, deriveKey(), iv);
+  decipher.setAuthTag(tag);
+  return Buffer.concat([decipher.update(data), decipher.final()]).toString("utf-8");
+}
+
+// src/settings.ts
+var import_node_fs4 = require("node:fs");
+var import_node_os3 = require("node:os");
+var import_node_path6 = require("node:path");
+var OCR_PROVIDERS_IDS = [
+  "openai",
+  "mistral",
+  "claude",
+  "nvidia",
+  "gemini"
+];
+var LOCALES2 = ["fr", "en", "it", "de", "es"];
+function configPath() {
+  return process.env.SYGAL_CONFIG_PATH ?? (0, import_node_path6.join)((0, import_node_os3.homedir)(), ".sygal", "config.json");
+}
+function load() {
+  const path = configPath();
+  if (!(0, import_node_fs4.existsSync)(path)) return {};
+  try {
+    return JSON.parse((0, import_node_fs4.readFileSync)(path, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function save(config2) {
+  const path = configPath();
+  (0, import_node_fs4.mkdirSync)((0, import_node_path6.dirname)(path), { recursive: true });
+  (0, import_node_fs4.writeFileSync)(path, JSON.stringify(config2, null, 2) + "\n", { mode: 384 });
+  try {
+    (0, import_node_fs4.chmodSync)(path, 384);
+  } catch {
+  }
+}
+var CliSettings = class {
+  config;
+  constructor() {
+    this.config = load();
+  }
+  getAppSettings() {
+    const envProvider = process.env.SYGAL_OCR_PROVIDER;
+    return {
+      locale: this.config.locale ?? "fr",
+      ocrProvider: envProvider && OCR_PROVIDERS_IDS.includes(envProvider) ? envProvider : this.config.ocrProvider ?? "openai",
+      // Providers personnalisés : non supportés dans le CLI en Phase 3
+      customProviderId: null
+    };
+  }
+  getCustomProviders() {
+    return [];
+  }
+  getCustomApiKey() {
+    return null;
+  }
+  /** Env key applies to the ACTIVE provider only (spec §3.5) */
+  getApiKey(provider) {
+    const envKey = process.env.SYGAL_OCR_API_KEY;
+    if (envKey && provider === this.getAppSettings().ocrProvider) return envKey;
+    const stored = this.config.apiKeys?.[provider];
+    if (!stored) return null;
+    try {
+      return decryptString(stored);
+    } catch {
+      return null;
+    }
+  }
+  hasApiKey(provider) {
+    return this.getApiKey(provider) !== null;
+  }
+  isAdvancedConversionEnabled() {
+    return this.config.advancedConversion === true;
+  }
+  getMaxOcrCalls() {
+    return typeof this.config.maxOcrCalls === "number" ? this.config.maxOcrCalls : null;
+  }
+  // ── Mutations (commandes `sygal config ...`) ────────────────────────────────
+  setOcrProvider(provider) {
+    this.config.ocrProvider = provider;
+    save(this.config);
+  }
+  setLocale(locale) {
+    this.config.locale = locale;
+    save(this.config);
+  }
+  setAdvancedConversion(enabled) {
+    this.config.advancedConversion = enabled;
+    save(this.config);
+  }
+  setMaxOcrCalls(limit) {
+    this.config.maxOcrCalls = limit;
+    save(this.config);
+  }
+  setApiKey(provider, key) {
+    this.config.apiKeys = { ...this.config.apiKeys, [provider]: encryptString(key) };
+    save(this.config);
+  }
+  clearApiKey(provider) {
+    if (this.config.apiKeys) {
+      delete this.config.apiKeys[provider];
+      save(this.config);
+    }
+  }
+  /** Presence only — never values (Paramètres app parity) */
+  describe() {
+    const settings = this.getAppSettings();
+    const apiKeys = {};
+    for (const provider of OCR_PROVIDERS_IDS) {
+      apiKeys[provider] = this.hasApiKey(provider);
+    }
+    return {
+      locale: settings.locale,
+      ocrProvider: settings.ocrProvider,
+      advancedConversion: this.isAdvancedConversionEnabled(),
+      maxOcrCalls: this.getMaxOcrCalls(),
+      apiKeys
+    };
+  }
+};
+
+// src/license.ts
+var VALIDATION_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1e3;
+function licensePath() {
+  return process.env.SYGAL_LICENSE_PATH ?? (0, import_node_path7.join)((0, import_node_path7.dirname)(configPath()), "license.enc");
+}
+var CliLicense = class {
+  data;
+  constructor() {
+    this.data = this.load();
+    if (!this.data.firstLaunchDate) {
+      this.data.firstLaunchDate = (/* @__PURE__ */ new Date()).toISOString();
+      this.save();
+    }
+  }
+  load() {
+    const path = licensePath();
+    if (!(0, import_node_fs5.existsSync)(path)) return {};
+    try {
+      return JSON.parse(decryptString((0, import_node_fs5.readFileSync)(path, "utf-8")));
+    } catch {
+      return {};
+    }
+  }
+  save() {
+    const path = licensePath();
+    (0, import_node_fs5.mkdirSync)((0, import_node_path7.dirname)(path), { recursive: true });
+    (0, import_node_fs5.writeFileSync)(path, encryptString(JSON.stringify(this.data)), { mode: 384 });
+  }
+  getStatus() {
+    return computeLicenseStatus(this.data);
+  }
+  /** Env SYGAL_LICENSE_KEY : activation automatisée (agents/CI) au premier usage */
+  envLicenseKey() {
+    return process.env.SYGAL_LICENSE_KEY ?? null;
+  }
+  async activate(licenseKey) {
+    const result = await lsActivate(licenseKey.trim(), `${(0, import_node_os4.hostname)()} (CLI)`);
+    if (!result.ok) return result;
+    this.data.licenseKey = licenseKey.trim();
+    this.data.instanceId = result.activation.instanceId;
+    this.data.activatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.data.lastValidatedAt = (/* @__PURE__ */ new Date()).toISOString();
+    this.save();
+    return { ok: true };
+  }
+  async deactivate() {
+    if (!this.data.licenseKey || !this.data.instanceId) {
+      return { ok: false, error: "Aucune licence active sur cette machine" };
+    }
+    const result = await lsDeactivate(this.data.licenseKey, this.data.instanceId);
+    if (!result.ok) return result;
+    delete this.data.licenseKey;
+    delete this.data.instanceId;
+    delete this.data.activatedAt;
+    this.save();
+    return { ok: true };
+  }
+  /**
+   * Revalidation en ligne si la dernière date de plus d'une semaine.
+   * Jamais bloquant offline ; seule une révocation explicite supprime la clé.
+   */
+  async validateIfStale() {
+    if (!this.data.licenseKey || !this.data.instanceId) return;
+    const last = this.data.lastValidatedAt ? new Date(this.data.lastValidatedAt).getTime() : 0;
+    if (Date.now() - last < VALIDATION_MAX_AGE_MS) return;
+    const verdict = await lsValidate(this.data.licenseKey, this.data.instanceId);
+    if (verdict === "revoked") {
+      delete this.data.licenseKey;
+      delete this.data.instanceId;
+      delete this.data.activatedAt;
+      this.save();
+      return;
+    }
+    if (verdict === "valid") {
+      this.data.lastValidatedAt = (/* @__PURE__ */ new Date()).toISOString();
+      this.save();
+    }
+  }
+  /** Clé masquée pour l'affichage (jamais la valeur complète) */
+  maskedKey() {
+    const key = this.data.licenseKey;
+    if (!key) return null;
+    return key.length <= 8 ? "********" : `${"*".repeat(Math.max(4, key.length - 8))}${key.slice(-8)}`;
+  }
+};
+async function requireLicensed(license) {
+  let status = license.getStatus();
+  if (status.state !== "active") {
+    const envKey = license.envLicenseKey();
+    if (envKey) {
+      const result = await license.activate(envKey);
+      if (result.ok) status = license.getStatus();
+    }
+  }
+  if (status.state === "active") {
+    await license.validateIfStale();
+    status = license.getStatus();
+  }
+  if (status.state === "expired") {
+    throw new CliCodedError(
+      "license_expired",
+      `Essai de 14 jours termin\xE9. Activez une licence : sygal license activate <cl\xE9> (achat : ${LS_STORE_URL})`
+    );
+  }
+}
+
+// src/report.ts
+var import_picocolors2 = __toESM(require("picocolors"));
+
+// src/ui.ts
+var import_picocolors = __toESM(require("picocolors"));
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var INTERVAL_MS = 80;
+var Spinner = class {
+  constructor(stream = process.stderr) {
+    this.stream = stream;
+    this.enabled = stream.isTTY === true;
+  }
+  timer = null;
+  frame = 0;
+  text = "";
+  enabled;
+  start(text) {
+    this.text = text;
+    if (!this.enabled || this.timer) return;
+    this.timer = setInterval(() => this.render(), INTERVAL_MS);
+    this.render();
+  }
+  update(text) {
+    this.text = text;
+  }
+  /** Prints a permanent line above the spinner without visual tearing. */
+  log(line) {
+    if (this.enabled && this.timer) {
+      this.clear();
+      console.log(line);
+      this.render();
+    } else {
+      console.log(line);
+    }
+  }
+  stop() {
+    if (this.timer) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+    if (this.enabled) this.clear();
+  }
+  render() {
+    this.frame = (this.frame + 1) % FRAMES.length;
+    this.stream.write(`\r\x1B[2K${import_picocolors.default.magenta(FRAMES[this.frame])} ${this.text}`);
+  }
+  clear() {
+    this.stream.write("\r\x1B[2K");
+  }
+};
+function progressBar(done, total, width = 14) {
+  if (total <= 0) return "";
+  const filled = Math.round(done / total * width);
+  const bar = import_picocolors.default.magenta("\u25B0".repeat(filled)) + import_picocolors.default.dim("\u25B1".repeat(Math.max(0, width - filled)));
+  return `${bar} ${done}/${total}`;
+}
+function formatBytes(bytes) {
+  if (!bytes || bytes <= 0) return "-";
+  if (bytes < 1024) return `${bytes} o`;
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1).replace(".", ",")} Ko`;
+  return `${(bytes / (1024 * 1024)).toFixed(1).replace(".", ",")} Mo`;
+}
+function renderTable(headers, rows) {
+  const ansiRe = new RegExp(String.fromCharCode(27) + "\\[[0-9;]*m", "g");
+  const visibleLength = (s) => s.replace(ansiRe, "").length;
+  const widths = headers.map(
+    (h, i) => Math.max(visibleLength(h), ...rows.map((r) => visibleLength(r[i] ?? "")))
+  );
+  const pad = (s, w) => s + " ".repeat(Math.max(0, w - visibleLength(s)));
+  const line = (cells) => cells.map((c, i) => pad(c, widths[i])).join(`  ${import_picocolors.default.dim("\xB7")}  `);
+  const out = [import_picocolors.default.dim(line(headers).replace(/·/g, " "))];
+  out.push(import_picocolors.default.dim("\u2500".repeat(widths.reduce((a, b) => a + b, 0) + (widths.length - 1) * 5)));
+  for (const row of rows) out.push(line(row));
+  return out.join("\n");
+}
+
+// src/report.ts
+var HumanReporter = class {
+  spinner = new Spinner();
+  total = 0;
+  completed = 0;
+  onExpanded(total) {
+    this.total = total;
+    this.spinner.start(total > 1 ? `Conversion ${progressBar(0, total)}` : "Conversion en cours...");
+  }
+  onReport(report) {
+    this.completed += 1;
+    this.spinner.log(fileLine(report));
+    if (this.total > 1) {
+      this.spinner.update(`Conversion ${progressBar(this.completed, this.total)}`);
+    }
+  }
+  finish(summary, licenseStatus) {
+    this.spinner.stop();
+    if (summary.reports.length > 1) {
+      const rows = summary.reports.map((r) => [
+        r.name,
+        formatBytes(r.sizeBytes ?? 0),
+        pipelineLabel(r),
+        r.status === "done" ? import_picocolors2.default.green("Termin\xE9") : import_picocolors2.default.red(`Erreur (${r.error?.code ?? "unknown"})`),
+        r.mdTokens !== void 0 ? String(r.mdTokens) : "-"
+      ]);
+      console.log("\n" + renderTable(["Nom", "Taille", "Pipeline", "Statut", "Tokens md"], rows));
+    }
+    const done = summary.done > 0 ? import_picocolors2.default.green(`${summary.done} Termin\xE9(s)`) : "0 Termin\xE9";
+    const failed = summary.failed > 0 ? import_picocolors2.default.red(`${summary.failed} Erreur(s)`) : import_picocolors2.default.dim("0 erreur");
+    const ocr = summary.ocrCalls > 0 ? ` \xB7 ${import_picocolors2.default.magenta(`${summary.ocrCalls} appel(s) OCR`)}` : "";
+    console.log(`
+${done} \xB7 ${failed}${ocr}`);
+    const deferredTotal = summary.reports.reduce((n, r) => n + (r.deferred?.length ?? 0), 0);
+    if (deferredTotal > 0) {
+      console.log(
+        import_picocolors2.default.yellow(`${deferredTotal} image(s) \xE0 transcrire`) + import_picocolors2.default.dim(
+          " \u2192 transcrivez puis r\xE9int\xE9grez avec : sygal inject <fichier.md> --transcripts <json>"
+        )
+      );
+    }
+    if (licenseStatus?.state === "trial") {
+      console.log(import_picocolors2.default.dim(`Essai Sygal : ${licenseStatus.daysLeft} jour(s) restant(s)`));
+    }
+  }
+};
+function fileLine(report) {
+  if (report.status === "done") {
+    const badge = import_picocolors2.default.dim(`(${pipelineLabel(report)})`);
+    const outputs = report.outputs.map((p) => shortPath(p)).join(", ");
+    const deferred = report.deferred && report.deferred.length > 0 ? ` ${import_picocolors2.default.yellow(`${report.deferred.length} image(s) \xE0 transcrire`)}` : "";
+    return `${import_picocolors2.default.green("\u2713")} ${report.name} ${import_picocolors2.default.magenta("\u2192")} ${outputs} ${badge}${deferred}`;
+  }
+  const detail = report.error ? `${report.error.message} ${import_picocolors2.default.dim(`[${report.error.code}]`)}` : "";
+  return `${import_picocolors2.default.red("\u2717")} ${report.name} ${import_picocolors2.default.dim("-")} ${detail}`;
+}
+function printJson(summary, cliVersion) {
+  const payload = {
+    version: cliVersion,
+    summary: { done: summary.done, failed: summary.failed, ocrCalls: summary.ocrCalls },
+    results: summary.reports.map((r) => ({
+      input: r.input,
+      name: r.name,
+      pipeline: r.pipeline,
+      status: r.status,
+      outputs: r.outputs,
+      ...r.sizeBytes !== void 0 ? { sizeBytes: r.sizeBytes } : {},
+      ...r.durationMs !== void 0 ? { durationMs: r.durationMs } : {},
+      ...r.mdTokens !== void 0 ? { mdTokens: r.mdTokens } : {},
+      ...r.jsonTokens !== void 0 ? { jsonTokens: r.jsonTokens } : {},
+      ...r.ocrProvider ? { ocrProvider: r.ocrProvider } : {},
+      ...r.ocrCalls ? { ocrCalls: r.ocrCalls } : {},
+      ...r.deferred ? { deferred: r.deferred } : {},
+      ...r.translatedTo ? { translatedTo: r.translatedTo } : {},
+      ...r.error ? { error: r.error } : {}
+    }))
+  };
+  process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+}
+function pipelineLabel(report) {
+  if (report.pipeline === null) return "-";
+  if (report.pipeline !== "ocr") return "Local MarkItDown";
+  return report.ocrProvider ? `API OCR (${report.ocrProvider})` : "API OCR (diff\xE9r\xE9)";
+}
+function shortPath(path) {
+  const cwd = process.cwd() + "/";
+  return path.startsWith(cwd) ? path.slice(cwd.length) : path;
+}
+
+// src/sidecar-path.ts
+var import_node_fs6 = require("node:fs");
+var import_node_module = require("node:module");
+var import_node_path8 = require("node:path");
+var requireFromHere = (0, import_node_module.createRequire)(__filename);
+function resolveSidecarCommand() {
+  const envPath = process.env.SYGAL_SIDECAR_PATH;
+  if (envPath) {
+    return { command: envPath, args: [] };
+  }
+  const suffix = process.platform === "win32" ? ".exe" : "";
+  const binaryName = `markitdown-worker-${process.platform}-${process.arch}${suffix}`;
+  const pkgName = `@sygal/sidecar-${process.platform}-${process.arch}`;
+  try {
+    const pkgJsonPath = requireFromHere.resolve(`${pkgName}/package.json`);
+    const bin = (0, import_node_path8.join)((0, import_node_path8.dirname)(pkgJsonPath), "bin", binaryName);
+    if ((0, import_node_fs6.existsSync)(bin)) return { command: bin, args: [] };
+  } catch {
+  }
+  let dir = __dirname;
+  for (let i = 0; i < 6; i++) {
+    const converter = (0, import_node_path8.join)(dir, "python", "converter");
+    if ((0, import_node_fs6.existsSync)((0, import_node_path8.join)(converter, "main.py"))) {
+      const python = process.platform === "win32" ? (0, import_node_path8.join)(converter, ".venv", "Scripts", "python.exe") : (0, import_node_path8.join)(converter, ".venv", "bin", "python");
+      if ((0, import_node_fs6.existsSync)(python)) {
+        return { command: python, args: [(0, import_node_path8.join)(converter, "main.py")] };
+      }
+      const onedir = (0, import_node_path8.join)(
+        converter,
+        "dist",
+        `markitdown-worker-${process.platform}-${process.arch}-onedir`,
+        binaryName
+      );
+      if ((0, import_node_fs6.existsSync)(onedir)) return { command: onedir, args: [] };
+      const binary = (0, import_node_path8.join)(converter, "dist", binaryName);
+      if ((0, import_node_fs6.existsSync)(binary)) return { command: binary, args: [] };
+    }
+    const parent = (0, import_node_path8.dirname)(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  return null;
+}
+
+// src/update.ts
+var import_node_child_process3 = require("node:child_process");
+var REGISTRY_URL = "https://registry.npmjs.org/sygal-cli/latest";
+function compareVersions(a, b) {
+  const pa = a.split(".").map((n) => parseInt(n, 10) || 0);
+  const pb = b.split(".").map((n) => parseInt(n, 10) || 0);
+  for (let i = 0; i < Math.max(pa.length, pb.length); i++) {
+    const diff = (pa[i] ?? 0) - (pb[i] ?? 0);
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+async function checkForUpdate(currentVersion, fetchImpl = (url) => fetch(url)) {
+  try {
+    const res = await fetchImpl(REGISTRY_URL);
+    if (!res.ok) {
+      return {
+        current: currentVersion,
+        latest: null,
+        updateAvailable: false,
+        error: res.status === 404 ? "Paquet sygal-cli introuvable sur npm (pas encore publi\xE9)" : `Registre npm : HTTP ${res.status}`
+      };
+    }
+    const json = await res.json();
+    if (!json?.version) {
+      return {
+        current: currentVersion,
+        latest: null,
+        updateAvailable: false,
+        error: "R\xE9ponse du registre npm invalide"
+      };
+    }
+    return {
+      current: currentVersion,
+      latest: json.version,
+      updateAvailable: compareVersions(json.version, currentVersion) > 0
+    };
+  } catch {
+    return {
+      current: currentVersion,
+      latest: null,
+      updateAvailable: false,
+      error: "Registre npm injoignable (r\xE9seau)"
+    };
+  }
+}
+function runGlobalInstall() {
+  return new Promise((resolve2) => {
+    const child = (0, import_node_child_process3.spawn)("npm", ["install", "-g", "sygal-cli@latest"], {
+      stdio: "inherit",
+      shell: process.platform === "win32"
+    });
+    child.on("close", (code) => resolve2(code ?? 1));
+    child.on("error", () => resolve2(1));
+  });
+}
+
+// src/index.ts
+var pkg = JSON.parse((0, import_node_fs7.readFileSync)((0, import_node_path9.join)(__dirname, "..", "package.json"), "utf-8"));
+var program = new import_commander.Command();
+program.name("sygal").description(
+  "Convertit fichiers et pages web en Markdown/JSON via le pipeline local MarkItDown, avec OCR API pour les images."
+).version(pkg.version).addHelpText(
+  "after",
+  `
+${import_picocolors3.default.magenta("D\xE9marrage rapide :")}
+  sygal convert rapport.pdf                    conversion locale, .md \xE0 c\xF4t\xE9 de la source
+  sygal config set-api-key openai              cl\xE9 OCR (lue sur stdin, chiffr\xE9e machine)
+  sygal convert capture.png                    image \u2192 OCR via le provider configur\xE9
+  sygal license activate <cl\xE9>                 apr\xE8s achat (essai 14 jours inclus)
+
+${import_picocolors3.default.magenta("Pour les agents :")}
+  sygal convert doc.docx --advanced --ocr defer --json    extraction sans appel API
+  sygal inject doc.docx.md --transcripts t.json           r\xE9int\xE9gration des transcriptions
+
+Documentation compl\xE8te : sygal <commande> --help`
+);
+function parseProvider(value) {
+  if (!OCR_PROVIDERS_IDS.includes(value)) {
+    throw new import_commander.InvalidArgumentError(`Provider inconnu (${OCR_PROVIDERS_IDS.join(" | ")})`);
+  }
+  return value;
+}
+function parseLocale(value) {
+  if (!LOCALES2.includes(value)) {
+    throw new import_commander.InvalidArgumentError(`Langue inconnue (${LOCALES2.join(" | ")})`);
+  }
+  return value;
+}
+function parsePositiveInt(value) {
+  const n = Number(value);
+  if (!Number.isInteger(n) || n < 1) throw new import_commander.InvalidArgumentError("Entier >= 1 attendu");
+  return n;
+}
+program.command("convert").description("Convertit un ou plusieurs fichiers, dossiers ou URLs en Markdown/JSON").argument("<paths...>", "chemins de fichiers/dossiers ou URLs http(s)").option("-o, --output <dir>", "dossier de sortie (d\xE9faut : dossier source de chaque fichier)").option("-f, --format <format>", "format de sortie : md | json | both", "md").option(
+  "--ocr <mode>",
+  "auto (provider configur\xE9) | defer (aucun appel, images extraites)",
+  "auto"
+).option("--advanced", "OCR des images embarqu\xE9es (docx, pptx, pdf, xlsx, html, eml)").option("--pdf-ocr <mode>", "PDF via OCR page par page : all | first | page").option("--page <n>", "num\xE9ro de page pour --pdf-ocr page", parsePositiveInt).option(
+  "--max-ocr-calls <n>",
+  "budget maximum d\u2019appels OCR pour cette ex\xE9cution",
+  parsePositiveInt
+).option("--translate <locale>", "traduit le markdown final (fr | en | it | de | es)", parseLocale).option("--batch", "accept\xE9 pour compatibilit\xE9 (les dossiers sont d\xE9velopp\xE9s automatiquement)").option("--json", "sortie machine JSON sur stdout (aucun habillage)").addHelpText(
+  "after",
+  `
+Exemples :
+  sygal convert rapport.pdf
+  sygal convert dossier/ --batch --format both --output ./sorties
+  sygal convert scan.pdf --pdf-ocr all --json
+  sygal convert dossier.docx --advanced --ocr defer --json
+  sygal convert https://example.com/article --json`
+).action(
+  async (paths, opts) => {
+    const json = opts.json === true;
+    const format = opts.format;
+    if (!["md", "json", "both"].includes(format)) {
+      fail(json, "invalid_format", `Format inconnu : ${opts.format} (md | json | both)`);
+      return;
+    }
+    const ocrMode = opts.ocr;
+    if (!["auto", "defer"].includes(ocrMode)) {
+      fail(json, "invalid_options", `Mode OCR inconnu : ${opts.ocr} (auto | defer)`);
+      return;
+    }
+    if (opts.pdfOcr && !["all", "first", "page"].includes(opts.pdfOcr)) {
+      fail(
+        json,
+        "invalid_options",
+        `Mode --pdf-ocr inconnu : ${opts.pdfOcr} (all | first | page)`
+      );
+      return;
+    }
+    if (opts.translate && ocrMode === "defer") {
+      fail(
+        json,
+        "invalid_options",
+        "La traduction (--translate) est incompatible avec --ocr defer"
+      );
+      return;
+    }
+    const license = new CliLicense();
+    try {
+      await requireLicensed(license);
+    } catch (err) {
+      const e = toCliError(err);
+      fail(json, e.code, e.message);
+      return;
+    }
+    const sidecarCommand = resolveSidecarCommand();
+    if (!sidecarCommand) {
+      fail(
+        json,
+        "sidecar_not_found",
+        "Moteur de conversion introuvable : r\xE9installez sygal-cli (npm install -g sygal-cli) ou d\xE9finissez SYGAL_SIDECAR_PATH"
+      );
+      return;
+    }
+    const settings = new CliSettings();
+    const appSettings = settings.getAppSettings();
+    const hasKey = settings.hasApiKey(appSettings.ocrProvider);
+    const ocr = hasKey ? new ApiOcrRunner(settings) : null;
+    const translationRunner = hasKey ? new TranslationRunner(settings) : null;
+    let singleFile = false;
+    if (paths.length === 1 && !/^https?:\/\//i.test(paths[0])) {
+      try {
+        singleFile = (0, import_node_fs7.statSync)(paths[0]).isFile();
+      } catch {
+        singleFile = true;
+      }
+    }
+    const sidecar = new SidecarPool({
+      ...sidecarCommand,
+      poolSize: paths.length === 1 && (singleFile || /^https?:\/\//i.test(paths[0])) ? 1 : 2,
+      logger: { info: () => {
+      }, warn: () => {
+      }, error: () => {
+      } }
+    });
+    sidecar.start();
+    try {
+      await sidecar.ping();
+    } catch (err) {
+      sidecar.stop();
+      const message = err instanceof SidecarError ? err.message : String(err);
+      fail(json, "sidecar_down", `Moteur de conversion injoignable : ${message}`);
+      return;
+    }
+    const reporter = json ? null : new HumanReporter();
+    try {
+      const summary = await runConvert(
+        paths,
+        {
+          output: opts.output,
+          format,
+          ocrMode,
+          advanced: opts.advanced ?? settings.isAdvancedConversionEnabled(),
+          pdfOcr: opts.pdfOcr,
+          pdfPage: opts.page,
+          maxOcrCalls: opts.maxOcrCalls ?? settings.getMaxOcrCalls(),
+          translate: opts.translate
+        },
+        {
+          sidecar,
+          ocr,
+          ocrProvider: appSettings.ocrProvider,
+          translate: translationRunner ? (markdown, target) => translationRunner.translate(markdown, target) : void 0
+        },
+        reporter ? {
+          onExpanded: (total) => reporter.onExpanded(total),
+          onReport: (report) => reporter.onReport(report)
+        } : void 0
+      );
+      if (json) {
+        printJson(summary, pkg.version);
+      } else {
+        reporter?.finish(summary, license.getStatus());
+      }
+      process.exitCode = summary.failed > 0 ? 1 : 0;
+    } finally {
+      sidecar.stop();
+    }
+  }
+);
+program.command("inject").description(
+  "R\xE9int\xE8gre des transcriptions OCR (mode --ocr defer) dans un markdown, \xE0 leur position exacte"
+).argument("<markdown>", "fichier .md contenant des marqueurs ![sygal:ocr:N](...)").requiredOption(
+  "--transcripts <file>",
+  'JSON : [{"index":1,"text":"...","provider":"..."}] (ocrText/ocrProvider accept\xE9s)'
+).option("--json", "sortie machine JSON sur stdout").action(async (markdownPath, opts) => {
+  const json = opts.json === true;
+  try {
+    await requireLicensed(new CliLicense());
+  } catch (err) {
+    const e = toCliError(err);
+    fail(json, e.code, e.message);
+    return;
+  }
+  let transcripts;
+  try {
+    const raw = JSON.parse((0, import_node_fs7.readFileSync)(opts.transcripts, "utf-8"));
+    transcripts = Array.isArray(raw) ? raw : [];
+  } catch (err) {
+    fail(json, "invalid_transcripts", `Fichier de transcriptions illisible : ${String(err)}`);
+    return;
+  }
+  try {
+    const result = await injectTranscripts(markdownPath, transcripts);
+    if (json) {
+      process.stdout.write(JSON.stringify({ ...result, file: markdownPath }, null, 2) + "\n");
+    } else {
+      console.log(
+        `${import_picocolors3.default.green("\u2713")} ${result.injected} transcription(s) inject\xE9e(s)` + (result.remaining > 0 ? ` \xB7 ${import_picocolors3.default.yellow(`${result.remaining} marqueur(s) restant(s)`)}` : "")
+      );
+    }
+    process.exitCode = 0;
+  } catch (err) {
+    fail(json, "inject_failed", err instanceof Error ? err.message : String(err));
+  }
+});
+program.command("update").description("V\xE9rifie et installe la derni\xE8re version (npm install -g sygal-cli)").option("--check", "v\xE9rifie seulement, sans installer").option("--json", "sortie machine JSON").action(async (opts) => {
+  const check = await checkForUpdate(pkg.version);
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(check, null, 2) + "\n");
+    if (check.error) process.exitCode = 1;
+    if (opts.check || !check.updateAvailable) return;
+  } else {
+    if (check.error) {
+      console.error(`${import_picocolors3.default.red("\u2717")} ${check.error}`);
+      process.exitCode = 1;
+      return;
+    }
+    if (!check.updateAvailable) {
+      console.log(`${import_picocolors3.default.green("\u2713")} Sygal CLI est \xE0 jour (${check.current})`);
+      return;
+    }
+    console.log(
+      `${import_picocolors3.default.magenta("\u2191")} Nouvelle version disponible : ${check.current} \u2192 ${check.latest}`
+    );
+    if (opts.check) return;
+    console.log(import_picocolors3.default.dim("Installation via npm..."));
+  }
+  const code = await runGlobalInstall();
+  if (code === 0) {
+    if (!opts.json) console.log(`${import_picocolors3.default.green("\u2713")} Sygal CLI mis \xE0 jour en ${check.latest}`);
+  } else {
+    if (!opts.json) {
+      console.error(`${import_picocolors3.default.red("\u2717")} \xC9chec de l\u2019installation (npm code ${code})`);
+    }
+    process.exitCode = 1;
+  }
+});
+var licenseCmd = program.command("license").description(`Licence Sygal CLI - essai 14 jours puis activation LemonSqueezy (${licensePath()})`);
+licenseCmd.command("activate").description("Active une licence sur cette machine (consomme un poste du pool)").argument("<key>", "cl\xE9 de licence LemonSqueezy").option("--json", "sortie machine JSON").action(async (key, opts) => {
+  const result = await new CliLicense().activate(key);
+  if (result.ok) {
+    if (opts.json) {
+      process.stdout.write(JSON.stringify({ ok: true, state: "active" }, null, 2) + "\n");
+    } else {
+      console.log(`${import_picocolors3.default.green("\u2713")} Licence activ\xE9e sur cette machine`);
+    }
+    return;
+  }
+  fail(opts.json === true, "activation_failed", `Activation refus\xE9e : ${result.error}`);
+});
+licenseCmd.command("status").description("\xC9tat de la licence (cl\xE9 jamais affich\xE9e en entier)").option("--json", "sortie machine JSON").action(async (opts) => {
+  const license = new CliLicense();
+  await license.validateIfStale();
+  const status = license.getStatus();
+  if (opts.json) {
+    const payload = status.state === "active" ? { state: "active", licenseKey: license.maskedKey() } : status.state === "trial" ? { state: "trial", daysLeft: status.daysLeft } : { state: "expired", store: LS_STORE_URL };
+    process.stdout.write(JSON.stringify(payload, null, 2) + "\n");
+    return;
+  }
+  if (status.state === "active") {
+    console.log(`${import_picocolors3.default.green("\u2713")} Licence active (${license.maskedKey()})`);
+  } else if (status.state === "trial") {
+    console.log(`${import_picocolors3.default.yellow("\u25F7")} Essai : ${status.daysLeft} jour(s) restant(s)`);
+  } else {
+    console.log(`${import_picocolors3.default.red("\u2717")} Essai termin\xE9 - achetez une licence : ${LS_STORE_URL}`);
+    process.exitCode = 1;
+  }
+});
+licenseCmd.command("deactivate").description("D\xE9sactive la licence sur cette machine (lib\xE8re le poste)").option("--json", "sortie machine JSON").action(async (opts) => {
+  const result = await new CliLicense().deactivate();
+  if (result.ok) {
+    if (opts.json) {
+      process.stdout.write(JSON.stringify({ ok: true }, null, 2) + "\n");
+    } else {
+      console.log(`${import_picocolors3.default.green("\u2713")} Licence d\xE9sactiv\xE9e - poste lib\xE9r\xE9`);
+    }
+    return;
+  }
+  fail(opts.json === true, "deactivation_failed", result.error ?? "D\xE9sactivation refus\xE9e");
+});
+var config = program.command("config").description(`Configuration Sygal CLI (${configPath()}, cl\xE9s chiffr\xE9es au repos)`);
+config.command("set-ocr-provider").description("Choisit le provider OCR actif").argument("<provider>", OCR_PROVIDERS_IDS.join(" | "), parseProvider).action((provider) => {
+  new CliSettings().setOcrProvider(provider);
+  console.log(`${import_picocolors3.default.green("\u2713")} Provider OCR : ${provider}`);
+});
+config.command("set-api-key").description("Enregistre la cl\xE9 API d\u2019un provider (chiffr\xE9e, li\xE9e \xE0 cette machine)").argument("<provider>", OCR_PROVIDERS_IDS.join(" | "), parseProvider).argument("[key]", "cl\xE9 API \u2014 omise : lue sur stdin (recommand\xE9, \xE9vite l\u2019historique shell)").action(async (provider, key) => {
+  const value = key ?? await readStdin();
+  if (!value.trim()) {
+    console.error(`${import_picocolors3.default.red("\u2717")} Aucune cl\xE9 fournie (argument ou stdin)`);
+    process.exitCode = 1;
+    return;
+  }
+  new CliSettings().setApiKey(provider, value.trim());
+  console.log(`${import_picocolors3.default.green("\u2713")} Cl\xE9 API ${provider} enregistr\xE9e (chiffr\xE9e)`);
+});
+config.command("clear-api-key").description("Supprime la cl\xE9 API d\u2019un provider").argument("<provider>", OCR_PROVIDERS_IDS.join(" | "), parseProvider).action((provider) => {
+  new CliSettings().clearApiKey(provider);
+  console.log(`${import_picocolors3.default.green("\u2713")} Cl\xE9 API ${provider} supprim\xE9e`);
+});
+config.command("set-locale").description("Langue des libell\xE9s ajout\xE9s par l\u2019OCR et cible par d\xE9faut").argument("<locale>", LOCALES2.join(" | "), parseLocale).action((locale) => {
+  new CliSettings().setLocale(locale);
+  console.log(`${import_picocolors3.default.green("\u2713")} Langue : ${locale}`);
+});
+config.command("set-advanced").description("Active/d\xE9sactive l\u2019OCR des images embarqu\xE9es par d\xE9faut").argument("<state>", "on | off").action((state) => {
+  if (!["on", "off"].includes(state)) {
+    console.error(`${import_picocolors3.default.red("\u2717")} Valeur attendue : on | off`);
+    process.exitCode = 1;
+    return;
+  }
+  new CliSettings().setAdvancedConversion(state === "on");
+  console.log(`${import_picocolors3.default.green("\u2713")} Conversion avanc\xE9e : ${state}`);
+});
+config.command("set-max-ocr-calls").description("Budget d\u2019appels OCR par ex\xE9cution (garde-fou de co\xFBt) \u2014 off = illimit\xE9").argument("<limit>", "entier >= 1, ou off").action((limit) => {
+  const settings = new CliSettings();
+  if (limit === "off") {
+    settings.setMaxOcrCalls(null);
+    console.log(`${import_picocolors3.default.green("\u2713")} Budget OCR : illimit\xE9`);
+    return;
+  }
+  const n = Number(limit);
+  if (!Number.isInteger(n) || n < 1) {
+    console.error(`${import_picocolors3.default.red("\u2717")} Valeur attendue : entier >= 1, ou off`);
+    process.exitCode = 1;
+    return;
+  }
+  settings.setMaxOcrCalls(n);
+  console.log(`${import_picocolors3.default.green("\u2713")} Budget OCR : ${n} appel(s) max par ex\xE9cution`);
+});
+config.command("show").description("Affiche la configuration (pr\xE9sence des cl\xE9s uniquement, jamais leur valeur)").option("--json", "sortie machine JSON").action((opts) => {
+  const described = new CliSettings().describe();
+  if (opts.json) {
+    process.stdout.write(JSON.stringify(described, null, 2) + "\n");
+    return;
+  }
+  console.log(`Config : ${configPath()}`);
+  console.log(`Langue : ${described.locale}`);
+  console.log(`Provider OCR : ${described.ocrProvider}`);
+  console.log(`Conversion avanc\xE9e : ${described.advancedConversion ? "on" : "off"}`);
+  console.log(`Budget OCR : ${described.maxOcrCalls ?? "illimit\xE9"}`);
+  console.log("Cl\xE9s API :");
+  for (const [provider, present] of Object.entries(described.apiKeys)) {
+    console.log(`  ${provider} : ${present ? import_picocolors3.default.green("configur\xE9e") : import_picocolors3.default.dim("absente")}`);
+  }
+});
+function readStdin() {
+  return new Promise((resolvePromise) => {
+    let data = "";
+    process.stdin.setEncoding("utf-8");
+    process.stdin.on("data", (chunk) => data += chunk);
+    process.stdin.on("end", () => resolvePromise(data));
+  });
+}
+function fail(json, code, message) {
+  if (json) {
+    process.stdout.write(
+      JSON.stringify({ summary: { done: 0, failed: 1 }, error: { code, message } }, null, 2) + "\n"
+    );
+  } else {
+    console.error(`${import_picocolors3.default.red("\u2717")} ${message} ${import_picocolors3.default.dim(`[${code}]`)}`);
+  }
+  process.exitCode = 1;
+}
+program.parseAsync(process.argv).catch((err) => {
+  console.error(import_picocolors3.default.red(String(err instanceof Error ? err.message : err)));
+  process.exitCode = 1;
+});