codetrellis 0.0.0-stage → 0.2.0

package/src/backend/services/rendition/engine-host.js

@@ -0,0 +1,249 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var engine_host_exports = {};
+__export(engine_host_exports, {
+  ConversionFailed: () => ConversionFailed,
+  ConversionTimedOut: () => ConversionTimedOut,
+  EngineHost: () => EngineHost,
+  EngineUnavailable: () => EngineUnavailable,
+  runtimeIsolation: () => runtimeIsolation
+});
+module.exports = __toCommonJS(engine_host_exports);
+var import_node_child_process = require("node:child_process");
+var import_engine_manifest = require("./engine-manifest");
+var import_confined_fs = require("../confined-fs");
+class EngineUnavailable extends Error {
+}
+class ConversionFailed extends Error {
+}
+class ConversionTimedOut extends ConversionFailed {
+}
+function runtimeIsolation() {
+  const flags = process.allowedNodeEnvironmentFlags;
+  return { fs: flags.has("--permission"), net: flags.has("--allow-net") };
+}
+const WARM_UP = new TextEncoder().encode("{\\rtf1\\ansi CodeTrellis warm-up.\\par}");
+class EngineHost {
+  constructor(opts) {
+    this.opts = opts;
+  }
+  opts;
+  child = null;
+  starting = null;
+  version = null;
+  seq = 0;
+  pending = /* @__PURE__ */ new Map();
+  queue = Promise.resolve();
+  idleTimer = null;
+  stderrTail = "";
+  get running() {
+    return this.child !== null;
+  }
+  /** The running engine's version, once it has started. */
+  get engineVersion() {
+    return this.version;
+  }
+  /** The engine's check, without starting it — its version keys the cache. */
+  async check() {
+    return (0, import_engine_manifest.verifyEngine)(this.opts.engineDir, this.opts.pinned ?? void 0);
+  }
+  convert(bytes, ext) {
+    const run = this.queue.then(() => this.convertNow(bytes, ext));
+    this.queue = run.catch(() => void 0);
+    return run;
+  }
+  stop() {
+    this.clearIdle();
+    const child = this.child;
+    this.child = null;
+    if (child && child.exitCode === null) child.kill("SIGKILL");
+  }
+  async convertNow(bytes, ext) {
+    this.clearIdle();
+    const child = await this.start();
+    const id = ++this.seq;
+    const timeoutMs = this.opts.timeoutMs ?? 3e4;
+    try {
+      return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          console.warn(`[rendition] a .${ext} conversion ran past ${timeoutMs}ms; stopping the engine`);
+          this.pending.delete(id);
+          reject(new ConversionTimedOut(`The conversion took longer than ${Math.round(timeoutMs / 1e3)}s, so it was stopped`));
+          this.stop();
+        }, timeoutMs);
+        this.pending.set(id, { resolve, reject, timer });
+        child.send({ type: "convert", id, bytes, ext });
+      });
+    } finally {
+      this.armIdle();
+    }
+  }
+  start() {
+    if (this.child) return Promise.resolve(this.child);
+    if (!this.starting) this.starting = this.spawn().finally(() => {
+      this.starting = null;
+    });
+    return this.starting;
+  }
+  /** Start an engine and warm it; one that hangs on the warm-up is replaced, once. */
+  async spawn() {
+    for (let attempt = 1; ; attempt++) {
+      const child = await this.spawnOnce();
+      if (await this.warmUp(child)) {
+        child.on("message", (msg) => this.onMessage(msg));
+        child.on("exit", () => this.onExit(child));
+        this.child = child;
+        return child;
+      }
+      if (child.exitCode === null) child.kill("SIGKILL");
+      if (attempt >= 2) throw new EngineUnavailable("the conversion engine did not settle after starting");
+      console.warn("[rendition] the engine hung on its warm-up; starting a fresh one");
+    }
+  }
+  /** True when the engine answered the warm-up — with a PDF or an error — in time. */
+  warmUp(child) {
+    const ms = this.opts.warmUpMs ?? 2e4;
+    if (ms <= 0) return Promise.resolve(true);
+    const startedAt = Date.now();
+    return new Promise((resolve) => {
+      const done = (ok) => {
+        clearTimeout(timer);
+        child.off("message", onMessage);
+        child.off("exit", onExit);
+        if (ok) console.log(`[rendition] engine warmed in ${Date.now() - startedAt}ms`);
+        resolve(ok);
+      };
+      const onMessage = (msg) => {
+        if (msg?.id === 0) done(true);
+      };
+      const onExit = () => done(false);
+      const timer = setTimeout(() => done(false), ms);
+      child.on("message", onMessage);
+      child.once("exit", onExit);
+      child.send({ type: "convert", id: 0, bytes: WARM_UP, ext: "rtf" });
+    });
+  }
+  async spawnOnce() {
+    const isolation = runtimeIsolation();
+    if (!isolation.fs) throw new EngineUnavailable("this runtime cannot confine the conversion engine");
+    const checked = await this.check();
+    if (!checked.ok) throw new EngineUnavailable(checked.reason);
+    if (!isolation.net && checked.manifest.networkFree !== true && this.opts.requireNetworkDenial !== false) {
+      throw new EngineUnavailable("this runtime cannot keep the conversion engine off the network, and this engine is not proven network-free");
+    }
+    const startedAt = Date.now();
+    let engineDir;
+    let childScript;
+    let read;
+    try {
+      engineDir = (0, import_confined_fs.canonicalRoot)(this.opts.engineDir);
+      childScript = (0, import_confined_fs.canonicalRoot)(this.opts.childScript);
+      read = [engineDir, childScript, ...(this.opts.allowRead ?? []).map((p) => (0, import_confined_fs.canonicalRoot)(p))];
+    } catch (err) {
+      console.warn(`[rendition] engine did not start: ${err.message}`);
+      throw new EngineUnavailable("the conversion engine could not start");
+    }
+    const child = (0, import_node_child_process.fork)(childScript, [engineDir], {
+      execPath: process.execPath,
+      // Its own directory — never the directory the app was started from.
+      cwd: engineDir,
+      // Omitting --allow-net, --allow-child-process, --allow-addons and every
+      // --allow-fs-write is the point.
+      execArgv: ["--permission", ...read.map((p) => `--allow-fs-read=${p}`), "--allow-worker"],
+      // Nothing of ours — no capability token, no data dir, no paths.
+      env: process.versions.electron ? { ELECTRON_RUN_AS_NODE: "1" } : {},
+      stdio: ["ignore", "ignore", "pipe", "ipc"],
+      serialization: "advanced"
+    });
+    this.stderrTail = "";
+    child.stderr?.on("data", (d) => {
+      this.stderrTail = (this.stderrTail + d.toString()).slice(-2e3);
+    });
+    await new Promise((resolve, reject) => {
+      const fail = (why) => {
+        clearTimeout(timer);
+        if (child.exitCode === null) child.kill("SIGKILL");
+        console.warn(`[rendition] engine did not start: ${why}
+${this.stderrTail}`);
+        reject(new EngineUnavailable("the conversion engine could not start"));
+      };
+      const timer = setTimeout(() => fail("timed out"), this.opts.startTimeoutMs ?? 6e4);
+      child.once("error", (err) => fail(err.message));
+      child.once("exit", (code) => fail(`exited with ${code}`));
+      child.on("message", function ready(msg) {
+        if (msg?.type !== "ready") return;
+        child.off("message", ready);
+        clearTimeout(timer);
+        child.removeAllListeners("exit");
+        child.removeAllListeners("error");
+        resolve();
+      });
+    });
+    this.version = checked.manifest.version;
+    console.log(`[rendition] engine ${checked.manifest.version} started in ${Date.now() - startedAt}ms`);
+    return child;
+  }
+  onMessage(msg) {
+    const p = this.pending.get(msg.id);
+    if (!p) return;
+    this.pending.delete(msg.id);
+    clearTimeout(p.timer);
+    if (msg.type === "result" && msg.pdf) {
+      const pdf = new Uint8Array(msg.pdf.buffer, msg.pdf.byteOffset, msg.pdf.byteLength);
+      if (pdf.byteLength > (this.opts.maxOutputBytes ?? 200 * 1024 * 1024)) {
+        p.reject(new ConversionFailed("The converted document is larger than the viewer will show"));
+      } else if (!startsWithPdf(pdf)) {
+        p.reject(new ConversionFailed("The engine did not produce a PDF"));
+      } else {
+        p.resolve(pdf);
+      }
+    } else {
+      console.warn(`[rendition] conversion failed: ${msg.message ?? "unknown"}`);
+      p.reject(new ConversionFailed("The document could not be converted"));
+    }
+  }
+  onExit(child) {
+    if (this.child === child) this.child = null;
+    for (const [id, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(new ConversionFailed("The conversion engine stopped unexpectedly"));
+      this.pending.delete(id);
+    }
+  }
+  armIdle() {
+    this.clearIdle();
+    if (!this.child || this.pending.size > 0) return;
+    this.idleTimer = setTimeout(() => this.stop(), this.opts.idleMs ?? 3 * 6e4);
+    this.idleTimer.unref();
+  }
+  clearIdle() {
+    if (this.idleTimer) clearTimeout(this.idleTimer);
+    this.idleTimer = null;
+  }
+}
+function startsWithPdf(bytes) {
+  return bytes.byteLength > 5 && String.fromCharCode(...bytes.subarray(0, 5)) === "%PDF-";
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConversionFailed,
+  ConversionTimedOut,
+  EngineHost,
+  EngineUnavailable,
+  runtimeIsolation
+});

