@hwp-editor/server 1.0.0-rc.0

package/dist/index.cjs

@@ -0,0 +1,964 @@
+"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 __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);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  DEFAULT_TTL_MS: () => DEFAULT_TTL_MS,
+  HWP_TIMEOUT_MS: () => HWP_TIMEOUT_MS,
+  HwpCliError: () => HwpCliError,
+  SessionNotFoundError: () => SessionNotFoundError,
+  createCliEngine: () => createCliEngine,
+  createHwpEditorHandler: () => createHwpEditorHandler,
+  createSessionStore: () => createSessionStore
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/cli-engine.ts
+var import_node_child_process = require("child_process");
+var import_node_crypto = require("crypto");
+var import_promises = require("fs/promises");
+var import_node_os = require("os");
+var import_node_path = __toESM(require("path"), 1);
+var import_core = require("@hwp-editor/core");
+var HWP_TIMEOUT_MS = 6e4;
+var HWP_MAX_BUFFER = 32 * 1024 * 1024;
+var KILL_GRACE_MS = 3e3;
+var MIN_VERSION = [0, 16, 0];
+var MAX_VERSION_EXCLUSIVE = [1, 0, 0];
+var FLAG_TOKEN = /(?:^|\s)(--[a-z][a-z0-9-]*)(?=[\s,=<]|$)/gm;
+var HANDSHAKE_FLAGS = [
+  ...Object.values(import_core.OP_FLAGS),
+  "--verify",
+  "--allow-partial"
+];
+var CFBF_SIGNATURE = [208, 207, 17, 224, 161, 177, 26, 225];
+var PNG_SIGNATURE = [137, 80, 78, 71, 13, 10, 26, 10];
+var HwpCliError = class extends Error {
+  constructor(reason, message, stderr, detail) {
+    super(message);
+    this.reason = reason;
+    this.stderr = stderr;
+    this.detail = detail;
+    this.name = "HwpCliError";
+  }
+  reason;
+  stderr;
+  detail;
+};
+function detailFor(bin, output) {
+  const trimmed = output?.trim() ?? "";
+  return trimmed === "" ? bin : `${bin}: ${trimmed}`;
+}
+var HWP_ENV_ALLOWLIST = ["HWP_FONT_DIR"];
+function scrubbedEnv(locale) {
+  const env = {};
+  for (const key of ["PATH", "HOME"]) {
+    const value = process.env[key];
+    if (value !== void 0) env[key] = value;
+  }
+  for (const key of HWP_ENV_ALLOWLIST) {
+    const value = process.env[key];
+    if (value !== void 0) env[key] = value;
+  }
+  env.LANG = "C.UTF-8";
+  env.LC_ALL = "C.UTF-8";
+  env.LC_MESSAGES = "C.UTF-8";
+  env.HWP_LANG = locale?.trim() || "en";
+  return env;
+}
+function runCli(bin, args, timeoutMs = HWP_TIMEOUT_MS, locale, requestSignal) {
+  return new Promise((resolve, reject) => {
+    if (requestSignal?.aborted === true) {
+      reject(new HwpCliError("cancelled", `hwp ${args[0] ?? ""} was cancelled by the caller`));
+      return;
+    }
+    let cause = null;
+    let escalation;
+    const signalChild = () => {
+      if (escalation !== void 0) return;
+      child.kill("SIGTERM");
+      escalation = setTimeout(() => child.kill("SIGKILL"), KILL_GRACE_MS);
+      escalation.unref();
+    };
+    const timer = setTimeout(() => {
+      cause = "timeout";
+      signalChild();
+    }, timeoutMs);
+    const onCancel = () => {
+      cause ??= "cancelled";
+      signalChild();
+    };
+    requestSignal?.addEventListener("abort", onCancel, { once: true });
+    const child = (0, import_node_child_process.execFile)(
+      bin,
+      args,
+      {
+        maxBuffer: HWP_MAX_BUFFER,
+        env: scrubbedEnv(locale),
+        encoding: "utf8"
+      },
+      (error2, stdout, stderr) => {
+        clearTimeout(timer);
+        if (escalation !== void 0) clearTimeout(escalation);
+        requestSignal?.removeEventListener("abort", onCancel);
+        if (cause === "timeout") {
+          reject(new HwpCliError("timeout", `hwp ${args[0] ?? ""} timed out after ${timeoutMs}ms`));
+          return;
+        }
+        if (cause === "cancelled") {
+          reject(new HwpCliError("cancelled", `hwp ${args[0] ?? ""} was cancelled by the caller`));
+          return;
+        }
+        if (error2 === null) {
+          resolve({ stdout, stderr, code: 0 });
+          return;
+        }
+        const raw = error2.code;
+        if (raw === "ERR_CHILD_PROCESS_STDIO_MAXBUFFER") {
+          reject(new HwpCliError(
+            "output_too_large",
+            `hwp ${args[0] ?? ""} produced more than ${HWP_MAX_BUFFER} bytes on stdout`
+          ));
+          return;
+        }
+        if (raw === "ENOENT") {
+          reject(new HwpCliError(
+            "unavailable",
+            "hwp binary not found (install hwp-cli >= 0.16.0, or set HWP_EDITOR_BIN / the bin option)",
+            void 0,
+            detailFor(bin)
+          ));
+          return;
+        }
+        resolve({ stdout, stderr, code: typeof raw === "number" ? raw : 1 });
+      }
+    );
+  });
+}
+async function runCliOk(bin, args, timeoutMs, locale, requestSignal) {
+  const result = await runCli(bin, args, timeoutMs, locale, requestSignal);
+  if (result.code !== 0) {
+    throw new HwpCliError(
+      "failed",
+      `hwp ${args[0] ?? ""} failed (exit ${result.code})`,
+      result.stderr,
+      detailFor(bin, result.stderr.trim() || result.stdout.trim())
+    );
+  }
+  return result;
+}
+function parseVersion(stdout) {
+  const match = stdout.match(/(\d+)\.(\d+)\.(\d+)/);
+  if (match === null) return null;
+  return [Number(match[1]), Number(match[2]), Number(match[3])];
+}
+function versionAtLeast(v, min) {
+  for (let i = 0; i < 3; i++) {
+    if (v[i] > min[i]) return true;
+    if (v[i] < min[i]) return false;
+  }
+  return true;
+}
+function sha256(data) {
+  return (0, import_node_crypto.createHash)("sha256").update(data).digest("hex");
+}
+var DEFAULT_CALL_SCOPE = "default";
+function cacheKey(scope, data) {
+  return (0, import_node_crypto.createHash)("sha256").update(`${scope ?? DEFAULT_CALL_SCOPE}\0${sha256(data)}`).digest("hex");
+}
+function sniffExtension(document) {
+  const ext = import_node_path.default.extname(document.name).toLowerCase();
+  if (ext === ".hwp" || ext === ".hwpx") return ext;
+  const isCfbf = document.data.length >= CFBF_SIGNATURE.length && CFBF_SIGNATURE.every((byte, i) => document.data[i] === byte);
+  return isCfbf ? ".hwp" : ".hwpx";
+}
+function safeOutputName(name, fallbackExt) {
+  const base = import_node_path.default.basename(name).replace(/[^\w.가-힣-]/g, "_") || `document${fallbackExt}`;
+  const ext = import_node_path.default.extname(base).toLowerCase();
+  if (ext === ".hwp" || ext === ".hwpx") return base;
+  return `${base}${fallbackExt}`;
+}
+async function tryJson(bin, args, timeoutMs, locale, requestSignal) {
+  try {
+    const result = await runCliOk(bin, args, timeoutMs, locale, requestSignal);
+    return JSON.parse(result.stdout);
+  } catch (error2) {
+    if (error2 instanceof HwpCliError && error2.reason === "cancelled") throw error2;
+    return null;
+  }
+}
+var PROTECTED_ATTRIBUTES = {
+  "DRM \uBCF4\uC548": "DRM-protected document (DRM \uBCF4\uC548)",
+  "\uACF5\uC778 \uC778\uC99D\uC11C \uC554\uD638\uD654": "certificate-encrypted document (\uACF5\uC778 \uC778\uC99D\uC11C \uC554\uD638\uD654)",
+  "\uACF5\uC778 \uC778\uC99D\uC11C DRM \uBCF4\uC548": "certificate DRM-protected document (\uACF5\uC778 \uC778\uC99D\uC11C DRM \uBCF4\uC548)",
+  "\uC804\uC790 \uC11C\uBA85 \uC815\uBCF4": "signed document (\uC804\uC790 \uC11C\uBA85 \uC815\uBCF4)"
+};
+function documentEditability(info) {
+  if (typeof info !== "object" || info === null) return { editable: true };
+  const record = info;
+  if (record["encrypted"] === true) {
+    return { editable: false, reason: "encrypted document; hwp-cli refuses edit/fill" };
+  }
+  if (record["distribution"] === true) {
+    return {
+      editable: false,
+      reason: "distribution (\uBC30\uD3EC\uC6A9) document; hwp-cli refuses edit/fill"
+    };
+  }
+  const attributes = record["attributes"];
+  if (Array.isArray(attributes)) {
+    for (const attribute of attributes) {
+      const label = typeof attribute === "string" ? PROTECTED_ATTRIBUTES[attribute] : void 0;
+      if (label !== void 0) {
+        return { editable: false, reason: `${label}; hwp-cli refuses edit/fill` };
+      }
+    }
+  }
+  return { editable: true };
+}
+function protectedReasonFromStderr(stderr) {
+  return (0, import_core.protectedReasonFromDiagnostics)(stderr);
+}
+function rethrowProtected(error2) {
+  if (error2 instanceof HwpCliError && error2.reason === "failed") {
+    const message = protectedReasonFromStderr(error2.stderr ?? "");
+    if (message !== null) throw new HwpCliError("protected", message, error2.stderr);
+  }
+  throw error2;
+}
+function positiveSize(width, height) {
+  if (!Number.isFinite(width) || !Number.isFinite(height)) return null;
+  if (width <= 0 || height <= 0) return null;
+  return { width, height };
+}
+function pngSize(data) {
+  if (data.length < 24) return null;
+  if (PNG_SIGNATURE.some((byte, i) => data[i] !== byte)) return null;
+  if (data[12] !== 73 || data[13] !== 72 || data[14] !== 68 || data[15] !== 82) return null;
+  const view = new DataView(data.buffer, data.byteOffset, data.byteLength);
+  return positiveSize(view.getUint32(16), view.getUint32(20));
+}
+var SVG_UNITS = "pt|px|mm|in|cm|em|%";
+function svgSize(source) {
+  const tag = source.match(/<svg\b[^>]*>/i);
+  if (tag === null) return null;
+  const width = tag[0].match(new RegExp(`\\bwidth="([\\d.]+)(${SVG_UNITS})?"`, "i"));
+  const height = tag[0].match(new RegExp(`\\bheight="([\\d.]+)(${SVG_UNITS})?"`, "i"));
+  if (width !== null && height !== null) {
+    if ((width[2] ?? "") !== (height[2] ?? "")) return null;
+    return positiveSize(Number(width[1]), Number(height[1]));
+  }
+  if (/\b(?:width|height)="/i.test(tag[0])) return null;
+  const viewBox = tag[0].match(/\bviewBox="[\d.-]+\s+[\d.-]+\s+([\d.]+)\s+([\d.]+)"/i);
+  if (viewBox === null) return null;
+  return positiveSize(Number(viewBox[1]), Number(viewBox[2]));
+}
+function parseSinglePage(pages) {
+  if (pages !== void 0 && /^\d+$/.test(pages)) return Number(pages);
+  return null;
+}
+function createCliEngine(opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? HWP_TIMEOUT_MS;
+  function resolveBin() {
+    const fromOpts = opts.bin?.trim();
+    if (fromOpts) return fromOpts;
+    const fromEditorEnv = process.env.HWP_EDITOR_BIN?.trim();
+    if (fromEditorEnv) return fromEditorEnv;
+    const fromCliEnv = process.env.HWP_CLI?.trim();
+    if (fromCliEnv) return fromCliEnv;
+    return "hwp";
+  }
+  let verifiedVersion = null;
+  function ensureVersion() {
+    verifiedVersion ??= (async () => {
+      const bin = resolveBin();
+      let result;
+      try {
+        result = await runCli(bin, ["--version"], timeoutMs, opts.locale, void 0);
+      } catch (error2) {
+        if (error2 instanceof HwpCliError) throw error2;
+        throw new HwpCliError(
+          "unavailable",
+          "hwp binary is not executable (set HWP_EDITOR_BIN or the bin option)",
+          void 0,
+          detailFor(bin, error2 instanceof Error ? error2.message : String(error2))
+        );
+      }
+      if (result.code !== 0) {
+        throw new HwpCliError(
+          "unavailable",
+          `hwp --version failed (exit ${result.code})`,
+          result.stderr,
+          detailFor(bin, result.stderr)
+        );
+      }
+      const version = parseVersion(result.stdout);
+      if (version === null) {
+        throw new HwpCliError(
+          "version",
+          "cannot parse a semver from the hwp --version output",
+          void 0,
+          detailFor(bin, result.stdout)
+        );
+      }
+      if (!versionAtLeast(version, MIN_VERSION)) {
+        throw new HwpCliError(
+          "version",
+          `hwp ${version.join(".")} is too old; >= ${MIN_VERSION.join(".")} required`,
+          void 0,
+          detailFor(bin)
+        );
+      }
+      if (versionAtLeast(version, MAX_VERSION_EXCLUSIVE)) {
+        throw new HwpCliError(
+          "version",
+          `hwp ${version.join(".")} is newer than this engine supports; < ${MAX_VERSION_EXCLUSIVE.join(".")} required`,
+          void 0,
+          detailFor(bin)
+        );
+      }
+      const help = await runCli(bin, ["edit", "--help"], timeoutMs, opts.locale, void 0);
+      if (help.code !== 0) {
+        throw new HwpCliError(
+          "version",
+          `hwp edit --help failed (exit ${help.code}); the edit flag surface cannot be verified`,
+          help.stderr,
+          detailFor(bin, help.stderr)
+        );
+      }
+      const present = new Set([...help.stdout.matchAll(FLAG_TOKEN)].map((match) => match[1]));
+      const missing = HANDSHAKE_FLAGS.filter((flag) => !present.has(flag));
+      if (missing.length > 0) {
+        throw new HwpCliError(
+          "version",
+          `hwp ${version.join(".")} does not accept ${missing.join(", ")} on edit; the binary does not match this engine's edit grammar`,
+          void 0,
+          detailFor(bin)
+        );
+      }
+      return version.join(".");
+    })();
+    return verifiedVersion;
+  }
+  async function withWorkDir(fn) {
+    const dir = await (0, import_promises.mkdtemp)(import_node_path.default.join((0, import_node_os.tmpdir)(), "hwp-editor-"));
+    try {
+      return await fn(dir);
+    } finally {
+      await (0, import_promises.rm)(dir, { recursive: true, force: true });
+    }
+  }
+  async function stage(dir, document) {
+    const file = import_node_path.default.join(dir, `in${sniffExtension(document)}`);
+    await (0, import_promises.writeFile)(file, document.data, { mode: 384 });
+    return file;
+  }
+  const inspections = /* @__PURE__ */ new Map();
+  const snapshots = /* @__PURE__ */ new Map();
+  async function describe(document, call) {
+    await ensureVersion();
+    const bin = resolveBin();
+    const key = cacheKey(call?.scope, document.data);
+    const cached = inspections.get(key);
+    if (cached !== void 0) return cached;
+    const signal = call?.signal;
+    const inspection = await withWorkDir(async (dir) => {
+      const file = await stage(dir, document);
+      const cat = await runCliOk(bin, ["cat", file, "--format", "markdown", "--with-segments"], timeoutMs, opts.locale, signal);
+      const envelope = (0, import_core.parseCatEnvelope)(cat.stdout);
+      const [fields, bookmarks, slots, info] = await Promise.all([
+        tryJson(bin, ["fields", file, "--json"], timeoutMs, opts.locale, signal),
+        tryJson(bin, ["bookmarks", file, "--json"], timeoutMs, opts.locale, signal),
+        tryJson(bin, ["slots", file, "--json"], timeoutMs, opts.locale, signal),
+        tryJson(bin, ["info", file, "--json"], timeoutMs, opts.locale, signal)
+      ]);
+      return {
+        envelope,
+        fields,
+        bookmarks,
+        slots,
+        info,
+        capabilities: documentEditability(info)
+      };
+    });
+    if (inspections.size >= 64) {
+      const oldest = inspections.keys().next().value;
+      if (oldest !== void 0) inspections.delete(oldest);
+    }
+    inspections.set(key, inspection);
+    return inspection;
+  }
+  const engine = {
+    async read(document, call) {
+      return (await describe(document, call)).envelope;
+    },
+    describe,
+    async render(document, options = {}, call) {
+      await ensureVersion();
+      const bin = resolveBin();
+      const requested = options.format ?? "svg";
+      if (requested === "jpeg" || requested === "webp") {
+        throw new HwpCliError(
+          "unsupported_format",
+          `hwp-cli render supports png and svg only; got "${requested}"`
+        );
+      }
+      const dpi = options.dpi ?? 96;
+      if (!Number.isFinite(dpi) || dpi < 36 || dpi > 600) {
+        throw new HwpCliError("bad_request", `dpi must be within 36..=600; got ${options.dpi}`);
+      }
+      const pages = options.pages ?? "all";
+      if (pages !== "all" && !/^\d+(-\d+)?$/.test(pages)) {
+        throw new HwpCliError("bad_request", `invalid page range: ${pages}`);
+      }
+      return withWorkDir(async (dir) => {
+        const input = await stage(dir, document);
+        const attempt = async (format) => {
+          const outBase = import_node_path.default.join(dir, `page.${format}`);
+          const reportPath = import_node_path.default.join(dir, "render-report.json");
+          await runCliOk(bin, [
+            "render",
+            input,
+            "-o",
+            outBase,
+            "--format",
+            format,
+            "--pages",
+            pages,
+            "--dpi",
+            String(dpi),
+            "--report",
+            reportPath
+          ], timeoutMs, opts.locale, call?.signal);
+          const filePattern = new RegExp(`^page-(\\d+)\\.${format}$`);
+          const files = (await (0, import_promises.readdir)(dir)).filter((f) => f === `page.${format}` || filePattern.test(f)).sort((a, b) => {
+            const na = Number(filePattern.exec(a)?.[1] ?? 0);
+            const nb = Number(filePattern.exec(b)?.[1] ?? 0);
+            return na - nb;
+          });
+          let selected = null;
+          try {
+            const report = JSON.parse(await (0, import_promises.readFile)(reportPath, "utf8"));
+            if (Array.isArray(report.selected_pages)) {
+              selected = report.selected_pages.filter((n) => typeof n === "number");
+            }
+          } catch {
+            selected = null;
+          }
+          const images = [];
+          for (let i = 0; i < files.length; i++) {
+            const file = files[i];
+            const data = new Uint8Array(await (0, import_promises.readFile)(import_node_path.default.join(dir, file)));
+            const suffix = file.match(/^page-(\d+)\./);
+            const page = suffix !== null ? Number(suffix[1]) : selected?.[i] ?? parseSinglePage(options.pages) ?? i + 1;
+            const size = format === "png" ? pngSize(data) : svgSize(Buffer.from(data).toString("utf8"));
+            if (size === null) {
+              throw new HwpCliError(
+                "failed",
+                `unreadable ${format} page dimensions on page ${page}`,
+                void 0,
+                detailFor(bin, file)
+              );
+            }
+            images.push({
+              page,
+              width: size.width,
+              height: size.height,
+              dpi,
+              format,
+              data
+            });
+          }
+          return images;
+        };
+        try {
+          return await attempt(requested);
+        } catch (error2) {
+          if (requested === "svg" && error2 instanceof HwpCliError && error2.reason === "failed") {
+            return attempt("png");
+          }
+          throw error2;
+        }
+      });
+    },
+    async edit(document, ops, options = {}, call) {
+      await ensureVersion();
+      const bin = resolveBin();
+      if (!Array.isArray(ops)) {
+        throw new HwpCliError("bad_request", "ops must be an array of edit operations");
+      }
+      const ext = sniffExtension(document);
+      const edited = await withWorkDir(async (dir) => {
+        const input = await stage(dir, document);
+        const cached = inspections.get(cacheKey(call?.scope, document.data))?.capabilities;
+        const capabilities = cached ?? documentEditability(await tryJson(bin, ["info", input, "--json"], timeoutMs, opts.locale, call?.signal));
+        if (!capabilities.editable) {
+          throw new HwpCliError(
+            "protected",
+            capabilities.reason ?? "protected document; hwp-cli refuses edit/compose"
+          );
+        }
+        const output = import_node_path.default.join(dir, `out${ext}`);
+        const args = ["edit", input, "-o", output, ...(0, import_core.opsToArgv)(ops)];
+        if (options.verify !== false) args.push("--verify");
+        if (options.allowPartial === true) args.push("--allow-partial");
+        await runCliOk(bin, args, timeoutMs, opts.locale, call?.signal).catch(rethrowProtected);
+        return new Uint8Array(await (0, import_promises.readFile)(output));
+      });
+      snapshots.set(cacheKey(call?.scope, edited), { name: document.name, data: document.data });
+      if (snapshots.size > 256) {
+        const oldest = snapshots.keys().next().value;
+        if (oldest !== void 0) snapshots.delete(oldest);
+      }
+      return { name: document.name, data: edited };
+    },
+    undo(document, call) {
+      const key = cacheKey(call?.scope, document.data);
+      const snapshot = snapshots.get(key) ?? null;
+      if (snapshot !== null) snapshots.delete(key);
+      return snapshot;
+    },
+    async compose(spec, name, call) {
+      await ensureVersion();
+      const bin = resolveBin();
+      const outName = safeOutputName(name, ".hwpx");
+      return withWorkDir(async (dir) => {
+        const specPath = import_node_path.default.join(dir, "spec.json");
+        await (0, import_promises.writeFile)(specPath, JSON.stringify(spec), { mode: 384 });
+        const outPath = import_node_path.default.join(dir, outName);
+        const result = await runCliOk(
+          bin,
+          ["compose", specPath, "-o", outPath, "--report"],
+          timeoutMs,
+          opts.locale,
+          call?.signal
+        ).catch(rethrowProtected);
+        let report;
+        try {
+          report = JSON.parse(result.stdout);
+        } catch {
+          report = void 0;
+        }
+        const data = new Uint8Array(await (0, import_promises.readFile)(outPath));
+        const composeResult = { document: { name: outName, data } };
+        if (report !== void 0) composeResult.report = report;
+        return composeResult;
+      });
+    },
+    async validate(document, call) {
+      await ensureVersion();
+      const bin = resolveBin();
+      return withWorkDir(async (dir) => {
+        const file = await stage(dir, document);
+        const result = await runCli(bin, ["validate", file, "--json"], timeoutMs, opts.locale, call?.signal);
+        let parsed;
+        try {
+          parsed = JSON.parse(result.stdout);
+        } catch {
+          throw new HwpCliError(
+            "failed",
+            `hwp validate failed (exit ${result.code}): no JSON report`,
+            result.stderr,
+            detailFor(bin, result.stderr.trim() || result.stdout.trim())
+          );
+        }
+        const rawErrors = Array.isArray(parsed.errors) ? parsed.errors : [];
+        const errors = rawErrors.map(
+          (entry) => typeof entry === "string" ? { code: "invalid", message: entry } : { code: "invalid", message: JSON.stringify(entry) }
+        );
+        const report = { valid: parsed.valid === true, errors };
+        return report;
+      });
+    },
+    async capabilities() {
+      const version = await ensureVersion();
+      return { version, editable: true, formats: ["hwp", "hwpx"] };
+    },
+    async binaryInfo() {
+      return { bin: resolveBin(), version: await ensureVersion() };
+    }
+  };
+  return engine;
+}
+
+// src/session.ts
+var import_node_crypto2 = require("crypto");
+var DEFAULT_TTL_MS = 30 * 60 * 1e3;
+var SESSION_ID_PATTERN = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/;
+var SessionNotFoundError = class extends Error {
+  constructor(id) {
+    super(`unknown or expired session: ${id}`);
+    this.name = "SessionNotFoundError";
+  }
+};
+function createSessionStore(opts = {}) {
+  const ttlMs = opts.ttlMs ?? DEFAULT_TTL_MS;
+  const sessions = /* @__PURE__ */ new Map();
+  function lookup(id) {
+    if (!SESSION_ID_PATTERN.test(id)) throw new SessionNotFoundError(id);
+    const session = sessions.get(id);
+    if (session === void 0) throw new SessionNotFoundError(id);
+    session.touchedAt = Date.now();
+    return session;
+  }
+  function sweepExpired(now = Date.now()) {
+    let removed = 0;
+    for (const [id, session] of [...sessions]) {
+      if (session.touchedAt + ttlMs < now) {
+        sessions.delete(id);
+        removed++;
+      }
+    }
+    return removed;
+  }
+  return {
+    create(name) {
+      sweepExpired();
+      const id = (0, import_node_crypto2.randomUUID)();
+      const now = Date.now();
+      const session = {
+        id,
+        // Basename only: the name rides out in nothing but this record, but a
+        // client-supplied string with a path in it should not be kept as one.
+        name: name.split(/[/\\]/).pop() || "document.hwpx",
+        createdAt: now,
+        touchedAt: now
+      };
+      sessions.set(id, session);
+      return session;
+    },
+    get(id) {
+      return lookup(id);
+    },
+    has(id) {
+      return sessions.has(id);
+    },
+    attachInspection(id, inspection) {
+      lookup(id).inspection = inspection;
+    },
+    sweep(now = Date.now()) {
+      return sweepExpired(now);
+    },
+    dispose() {
+      sessions.clear();
+    },
+    size() {
+      return sessions.size;
+    },
+    ids() {
+      return [...sessions.keys()];
+    }
+  };
+}
+
+// src/routes.ts
+var import_node_crypto3 = require("crypto");
+var ACTION_LIST = ["read", "render", "edit", "compose", "validate", "capabilities"];
+var DEFAULT_SCOPE = "default";
+var DEFAULT_MAX_REQUEST_BYTES = 50 * 1024 * 1024;
+var ACTIONS = new Set(ACTION_LIST);
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json; charset=utf-8" }
+  });
+}
+function error(status, code, message) {
+  const body = { error: { code, message } };
+  return json(body, status);
+}
+function statusFor(err) {
+  switch (err.reason) {
+    case "bad_request":
+    case "unsupported_format":
+      return 400;
+    case "unavailable":
+      return 503;
+    case "timeout":
+      return 504;
+    case "version":
+      return 500;
+    // The client went away; nothing was produced and nobody is listening.
+    case "cancelled":
+      return 499;
+    // The document's CLI output exceeded the 32 MiB stdout ceiling.
+    case "output_too_large":
+      return 413;
+    case "failed":
+    // 403 is deliberately left unclaimed for Phase 4's `authorize`
+    // rejections, so a host can tell an auth refusal from a document
+    // refusal by status alone.
+    case "protected":
+      return 422;
+  }
+}
+function toBase64(data) {
+  return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("base64");
+}
+function sha2562(data) {
+  return (0, import_node_crypto3.createHash)("sha256").update(data).digest("hex");
+}
+function sha256Text(text) {
+  return (0, import_node_crypto3.createHash)("sha256").update(text).digest("hex");
+}
+var CFBF_SIGNATURE2 = [208, 207, 17, 224, 161, 177, 26, 225];
+var HWPX_MIMETYPE = "application/hwp+zip";
+function sniffFormat(d) {
+  if (d.length >= CFBF_SIGNATURE2.length && CFBF_SIGNATURE2.every((b, i) => d[i] === b)) {
+    return ".hwp";
+  }
+  if (d.length < 38) return null;
+  if (!(d[0] === 80 && d[1] === 75 && d[2] === 3 && d[3] === 4)) return null;
+  const view = new DataView(d.buffer, d.byteOffset, d.byteLength);
+  if (view.getUint16(8, true) !== 0) return null;
+  const nameLen = view.getUint16(26, true);
+  const extraLen = view.getUint16(28, true);
+  if (nameLen !== 8) return null;
+  if (new TextDecoder().decode(d.subarray(30, 38)) !== "mimetype") return null;
+  const start = 30 + nameLen + extraLen;
+  const end = start + HWPX_MIMETYPE.length;
+  if (d.length < end) return null;
+  return new TextDecoder().decode(d.subarray(start, end)) === HWPX_MIMETYPE ? ".hwpx" : null;
+}
+async function formDocument(req) {
+  let form;
+  try {
+    form = await req.formData();
+  } catch {
+    throw new HwpCliError("bad_request", "expected multipart/form-data with a file field");
+  }
+  const file = form.get("file");
+  if (file === null || typeof file === "string") {
+    throw new HwpCliError("bad_request", 'multipart field "file" is required');
+  }
+  const blob = file;
+  const name = "name" in blob && typeof blob.name === "string" && blob.name !== "" ? blob.name : "document.hwpx";
+  const data = new Uint8Array(await blob.arrayBuffer());
+  if (data.length === 0) {
+    throw new HwpCliError("bad_request", 'multipart field "file" is empty');
+  }
+  if (sniffFormat(data) === null) {
+    throw new HwpCliError("bad_request", "file is not an HWP or HWPX document");
+  }
+  return { form, document: { name, data } };
+}
+function formString(form, key) {
+  const value = form.get(key);
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function formFlag(form, key) {
+  const value = form.get(key);
+  if (value === null) return void 0;
+  return value === "true" || value === "1";
+}
+function createHwpEditorHandler(opts = {}) {
+  const engine = opts.engine ?? createCliEngine({
+    ...opts.bin === void 0 ? {} : { bin: opts.bin },
+    ...opts.timeoutMs === void 0 ? {} : { timeoutMs: opts.timeoutMs },
+    ...opts.locale === void 0 ? {} : { locale: opts.locale }
+  });
+  const cli = "describe" in engine ? engine : null;
+  const maxRequestBytes = opts.maxRequestBytes ?? DEFAULT_MAX_REQUEST_BYTES;
+  const sessions = opts.sessions === false ? null : opts.sessions ?? createSessionStore();
+  function sessionFor(document, scope) {
+    if (sessions === null) return null;
+    const key = sha256Text(`${scope}\0${sha2562(document.data)}`);
+    const existing = hashToSession.get(key);
+    if (existing !== void 0 && sessions.has(existing)) return existing;
+    const session = sessions.create(document.name);
+    hashToSession.set(key, session.id);
+    return session.id;
+  }
+  const hashToSession = /* @__PURE__ */ new Map();
+  async function handleRead(req, scope) {
+    const { document } = await formDocument(req);
+    if (sessions !== null && cli !== null) {
+      const inspection = await cli.describe(document, { signal: req.signal, scope });
+      const id = sessionFor(document, scope);
+      if (id !== null) sessions.attachInspection(id, inspection);
+      return json(inspection.envelope);
+    }
+    return json(
+      cli !== null ? await cli.read(document, { signal: req.signal, scope }) : await engine.read(document)
+    );
+  }
+  async function handleRender(req, scope) {
+    const { form, document } = await formDocument(req);
+    const dpiField = formString(form, "dpi");
+    const dpi = dpiField === void 0 ? void 0 : Number(dpiField);
+    if (dpi !== void 0 && !Number.isFinite(dpi)) {
+      throw new HwpCliError("bad_request", `dpi must be a number; got "${dpiField}"`);
+    }
+    const format = formString(form, "format");
+    const options = {};
+    const pagesField = formString(form, "pages");
+    if (pagesField !== void 0) options.pages = pagesField;
+    if (dpi !== void 0) options.dpi = dpi;
+    if (format !== void 0) options.format = format;
+    const pages = cli !== null ? await cli.render(document, options, { signal: req.signal, scope }) : await engine.render(document, options);
+    const body = {
+      pages: pages.map(
+        (p) => ({
+          page: p.page,
+          width: p.width,
+          height: p.height,
+          dpi: p.dpi,
+          format: p.format,
+          dataBase64: toBase64(p.data)
+        })
+      )
+    };
+    return json(body);
+  }
+  async function handleEdit(req, scope) {
+    const { form, document } = await formDocument(req);
+    const opsField = form.get("ops");
+    if (typeof opsField !== "string" || opsField === "") {
+      throw new HwpCliError("bad_request", 'multipart field "ops" (EditOp[] JSON) is required');
+    }
+    let ops;
+    try {
+      const parsed = JSON.parse(opsField);
+      if (!Array.isArray(parsed)) throw new Error("not an array");
+      ops = parsed;
+    } catch {
+      throw new HwpCliError("bad_request", 'multipart field "ops" is not a JSON array');
+    }
+    if (ops.some((op) => op?.kind === "insert-image" || op?.kind === "seal")) {
+      return error(
+        400,
+        "path_traversal",
+        'ops "insert-image" and "seal" name a server-local path and are not accepted over HTTP; upload the asset with the request instead'
+      );
+    }
+    const options = {};
+    const verify = formFlag(form, "verify");
+    if (verify !== void 0) options.verify = verify;
+    const allowPartial = formFlag(form, "allowPartial");
+    if (allowPartial !== void 0) options.allowPartial = allowPartial;
+    const edited = cli !== null ? await cli.edit(document, ops, options, { signal: req.signal, scope }) : await engine.edit(document, ops, options);
+    const body = { name: edited.name, dataBase64: toBase64(edited.data) };
+    return json(body);
+  }
+  async function handleCompose(req, scope) {
+    let body;
+    try {
+      body = await req.json();
+    } catch {
+      throw new HwpCliError("bad_request", "expected a JSON ComposeRequest body");
+    }
+    if (typeof body !== "object" || body === null || typeof body.spec !== "object" || body.spec === null) {
+      throw new HwpCliError("bad_request", 'ComposeRequest requires a "spec" object');
+    }
+    if (typeof body.name !== "string" || body.name === "") {
+      throw new HwpCliError("bad_request", 'ComposeRequest requires a non-empty "name"');
+    }
+    const result = cli !== null ? await cli.compose(body.spec, body.name, { signal: req.signal, scope }) : await engine.compose(body.spec, body.name);
+    const responseBody = {
+      name: result.document.name,
+      dataBase64: toBase64(result.document.data)
+    };
+    if (result.report !== void 0) responseBody.report = result.report;
+    return json(responseBody);
+  }
+  async function handleValidate(req, scope) {
+    const { document } = await formDocument(req);
+    return json(
+      cli !== null ? await cli.validate(document, { signal: req.signal, scope }) : await engine.validate(document)
+    );
+  }
+  async function handleCapabilities() {
+    return json(await engine.capabilities());
+  }
+  return async function handler(req) {
+    const url = new URL(req.url);
+    const segments = url.pathname.split("/").filter(Boolean);
+    const action = segments[segments.length - 1] ?? "";
+    try {
+      if (!ACTIONS.has(action)) {
+        return error(404, "not_found", `unknown action: ${action || "(empty)"}`);
+      }
+      if (action === "capabilities") {
+        if (req.method !== "GET") return error(405, "method_not_allowed", "capabilities requires GET");
+      } else if (req.method !== "POST") {
+        return error(405, "method_not_allowed", `${action} requires POST`);
+      }
+      const scope = opts.authorize === void 0 ? DEFAULT_SCOPE : await opts.authorize(req, action);
+      if (scope === null) return error(403, "forbidden", "forbidden");
+      if (action === "capabilities") {
+        return await handleCapabilities();
+      }
+      const declared = req.headers.get("content-length");
+      if (declared === null) {
+        return error(400, "bad_request", "content-length is required");
+      }
+      const bytes = /^\d+$/.test(declared) ? Number(declared) : NaN;
+      if (!Number.isSafeInteger(bytes)) {
+        return error(400, "bad_request", "invalid content-length");
+      }
+      if (bytes > maxRequestBytes) {
+        return error(413, "bad_request", `request exceeds the ${maxRequestBytes} byte limit`);
+      }
+      switch (action) {
+        case "read":
+          return await handleRead(req, scope);
+        case "render":
+          return await handleRender(req, scope);
+        case "edit":
+          return await handleEdit(req, scope);
+        case "compose":
+          return await handleCompose(req, scope);
+        case "validate":
+          return await handleValidate(req, scope);
+        default:
+          return error(404, "not_found", `unknown action: ${action}`);
+      }
+    } catch (err) {
+      if (err instanceof HwpCliError) {
+        return error(statusFor(err), err.reason, err.message);
+      }
+      if (err instanceof SessionNotFoundError) {
+        return error(404, "session_not_found", err.message);
+      }
+      return error(500, "internal", "internal error");
+    }
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_TTL_MS,
+  HWP_TIMEOUT_MS,
+  HwpCliError,
+  SessionNotFoundError,
+  createCliEngine,
+  createHwpEditorHandler,
+  createSessionStore
+});
+//# sourceMappingURL=index.cjs.map