package/src/backend/services/rendition/engine-lock.js

@@ -0,0 +1,39 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var engine_lock_exports = {};
+__export(engine_lock_exports, {
+  ENGINE_PIN: () => ENGINE_PIN
+});
+module.exports = __toCommonJS(engine_lock_exports);
+var import_engine_lock = __toESM(require("./engine-lock.json"));
+const pinned = import_engine_lock.default;
+const ENGINE_PIN = pinned.version ? { version: pinned.version, files: pinned.files, networkFree: pinned.networkFree === true } : null;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ENGINE_PIN
+});

package/src/backend/services/rendition/engine-lock.json

@@ -0,0 +1,14 @@
+{
+  "version": "24.8-d1c9e0e4e1-fb2575f33e82",
+  "networkFree": true,
+  "archive": {
+    "url": "https://github.com/lionroseway/codetrellis/releases/download/rendition-engine-24.8-d1c9e0e4e1-fb2575f33e82/rendition-engine-24.8-d1c9e0e4e1-fb2575f33e82.tar.gz",
+    "sha256": "b751353127f71c75f605e180963eff9fae52351c02994d8c4d45732fde18aa14"
+  },
+  "files": {
+    "adapter.cjs": "3385951f56a3c5b1ad8a689eac16d66cf631a0b70da9f1c41853e74a7afde831",
+    "soffice.data": "5fa78496011c4c2392e736a4cb869a3964e62b8138e3e70f4149bdb8945554d9",
+    "soffice.mjs": "22c4c073474ee2029dd55f32ee46ce0e40ccbc8eb0f078abd48a63233456e395",
+    "soffice.wasm": "d6b4f176a73925db14ea53bec8525e4fc3b92def1e0cb73b0ed84cf698349222"
+  }
+}

package/src/backend/services/rendition/engine-manifest.js

@@ -0,0 +1,97 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var engine_manifest_exports = {};
+__export(engine_manifest_exports, {
+  verifyEngine: () => verifyEngine
+});
+module.exports = __toCommonJS(engine_manifest_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+const verified = /* @__PURE__ */ new Map();
+function hashFile(file) {
+  return new Promise((resolve, reject) => {
+    const hash = (0, import_node_crypto.createHash)("sha256");
+    import_node_fs.default.createReadStream(file).on("data", (chunk) => hash.update(chunk)).on("error", reject).on("end", () => resolve(hash.digest("hex")));
+  });
+}
+function readManifest(dir) {
+  let raw;
+  try {
+    raw = JSON.parse(import_node_fs.default.readFileSync(import_node_path.default.join(dir, "engine.json"), "utf-8"));
+  } catch {
+    return "no engine is installed";
+  }
+  const m = raw;
+  if (typeof m.name !== "string" || typeof m.version !== "string" || typeof m.adapter !== "string" || !m.files || typeof m.files !== "object") {
+    return "the engine manifest is malformed";
+  }
+  if (!(m.adapter in m.files)) return "the engine manifest does not cover its adapter";
+  for (const [rel, sha] of Object.entries(m.files)) {
+    if (typeof sha !== "string" || !/^[0-9a-f]{64}$/.test(sha)) return "the engine manifest is malformed";
+    if (import_node_path.default.isAbsolute(rel) || rel.split(/[\\/]/).includes("..")) return "the engine manifest names a file outside the engine";
+  }
+  return m;
+}
+async function verifyEngine(dir, pin) {
+  const read = readManifest(dir);
+  if (typeof read === "string") return { ok: false, reason: read };
+  let manifest = read;
+  if (pin) {
+    if (read.version !== pin.version) return { ok: false, reason: `the engine is ${read.version}; this build expects ${pin.version}` };
+    if (!(read.adapter in pin.files)) return { ok: false, reason: "the engine's adapter is not one this build pinned" };
+    manifest = { ...read, files: pin.files, networkFree: pin.networkFree === true };
+  }
+  const stats = [];
+  for (const rel of Object.keys(manifest.files)) {
+    let st;
+    try {
+      st = import_node_fs.default.lstatSync(import_node_path.default.join(dir, rel));
+    } catch {
+      return { ok: false, reason: `the engine is missing ${rel}` };
+    }
+    if (!st.isFile()) return { ok: false, reason: `the engine's ${rel} is not a regular file` };
+    stats.push(`${rel}:${st.size}:${st.mtimeMs}`);
+  }
+  const stamp = `${JSON.stringify(manifest.files)}|${manifest.version}|${manifest.networkFree === true}|${stats.join("|")}`;
+  const cached = verified.get(dir);
+  if (cached && cached.stamp === stamp) return cached.result;
+  let result = { ok: true, manifest };
+  for (const [rel, expected] of Object.entries(manifest.files)) {
+    if (await hashFile(import_node_path.default.join(dir, rel)) !== expected) {
+      result = { ok: false, reason: `the engine's ${rel} does not match the hash it was built with` };
+      break;
+    }
+  }
+  verified.set(dir, { stamp, result });
+  return result;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  verifyEngine
+});

package/src/backend/services/rendition/network-proof.js

@@ -0,0 +1,73 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var network_proof_exports = {};
+__export(network_proof_exports, {
+  proveNetworkFree: () => proveNetworkFree,
+  removedGlobals: () => removedGlobals,
+  withoutSymbolLists: () => withoutSymbolLists
+});
+module.exports = __toCommonJS(network_proof_exports);
+const NETWORK_IMPORT = /^(__syscall_(socket|socketpair|connect|bind|listen|accept4?|getsockname|getpeername|getsockopt|setsockopt|sendto|recvfrom|sendmsg|recvmsg|shutdown)|getaddrinfo|getnameinfo|gethostbyname2?|gethostbyaddr|_emscripten_lookup_name)$|fetch|websocket|xhr/i;
+const FORBIDDEN_IN_GLUE = [
+  ["SOCKFS", /\bSOCKFS\b/, null],
+  ["WebSocket", /\bWebSocket\b/, "WebSocket"],
+  ["XMLHttpRequest", /\bXMLHttpRequest\b/, "XMLHttpRequest"],
+  ["a network module", /require\(\s*["'](?:node:)?(?:net|tls|http|https|http2|dgram|dns|ws)["']\s*\)/, null],
+  ["fetch()", /\bfetch\s*\(/, "fetch"]
+];
+function withoutSymbolLists(glue) {
+  return glue.replace(/\bvar\s+(?:unexportedSymbols|missingLibrarySymbols)\s*=\s*\[(?:\s*"[\w$]+"\s*,?)*\s*\]\s*;?/g, "");
+}
+function removedGlobals(adapter) {
+  const list = adapter?.match(/const\s+NETWORK_GLOBALS\s*=\s*\[([^\]]*)\]/)?.[1];
+  if (!list || !/async function load\([^)]*\)\s*\{\s*withoutNetworkGlobals\(\);/.test(adapter ?? "")) return /* @__PURE__ */ new Set();
+  return new Set(Array.from(list.matchAll(/['"]([A-Za-z]+)['"]/g), (m) => m[1]));
+}
+function stubValue(glue, importName) {
+  const js = `_${importName}`.replace(/\$/g, "\\$");
+  const arrow = new RegExp(`(?:var|let|const)\\s+${js}\\s*=\\s*\\([^)]*\\)\\s*=>\\s*(-?\\d+)\\s*[;,\\n]`);
+  const ident = "[A-Za-z_$][\\w$]*";
+  const proxy = `if\\s*\\(\\s*ENVIRONMENT_IS_PTHREAD\\s*\\)\\s*return\\s+proxyToMainThread\\(\\s*\\d+\\s*,\\s*\\d+\\s*,\\s*[01]\\s*(?:,\\s*${ident}\\s*)*\\)\\s*;\\s*`;
+  const unsigned = `(?:${ident}\\s*>>>=\\s*0\\s*;\\s*)*`;
+  const fn = new RegExp(`function\\s+${js}\\s*\\([^)]*\\)\\s*\\{\\s*(?:${proxy})?${unsigned}return\\s+(-?\\d+)\\s*;?\\s*\\}`);
+  const m = glue.match(arrow) ?? glue.match(fn);
+  return m ? Number(m[1]) : null;
+}
+function proveNetworkFree(wasm, glue, adapter) {
+  const imports = WebAssembly.Module.imports(new WebAssembly.Module(wasm)).filter((i) => i.kind === "function");
+  const networkImports = imports.filter((i) => NETWORK_IMPORT.test(i.name)).map((i) => i.name);
+  const failures = [];
+  const stubs = {};
+  for (const name of networkImports) {
+    const value = stubValue(glue, name);
+    if (value === null) failures.push(`${name} is imported and is not a no-network stub`);
+    else stubs[name] = value;
+  }
+  const removed = removedGlobals(adapter);
+  const code = withoutSymbolLists(glue);
+  for (const [what, re, global] of FORBIDDEN_IN_GLUE) {
+    if (re.test(code) && !(global && removed.has(global))) failures.push(`the glue contains ${what}`);
+  }
+  return { imports: imports.length, networkImports, stubs, networkFree: failures.length === 0, failures };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  proveNetworkFree,
+  removedGlobals,
+  withoutSymbolLists
+});

package/src/backend/services/rendition/rendition-service.js

@@ -0,0 +1,175 @@
+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 __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+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
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var rendition_service_exports = {};
+__export(rendition_service_exports, {
+  CONVERTIBLE: () => CONVERTIBLE,
+  existingRendition: () => existingRendition,
+  getEngineHost: () => getEngineHost,
+  renditionOf: () => renditionOf,
+  stopEngine: () => stopEngine
+});
+module.exports = __toCommonJS(rendition_service_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_crypto = require("node:crypto");
+var import_persistence = require("../persistence");
+var import_confined_fs = require("../confined-fs");
+var import_artefact_content_service = require("../artefact-content-service");
+var import_command = require("../../mcp/connector/command");
+var import_engine_lock = require("./engine-lock");
+var import_engine_host = require("./engine-host");
+const CONVERTIBLE = {
+  docx: 25 * 1024 * 1024,
+  pptx: 100 * 1024 * 1024,
+  xlsx: 25 * 1024 * 1024,
+  xls: 25 * 1024 * 1024
+};
+const CACHE_CAP_BYTES = 500 * 1024 * 1024;
+let sharedHost;
+function getEngineHost() {
+  if (sharedHost !== void 0) return sharedHost;
+  const resourcesPath = process.resourcesPath;
+  const packaged = (0, import_command.isPackagedElectron)({ execPath: process.execPath, electronVersion: process.versions.electron });
+  if (packaged) {
+    sharedHost = import_engine_lock.ENGINE_PIN && resourcesPath ? new import_engine_host.EngineHost({
+      engineDir: import_node_path.default.join(resourcesPath, "rendition", "engine"),
+      childScript: import_node_path.default.join(resourcesPath, "rendition", "engine-child.cjs"),
+      pinned: import_engine_lock.ENGINE_PIN
+    }) : null;
+  } else {
+    sharedHost = new import_engine_host.EngineHost({
+      engineDir: process.env.CODETRELLIS_RENDITION_ENGINE || import_node_path.default.join(process.cwd(), "resources", "rendition", "engine"),
+      childScript: import_node_path.default.join(process.cwd(), "out", "rendition", "engine-child.cjs"),
+      pinned: import_engine_lock.ENGINE_PIN
+    });
+  }
+  return sharedHost;
+}
+function stopEngine() {
+  sharedHost?.stop();
+}
+function cacheRoot() {
+  const root = import_node_path.default.join((0, import_persistence.getDataDir)(), "renditions");
+  import_node_fs.default.mkdirSync(root, { recursive: true });
+  return root;
+}
+function prune(root) {
+  const entries = import_node_fs.default.readdirSync(root, { withFileTypes: true }).filter((e) => e.isFile() && e.name.endsWith(".pdf")).map((e) => {
+    const st = import_node_fs.default.statSync(import_node_path.default.join(root, e.name));
+    return { name: e.name, size: st.size, mtimeMs: st.mtimeMs };
+  }).sort((a, b) => a.mtimeMs - b.mtimeMs);
+  let total = entries.reduce((n, e) => n + e.size, 0);
+  for (const e of entries) {
+    if (total <= CACHE_CAP_BYTES) break;
+    try {
+      (0, import_confined_fs.removeWithin)(root, e.name, {}, "rendition");
+      total -= e.size;
+    } catch {
+    }
+  }
+}
+function renditionName(bytes, version) {
+  const sha = (0, import_node_crypto.createHash)("sha256").update(bytes).digest("hex");
+  return `${sha}-${version.replace(/[^A-Za-z0-9._-]/g, "_")}.pdf`;
+}
+const RENDITION_READ_CAP = 100 * 1024 * 1024;
+async function existingRendition(bytes, ext, host = getEngineHost()) {
+  if (!host || !CONVERTIBLE[ext]) return null;
+  try {
+    const checked = await host.check();
+    if (!checked.ok) return null;
+    const rel = renditionName(bytes, checked.manifest.version);
+    return await (0, import_artefact_content_service.readServableCapped)({ root: cacheRoot(), rel, contentType: "application/pdf", itemUid: "" }, RENDITION_READ_CAP);
+  } catch {
+    return null;
+  }
+}
+const inFlight = /* @__PURE__ */ new Map();
+async function renditionOf(uid, host = getEngineHost()) {
+  const file = await (0, import_artefact_content_service.resolveServable)(uid);
+  if (!file) return { ok: false, status: 404, reason: "This attachment is not a file that can be shown" };
+  const ext = import_node_path.default.extname(file.rel).slice(1).toLowerCase();
+  const cap = CONVERTIBLE[ext];
+  if (!cap) return { ok: false, status: 415, reason: `.${ext} files are not converted` };
+  if (!host) return { ok: false, status: 503, reason: "this build carries no conversion engine" };
+  const checked = await host.check();
+  if (!checked.ok) return { ok: false, status: 503, reason: checked.reason };
+  let bytes;
+  try {
+    bytes = await (0, import_artefact_content_service.readServableCapped)(file, cap);
+  } catch {
+    return { ok: false, status: 404, reason: "The file is not there, or is not a regular file in the project" };
+  }
+  if (!bytes) return { ok: false, status: 413, reason: "This file is larger than the viewer will convert" };
+  const name = renditionName(bytes, checked.manifest.version);
+  const root = cacheRoot();
+  const served = () => ({ ok: true, file: { root, rel: name, contentType: "application/pdf", itemUid: file.itemUid } });
+  try {
+    const cached = (0, import_confined_fs.resolveWithin)(root, name, "rendition");
+    if (import_node_fs.default.lstatSync(cached).isFile()) {
+      const now = /* @__PURE__ */ new Date();
+      import_node_fs.default.utimesSync(cached, now, now);
+      return served();
+    }
+  } catch {
+  }
+  const running = inFlight.get(name);
+  if (running) return running;
+  const job = (async () => {
+    try {
+      let pdf;
+      try {
+        pdf = await host.convert(bytes, ext);
+      } catch (err) {
+        if (!(err instanceof import_engine_host.ConversionTimedOut)) throw err;
+        pdf = await host.convert(bytes, ext);
+      }
+      (0, import_confined_fs.writeFileWithin)(root, name, Buffer.from(pdf.buffer, pdf.byteOffset, pdf.byteLength), "rendition");
+      prune(root);
+      return served();
+    } catch (err) {
+      if (err instanceof import_engine_host.EngineUnavailable || err instanceof import_engine_host.ConversionFailed) {
+        return { ok: false, status: 503, reason: err.message };
+      }
+      console.warn("[rendition] unexpected failure", err);
+      return { ok: false, status: 503, reason: "The document could not be converted" };
+    } finally {
+      inFlight.delete(name);
+    }
+  })();
+  inFlight.set(name, job);
+  return job;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CONVERTIBLE,
+  existingRendition,
+  getEngineHost,
+  renditionOf,
+  stopEngine
+});