@akairos/typeset-studio 0.2.1 → 0.2.3

package/dist/lib/index-t9w3p2p9.js

@@ -0,0 +1,3366 @@
+import {
+  computeStageDimensions,
+  getCanvasSpec,
+  renderPageToPng,
+  renderTypesetResultToPngs,
+  resolveDataDir
+} from "./index-zdhqg5f0.js";
+import {
+  buildLineTextFromRange,
+  getLineTextCache,
+  measureNaturalWidth,
+  prepareWithSegments,
+  stepPreparedLineGeometry
+} from "./index-6c43c7h4.js";
+import {
+  __require
+} from "./index-37x76zdn.js";
+
+// node_modules/hono/dist/request/constants.js
+var GET_MATCH_RESULT = Symbol();
+
+// node_modules/hono/dist/utils/buffer.js
+var bufferToFormData = (arrayBuffer, contentType) => {
+  return new Response(arrayBuffer, { headers: { "Content-Type": contentType.replace(/^[^;]+/, (mediaType) => mediaType.toLowerCase()) } }).formData();
+};
+
+// node_modules/hono/dist/utils/body.js
+var MAX_NESTED_OBJECTS = 1e4;
+var isRawRequest = (request) => ("headers" in request);
+var parseBody = async (request, options = Object.create(null)) => {
+  const { all = false, dot = false } = options;
+  const mediaType = (isRawRequest(request) ? request.headers : request.raw.headers).get("Content-Type")?.split(";")[0].trim().toLowerCase();
+  if (mediaType === "multipart/form-data" || mediaType === "application/x-www-form-urlencoded")
+    return parseFormData(request, {
+      all,
+      dot
+    });
+  return {};
+};
+async function parseFormData(request, options) {
+  if (!isRawRequest(request) && request.bodyCache.formData)
+    return convertFormDataToBodyData(await request.bodyCache.formData, options);
+  const headers = isRawRequest(request) ? request.headers : request.raw.headers;
+  const arrayBuffer = await request.arrayBuffer();
+  const formDataPromise = bufferToFormData(arrayBuffer, headers.get("Content-Type") || "");
+  if (!isRawRequest(request))
+    request.bodyCache.formData = formDataPromise;
+  const formData = await formDataPromise;
+  if (formData)
+    return convertFormDataToBodyData(formData, options);
+  return {};
+}
+function convertFormDataToBodyData(formData, options) {
+  const form = Object.create(null);
+  const nestingState = { count: 0 };
+  formData.forEach((value, key) => {
+    if (!(options.all || key.endsWith("[]")))
+      form[key] = value;
+    else
+      handleParsingAllValues(form, key, value);
+  });
+  if (options.dot)
+    Object.entries(form).forEach(([key, value]) => {
+      if (key.includes(".")) {
+        handleParsingNestedValues(form, key, value, nestingState);
+        delete form[key];
+      }
+    });
+  return form;
+}
+var handleParsingAllValues = (form, key, value) => {
+  if (form[key] !== undefined) {
+    if (Array.isArray(form[key]))
+      form[key].push(value);
+    else
+      form[key] = [form[key], value];
+  } else if (!key.endsWith("[]"))
+    form[key] = value;
+  else
+    form[key] = [value];
+};
+var handleParsingNestedValues = (form, key, value, state) => {
+  if (/(?:^|\.)__proto__\./.test(key))
+    return;
+  let nestedForm = form;
+  const keys = key.split(".", 34);
+  if (keys.length > 33)
+    throwNestingLimitExceeded();
+  keys.forEach((key2, index) => {
+    if (index === keys.length - 1)
+      nestedForm[key2] = value;
+    else {
+      if (!nestedForm[key2] || typeof nestedForm[key2] !== "object" || Array.isArray(nestedForm[key2]) || nestedForm[key2] instanceof File) {
+        if (state.count++ >= MAX_NESTED_OBJECTS)
+          throwNestingLimitExceeded();
+        nestedForm[key2] = Object.create(null);
+      }
+      nestedForm = nestedForm[key2];
+    }
+  });
+};
+var throwNestingLimitExceeded = () => {
+  throw new Error("Nesting limit exceeded");
+};
+
+// node_modules/hono/dist/utils/url.js
+var splitPath = (path) => {
+  const paths = path.split("/");
+  if (paths[0] === "")
+    paths.shift();
+  return paths;
+};
+var splitRoutingPath = (routePath) => {
+  const { groups, path } = extractGroupsFromPath(routePath);
+  const paths = splitPath(path);
+  return replaceGroupMarks(paths, groups);
+};
+var extractGroupsFromPath = (path) => {
+  const groups = [];
+  path = path.replace(/\{[^}]+\}/g, (match, index) => {
+    const mark = `@${index}`;
+    groups.push([mark, match]);
+    return mark;
+  });
+  return {
+    groups,
+    path
+  };
+};
+var replaceGroupMarks = (paths, groups) => {
+  for (let i = groups.length - 1;i >= 0; i--) {
+    const [mark] = groups[i];
+    for (let j = paths.length - 1;j >= 0; j--)
+      if (paths[j].includes(mark)) {
+        paths[j] = paths[j].replace(mark, groups[i][1]);
+        break;
+      }
+  }
+  return paths;
+};
+var patternCache = {};
+var getPattern = (label, next) => {
+  if (label === "*")
+    return "*";
+  const match = label.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+  if (match) {
+    const cacheKey = `${label}#${next}`;
+    if (!patternCache[cacheKey]) {
+      if (match[2])
+        patternCache[cacheKey] = next && next[0] !== ":" && next[0] !== "*" ? [
+          cacheKey,
+          match[1],
+          new RegExp(`^${match[2]}(?=/${next})`)
+        ] : [
+          label,
+          match[1],
+          new RegExp(`^${match[2]}$`)
+        ];
+      else
+        patternCache[cacheKey] = [
+          label,
+          match[1],
+          true
+        ];
+    }
+    return patternCache[cacheKey];
+  }
+  return null;
+};
+var tryDecode = (str, decoder) => {
+  try {
+    return decoder(str);
+  } catch {
+    return str.replace(/(?:%[0-9A-Fa-f]{2})+/g, (match) => {
+      try {
+        return decoder(match);
+      } catch {
+        return match;
+      }
+    });
+  }
+};
+var tryDecodeURI = (str) => tryDecode(str, decodeURI);
+var getPath = (request) => {
+  const url = request.url;
+  const start = url.indexOf("/", url.indexOf(":") + 4);
+  let i = start;
+  for (;i < url.length; i++) {
+    const charCode = url.charCodeAt(i);
+    if (charCode === 37) {
+      const queryIndex = url.indexOf("?", i);
+      const hashIndex = url.indexOf("#", i);
+      const end = queryIndex === -1 ? hashIndex === -1 ? undefined : hashIndex : hashIndex === -1 ? queryIndex : Math.min(queryIndex, hashIndex);
+      const path = url.slice(start, end);
+      return tryDecodeURI(path.includes("%25") ? path.replace(/%25/g, "%2525") : path);
+    } else if (charCode === 63 || charCode === 35)
+      break;
+  }
+  return url.slice(start, i);
+};
+var getPathNoStrict = (request) => {
+  const result = getPath(request);
+  return result.length > 1 && result.at(-1) === "/" ? result.slice(0, -1) : result;
+};
+var mergePath = (base, sub, ...rest) => {
+  if (rest.length)
+    sub = mergePath(sub, ...rest);
+  return `${base?.[0] === "/" ? "" : "/"}${base}${sub === "/" ? "" : `${base?.at(-1) === "/" ? "" : "/"}${sub?.[0] === "/" ? sub.slice(1) : sub}`}`;
+};
+var checkOptionalParameter = (path) => {
+  if (path.charCodeAt(path.length - 1) !== 63 || !path.includes(":"))
+    return null;
+  const segments = path.split("/");
+  const results = [];
+  let basePath = "";
+  segments.forEach((segment) => {
+    if (segment !== "" && !/\:/.test(segment))
+      basePath += "/" + segment;
+    else if (/\:/.test(segment)) {
+      if (segment.charCodeAt(segment.length - 1) === 63) {
+        if (results.length === 0 && basePath === "")
+          results.push("/");
+        else
+          results.push(basePath);
+        const optionalSegment = segment.slice(0, -1);
+        basePath += "/" + optionalSegment;
+        results.push(basePath);
+      } else
+        basePath += "/" + segment;
+    }
+  });
+  return results.filter((v, i, a) => a.indexOf(v) === i);
+};
+var tryDecodeURIComponent = (str) => str.indexOf("%") !== -1 ? tryDecode(str, decodeURIComponent_) : str;
+var _decodeURI = (value) => {
+  if (value.indexOf("+") !== -1)
+    value = value.replace(/\+/g, " ");
+  return tryDecodeURIComponent(value);
+};
+var _getQueryParam = (url, key, multiple) => {
+  const hashIndex = url.indexOf("#", 8);
+  if (hashIndex !== -1)
+    url = url.slice(0, hashIndex);
+  let encoded;
+  if (!multiple && key && key.indexOf("%") === -1 && key.indexOf("+") === -1) {
+    let keyIndex2 = url.indexOf("?", 8);
+    if (keyIndex2 === -1)
+      return;
+    if (!url.startsWith(key, keyIndex2 + 1))
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    while (keyIndex2 !== -1) {
+      const trailingKeyCode = url.charCodeAt(keyIndex2 + key.length + 1);
+      if (trailingKeyCode === 61) {
+        const valueIndex = keyIndex2 + key.length + 2;
+        const endIndex = url.indexOf("&", valueIndex);
+        return _decodeURI(url.slice(valueIndex, endIndex === -1 ? undefined : endIndex));
+      } else if (trailingKeyCode == 38 || isNaN(trailingKeyCode))
+        return "";
+      keyIndex2 = url.indexOf(`&${key}`, keyIndex2 + 1);
+    }
+    encoded = /[%+]/.test(url);
+    if (!encoded)
+      return;
+  }
+  const results = Object.create(null);
+  encoded ??= /[%+]/.test(url);
+  let keyIndex = url.indexOf("?", 8);
+  while (keyIndex !== -1) {
+    const nextKeyIndex = url.indexOf("&", keyIndex + 1);
+    let valueIndex = url.indexOf("=", keyIndex);
+    if (valueIndex > nextKeyIndex && nextKeyIndex !== -1)
+      valueIndex = -1;
+    let name = url.slice(keyIndex + 1, valueIndex === -1 ? nextKeyIndex === -1 ? undefined : nextKeyIndex : valueIndex);
+    if (encoded)
+      name = _decodeURI(name);
+    keyIndex = nextKeyIndex;
+    if (name === "")
+      continue;
+    let value;
+    if (valueIndex === -1)
+      value = "";
+    else {
+      value = url.slice(valueIndex + 1, nextKeyIndex === -1 ? undefined : nextKeyIndex);
+      if (encoded)
+        value = _decodeURI(value);
+    }
+    if (multiple) {
+      if (!(results[name] && Array.isArray(results[name])))
+        results[name] = [];
+      results[name].push(value);
+    } else
+      results[name] ??= value;
+  }
+  return key ? results[key] : results;
+};
+var getQueryParam = _getQueryParam;
+var getQueryParams = (url, key) => {
+  return _getQueryParam(url, key, true);
+};
+var decodeURIComponent_ = decodeURIComponent;
+
+// node_modules/hono/dist/request.js
+var HonoRequest = class {
+  raw;
+  #validatedData;
+  #matchResult;
+  routeIndex = 0;
+  path;
+  bodyCache = {};
+  constructor(request, path = "/", matchResult = [[]]) {
+    this.raw = request;
+    this.path = path;
+    this.#matchResult = matchResult;
+  }
+  param(key) {
+    return key ? this.#getDecodedParam(key) : this.#getAllDecodedParams();
+  }
+  #getDecodedParam(key) {
+    const paramKey = this.#matchResult[0][this.routeIndex]?.[1][key];
+    const param = this.#getParamValue(paramKey);
+    return param && tryDecodeURIComponent(param);
+  }
+  #getAllDecodedParams() {
+    const decoded = {};
+    const keys = Object.keys(this.#matchResult[0][this.routeIndex]?.[1] ?? {});
+    for (const key of keys) {
+      const value = this.#getParamValue(this.#matchResult[0][this.routeIndex][1][key]);
+      if (value !== undefined)
+        decoded[key] = tryDecodeURIComponent(value);
+    }
+    return decoded;
+  }
+  #getParamValue(paramKey) {
+    return this.#matchResult[1] ? this.#matchResult[1][paramKey] : paramKey;
+  }
+  query(key) {
+    return getQueryParam(this.url, key);
+  }
+  queries(key) {
+    return getQueryParams(this.url, key);
+  }
+  header(name) {
+    if (name)
+      return this.raw.headers.get(name) ?? undefined;
+    const headerData = Object.create(null);
+    this.raw.headers.forEach((value, key) => {
+      headerData[key] = value;
+    });
+    return headerData;
+  }
+  async parseBody(options) {
+    return parseBody(this, options);
+  }
+  #cachedBody = (key) => {
+    const { bodyCache, raw } = this;
+    const cachedBody = bodyCache[key];
+    if (cachedBody)
+      return cachedBody;
+    for (const anyCachedKey in bodyCache)
+      return bodyCache[anyCachedKey].then((body) => {
+        if (anyCachedKey === "json")
+          body = JSON.stringify(body);
+        const contentType = anyCachedKey === "formData" ? undefined : raw.headers.get("content-type");
+        return new Response(body, { headers: contentType ? { "Content-Type": contentType } : undefined })[key]();
+      });
+    return bodyCache[key] = raw[key]();
+  };
+  json() {
+    return this.#cachedBody("text").then((text) => JSON.parse(text));
+  }
+  text() {
+    return this.#cachedBody("text");
+  }
+  arrayBuffer() {
+    return this.#cachedBody("arrayBuffer");
+  }
+  bytes() {
+    return this.#cachedBody("arrayBuffer").then((buffer) => new Uint8Array(buffer));
+  }
+  blob() {
+    return this.#cachedBody("blob");
+  }
+  formData() {
+    return this.#cachedBody("formData");
+  }
+  addValidatedData(target, data) {
+    (this.#validatedData ??= {})[target] = data;
+  }
+  valid(target) {
+    return this.#validatedData?.[target];
+  }
+  get url() {
+    return this.raw.url;
+  }
+  get method() {
+    return this.raw.method;
+  }
+  get [GET_MATCH_RESULT]() {
+    return this.#matchResult;
+  }
+  get matchedRoutes() {
+    return this.#matchResult[0].map(([[, route]]) => route);
+  }
+  get routePath() {
+    return this.#matchResult[0].map(([[, route]]) => route)[this.routeIndex].path;
+  }
+};
+
+// node_modules/hono/dist/utils/html.js
+var HtmlEscapedCallbackPhase = {
+  Stringify: 1,
+  BeforeStream: 2,
+  Stream: 3
+};
+var raw = (value, callbacks) => {
+  const escapedString = new String(value);
+  escapedString.isEscaped = true;
+  escapedString.callbacks = callbacks;
+  return escapedString;
+};
+var resolveCallback = async (str, phase, preserveCallbacks, context, buffer) => {
+  if (typeof str === "object" && !(str instanceof String)) {
+    if (!(str instanceof Promise))
+      str = str.toString();
+    if (str instanceof Promise)
+      str = await str;
+  }
+  const callbacks = str.callbacks;
+  if (!callbacks?.length)
+    return Promise.resolve(str);
+  if (buffer)
+    buffer[0] += str;
+  else
+    buffer = [str];
+  const resStr = Promise.all(callbacks.map((c) => c({
+    phase,
+    buffer,
+    context
+  }))).then((res) => Promise.all(res.filter(Boolean).map((str2) => resolveCallback(str2, phase, false, context, buffer))).then(() => buffer[0]));
+  if (preserveCallbacks)
+    return raw(await resStr, callbacks);
+  else
+    return resStr;
+};
+
+// node_modules/hono/dist/context.js
+var TEXT_PLAIN = "text/plain; charset=UTF-8";
+var setDefaultContentType = (contentType, headers) => {
+  return {
+    "Content-Type": contentType,
+    ...headers
+  };
+};
+var createResponseInstance = (body, init) => new Response(body, init);
+var Context = class {
+  #rawRequest;
+  #req;
+  env = {};
+  #var;
+  finalized = false;
+  error;
+  #status;
+  #executionCtx;
+  #res;
+  #layout;
+  #renderer;
+  #notFoundHandler;
+  #preparedHeaders;
+  #matchResult;
+  #path;
+  constructor(req, options) {
+    this.#rawRequest = req;
+    if (options) {
+      this.#executionCtx = options.executionCtx;
+      this.env = options.env;
+      this.#notFoundHandler = options.notFoundHandler;
+      this.#path = options.path;
+      this.#matchResult = options.matchResult;
+    }
+  }
+  get req() {
+    this.#req ??= new HonoRequest(this.#rawRequest, this.#path, this.#matchResult);
+    return this.#req;
+  }
+  get event() {
+    if (this.#executionCtx && "respondWith" in this.#executionCtx)
+      return this.#executionCtx;
+    else
+      throw Error("This context has no FetchEvent");
+  }
+  get executionCtx() {
+    if (this.#executionCtx)
+      return this.#executionCtx;
+    else
+      throw Error("This context has no ExecutionContext");
+  }
+  get res() {
+    return this.#res ||= createResponseInstance(null, { headers: this.#preparedHeaders ??= new Headers });
+  }
+  set res(_res) {
+    if (this.#res && _res) {
+      _res = createResponseInstance(_res.body, _res);
+      for (const [k, v] of this.#res.headers.entries()) {
+        if (k === "content-type")
+          continue;
+        if (k === "set-cookie") {
+          const cookies = this.#res.headers.getSetCookie();
+          _res.headers.delete("set-cookie");
+          for (const cookie of cookies)
+            _res.headers.append("set-cookie", cookie);
+        } else
+          _res.headers.set(k, v);
+      }
+    }
+    this.#res = _res;
+    this.finalized = true;
+  }
+  render = (...args) => {
+    this.#renderer ??= (content) => this.html(content);
+    return this.#renderer(...args);
+  };
+  setLayout = (layout) => this.#layout = layout;
+  getLayout = () => this.#layout;
+  setRenderer = (renderer) => {
+    this.#renderer = renderer;
+  };
+  header = (name, value, options) => {
+    if (this.finalized)
+      this.#res = createResponseInstance(this.#res.body, this.#res);
+    const headers = this.#res ? this.#res.headers : this.#preparedHeaders ??= new Headers;
+    if (value === undefined)
+      headers.delete(name);
+    else if (options?.append)
+      headers.append(name, value);
+    else
+      headers.set(name, value);
+  };
+  status = (status) => {
+    this.#status = status;
+  };
+  set = (key, value) => {
+    this.#var ??= /* @__PURE__ */ new Map;
+    this.#var.set(key, value);
+  };
+  get = (key) => {
+    return this.#var ? this.#var.get(key) : undefined;
+  };
+  get var() {
+    if (!this.#var)
+      return {};
+    return Object.fromEntries(this.#var);
+  }
+  #newResponse(data, arg, headers) {
+    let responseHeaders = this.#res ? new Headers(this.#res.headers) : this.#preparedHeaders;
+    if (typeof arg === "object" && arg.headers) {
+      responseHeaders ??= new Headers;
+      for (const [key, value] of new Headers(arg.headers))
+        if (key === "set-cookie")
+          responseHeaders.append(key, value);
+        else
+          responseHeaders.set(key, value);
+    }
+    if (headers) {
+      if (!responseHeaders) {
+        let count = 0;
+        for (const k in headers)
+          if (++count > 1 || typeof headers[k] !== "string") {
+            responseHeaders = new Headers;
+            break;
+          }
+      }
+      if (responseHeaders)
+        for (const k in headers) {
+          const v = headers[k];
+          if (typeof v === "string")
+            responseHeaders.set(k, v);
+          else {
+            responseHeaders.delete(k);
+            for (const v2 of v)
+              responseHeaders.append(k, v2);
+          }
+        }
+    }
+    const status = typeof arg === "number" ? arg : arg?.status ?? this.#status;
+    return createResponseInstance(data, {
+      status,
+      headers: responseHeaders ?? headers
+    });
+  }
+  newResponse = (...args) => this.#newResponse(...args);
+  body = (data, arg, headers) => this.#newResponse(data, arg, headers);
+  text = (text, arg, headers) => {
+    return !this.#preparedHeaders && !this.#status && !arg && !headers && !this.finalized ? new Response(text) : this.#newResponse(text, arg, setDefaultContentType(TEXT_PLAIN, headers));
+  };
+  json = (object, arg, headers) => {
+    return this.#newResponse(JSON.stringify(object), arg, setDefaultContentType("application/json", headers));
+  };
+  html = (html, arg, headers) => {
+    const res = (html2) => this.#newResponse(html2, arg, setDefaultContentType("text/html; charset=UTF-8", headers));
+    return typeof html === "object" ? resolveCallback(html, HtmlEscapedCallbackPhase.Stringify, false, {}).then(res) : res(html);
+  };
+  redirect = (location, status) => {
+    const locationString = String(location);
+    this.header("Location", !/[^\x00-\xFF]/.test(locationString) ? locationString : encodeURI(locationString));
+    return this.newResponse(null, status ?? 302);
+  };
+  notFound = () => {
+    this.#notFoundHandler ??= () => createResponseInstance();
+    return this.#notFoundHandler(this);
+  };
+};
+
+// node_modules/hono/dist/compose.js
+var compose = (middleware, onError, onNotFound) => {
+  return (context, next) => {
+    let index = -1;
+    return dispatch(0);
+    async function dispatch(i) {
+      if (i <= index)
+        throw new Error("next() called multiple times");
+      index = i;
+      let res;
+      let isError = false;
+      let handler;
+      if (middleware[i]) {
+        handler = middleware[i][0][0];
+        context.req.routeIndex = i;
+      } else
+        handler = i === middleware.length && next || undefined;
+      if (handler)
+        try {
+          res = await handler(context, () => dispatch(i + 1));
+        } catch (err) {
+          if (err instanceof Error && onError) {
+            context.error = err;
+            res = await onError(err, context);
+            isError = true;
+          } else
+            throw err;
+        }
+      else if (context.finalized === false && onNotFound)
+        res = await onNotFound(context);
+      if (res && (context.finalized === false || isError))
+        context.res = res;
+      return context;
+    }
+  };
+};
+
+// node_modules/hono/dist/router.js
+var METHODS = [
+  "get",
+  "post",
+  "put",
+  "delete",
+  "options",
+  "patch",
+  "query"
+];
+var MESSAGE_MATCHER_IS_ALREADY_BUILT = "Can not add a route since the matcher is already built.";
+var UnsupportedPathError = class extends Error {
+};
+
+// node_modules/hono/dist/utils/constants.js
+var COMPOSED_HANDLER = "__COMPOSED_HANDLER";
+
+// node_modules/hono/dist/hono-base.js
+var notFoundHandler = (c) => {
+  return c.text("404 Not Found", 404);
+};
+var errorHandler = (err, c) => {
+  if ("getResponse" in err) {
+    const res = err.getResponse();
+    return c.newResponse(res.body, res);
+  }
+  console.error(err);
+  return c.text("Internal Server Error", 500);
+};
+var Hono = class Hono2 {
+  get;
+  post;
+  put;
+  delete;
+  options;
+  patch;
+  query;
+  all;
+  on;
+  use;
+  router;
+  getPath;
+  _basePath = "/";
+  #path = "/";
+  routes = [];
+  constructor(options = {}) {
+    [...METHODS, "all"].forEach((method) => {
+      this[method] = (args1, ...args) => {
+        const methodName = method.toUpperCase();
+        if (typeof args1 === "string")
+          this.#path = args1;
+        else
+          this.#addRoute(methodName, this.#path, args1);
+        args.forEach((handler) => {
+          this.#addRoute(methodName, this.#path, handler);
+        });
+        return this;
+      };
+    });
+    this.on = (method, path, ...handlers) => {
+      for (const p of [path].flat()) {
+        this.#path = p;
+        for (const m of [method].flat()) {
+          const methodName = m.toUpperCase();
+          for (const handler of handlers)
+            this.#addRoute(methodName, this.#path, handler);
+        }
+      }
+      return this;
+    };
+    this.use = (arg1, ...handlers) => {
+      if (typeof arg1 === "string")
+        this.#path = arg1;
+      else {
+        this.#path = "*";
+        handlers.unshift(arg1);
+      }
+      handlers.forEach((handler) => {
+        this.#addRoute("ALL", this.#path, handler);
+      });
+      return this;
+    };
+    const { strict, ...optionsWithoutStrict } = options;
+    Object.assign(this, optionsWithoutStrict);
+    this.getPath = strict ?? true ? options.getPath ?? getPath : getPathNoStrict;
+  }
+  #clone() {
+    const clone = new Hono2({
+      router: this.router,
+      getPath: this.getPath
+    });
+    clone.errorHandler = this.errorHandler;
+    clone.#notFoundHandler = this.#notFoundHandler;
+    clone.routes = this.routes;
+    return clone;
+  }
+  #notFoundHandler = notFoundHandler;
+  errorHandler = errorHandler;
+  route(path, app) {
+    const subApp = this.basePath(path);
+    app.routes.map((r) => {
+      let handler;
+      if (app.errorHandler === errorHandler)
+        handler = r.handler;
+      else {
+        handler = async (c, next) => (await compose([], app.errorHandler)(c, () => r.handler(c, next))).res;
+        handler[COMPOSED_HANDLER] = r.handler;
+      }
+      subApp.#addRoute(r.method, r.path, handler, r.basePath);
+    });
+    return this;
+  }
+  basePath(path) {
+    const subApp = this.#clone();
+    subApp._basePath = mergePath(this._basePath, path);
+    return subApp;
+  }
+  onError = (handler) => {
+    this.errorHandler = handler;
+    return this;
+  };
+  notFound = (handler) => {
+    this.#notFoundHandler = handler;
+    return this;
+  };
+  mount(path, applicationHandler, options) {
+    let replaceRequest;
+    let optionHandler;
+    if (options) {
+      if (typeof options === "function")
+        optionHandler = options;
+      else {
+        optionHandler = options.optionHandler;
+        if (options.replaceRequest === false)
+          replaceRequest = (request) => request;
+        else
+          replaceRequest = options.replaceRequest;
+      }
+    }
+    const getOptions = optionHandler ? (c) => {
+      const options2 = optionHandler(c);
+      return Array.isArray(options2) ? options2 : [options2];
+    } : (c) => {
+      let executionContext = undefined;
+      try {
+        executionContext = c.executionCtx;
+      } catch {}
+      return [c.env, executionContext];
+    };
+    replaceRequest ||= (() => {
+      const mergedPath = mergePath(this._basePath, path);
+      const pathPrefixLength = mergedPath === "/" ? 0 : mergedPath.length;
+      return (request) => {
+        const url = new URL(request.url);
+        url.pathname = this.getPath(request).slice(pathPrefixLength) || "/";
+        return new Request(url, request);
+      };
+    })();
+    const handler = async (c, next) => {
+      const res = await applicationHandler(replaceRequest(c.req.raw), ...getOptions(c));
+      if (res)
+        return res;
+      await next();
+    };
+    this.#addRoute("ALL", mergePath(path, "*"), handler);
+    return this;
+  }
+  #addRoute(method, path, handler, baseRoutePath) {
+    path = mergePath(this._basePath, path);
+    const r = {
+      basePath: baseRoutePath !== undefined ? mergePath(this._basePath, baseRoutePath) : this._basePath,
+      path,
+      method,
+      handler
+    };
+    this.router.add(method, path, [handler, r]);
+    this.routes.push(r);
+  }
+  #handleError(err, c) {
+    if (err instanceof Error)
+      return this.errorHandler(err, c);
+    throw err;
+  }
+  #dispatch(request, executionCtx, env, method) {
+    if (method === "HEAD")
+      return (async () => new Response(null, await this.#dispatch(request, executionCtx, env, "GET")))();
+    const path = this.getPath(request, { env });
+    const matchResult = this.router.match(method, path);
+    const c = new Context(request, {
+      path,
+      matchResult,
+      env,
+      executionCtx,
+      notFoundHandler: this.#notFoundHandler
+    });
+    if (matchResult[0].length === 1) {
+      let res;
+      try {
+        res = matchResult[0][0][0][0](c, async () => {
+          c.res = await this.#notFoundHandler(c);
+        });
+      } catch (err) {
+        return this.#handleError(err, c);
+      }
+      return res instanceof Promise ? res.then((resolved) => resolved || (c.finalized ? c.res : this.#notFoundHandler(c))).catch((err) => this.#handleError(err, c)) : res ?? this.#notFoundHandler(c);
+    }
+    const composed = compose(matchResult[0], this.errorHandler, this.#notFoundHandler);
+    return (async () => {
+      try {
+        const context = await composed(c);
+        if (!context.finalized)
+          throw new Error("Context is not finalized. Did you forget to return a Response object or `await next()`?");
+        return context.res;
+      } catch (err) {
+        return this.#handleError(err, c);
+      }
+    })();
+  }
+  fetch = (request, ...rest) => {
+    return this.#dispatch(request, rest[1], rest[0], request.method);
+  };
+  request = (input, requestInit, Env, executionCtx) => {
+    if (input instanceof Request)
+      return this.fetch(requestInit ? new Request(input, requestInit) : input, Env, executionCtx);
+    input = input.toString();
+    return this.fetch(new Request(/^https?:\/\//.test(input) ? input : `http://localhost${mergePath("/", input)}`, requestInit), Env, executionCtx);
+  };
+  fire = () => {
+    addEventListener("fetch", (event) => {
+      event.respondWith(this.#dispatch(event.request, event, undefined, event.request.method));
+    });
+  };
+};
+
+// node_modules/hono/dist/router/utils.js
+var createNullObject = () => Object.create(null);
+
+// node_modules/hono/dist/router/reg-exp-router/matcher.js
+var emptyParam = [];
+function match(method, path) {
+  const matchers = this.buildAllMatchers();
+  const match2 = (method2, path2) => {
+    const matcher = matchers[method2] || matchers["ALL"];
+    const staticMatch = matcher[2][path2];
+    if (staticMatch)
+      return staticMatch;
+    const match3 = path2.match(matcher[0]);
+    if (!match3)
+      return [[], emptyParam];
+    const index = match3.indexOf("", 1);
+    return [matcher[1][index], match3];
+  };
+  this.match = match2;
+  return match2(method, path);
+}
+
+// node_modules/hono/dist/router/reg-exp-router/node.js
+var LABEL_REG_EXP_STR = "[^/]+";
+var TAIL_WILDCARD_REG_EXP_STR = "(?:|/.*)";
+var PATH_ERROR = Symbol();
+var regExpMetaChars = /* @__PURE__ */ new Set(".\\+*[^]$()");
+function compareKey(a, b) {
+  if (a.length === 1)
+    return b.length === 1 ? a < b ? -1 : 1 : -1;
+  if (b.length === 1)
+    return 1;
+  if (a === ".*" || a === "(?:|/.*)")
+    return b === "(?:|/.*)" ? -1 : 1;
+  else if (b === ".*" || b === "(?:|/.*)")
+    return -1;
+  if (a === "[^/]+")
+    return 1;
+  else if (b === "[^/]+")
+    return -1;
+  return a.length === b.length ? a < b ? -1 : 1 : b.length - a.length;
+}
+var Node = class Node2 {
+  #index;
+  #varIndex;
+  #children = createNullObject();
+  insert(tokens, index, paramMap, context, isStatic) {
+    let node = this;
+    for (let i = 0, len = tokens.length;i < len; i++) {
+      const token = tokens[i];
+      const pattern = token.length === 1 ? token === "*" ? i === len - 1 ? [
+        "",
+        "",
+        ".*"
+      ] : [
+        "",
+        "",
+        LABEL_REG_EXP_STR
+      ] : null : token === "/*" ? [
+        "",
+        "",
+        TAIL_WILDCARD_REG_EXP_STR
+      ] : token.match(/^\:([^\{\}]+)(?:\{(.+)\})?$/);
+      let nextNode;
+      if (pattern) {
+        const name = pattern[1];
+        let regexpStr = pattern[2] || "[^/]+";
+        if (name && pattern[2]) {
+          if (regexpStr === ".*")
+            throw PATH_ERROR;
+          regexpStr = regexpStr.replace(/^\((?!\?:)(?=[^)]+\)$)/, "(?:");
+          if (/\((?!\?:)/.test(regexpStr))
+            throw PATH_ERROR;
+          if (regexpStr.length === 1 && regExpMetaChars.has(regexpStr))
+            throw PATH_ERROR;
+        }
+        nextNode = node.#children[regexpStr];
+        if (!nextNode) {
+          if (regexpStr !== ".*" && regexpStr !== "(?:|/.*)") {
+            for (const k in node.#children)
+              if ((regexpStr.length > 1 || k.length > 1) && k !== ".*" && k !== "(?:|/.*)")
+                throw PATH_ERROR;
+          }
+          nextNode = node.#children[regexpStr] = new Node2;
+        }
+        if (name !== "") {
+          nextNode.#varIndex ??= context.varIndex++;
+          paramMap.push([name, nextNode.#varIndex]);
+        }
+      } else {
+        nextNode = node.#children[token];
+        if (!nextNode) {
+          for (const k in node.#children)
+            if (k.length > 1 && k !== ".*" && k !== "(?:|/.*)")
+              throw PATH_ERROR;
+          nextNode = node.#children[token] = new Node2;
+        }
+      }
+      node = nextNode;
+    }
+    if (node.#index !== undefined)
+      throw PATH_ERROR;
+    node.#index = isStatic ? -1 : index;
+  }
+  buildRegExpStr() {
+    const strList = Object.keys(this.#children).sort(compareKey).map((k) => {
+      const c = this.#children[k];
+      const childStr = c.buildRegExpStr();
+      return childStr === "" ? "" : (typeof c.#varIndex === "number" ? `(${k})@${c.#varIndex}` : regExpMetaChars.has(k) ? `\\${k}` : k) + childStr;
+    }).filter(Boolean);
+    if (typeof this.#index === "number" && this.#index !== -1)
+      strList.unshift(`#${this.#index}`);
+    if (strList.length === 0)
+      return "";
+    if (strList.length === 1)
+      return strList[0];
+    return "(?:" + strList.join("|") + ")";
+  }
+};
+
+// node_modules/hono/dist/router/reg-exp-router/trie.js
+var Trie = class {
+  #context = { varIndex: 0 };
+  #root = new Node;
+  #index = 0;
+  paths = createNullObject();
+  insert(path, isStatic) {
+    if (isStatic) {
+      this.#root.insert(path.split(""), 0, [], this.#context, true);
+      return;
+    }
+    const paramAssoc = [];
+    const groups = [];
+    let markedPath = path;
+    for (let i = 0;; ) {
+      let replaced = false;
+      markedPath = markedPath.replace(/\{[^}]+\}/g, (m) => {
+        const mark = `@\\${i}`;
+        groups[i] = [mark, m];
+        i++;
+        replaced = true;
+        return mark;
+      });
+      if (!replaced)
+        break;
+    }
+    const tokens = markedPath.match(/(?::[^\/]+)|(?:\/\*$)|./g) || [];
+    for (let i = groups.length - 1;i >= 0; i--) {
+      const [mark] = groups[i];
+      for (let j = tokens.length - 1;j >= 0; j--)
+        if (tokens[j].indexOf(mark) !== -1) {
+          tokens[j] = tokens[j].replace(mark, groups[i][1]);
+          break;
+        }
+    }
+    this.#root.insert(tokens, this.#index, paramAssoc, this.#context, false);
+    this.paths[path] = [this.#index++, paramAssoc];
+  }
+  buildRegExp() {
+    let regexp = this.#root.buildRegExpStr();
+    if (regexp === "")
+      return [
+        /^$/,
+        [],
+        []
+      ];
+    let captureIndex = 0;
+    const indexReplacementMap = [];
+    const paramReplacementMap = [];
+    regexp = regexp.replace(/#(\d+)|@(\d+)|\.\*\$/g, (_, handlerIndex, paramIndex) => {
+      if (handlerIndex !== undefined) {
+        indexReplacementMap[++captureIndex] = Number(handlerIndex);
+        return "$()";
+      }
+      if (paramIndex !== undefined) {
+        paramReplacementMap[Number(paramIndex)] = ++captureIndex;
+        return "";
+      }
+      return "";
+    });
+    return [
+      new RegExp(`^${regexp}`),
+      indexReplacementMap,
+      paramReplacementMap
+    ];
+  }
+};
+
+// node_modules/hono/dist/router/reg-exp-router/router.js
+var wildcardRegExpCache = createNullObject();
+function buildWildcardRegExp(path) {
+  return wildcardRegExpCache[path] ??= new RegExp(`^${path.replace(/\/:[^/{}]+(?:\{\[\^\/]\+})?(?=[/{]|$)|\/?\*$|([.\\+*[^\]$()?{}|])/g, (match2, metaChar) => metaChar ? `\\${metaChar}` : match2 === "/*" ? TAIL_WILDCARD_REG_EXP_STR : match2 === "*" ? ".*" : `/:${LABEL_REG_EXP_STR}`)}$`);
+}
+function findMiddleware(middleware, path) {
+  for (const k of Object.keys(middleware).sort((a, b) => b.length - a.length))
+    if (buildWildcardRegExp(k).test(path))
+      return [...middleware[k]];
+}
+var RegExpRouter = class {
+  name = "RegExpRouter";
+  #middleware;
+  #routes;
+  #tries;
+  constructor() {
+    this.#middleware = { ["ALL"]: createNullObject() };
+    this.#routes = { ["ALL"]: createNullObject() };
+    this.#tries = { ["ALL"]: new Trie };
+  }
+  #insertPath(method, path) {
+    try {
+      this.#tries[method].insert(path, !/\*|\/:/.test(path));
+    } catch (e) {
+      throw e === PATH_ERROR ? new UnsupportedPathError(path) : e;
+    }
+  }
+  add(method, path, handler) {
+    const middleware = this.#middleware;
+    const routes = this.#routes;
+    if (!middleware)
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    if (!middleware[method]) {
+      this.#tries[method] = new Trie;
+      for (const handlerMap of [middleware, routes]) {
+        handlerMap[method] = createNullObject();
+        for (const p in handlerMap["ALL"]) {
+          handlerMap[method][p] = [...handlerMap["ALL"][p]];
+          this.#insertPath(method, p);
+        }
+      }
+    }
+    if (path === "/*")
+      path = "*";
+    const methods = method === "ALL" ? Object.keys(middleware) : [method];
+    if (/\*$/.test(path)) {
+      const re = buildWildcardRegExp(path);
+      for (const m of methods)
+        if (!middleware[m][path]) {
+          this.#insertPath(m, path);
+          middleware[m][path] = findMiddleware(middleware[m], path) || findMiddleware(middleware["ALL"], path) || [];
+        }
+      for (const handlerMap of [middleware, routes])
+        for (const m of methods)
+          for (const p in handlerMap[m])
+            re.test(p) && handlerMap[m][p].push([handler, path]);
+      return;
+    }
+    const paths = checkOptionalParameter(path) || [path];
+    for (const path2 of paths)
+      for (const m of methods) {
+        if (!routes[m][path2]) {
+          this.#insertPath(m, path2);
+          routes[m][path2] = findMiddleware(middleware[m], path2) || findMiddleware(middleware["ALL"], path2) || [];
+        }
+        routes[m][path2].push([handler, path2]);
+      }
+  }
+  match = match;
+  buildAllMatchers() {
+    const matchers = createNullObject();
+    for (const method of Object.keys(this.#routes))
+      matchers[method] = this.#buildMatcher(method);
+    this.#middleware = this.#routes = this.#tries = undefined;
+    wildcardRegExpCache = createNullObject();
+    return matchers;
+  }
+  #buildMatcher(method) {
+    const middleware = this.#middleware[method];
+    const routes = this.#routes[method];
+    const trie = this.#tries[method];
+    const staticMap = createNullObject();
+    const handlerData = [];
+    const [regexp, indexReplacementMap, paramReplacementMap] = trie.buildRegExp();
+    for (const r of [middleware, routes])
+      for (const path in r) {
+        const handlers = r[path];
+        const pathData = trie.paths[path];
+        if (!pathData) {
+          staticMap[path] = [handlers.map(([h]) => [h, createNullObject()]), emptyParam];
+          continue;
+        }
+        handlerData[pathData[0]] = handlers.map(([h, handlerPath]) => [h, trie.paths[handlerPath][1].reduceRight((map, [key], i) => {
+          map[key] = paramReplacementMap[pathData[1][i][1]];
+          return map;
+        }, createNullObject())]);
+      }
+    return [
+      regexp,
+      indexReplacementMap.map((i) => handlerData[i]),
+      staticMap
+    ];
+  }
+};
+
+// node_modules/hono/dist/router/reg-exp-router/prepared-router.js
+var PreparedRegExpRouter = class {
+  name = "PreparedRegExpRouter";
+  #matchers;
+  #relocateMap;
+  constructor(matchers, relocateMap) {
+    this.#matchers = matchers;
+    this.#relocateMap = relocateMap;
+  }
+  #addWildcard(method, handlerData) {
+    const matcher = this.#matchers[method];
+    matcher[1].forEach((list) => list && list.push(handlerData));
+    Object.values(matcher[2]).forEach((list) => list[0].push(handlerData));
+  }
+  #addPath(method, path, handler, indexes, map) {
+    const matcher = this.#matchers[method];
+    if (!map)
+      matcher[2][path][0].push([handler, {}]);
+    else
+      indexes.forEach((index) => {
+        if (typeof index === "number")
+          matcher[1][index].push([handler, map]);
+        else
+          matcher[2][index || path][0].push([handler, map]);
+      });
+  }
+  add(method, path, handler) {
+    if (!this.#matchers[method]) {
+      const all = this.#matchers["ALL"];
+      const staticMap = {};
+      for (const key in all[2])
+        staticMap[key] = [all[2][key][0].slice(), emptyParam];
+      this.#matchers[method] = [
+        all[0],
+        all[1].map((list) => Array.isArray(list) ? list.slice() : 0),
+        staticMap
+      ];
+    }
+    if (path === "/*" || path === "*") {
+      const handlerData = [handler, {}];
+      if (method === "ALL")
+        for (const m in this.#matchers)
+          this.#addWildcard(m, handlerData);
+      else
+        this.#addWildcard(method, handlerData);
+      return;
+    }
+    const data = this.#relocateMap[path];
+    if (!data)
+      throw new Error(`Path ${path} is not registered`);
+    for (const [indexes, map] of data)
+      if (method === "ALL")
+        for (const m in this.#matchers)
+          this.#addPath(m, path, handler, indexes, map);
+      else
+        this.#addPath(method, path, handler, indexes, map);
+  }
+  buildAllMatchers() {
+    return this.#matchers;
+  }
+  match = match;
+};
+
+// node_modules/hono/dist/router/smart-router/router.js
+var SmartRouter = class {
+  name = "SmartRouter";
+  #routers = [];
+  #routes = [];
+  constructor(init) {
+    this.#routers = init.routers;
+  }
+  add(method, path, handler) {
+    if (!this.#routes)
+      throw new Error(MESSAGE_MATCHER_IS_ALREADY_BUILT);
+    this.#routes.push([
+      method,
+      path,
+      handler
+    ]);
+  }
+  match(method, path) {
+    if (!this.#routes)
+      throw new Error("Fatal error");
+    const routers = this.#routers;
+    const routes = this.#routes;
+    const len = routers.length;
+    let i = 0;
+    let res;
+    for (;i < len; i++) {
+      const router = routers[i];
+      try {
+        for (let i2 = 0, len2 = routes.length;i2 < len2; i2++)
+          router.add(...routes[i2]);
+        res = router.match(method, path);
+      } catch (e) {
+        if (e instanceof UnsupportedPathError)
+          continue;
+        throw e;
+      }
+      this.match = router.match.bind(router);
+      this.#routers = [router];
+      this.#routes = undefined;
+      break;
+    }
+    if (i === len)
+      throw new Error("Fatal error");
+    this.name = `SmartRouter + ${this.activeRouter.name}`;
+    return res;
+  }
+  get activeRouter() {
+    if (this.#routes || this.#routers.length !== 1)
+      throw new Error("No active router has been determined yet.");
+    return this.#routers[0];
+  }
+};
+
+// node_modules/hono/dist/router/trie-router/node.js
+var emptyParams = createNullObject();
+var order = 0;
+var Node3 = class Node4 {
+  #methods = [];
+  #children = createNullObject();
+  #patterns = [];
+  #pattern;
+  #params = emptyParams;
+  insert(method, path, handler) {
+    let curNode = this;
+    const parts = splitRoutingPath(path);
+    const possibleKeys = /* @__PURE__ */ new Set;
+    let i = 0;
+    for (const p of parts) {
+      const nextP = parts[++i];
+      const pattern = getPattern(p, nextP) || (nextP === undefined && p && p.indexOf("*") === p.length - 1 ? p : null);
+      const isParam = Array.isArray(pattern);
+      const key = isParam ? pattern[0] : pattern || p;
+      const child = curNode.#children[key] ||= new Node4;
+      if (pattern && !child.#pattern) {
+        child.#pattern = pattern;
+        curNode.#patterns.push(child);
+      }
+      curNode = child;
+      if (isParam)
+        possibleKeys.add(pattern[1]);
+    }
+    curNode.#methods.push({ [method]: {
+      handler,
+      possibleKeys: [...possibleKeys],
+      score: ++order
+    } });
+  }
+  #pushHandlerSets(handlerSets, node, method, nodeParams, params) {
+    for (let i = 0, len = node.#methods.length;i < len; i++) {
+      const m = node.#methods[i];
+      const handlerSet = m[method] || m["ALL"];
+      if (handlerSet) {
+        handlerSet.params = createNullObject();
+        handlerSets.push(handlerSet);
+        for (let i2 = 0, len2 = handlerSet.possibleKeys.length;i2 < len2; i2++) {
+          const key = handlerSet.possibleKeys[i2];
+          handlerSet.params[key] = params?.[key] && !i2 ? params[key] : nodeParams[key] ?? params?.[key];
+        }
+      }
+    }
+  }
+  search(method, path) {
+    const handlerSets = [];
+    this.#params = emptyParams;
+    let curNodes = [this];
+    const parts = splitPath(path);
+    const curNodesQueue = [];
+    const len = parts.length;
+    let partOffsets = null;
+    for (let i = 0;i < len; i++) {
+      const part = parts[i];
+      const isLast = i === len - 1;
+      const tempNodes = [];
+      for (let j = 0, len2 = curNodes.length;j < len2; j++) {
+        const node = curNodes[j];
+        const nextNode = node.#children[part];
+        if (nextNode) {
+          nextNode.#params = node.#params;
+          if (isLast) {
+            if (nextNode.#children["*"])
+              this.#pushHandlerSets(handlerSets, nextNode.#children["*"], method, node.#params);
+            this.#pushHandlerSets(handlerSets, nextNode, method, node.#params);
+          } else
+            tempNodes.push(nextNode);
+        }
+        for (const child of node.#patterns) {
+          const pattern = child.#pattern;
+          const params = node.#params === emptyParams ? {} : { ...node.#params };
+          if (typeof pattern === "string") {
+            if (pattern === "*" || part.startsWith(pattern.slice(0, -1))) {
+              this.#pushHandlerSets(handlerSets, child, method, node.#params);
+              if (pattern === "*") {
+                child.#params = params;
+                tempNodes.push(child);
+              }
+            }
+            continue;
+          }
+          const [, name, matcher] = pattern;
+          if (!part && matcher === true)
+            continue;
+          if (matcher !== true) {
+            if (!partOffsets) {
+              partOffsets = [];
+              let offset = path[0] === "/" ? 1 : 0;
+              for (let p = 0;p < len; p++) {
+                partOffsets[p] = offset;
+                offset += parts[p].length + 1;
+              }
+            }
+            const restPathString = path.slice(partOffsets[i]);
+            const m = matcher.exec(restPathString);
+            if (m) {
+              params[name] = m[0];
+              this.#pushHandlerSets(handlerSets, child, method, node.#params, params);
+              if (m[0].length === restPathString.length && child.#children["*"])
+                this.#pushHandlerSets(handlerSets, child.#children["*"], method, node.#params, params);
+              for (const _ in child.#children) {
+                child.#params = params;
+                const componentCount = m[0].match(/\//g)?.length ?? 0;
+                (curNodesQueue[componentCount] ||= []).push(child);
+                break;
+              }
+              continue;
+            }
+          }
+          if (matcher === true || matcher.test(part)) {
+            params[name] = part;
+            if (isLast) {
+              this.#pushHandlerSets(handlerSets, child, method, params, node.#params);
+              if (child.#children["*"])
+                this.#pushHandlerSets(handlerSets, child.#children["*"], method, params, node.#params);
+            } else {
+              child.#params = params;
+              tempNodes.push(child);
+            }
+          }
+        }
+      }
+      const shifted = curNodesQueue.shift();
+      curNodes = shifted ? tempNodes.concat(shifted) : tempNodes;
+    }
+    if (handlerSets[1])
+      handlerSets.sort((a, b) => {
+        return a.score - b.score;
+      });
+    return [handlerSets.map(({ handler, params }) => [handler, params])];
+  }
+};
+
+// node_modules/hono/dist/router/trie-router/router.js
+var TrieRouter = class {
+  name = "TrieRouter";
+  #node = new Node3;
+  add(method, path, handler) {
+    for (const result of checkOptionalParameter(path) || [path])
+      this.#node.insert(method, result, handler);
+  }
+  match(method, path) {
+    return this.#node.search(method, path);
+  }
+};
+
+// node_modules/hono/dist/hono.js
+var Hono3 = class extends Hono {
+  constructor(options = {}) {
+    super(options);
+    this.router = options.router ?? new SmartRouter({ routers: [new RegExpRouter, new TrieRouter] });
+  }
+};
+
+// src/core/inline-text.ts
+function normalizeMixedTextSpacing(text) {
+  return text.replace(/[ \t]+/g, " ");
+}
+function parseInlineRuns(text, highlightWords = []) {
+  const runs = [];
+  const escapedWords = highlightWords.filter((word) => word.length > 0).map((word) => word.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"));
+  const hlRegex = escapedWords.length ? new RegExp(`(${escapedWords.join("|")})`, "g") : null;
+  const pattern = /(\*\*[^*]+\*\*|\*[^*]+\*|==[^=]+==)/g;
+  let lastIndex = 0;
+  let match2;
+  function pushTextWithHighlights(str, baseStyle = {}) {
+    if (!str)
+      return;
+    if (!hlRegex) {
+      runs.push({ text: str, ...baseStyle });
+      return;
+    }
+    hlRegex.lastIndex = 0;
+    let hlLast = 0;
+    let hlMatch;
+    while ((hlMatch = hlRegex.exec(str)) !== null) {
+      if (hlMatch.index > hlLast) {
+        runs.push({ text: str.slice(hlLast, hlMatch.index), ...baseStyle });
+      }
+      runs.push({ text: hlMatch[0], ...baseStyle, highlight: true });
+      hlLast = hlMatch.index + hlMatch[0].length;
+    }
+    if (hlLast < str.length) {
+      runs.push({ text: str.slice(hlLast), ...baseStyle });
+    }
+  }
+  while ((match2 = pattern.exec(text)) !== null) {
+    if (match2.index > lastIndex) {
+      pushTextWithHighlights(text.slice(lastIndex, match2.index));
+    }
+    const token = match2[0];
+    if (token.startsWith("**") && token.endsWith("**")) {
+      pushTextWithHighlights(token.slice(2, -2), { bold: true });
+    } else if (token.startsWith("*") && token.endsWith("*")) {
+      pushTextWithHighlights(token.slice(1, -1), { italic: true });
+    } else if (token.startsWith("==") && token.endsWith("==")) {
+      runs.push({ text: token.slice(2, -2), highlight: true, bold: true });
+    }
+    lastIndex = match2.index + token.length;
+  }
+  if (lastIndex < text.length) {
+    pushTextWithHighlights(text.slice(lastIndex));
+  }
+  return runs.length > 0 ? runs : [{ text }];
+}
+function parseContentBlocks(rawMarkdown) {
+  const lines = rawMarkdown.replaceAll(`\r
+`, `
+`).split(`
+`);
+  const blocks = [];
+  let paragraphBuffer = [];
+  function flushParagraph() {
+    const value = normalizeMixedTextSpacing(paragraphBuffer.join(" ").trim());
+    if (value.length > 0) {
+      blocks.push({ kind: "paragraph", text: value });
+    }
+    paragraphBuffer = [];
+  }
+  for (const rawLine of lines) {
+    const line = rawLine.trim();
+    if (line.length === 0) {
+      flushParagraph();
+      continue;
+    }
+    if (isPageMarkerLine(line)) {
+      flushParagraph();
+      continue;
+    }
+    const heading = line.match(/^(#{1,6})\s+(.+)$/);
+    if (heading) {
+      flushParagraph();
+      const level = heading[1].length;
+      blocks.push({
+        kind: level === 1 ? "heading" : level === 2 ? "subheading" : "minor-heading",
+        text: normalizeMixedTextSpacing(heading[2])
+      });
+      continue;
+    }
+    if (line.startsWith(">")) {
+      flushParagraph();
+      blocks.push({
+        kind: "quote",
+        text: normalizeMixedTextSpacing(line.replace(/^>\s?/, "").trim())
+      });
+      continue;
+    }
+    const listItem = line.match(/^(\d+[.)]|[-*+])\s+(.+)$/);
+    if (listItem) {
+      flushParagraph();
+      blocks.push({
+        kind: "list-item",
+        text: normalizeMixedTextSpacing(listItem[2]),
+        bullet: /^\d/.test(listItem[1]) ? listItem[1] : "•"
+      });
+      continue;
+    }
+    paragraphBuffer.push(line);
+  }
+  flushParagraph();
+  return blocks;
+}
+function isPageMarkerLine(line) {
+  const trimmed = line.trim();
+  return /^【第([一二三四五六七八九十百两\d]+)页】$/.test(trimmed) || /^【Page\s*(\d+)】$/i.test(trimmed) || /^(?:-{3,}|\*{3,}|_{3,})$/.test(trimmed) || /^<!--\s*(?:pagebreak|page-break|next-page|page(?::\s*\d+)?)\s*-->$/i.test(trimmed);
+}
+function splitTextByPages(text) {
+  const lines = text.replaceAll(`\r
+`, `
+`).split(`
+`);
+  const pages = [[]];
+  let hasMarker = false;
+  for (const line of lines) {
+    if (isPageMarkerLine(line)) {
+      hasMarker = true;
+      if (pages.length === 1 && pages[0].length === 0) {
+        continue;
+      }
+      pages.push([]);
+      continue;
+    }
+    pages[pages.length - 1].push(line);
+  }
+  if (!hasMarker) {
+    return [text];
+  }
+  return pages.map((pageLines) => pageLines.join(`
+`).trim());
+}
+
+// node_modules/@chenglou/pretext/dist/rich-inline.js
+var COLLAPSIBLE_BOUNDARY_RE = /[ \t\n\f\r]+/;
+var LEADING_COLLAPSIBLE_BOUNDARY_RE = /^[ \t\n\f\r]+/;
+var TRAILING_COLLAPSIBLE_BOUNDARY_RE = /[ \t\n\f\r]+$/;
+var EMPTY_LAYOUT_CURSOR = { segmentIndex: 0, graphemeIndex: 0 };
+var RICH_INLINE_START_CURSOR = {
+  itemIndex: 0,
+  segmentIndex: 0,
+  graphemeIndex: 0
+};
+function getInternalPreparedRichInline(prepared) {
+  return prepared;
+}
+function cloneCursor(cursor) {
+  return {
+    segmentIndex: cursor.segmentIndex,
+    graphemeIndex: cursor.graphemeIndex
+  };
+}
+function isLineStartCursor(cursor) {
+  return cursor.segmentIndex === 0 && cursor.graphemeIndex === 0;
+}
+function getCollapsedSpaceWidth(font, letterSpacing, cache) {
+  const cacheKey = `${font}\x00${letterSpacing}`;
+  const cached = cache.get(cacheKey);
+  if (cached !== undefined)
+    return cached;
+  const options = letterSpacing === 0 ? undefined : { letterSpacing };
+  const joinedWidth = measureNaturalWidth(prepareWithSegments("A A", font, options));
+  const compactWidth = measureNaturalWidth(prepareWithSegments("AA", font, options));
+  const collapsedWidth = Math.max(0, joinedWidth - compactWidth);
+  cache.set(cacheKey, collapsedWidth);
+  return collapsedWidth;
+}
+function prepareWholeItemLine(prepared) {
+  const end = { segmentIndex: 0, graphemeIndex: 0 };
+  const width = stepPreparedLineGeometry(prepared, end, Number.POSITIVE_INFINITY);
+  if (width === null)
+    return null;
+  return {
+    endGraphemeIndex: end.graphemeIndex,
+    endSegmentIndex: end.segmentIndex,
+    width
+  };
+}
+function endsInsideFirstSegment(segmentIndex, graphemeIndex) {
+  return segmentIndex === 0 && graphemeIndex > 0;
+}
+function prepareRichInline(items) {
+  const preparedItems = [];
+  const itemsBySourceItemIndex = Array.from({ length: items.length });
+  const collapsedSpaceWidthCache = new Map;
+  let pendingGapWidth = 0;
+  for (let index = 0;index < items.length; index++) {
+    const item = items[index];
+    const letterSpacing = item.letterSpacing ?? 0;
+    const hasLeadingWhitespace = LEADING_COLLAPSIBLE_BOUNDARY_RE.test(item.text);
+    const hasTrailingWhitespace = TRAILING_COLLAPSIBLE_BOUNDARY_RE.test(item.text);
+    const trimmedText = item.text.replace(LEADING_COLLAPSIBLE_BOUNDARY_RE, "").replace(TRAILING_COLLAPSIBLE_BOUNDARY_RE, "");
+    if (trimmedText.length === 0) {
+      if (COLLAPSIBLE_BOUNDARY_RE.test(item.text) && pendingGapWidth === 0) {
+        pendingGapWidth = getCollapsedSpaceWidth(item.font, letterSpacing, collapsedSpaceWidthCache);
+      }
+      continue;
+    }
+    const gapBefore = pendingGapWidth > 0 ? pendingGapWidth : hasLeadingWhitespace ? getCollapsedSpaceWidth(item.font, letterSpacing, collapsedSpaceWidthCache) : 0;
+    const prepared = prepareWithSegments(trimmedText, item.font, letterSpacing === 0 ? undefined : { letterSpacing });
+    const wholeLine = prepareWholeItemLine(prepared);
+    if (wholeLine === null) {
+      pendingGapWidth = hasTrailingWhitespace ? getCollapsedSpaceWidth(item.font, letterSpacing, collapsedSpaceWidthCache) : 0;
+      continue;
+    }
+    const preparedItem = {
+      break: item.break ?? "normal",
+      endGraphemeIndex: wholeLine.endGraphemeIndex,
+      endSegmentIndex: wholeLine.endSegmentIndex,
+      extraWidth: item.extraWidth ?? 0,
+      gapBefore,
+      naturalWidth: wholeLine.width,
+      prepared,
+      sourceItemIndex: index
+    };
+    preparedItems.push(preparedItem);
+    itemsBySourceItemIndex[index] = preparedItem;
+    pendingGapWidth = hasTrailingWhitespace ? getCollapsedSpaceWidth(item.font, letterSpacing, collapsedSpaceWidthCache) : 0;
+  }
+  return {
+    items: preparedItems,
+    itemsBySourceItemIndex
+  };
+}
+function stepRichInlineLine(flow, maxWidth, cursor, collectFragment) {
+  if (flow.items.length === 0 || cursor.itemIndex >= flow.items.length)
+    return null;
+  const safeWidth = Math.max(1, maxWidth);
+  let lineWidth = 0;
+  let remainingWidth = safeWidth;
+  let itemIndex = cursor.itemIndex;
+  lineLoop:
+    while (itemIndex < flow.items.length) {
+      const item = flow.items[itemIndex];
+      if (!isLineStartCursor(cursor) && cursor.segmentIndex === item.endSegmentIndex && cursor.graphemeIndex === item.endGraphemeIndex) {
+        itemIndex++;
+        cursor.segmentIndex = 0;
+        cursor.graphemeIndex = 0;
+        continue;
+      }
+      const gapBefore = lineWidth === 0 ? 0 : item.gapBefore;
+      const atItemStart = isLineStartCursor(cursor);
+      if (item.break === "never") {
+        if (!atItemStart) {
+          itemIndex++;
+          cursor.segmentIndex = 0;
+          cursor.graphemeIndex = 0;
+          continue;
+        }
+        const occupiedWidth = item.naturalWidth + item.extraWidth;
+        const totalWidth = gapBefore + occupiedWidth;
+        if (lineWidth > 0 && totalWidth > remainingWidth)
+          break lineLoop;
+        collectFragment?.(item, gapBefore, occupiedWidth, cloneCursor(EMPTY_LAYOUT_CURSOR), {
+          segmentIndex: item.endSegmentIndex,
+          graphemeIndex: item.endGraphemeIndex
+        });
+        lineWidth += totalWidth;
+        remainingWidth = Math.max(0, safeWidth - lineWidth);
+        itemIndex++;
+        cursor.segmentIndex = 0;
+        cursor.graphemeIndex = 0;
+        continue;
+      }
+      const reservedWidth = gapBefore + item.extraWidth;
+      if (lineWidth > 0 && reservedWidth >= remainingWidth)
+        break lineLoop;
+      if (atItemStart) {
+        const totalWidth = reservedWidth + item.naturalWidth;
+        if (totalWidth <= remainingWidth) {
+          collectFragment?.(item, gapBefore, item.naturalWidth + item.extraWidth, cloneCursor(EMPTY_LAYOUT_CURSOR), {
+            segmentIndex: item.endSegmentIndex,
+            graphemeIndex: item.endGraphemeIndex
+          });
+          lineWidth += totalWidth;
+          remainingWidth = Math.max(0, safeWidth - lineWidth);
+          itemIndex++;
+          cursor.segmentIndex = 0;
+          cursor.graphemeIndex = 0;
+          continue;
+        }
+      }
+      const availableWidth = Math.max(1, remainingWidth - reservedWidth);
+      const lineEnd = {
+        segmentIndex: cursor.segmentIndex,
+        graphemeIndex: cursor.graphemeIndex
+      };
+      const lineWidthForItem = stepPreparedLineGeometry(item.prepared, lineEnd, availableWidth);
+      if (lineWidthForItem === null) {
+        itemIndex++;
+        cursor.segmentIndex = 0;
+        cursor.graphemeIndex = 0;
+        continue;
+      }
+      if (cursor.segmentIndex === lineEnd.segmentIndex && cursor.graphemeIndex === lineEnd.graphemeIndex) {
+        itemIndex++;
+        cursor.segmentIndex = 0;
+        cursor.graphemeIndex = 0;
+        continue;
+      }
+      const itemOccupiedWidth = lineWidthForItem + item.extraWidth;
+      const lineWidthContribution = gapBefore + itemOccupiedWidth;
+      if (lineWidth > 0 && atItemStart && lineWidthContribution > remainingWidth)
+        break lineLoop;
+      if (lineWidth > 0 && atItemStart && gapBefore > 0 && endsInsideFirstSegment(lineEnd.segmentIndex, lineEnd.graphemeIndex)) {
+        const freshLineEnd = { segmentIndex: 0, graphemeIndex: 0 };
+        const freshLineWidth = stepPreparedLineGeometry(item.prepared, freshLineEnd, Math.max(1, safeWidth - item.extraWidth));
+        if (freshLineWidth !== null && (freshLineEnd.segmentIndex > lineEnd.segmentIndex || freshLineEnd.segmentIndex === lineEnd.segmentIndex && freshLineEnd.graphemeIndex > lineEnd.graphemeIndex)) {
+          break lineLoop;
+        }
+      }
+      collectFragment?.(item, gapBefore, itemOccupiedWidth, cloneCursor(cursor), {
+        segmentIndex: lineEnd.segmentIndex,
+        graphemeIndex: lineEnd.graphemeIndex
+      });
+      lineWidth += lineWidthContribution;
+      remainingWidth = Math.max(0, safeWidth - lineWidth);
+      if (lineEnd.segmentIndex === item.endSegmentIndex && lineEnd.graphemeIndex === item.endGraphemeIndex) {
+        itemIndex++;
+        cursor.segmentIndex = 0;
+        cursor.graphemeIndex = 0;
+        continue;
+      }
+      cursor.segmentIndex = lineEnd.segmentIndex;
+      cursor.graphemeIndex = lineEnd.graphemeIndex;
+      break;
+    }
+  if (lineWidth === 0)
+    return null;
+  cursor.itemIndex = itemIndex;
+  return lineWidth;
+}
+function layoutNextRichInlineLineRange(prepared, maxWidth, start = RICH_INLINE_START_CURSOR) {
+  const flow = getInternalPreparedRichInline(prepared);
+  const end = {
+    itemIndex: start.itemIndex,
+    segmentIndex: start.segmentIndex,
+    graphemeIndex: start.graphemeIndex
+  };
+  const fragments = [];
+  const width = stepRichInlineLine(flow, maxWidth, end, (item, gapBefore, occupiedWidth, fragmentStart, fragmentEnd) => {
+    fragments.push({
+      itemIndex: item.sourceItemIndex,
+      gapBefore,
+      occupiedWidth,
+      start: fragmentStart,
+      end: fragmentEnd
+    });
+  });
+  if (width === null)
+    return null;
+  return {
+    fragments,
+    width,
+    end
+  };
+}
+function materializeFragmentText(item, fragment) {
+  return buildLineTextFromRange(item.prepared, getLineTextCache(item.prepared), fragment.start.segmentIndex, fragment.start.graphemeIndex, fragment.end.segmentIndex, fragment.end.graphemeIndex);
+}
+function materializeRichInlineLineRange(prepared, line) {
+  const flow = getInternalPreparedRichInline(prepared);
+  const fragments = [];
+  for (let i = 0;i < line.fragments.length; i++) {
+    const fragment = line.fragments[i];
+    const item = flow.itemsBySourceItemIndex[fragment.itemIndex];
+    if (item === undefined)
+      throw new Error("Missing rich-text inline item for fragment");
+    fragments.push({
+      itemIndex: fragment.itemIndex,
+      text: materializeFragmentText(item, fragment),
+      gapBefore: fragment.gapBefore,
+      occupiedWidth: fragment.occupiedWidth,
+      start: fragment.start,
+      end: fragment.end
+    });
+  }
+  return {
+    fragments,
+    width: line.width,
+    end: line.end
+  };
+}
+
+// src/core/pretext.ts
+var requireFn = typeof process !== "undefined" && process.versions?.node ? (await import("node:module")).createRequire(import.meta.url) : undefined;
+var initialized = false;
+function ensurePretextRuntime() {
+  if (initialized)
+    return;
+  if (typeof globalThis.OffscreenCanvas !== "undefined") {
+    initialized = true;
+    return;
+  }
+  if (typeof document !== "undefined") {
+    const hidden = document.createElement("canvas");
+
+    class DomOffscreenCanvas {
+      width = 1000;
+      height = 1000;
+      getContext(type) {
+        return hidden.getContext(type);
+      }
+    }
+    globalThis.OffscreenCanvas = DomOffscreenCanvas;
+    initialized = true;
+    return;
+  }
+  try {
+    if (requireFn) {
+      const { createCanvas } = requireFn("@napi-rs/canvas");
+
+      class BunOffscreenCanvas {
+        width;
+        height;
+        #canvas;
+        constructor(width, height) {
+          this.width = width;
+          this.height = height;
+          this.#canvas = createCanvas(width, height);
+        }
+        getContext(type) {
+          if (type !== "2d")
+            return null;
+          return this.#canvas.getContext("2d");
+        }
+      }
+      globalThis.OffscreenCanvas = BunOffscreenCanvas;
+      initialized = true;
+    }
+  } catch {
+    console.warn("Pretext requires OffscreenCanvas or @napi-rs/canvas for text measurement.");
+  }
+}
+
+// src/core/image-layout.ts
+function computeSafePresetY(indexOnPage, height, captionH, stageHeight) {
+  const topTextBuffer = Math.min(260, Math.round(stageHeight * 0.22));
+  const rawY = topTextBuffer + indexOnPage * (height + 32);
+  const maxY = Math.max(60, stageHeight - height - captionH - 16);
+  return Math.min(rawY, maxY);
+}
+function resolveImagePlacement(img, indexOnPage, stageWidth, stageHeight) {
+  if (img.templateAssetKey && img.x != null && img.y != null && img.width != null && img.height != null) {
+    return { ...img, x: img.x, y: img.y, width: img.width, height: img.height };
+  }
+  const preset = img.layoutPreset || "auto";
+  const padding = 16;
+  const captionH = img.captionHeight ?? 36;
+  if (img.isAbsolute) {
+    return {
+      ...img,
+      x: img.x ?? padding,
+      y: img.y ?? 100,
+      width: img.width ?? 420,
+      height: img.height ?? 280
+    };
+  }
+  if (preset === "custom") {
+    return {
+      ...img,
+      x: img.x ?? padding,
+      y: img.y ?? 260,
+      width: img.width ?? 420,
+      height: img.height ?? 280
+    };
+  }
+  if (preset === "fill") {
+    const width2 = stageWidth;
+    const height2 = img.height || Math.round(stageHeight * 0.28);
+    const y = Math.max(160, stageHeight - height2 - captionH - padding);
+    return {
+      ...img,
+      x: 0,
+      y,
+      width: width2,
+      height: height2
+    };
+  }
+  if (preset === "corner-soft") {
+    const cornerWidth = Math.min(img.width || 380, Math.round(stageWidth * 0.48));
+    const cornerHeight = img.height || 260;
+    const x = Math.max(0, stageWidth - cornerWidth - padding);
+    const y = Math.max(160, stageHeight - cornerHeight - captionH - 24);
+    return {
+      ...img,
+      x,
+      y,
+      width: cornerWidth,
+      height: cornerHeight
+    };
+  }
+  const defaultWidth = 420;
+  const defaultHeight = 280;
+  const maxFloatWidth = Math.round(stageWidth * 0.52);
+  const width = Math.min(img.width || defaultWidth, maxFloatWidth);
+  const height = img.height || defaultHeight;
+  const safeY = computeSafePresetY(indexOnPage, height, captionH, stageHeight);
+  if (preset === "center") {
+    const centerWidth = Math.min(img.width || 560, stageWidth - padding * 2);
+    const x = Math.max(0, Math.round((stageWidth - centerWidth) / 2));
+    return {
+      ...img,
+      x,
+      y: safeY,
+      width: centerWidth,
+      height
+    };
+  }
+  if (preset === "staggered") {
+    const isRight = indexOnPage % 2 === 1;
+    const x = isRight ? Math.max(0, stageWidth - width - padding) : padding;
+    return {
+      ...img,
+      x,
+      y: safeY,
+      width,
+      height
+    };
+  }
+  if (preset === "mid-right") {
+    const x = Math.max(0, stageWidth - width - padding);
+    return {
+      ...img,
+      x,
+      y: safeY,
+      width,
+      height
+    };
+  }
+  if (preset === "mid-left") {
+    const x = padding;
+    return {
+      ...img,
+      x,
+      y: safeY,
+      width,
+      height
+    };
+  }
+  const isWide = (img.width || defaultWidth) >= stageWidth * 0.75;
+  if (isWide) {
+    const centerWidth = Math.min(img.width || defaultWidth, stageWidth - padding * 2);
+    return {
+      ...img,
+      x: Math.max(0, Math.round((stageWidth - centerWidth) / 2)),
+      y: safeY,
+      width: centerWidth,
+      height
+    };
+  }
+  const autoRight = indexOnPage % 2 === 1;
+  const autoX = autoRight ? Math.max(0, stageWidth - width - padding) : padding;
+  return {
+    ...img,
+    x: autoX,
+    y: safeY,
+    width,
+    height
+  };
+}
+
+// src/core/obstacle-flow.ts
+var START = { itemIndex: 0, segmentIndex: 0, graphemeIndex: 0 };
+function runFont(font, run) {
+  const weighted = run.bold ? font.replace(/^\d+\s+/, "700 ") : font;
+  return run.italic ? "italic " + weighted : weighted;
+}
+function compareCursor(a, b) {
+  return a.itemIndex - b.itemIndex || a.segmentIndex - b.segmentIndex || a.graphemeIndex - b.graphemeIndex;
+}
+function paginateBlocks(blocks, stageWidth, stageHeight, allImages, options = {}) {
+  ensurePretextRuntime();
+  let textHeight = stageHeight;
+  const gap = options.obstacleGap ?? 24;
+  const imageLimit = options.pageImageLimit ?? 2;
+  const prepared = blocks.map((block) => {
+    const runs = block.runs.map((run) => ({
+      ...run,
+      font: runFont(block.font, run)
+    }));
+    return {
+      ...block,
+      runs,
+      prepared: prepareRichInline(runs)
+    };
+  });
+  function place(block, cursor2, initialY, images, limit = Infinity) {
+    const lines = [];
+    let y = initialY;
+    while (y + block.lineHeight <= textHeight && lines.length < limit) {
+      if (!layoutNextRichInlineLineRange(block.prepared, stageWidth, cursor2)) {
+        return { lines, cursor: cursor2, y, done: true };
+      }
+      const indent = block.textIndent ?? 0;
+      let intervals = [{ left: 0, right: stageWidth }];
+      const blockers = images.filter((img) => !img.isAbsolute && y + block.lineHeight > img.y - gap && y < img.y + img.height + (img.captionHeight ?? 0) + gap);
+      for (const img of blockers) {
+        intervals = intervals.flatMap((interval) => {
+          if (img.x - gap >= interval.right || img.x + img.width + gap <= interval.left) {
+            return [interval];
+          }
+          return [
+            { left: interval.left, right: Math.min(interval.right, img.x - gap) },
+            { left: Math.max(interval.left, img.x + img.width + gap), right: interval.right }
+          ];
+        }).filter((interval) => interval.right > interval.left);
+      }
+      const fontSize = Number(block.font.match(/(\d+(?:\.\d+)?)px/)?.[1] ?? 36);
+      let best = null;
+      for (const interval of intervals) {
+        const slotWidth = interval.right - interval.left - indent;
+        if (slotWidth < fontSize * (blockers.length ? 2.5 : 1))
+          continue;
+        const line = layoutNextRichInlineLineRange(block.prepared, slotWidth, cursor2);
+        if (!line || line.width > slotWidth + 0.5)
+          continue;
+        if (!best || compareCursor(line.end, best.line.end) > 0) {
+          best = { line, left: interval.left + indent, width: slotWidth };
+        }
+      }
+      if (!best) {
+        if (!blockers.length) {
+          break;
+        }
+        y = Math.min(...blockers.map((img) => img.y + img.height + (img.captionHeight ?? 0) + gap));
+        continue;
+      }
+      if (compareCursor(best.line.end, cursor2) <= 0) {
+        break;
+      }
+      const lineData = materializeRichInlineLineRange(block.prepared, best.line);
+      const fragments = lineData.fragments.map((frag) => {
+        const originalRun = block.runs[frag.itemIndex];
+        return {
+          text: frag.text,
+          font: originalRun.font ?? block.font,
+          bold: originalRun.bold,
+          italic: originalRun.italic,
+          highlight: originalRun.highlight,
+          gapBefore: frag.gapBefore,
+          occupiedWidth: frag.occupiedWidth,
+          letterSpacing: originalRun.letterSpacing
+        };
+      });
+      let lineX = best.left;
+      let bulletX = compareCursor(cursor2, START) === 0 && block.bullet ? best.left - indent : undefined;
+      const occupied = best.line.width;
+      if (options.textAlign === "center") {
+        const free = Math.max(0, best.width - occupied);
+        const shift = Math.round(free / 2);
+        lineX += shift;
+        if (bulletX !== undefined)
+          bulletX += shift;
+      } else if (options.textAlign === "right") {
+        const free = Math.max(0, best.width - occupied);
+        lineX += free;
+        if (bulletX !== undefined)
+          bulletX += free;
+      }
+      lines.push({
+        text: fragments.map((f) => f.text).join(""),
+        fragments,
+        x: lineX,
+        y,
+        className: block.className,
+        font: block.font,
+        lineHeight: block.lineHeight,
+        maxWidth: best.width,
+        start: cursor2,
+        end: best.line.end,
+        bullet: compareCursor(cursor2, START) === 0 ? block.bullet : undefined,
+        bulletX
+      });
+      cursor2 = best.line.end;
+      y += block.lineHeight;
+    }
+    return {
+      lines,
+      cursor: cursor2,
+      y,
+      done: layoutNextRichInlineLineRange(block.prepared, stageWidth, cursor2) === null
+    };
+  }
+  const pages = [];
+  let blockIndex = 0;
+  let cursor = START;
+  const initialPageNumber = options.initialPageNumber ?? 1;
+  const isSegmentMode = options.initialPageNumber !== undefined;
+  let unassignedIndex = 0;
+  const unassignedImages = allImages.filter((img) => !img.pageIndex);
+  let segmentImagesPlaced = false;
+  const MAX_PAGES = options.maxPages || 50;
+  const templateImages = options.templateImages || [];
+  const lastTemplatePage = Math.max(0, ...templateImages.filter((image) => !image.repeatEveryPage).map((image) => image.pageIndex || 1));
+  const lastPageNumber = Math.max(options.lastPageNumber || 0, isSegmentMode ? 0 : lastTemplatePage);
+  const templatesForPage = (page) => templateImages.filter((image) => image.repeatEveryPage || (image.pageIndex || 1) === page);
+  const lastImagePage = isSegmentMode ? 0 : Math.max(0, ...allImages.map((image) => image.pageIndex || 0));
+  const hasRemaining = () => blockIndex < prepared.length || !isSegmentMode && (unassignedIndex < unassignedImages.length || initialPageNumber + pages.length <= lastImagePage) || isSegmentMode && !segmentImagesPlaced && (allImages.length > 0 || templatesForPage(initialPageNumber).length > 0) || initialPageNumber + pages.length <= lastPageNumber;
+  while (pages.length < MAX_PAGES && hasRemaining()) {
+    const pageNum = initialPageNumber + pages.length;
+    const targetFill = options.pageFillRatios?.[pageNum] ?? options.targetFillRatio ?? 1;
+    if (!Number.isFinite(targetFill) || targetFill <= 0 || targetFill > 1) {
+      throw new RangeError("targetFillRatio must be greater than 0 and at most 1");
+    }
+    textHeight = stageHeight * targetFill;
+    let targetImages = [];
+    if (isSegmentMode) {
+      if (!segmentImagesPlaced) {
+        targetImages = allImages;
+        segmentImagesPlaced = true;
+      }
+    } else {
+      const pageExplicitImages = allImages.filter((img) => img.pageIndex === pageNum);
+      if (pageExplicitImages.length > 0) {
+        targetImages = pageExplicitImages;
+      } else {
+        targetImages = unassignedImages.slice(unassignedIndex, unassignedIndex + imageLimit);
+        unassignedIndex += Math.max(targetImages.length, 1);
+      }
+    }
+    const images = [...targetImages, ...templatesForPage(pageNum)].map((img, idx) => resolveImagePlacement(img, idx, stageWidth, stageHeight));
+    const lines = [];
+    let y = 0;
+    const initialBlockIndex = blockIndex;
+    const initialCursor = cursor;
+    while (blockIndex < prepared.length) {
+      const block = prepared[blockIndex];
+      const startsBlock = compareCursor(cursor, START) === 0;
+      const startY = y + (startsBlock && lines.length ? block.gapBefore ?? 0 : 0);
+      if (startsBlock && block.keepWithNext && lines.length) {
+        let probeY = startY;
+        let fits = true;
+        for (let idx = blockIndex;idx < prepared.length; idx++) {
+          const f = prepared[idx];
+          if (idx > blockIndex)
+            probeY += f.gapBefore ?? 0;
+          const probe = place(f, START, probeY, images, f.keepWithNext ? Infinity : 2);
+          if (f.keepWithNext ? !probe.done : probe.lines.length < 2 && !probe.done) {
+            fits = false;
+            break;
+          }
+          if (!f.keepWithNext)
+            break;
+          probeY = probe.y + (f.gapAfter ?? 0);
+        }
+        if (!fits)
+          break;
+      }
+      const chunk = place(block, cursor, startY, images);
+      if (!chunk.done && chunk.lines.length) {
+        const remainder = place(block, chunk.cursor, 0, [], 2);
+        if (remainder.done && remainder.lines.length === 1 && chunk.lines.length >= 2) {
+          const moved = chunk.lines.pop();
+          chunk.cursor = moved.start;
+          chunk.y = moved.y;
+        }
+        if (startsBlock && chunk.lines.length < 2 && lines.length) {
+          break;
+        }
+      }
+      lines.push(...chunk.lines);
+      cursor = chunk.cursor;
+      y = chunk.y;
+      if (!chunk.done)
+        break;
+      blockIndex++;
+      cursor = START;
+      y += block.gapAfter ?? 0;
+    }
+    if (blockIndex === initialBlockIndex && compareCursor(cursor, initialCursor) === 0 && !targetImages.length && !images.some((image) => !image.isAbsolute && !image.repeatEveryPage) && blockIndex < prepared.length) {
+      throw new RangeError("Text cannot fit in the available page area; reduce font size or enlarge the safe area");
+    }
+    const textBottom = lines.reduce((max, l) => Math.max(max, l.y + l.lineHeight), 0);
+    const flowImages = images.filter((img) => !img.isAbsolute);
+    const imageBottom = flowImages.reduce((max, img) => Math.max(max, img.y + img.height + (img.captionHeight ?? 0)), 0);
+    const contentBottom = Math.max(textBottom, imageBottom);
+    const fillRatio = stageHeight > 0 ? Math.min(1, contentBottom / stageHeight) : 0;
+    if (lines.length > 0 && options.verticalAlign && options.verticalAlign !== "top") {
+      const minTextY = lines.reduce((min, l) => Math.min(min, l.y), Infinity);
+      const minImageY = flowImages.reduce((min, img) => Math.min(min, img.y), Infinity);
+      const contentTop = Math.min(minTextY, minImageY === Infinity ? minTextY : minImageY);
+      const contentSpan = contentBottom - contentTop;
+      if (stageHeight > contentSpan) {
+        let offsetY = 0;
+        if (options.verticalAlign === "center") {
+          const targetTop = Math.round((stageHeight - contentSpan) / 2);
+          offsetY = targetTop - contentTop;
+        } else if (options.verticalAlign === "bottom") {
+          const targetTop = stageHeight - contentSpan;
+          offsetY = targetTop - contentTop;
+        }
+        if (offsetY !== 0) {
+          for (const line of lines) {
+            line.y += offsetY;
+          }
+          for (const img of flowImages) {
+            if (img.layoutPreset !== "custom") {
+              img.y += offsetY;
+            }
+          }
+        }
+      }
+    }
+    pages.push({
+      pageNumber: pageNum,
+      lines,
+      images,
+      textBottom,
+      fillRatio
+    });
+  }
+  if (hasRemaining())
+    throw new RangeError(`Content exceeds maxPages=${MAX_PAGES}; no content was discarded`);
+  return pages;
+}
+
+// src/core/typography.ts
+function modularScale(base, ratio, step) {
+  return Math.round(base * Math.pow(ratio, step));
+}
+function calculateLineHeight(fontSizePx, userMultiplier = 1.45) {
+  if (fontSizePx <= 0)
+    return 24;
+  const logNorm = Math.log(Math.max(8, fontSizePx) / 8) / Math.log(160 / 8);
+  const baseCurve = 1.65 - logNorm * (1.65 - 1.15);
+  const ratio = Math.max(1.1, Math.min(1.8, baseCurve * (userMultiplier / 1.45)));
+  return Math.round(fontSizePx * ratio);
+}
+function resolveFontFamilyStack(fontName, isSerif = false) {
+  const trimmed = (fontName || "").trim();
+  switch (trimmed) {
+    case "PingFang SC":
+      return `"PingFang SC", -apple-system, BlinkMacSystemFont, "Noto Sans SC", "Microsoft YaHei", sans-serif`;
+    case "Noto Sans SC":
+      return `"Noto Sans SC", "PingFang SC", "Microsoft YaHei", sans-serif`;
+    case "Songti SC":
+      return `"Songti SC", "Noto Serif SC", "STSong", "SimSun", serif`;
+    case "Noto Serif SC":
+      return `"Noto Serif SC", "Songti SC", "SimSun", serif`;
+    case "Kaiti SC":
+      return `"Kaiti SC", "LXGW WenKai Screen", "STKaiti", "KaiTi", serif`;
+    case "Yuanti SC":
+      return `"Yuanti SC", "STYuanti", "PingFang SC", sans-serif`;
+    case "Inter":
+      return `Inter, "PingFang SC", system-ui, sans-serif`;
+    case "Georgia":
+      return `Georgia, "Songti SC", serif`;
+    default:
+      if (!trimmed) {
+        return isSerif ? '"Songti SC", serif' : '"PingFang SC", sans-serif';
+      }
+      if (trimmed.includes(","))
+        return trimmed;
+      return `"${trimmed}", ${isSerif ? "serif" : "sans-serif"}`;
+  }
+}
+function computeBlockStyles(params) {
+  const { baseFontSize, scaleRatio, lineHeightMultiplier, headingFont, bodyFont } = params;
+  const resolvedHeadingFont = resolveFontFamilyStack(headingFont, false);
+  const resolvedBodyFont = resolveFontFamilyStack(bodyFont, true);
+  const pSize = baseFontSize;
+  const h3Size = modularScale(baseFontSize, scaleRatio, 1);
+  const h2Size = modularScale(baseFontSize, scaleRatio, 2);
+  const h1Size = modularScale(baseFontSize, scaleRatio, 3);
+  const quoteSize = baseFontSize;
+  const listSize = baseFontSize;
+  return {
+    heading: {
+      font: `700 ${h1Size}px ${resolvedHeadingFont}`,
+      fontSize: h1Size,
+      lineHeight: calculateLineHeight(h1Size, lineHeightMultiplier * 0.95),
+      gapBefore: Math.round(h1Size * 0.8),
+      gapAfter: Math.round(h1Size * 0.4),
+      className: "body-heading"
+    },
+    subheading: {
+      font: `700 ${h2Size}px ${resolvedHeadingFont}`,
+      fontSize: h2Size,
+      lineHeight: calculateLineHeight(h2Size, lineHeightMultiplier * 0.98),
+      gapBefore: Math.round(h2Size * 0.7),
+      gapAfter: Math.round(h2Size * 0.35),
+      className: "body-subheading"
+    },
+    "minor-heading": {
+      font: `700 ${h3Size}px ${resolvedHeadingFont}`,
+      fontSize: h3Size,
+      lineHeight: calculateLineHeight(h3Size, lineHeightMultiplier),
+      gapBefore: Math.round(h3Size * 0.6),
+      gapAfter: Math.round(h3Size * 0.3),
+      className: "body-minor-heading"
+    },
+    paragraph: {
+      font: `400 ${pSize}px ${resolvedBodyFont}`,
+      fontSize: pSize,
+      lineHeight: calculateLineHeight(pSize, lineHeightMultiplier),
+      gapBefore: 0,
+      gapAfter: Math.round(pSize * 0.6),
+      className: "body-line"
+    },
+    quote: {
+      font: `400 ${quoteSize}px ${resolvedBodyFont}`,
+      fontSize: quoteSize,
+      lineHeight: calculateLineHeight(quoteSize, lineHeightMultiplier * 1.05),
+      gapBefore: Math.round(quoteSize * 0.5),
+      gapAfter: Math.round(quoteSize * 0.5),
+      className: "body-quote"
+    },
+    "list-item": {
+      font: `400 ${listSize}px ${resolvedBodyFont}`,
+      fontSize: listSize,
+      lineHeight: calculateLineHeight(listSize, lineHeightMultiplier),
+      gapBefore: 0,
+      gapAfter: Math.round(listSize * 0.3),
+      className: "body-line"
+    }
+  };
+}
+
+// src/core/template.ts
+function validateTemplateAssets(images = []) {
+  if (!Array.isArray(images))
+    throw new RangeError("模板图片必须是数组");
+  const keys = new Set;
+  for (const image of images) {
+    if (!image || typeof image !== "object")
+      throw new RangeError("无效的模板图片");
+    if (image.templateAssetKey === undefined)
+      continue;
+    const key = image.templateAssetKey;
+    if (image.repeatEveryPage !== undefined && typeof image.repeatEveryPage !== "boolean")
+      throw new RangeError(`素材 ${key} 的每页重复开关必须是布尔值`);
+    if (typeof key !== "string" || !/^[a-zA-Z0-9_-]+$/.test(key)) {
+      throw new RangeError("素材标识只能包含字母、数字、下划线和短横线");
+    }
+    if (image.repeatEveryPage && !image.isAbsolute)
+      throw new RangeError(`素材 ${key} 的每页重复仅支持自由定位模式`);
+    if (keys.has(key))
+      throw new RangeError(`重复的模板素材标识：${key}`);
+    keys.add(key);
+  }
+}
+function applyTemplateImages(currentImages, templateImages = [], overrides = {}) {
+  validateTemplateAssets(templateImages);
+  if (!overrides || typeof overrides !== "object" || Array.isArray(overrides))
+    throw new RangeError("素材替换必须是标识到图片地址的映射");
+  const fixed = templateImages.filter((image) => image.templateAssetKey);
+  for (const [key, src] of Object.entries(overrides)) {
+    if (!fixed.some((image) => image.templateAssetKey === key))
+      throw new RangeError(`未知模板素材：${key}`);
+    if (typeof src !== "string" || !src.trim())
+      throw new RangeError(`素材 ${key} 的替换图片不能为空`);
+  }
+  const content = currentImages.filter((image) => !image.templateAssetKey);
+  const slots = templateImages.filter((image) => !image.templateAssetKey);
+  const mapped = content.length === 0 ? slots.map((image) => ({ ...image, id: `img_${crypto.randomUUID()}` })) : content.map((image, index) => {
+    const slot = slots[index];
+    if (!slot)
+      return image;
+    return {
+      ...image,
+      layoutPreset: slot.layoutPreset ?? image.layoutPreset,
+      isAbsolute: slot.isAbsolute ?? image.isAbsolute,
+      x: slot.x ?? image.x,
+      y: slot.y ?? image.y,
+      width: slot.width ?? image.width,
+      height: slot.height ?? image.height,
+      rotate: slot.rotate ?? image.rotate,
+      opacity: slot.opacity ?? image.opacity,
+      zIndex: slot.zIndex ?? image.zIndex,
+      borderRadius: slot.borderRadius ?? image.borderRadius,
+      captionHeight: slot.captionHeight ?? image.captionHeight,
+      pageIndex: slot.pageIndex ?? image.pageIndex
+    };
+  });
+  return [...mapped, ...fixed.map((image) => ({
+    ...image,
+    src: Object.hasOwn(overrides, image.templateAssetKey) ? overrides[image.templateAssetKey] : image.src
+  }))];
+}
+
+// src/core/engine.ts
+function getDefaultConfig(aspectRatio = "longform-3-4") {
+  const spec = getCanvasSpec(aspectRatio);
+  const isCover = aspectRatio === "wechat-cover-2.35";
+  const isSquare = aspectRatio === "square-1-1";
+  const baseSize = aspectRatio === "wechat-cover-2.35" ? 56 : aspectRatio === "wide-16-9" ? 44 : aspectRatio === "square-1-1" ? 48 : 40;
+  return {
+    name: "默认样式",
+    aspectRatio,
+    algorithm: {
+      baseFontSize: baseSize,
+      scaleRatio: isCover ? 1.35 : 1.25,
+      lineHeightMultiplier: 1.45,
+      obstacleGap: 24,
+      targetFillRatio: 0.8,
+      contentBottomGap: isCover ? 0 : 20,
+      textAlign: isCover || isSquare ? "center" : "left",
+      verticalAlign: isCover || isSquare ? "center" : "top",
+      safeArea: isCover ? { top: 40, right: 60, bottom: 40, left: 60 } : spec.defaultSafeArea
+    },
+    theme: {
+      bgColor: "#ffffff",
+      textColor: "#171717",
+      headingColor: "#171717",
+      accentColor: "#059669",
+      quoteColor: "#525252",
+      captionColor: "#737373",
+      watermarkColor: "#a3a3a3",
+      cardBg: "#f5f5f5",
+      borderSubtle: "#e5e5e5"
+    },
+    typography: {
+      headingFont: "PingFang SC",
+      bodyFont: "Songti SC"
+    },
+    footerText: isCover ? "" : "Typeset Studio · 纯算法排版",
+    watermarkText: isCover ? "" : "@Antigravity",
+    chrome: {
+      showHeader: !isCover,
+      showWatermark: !isCover,
+      showPageNumber: !isCover && !isSquare,
+      showFooter: !isCover,
+      showFooterDivider: !isCover,
+      showFooterText: !isCover,
+      showFillRatio: false
+    }
+  };
+}
+function runTypeset(params) {
+  const { markdown, images = [], config, highlightWords = [], minPages = 1, maxPages = 0, pageFillRatios } = params;
+  if (!Number.isInteger(minPages) || minPages < 1 || !Number.isInteger(maxPages) || maxPages < 0 || maxPages > 0 && maxPages < minPages) {
+    throw new RangeError("Invalid page constraints: maxPages must be 0 or at least minPages");
+  }
+  validateTemplateAssets(images);
+  if (images.some((image) => !image.repeatEveryPage && image.pageIndex != null && (!Number.isInteger(image.pageIndex) || image.pageIndex < 1 || image.pageIndex > 50))) {
+    throw new RangeError("Image pageIndex must be an integer between 1 and 50");
+  }
+  const spec = getCanvasSpec(config.aspectRatio);
+  const { stageWidth, stageHeight } = computeStageDimensions(spec, config.algorithm.safeArea, config.algorithm.contentBottomGap);
+  const blockStyles = computeBlockStyles({
+    baseFontSize: config.algorithm.baseFontSize,
+    scaleRatio: config.algorithm.scaleRatio,
+    lineHeightMultiplier: config.algorithm.lineHeightMultiplier,
+    headingFont: config.typography.headingFont,
+    bodyFont: config.typography.bodyFont
+  });
+  if (config.coverTheme) {
+    const fonts = config.coverTheme.typography;
+    for (const [kind, style] of Object.entries(blockStyles)) {
+      const font = kind.includes("heading") ? fonts.title : fonts.subtitle;
+      Object.assign(style, {
+        font: `${font.fontWeight} ${font.fontSize}px "${font.fontFamily}"`,
+        lineHeight: Math.round(font.fontSize * font.lineHeight)
+      });
+    }
+  }
+  const createFlowBlocks = (text) => parseContentBlocks(text).map((block) => ({
+    ...blockStyles[block.kind],
+    kind: block.kind,
+    text: block.text,
+    runs: parseInlineRuns(block.text, highlightWords).map((run) => ({
+      ...run,
+      letterSpacing: config.coverTheme?.typography[block.kind.includes("heading") ? "title" : "subtitle"].letterSpacing
+    })),
+    bullet: block.kind === "list-item" ? block.bullet ?? "•" : undefined,
+    textIndent: block.kind === "list-item" ? 28 : block.kind === "quote" ? 20 : 0,
+    keepWithNext: ["heading", "subheading", "minor-heading"].includes(block.kind)
+  }));
+  const templateImages = images.filter((image) => image.templateAssetKey);
+  const contentImages = images.filter((image) => !image.templateAssetKey);
+  const pageSegments = splitTextByPages(markdown);
+  let pages = [];
+  if (pageSegments.length > 1) {
+    const segmentCount = Math.max(pageSegments.length, ...contentImages.map((image) => image.pageIndex || 1));
+    if (segmentCount > 50)
+      throw new RangeError("Content exceeds engine limit of 50 pages");
+    for (let index = 0;index < segmentCount; index++) {
+      const pageImages = contentImages.filter((image) => (image.pageIndex || 1) === index + 1);
+      const subPages = paginateBlocks(createFlowBlocks(pageSegments[index] || ""), stageWidth, stageHeight, pageImages, {
+        obstacleGap: config.algorithm.obstacleGap,
+        pageImageLimit: 2,
+        textAlign: config.algorithm.textAlign,
+        verticalAlign: config.algorithm.verticalAlign,
+        initialPageNumber: pages.length + 1,
+        templateImages,
+        targetFillRatio: pageFillRatios?.[index + 1] ?? config.algorithm.targetFillRatio
+      });
+      pages.push(...subPages.length ? subPages : [{
+        pageNumber: pages.length + 1,
+        lines: [],
+        images: [],
+        textBottom: 0,
+        fillRatio: 0
+      }]);
+    }
+    const lastTemplatePage = Math.max(0, ...templateImages.filter((image) => !image.repeatEveryPage).map((image) => image.pageIndex || 1));
+    if (pages.length < lastTemplatePage) {
+      pages.push(...paginateBlocks([], stageWidth, stageHeight, [], {
+        initialPageNumber: pages.length + 1,
+        lastPageNumber: lastTemplatePage,
+        templateImages
+      }));
+    }
+  } else {
+    const flowBlocks = createFlowBlocks(markdown);
+    pages = paginateBlocks(flowBlocks, stageWidth, stageHeight, contentImages, {
+      obstacleGap: config.algorithm.obstacleGap,
+      pageImageLimit: config.aspectRatio === "longform-3-4" ? 2 : 1,
+      textAlign: config.algorithm.textAlign,
+      verticalAlign: config.algorithm.verticalAlign,
+      targetFillRatio: config.algorithm.targetFillRatio,
+      pageFillRatios,
+      templateImages
+    });
+  }
+  if (pageSegments.length === 1 && pages.length < minPages && markdown.trim()) {
+    for (let attempt = 1;attempt <= 8 && pages.length < minPages; attempt++) {
+      const ratio = config.algorithm.targetFillRatio * Math.pow(0.75, attempt);
+      try {
+        pages = paginateBlocks(createFlowBlocks(markdown), stageWidth, stageHeight, contentImages, {
+          obstacleGap: config.algorithm.obstacleGap,
+          pageImageLimit: config.aspectRatio === "longform-3-4" ? 2 : 1,
+          textAlign: config.algorithm.textAlign,
+          verticalAlign: config.algorithm.verticalAlign,
+          targetFillRatio: ratio,
+          templateImages,
+          pageFillRatios: pageFillRatios && Object.fromEntries(Object.entries(pageFillRatios).map(([page, fill]) => [page, Math.min(fill, ratio)]))
+        });
+      } catch {
+        break;
+      }
+    }
+  }
+  if (pages.length < minPages && minPages > 1)
+    throw new RangeError(`Content cannot satisfy minPages=${minPages}; lower the minimum page count`);
+  if (pages.length > 50)
+    throw new RangeError("Content exceeds engine limit of 50 pages");
+  if (maxPages > 0 && pages.length > maxPages)
+    throw new RangeError(`Content exceeds maxPages=${maxPages}; no content was discarded`);
+  if (pages.length === 0) {
+    pages = [
+      {
+        pageNumber: 1,
+        lines: [],
+        images: images.filter((image) => !image.templateAssetKey || image.repeatEveryPage || (image.pageIndex || 1) === 1).map((img, idx) => resolveImagePlacement(img, idx, stageWidth, stageHeight)),
+        textBottom: 0,
+        fillRatio: 0
+      }
+    ];
+  }
+  return {
+    pages,
+    pageCount: pages.length,
+    canvasSpec: spec,
+    config
+  };
+}
+
+// src/server/routes/templates.ts
+import { existsSync, mkdirSync, readdirSync, readFileSync, unlinkSync, writeFileSync } from "fs";
+import { dirname, join } from "path";
+var TEMPLATES_DIR = join(resolveDataDir(), "templates");
+function ensureTemplatesDir() {
+  if (!existsSync(TEMPLATES_DIR)) {
+    try {
+      mkdirSync(TEMPLATES_DIR, { recursive: true });
+    } catch {}
+  }
+  const seedMarker = join(TEMPLATES_DIR, ".initialized");
+  if (!existsSync(seedMarker)) {
+    seedDefaultTemplates();
+    try {
+      writeFileSync(seedMarker, "1");
+    } catch {}
+  }
+}
+var BUILTIN_PRESETS = [
+  {
+    ...getDefaultConfig("wechat-cover-2.35"),
+    id: "tpl_wechat_cover_minimal",
+    name: "微信纯净大图封面 (2.35:1)",
+    slot: "article_cover",
+    algorithm: {
+      ...getDefaultConfig("wechat-cover-2.35").algorithm,
+      baseFontSize: 58,
+      scaleRatio: 1.4,
+      verticalAlign: "center",
+      textAlign: "center"
+    },
+    theme: {
+      bgColor: "#09090b",
+      textColor: "#ffffff",
+      headingColor: "#ffffff",
+      accentColor: "#10b981",
+      quoteColor: "#71717a",
+      captionColor: "#71717a",
+      watermarkColor: "#3f3f46",
+      cardBg: "#18181b"
+    },
+    typography: {
+      headingFont: "PingFang SC",
+      bodyFont: "Songti SC"
+    },
+    footerText: "",
+    watermarkText: "",
+    chrome: {
+      showHeader: false,
+      showWatermark: false,
+      showPageNumber: false,
+      showFooter: false,
+      showFooterDivider: false,
+      showFooterText: false,
+      showFillRatio: false
+    },
+    images: [
+      {
+        id: "tpl_img_cover_bg",
+        src: "https://images.unsplash.com/photo-1618005182384-a83a8bd57fbe?w=1200&auto=format&fit=crop&q=80",
+        alt: "封面装饰图",
+        isAbsolute: true,
+        x: 1350,
+        y: 120,
+        width: 880,
+        height: 760,
+        zIndex: 5,
+        rotate: 0,
+        opacity: 0.95,
+        borderRadius: 24,
+        layoutPreset: "custom"
+      }
+    ]
+  },
+  {
+    ...getDefaultConfig("wechat-cover-2.35"),
+    id: "tpl_wechat_cover_editorial",
+    name: "微信杂志标封面 (2.35:1)",
+    slot: "article_cover",
+    algorithm: {
+      ...getDefaultConfig("wechat-cover-2.35").algorithm,
+      baseFontSize: 54,
+      scaleRatio: 1.35,
+      verticalAlign: "center",
+      textAlign: "left"
+    },
+    theme: {
+      bgColor: "#ffffff",
+      textColor: "#111827",
+      headingColor: "#000000",
+      accentColor: "#059669",
+      quoteColor: "#4b5563",
+      captionColor: "#6b7280",
+      watermarkColor: "#9ca3af",
+      cardBg: "#f3f4f6"
+    },
+    typography: {
+      headingFont: "PingFang SC",
+      bodyFont: "Songti SC"
+    },
+    footerText: "",
+    watermarkText: "SPECIAL EDITION · 专栏特辑",
+    chrome: {
+      showHeader: true,
+      showWatermark: true,
+      showPageNumber: false,
+      showFooter: false,
+      showFooterDivider: false,
+      showFooterText: false,
+      showFillRatio: false
+    },
+    images: [
+      {
+        id: "tpl_img_editorial_card",
+        src: "https://images.unsplash.com/photo-1600585154340-be6161a56a0c?w=1200&auto=format&fit=crop&q=80",
+        alt: "杂志插图",
+        isAbsolute: true,
+        x: 1400,
+        y: 140,
+        width: 820,
+        height: 720,
+        zIndex: 15,
+        rotate: -2,
+        opacity: 1,
+        borderRadius: 20,
+        layoutPreset: "custom"
+      }
+    ]
+  },
+  {
+    ...getDefaultConfig("longform-3-4"),
+    id: "tpl_newspic_poster_cover",
+    name: "贴图封面海报 (3:4)",
+    slot: "newspic_cover",
+    algorithm: {
+      ...getDefaultConfig("longform-3-4").algorithm,
+      baseFontSize: 56,
+      scaleRatio: 1.35,
+      verticalAlign: "center",
+      textAlign: "center"
+    },
+    theme: {
+      bgColor: "#121212",
+      textColor: "#ffffff",
+      headingColor: "#ffffff",
+      accentColor: "#f59e0b",
+      quoteColor: "#a3a3a3",
+      captionColor: "#737373",
+      watermarkColor: "#525252",
+      cardBg: "#1c1c1c"
+    },
+    typography: {
+      headingFont: "PingFang SC",
+      bodyFont: "Songti SC"
+    },
+    footerText: "Typeset Studio · 贴图精选",
+    watermarkText: "FEATURED NEWSPIC",
+    chrome: {
+      showHeader: true,
+      showWatermark: true,
+      showPageNumber: false,
+      showFooter: true,
+      showFooterDivider: false,
+      showFooterText: true,
+      showFillRatio: false
+    },
+    images: [
+      {
+        id: "tpl_img_poster_bg",
+        src: "https://images.unsplash.com/photo-1618005182384-a83a8bd57fbe?w=1200&auto=format&fit=crop&q=80",
+        alt: "海报主图",
+        isAbsolute: true,
+        x: 100,
+        y: 780,
+        width: 1000,
+        height: 650,
+        zIndex: 10,
+        rotate: 0,
+        opacity: 1,
+        borderRadius: 20,
+        layoutPreset: "custom"
+      }
+    ]
+  },
+  {
+    ...getDefaultConfig("longform-3-4"),
+    id: "tpl_longform_paper_sage",
+    name: "纸白典雅长图文 (3:4)",
+    slot: "newspic_content",
+    theme: {
+      bgColor: "#fbfcfb",
+      textColor: "#1c1917",
+      headingColor: "#0c0a09",
+      accentColor: "#047857",
+      quoteColor: "#44403c",
+      captionColor: "#78716c",
+      watermarkColor: "#a8a29e",
+      cardBg: "#ffffff"
+    },
+    typography: {
+      headingFont: "Songti SC",
+      bodyFont: "Songti SC"
+    },
+    footerText: "Typeset Studio · 纯算法空间排版",
+    watermarkText: "@ANTIGRAVITY",
+    chrome: {
+      showHeader: true,
+      showWatermark: true,
+      showPageNumber: true,
+      showFooter: true,
+      showFooterDivider: true,
+      showFooterText: true,
+      showFillRatio: false
+    }
+  },
+  {
+    ...getDefaultConfig("square-1-1"),
+    id: "tpl_square_quote_card",
+    name: "金句留白方卡 (1:1)",
+    algorithm: {
+      ...getDefaultConfig("square-1-1").algorithm,
+      baseFontSize: 50,
+      scaleRatio: 1.3,
+      verticalAlign: "center",
+      textAlign: "center"
+    },
+    theme: {
+      bgColor: "#18181b",
+      textColor: "#fafafa",
+      headingColor: "#ffffff",
+      accentColor: "#f59e0b",
+      quoteColor: "#d4d4d8",
+      captionColor: "#a1a1aa",
+      watermarkColor: "#71717a",
+      cardBg: "#27272a"
+    },
+    typography: {
+      headingFont: "PingFang SC",
+      bodyFont: "Kaiti SC"
+    },
+    footerText: "",
+    watermarkText: "",
+    chrome: {
+      showHeader: false,
+      showWatermark: false,
+      showPageNumber: false,
+      showFooter: false,
+      showFooterDivider: false,
+      showFooterText: false,
+      showFillRatio: false
+    }
+  },
+  {
+    ...getDefaultConfig("wide-16-9"),
+    id: "tpl_wide_tech_banner",
+    name: "极简技术宽屏 (16:9)",
+    algorithm: {
+      ...getDefaultConfig("wide-16-9").algorithm,
+      baseFontSize: 46,
+      scaleRatio: 1.3,
+      verticalAlign: "center",
+      textAlign: "left"
+    },
+    theme: {
+      bgColor: "#09090b",
+      textColor: "#f4f4f5",
+      headingColor: "#ffffff",
+      accentColor: "#3b82f6",
+      quoteColor: "#a1a1aa",
+      captionColor: "#71717a",
+      watermarkColor: "#52525b",
+      cardBg: "#18181b"
+    },
+    typography: {
+      headingFont: "PingFang SC",
+      bodyFont: "SourceHanSansSC, sans-serif"
+    },
+    footerText: "TECH ENGINEERING INSIGHTS",
+    watermarkText: "DEV // ARCHITECTURE",
+    chrome: {
+      showHeader: true,
+      showWatermark: true,
+      showPageNumber: false,
+      showFooter: true,
+      showFooterDivider: false,
+      showFooterText: true,
+      showFillRatio: false
+    }
+  },
+  {
+    ...getDefaultConfig("longform-3-4"),
+    id: "tpl_longform_vintage_news",
+    name: "复古报刊多图 (3:4)",
+    slot: "newspic_content",
+    algorithm: {
+      ...getDefaultConfig("longform-3-4").algorithm,
+      baseFontSize: 38,
+      scaleRatio: 1.25,
+      verticalAlign: "top",
+      textAlign: "left"
+    },
+    theme: {
+      bgColor: "#f7f4ee",
+      textColor: "#262320",
+      headingColor: "#141210",
+      accentColor: "#991b1b",
+      quoteColor: "#57534e",
+      captionColor: "#78716c",
+      watermarkColor: "#a8a29e",
+      cardBg: "#eee9df"
+    },
+    typography: {
+      headingFont: "SourceHanSerifSC, serif",
+      bodyFont: "SourceHanSerifSC, serif"
+    },
+    footerText: "WEEKLY REPORT · 观察与沉淀",
+    watermarkText: "VOL. 42 // THE CHRONICLE",
+    chrome: {
+      showHeader: true,
+      showWatermark: true,
+      showPageNumber: true,
+      showFooter: true,
+      showFooterDivider: true,
+      showFooterText: true,
+      showFillRatio: false
+    }
+  }
+];
+function seedDefaultTemplates() {
+  if (!existsSync(TEMPLATES_DIR))
+    return;
+  for (const preset of BUILTIN_PRESETS) {
+    const filePath = join(TEMPLATES_DIR, `${preset.id}.json`);
+    if (!existsSync(filePath)) {
+      try {
+        writeFileSync(filePath, JSON.stringify(preset, null, 2), "utf-8");
+      } catch {}
+    }
+  }
+}
+var DEFAULT_SETTINGS_PATH = join(resolveDataDir(), "default-template.json");
+var BUILTIN_SLOT_DEFAULTS = {
+  article_cover: "tpl_wechat_cover_minimal",
+  newspic_cover: "tpl_newspic_poster_cover",
+  newspic_content: "tpl_longform_paper_sage"
+};
+function getSlotDefaultTemplateId(slot, account = "default") {
+  if (existsSync(DEFAULT_SETTINGS_PATH)) {
+    try {
+      const data = JSON.parse(readFileSync(DEFAULT_SETTINGS_PATH, "utf-8"));
+      if (account && data.accounts?.[account]?.[slot]) {
+        return data.accounts[account][slot];
+      }
+      if (data.slots?.[slot]) {
+        return data.slots[slot];
+      }
+    } catch {}
+  }
+  return BUILTIN_SLOT_DEFAULTS[slot] || "tpl_wechat_cover_minimal";
+}
+function setSlotDefaultTemplateId(slot, templateId, account = "default") {
+  const dir = dirname(DEFAULT_SETTINGS_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  let current = { slots: { ...BUILTIN_SLOT_DEFAULTS }, accounts: {} };
+  if (existsSync(DEFAULT_SETTINGS_PATH)) {
+    try {
+      current = JSON.parse(readFileSync(DEFAULT_SETTINGS_PATH, "utf-8"));
+    } catch {}
+  }
+  if (!current.slots)
+    current.slots = { ...BUILTIN_SLOT_DEFAULTS };
+  if (!current.accounts)
+    current.accounts = {};
+  if (!account || account === "default") {
+    current.slots[slot] = templateId;
+  } else {
+    if (!current.accounts[account])
+      current.accounts[account] = {};
+    current.accounts[account][slot] = templateId;
+  }
+  writeFileSync(DEFAULT_SETTINGS_PATH, JSON.stringify(current, null, 2), "utf-8");
+}
+function getDefaultTemplateId() {
+  if (existsSync(DEFAULT_SETTINGS_PATH)) {
+    try {
+      const data = JSON.parse(readFileSync(DEFAULT_SETTINGS_PATH, "utf-8"));
+      return data.defaultTemplateId || data.slots?.article_cover || null;
+    } catch {
+      return null;
+    }
+  }
+  return BUILTIN_SLOT_DEFAULTS.article_cover;
+}
+function setDefaultTemplateId(id) {
+  const dir = dirname(DEFAULT_SETTINGS_PATH);
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  let current = { slots: { ...BUILTIN_SLOT_DEFAULTS }, accounts: {} };
+  if (existsSync(DEFAULT_SETTINGS_PATH)) {
+    try {
+      current = JSON.parse(readFileSync(DEFAULT_SETTINGS_PATH, "utf-8"));
+    } catch {}
+  }
+  current.defaultTemplateId = id;
+  writeFileSync(DEFAULT_SETTINGS_PATH, JSON.stringify(current, null, 2), "utf-8");
+}
+function findTemplateByKeyOrName(key) {
+  const lowerKey = key.trim().toLowerCase();
+  if (!lowerKey)
+    return null;
+  ensureTemplatesDir();
+  if (!existsSync(TEMPLATES_DIR))
+    return BUILTIN_PRESETS.find((p) => p.id?.toLowerCase() === lowerKey || p.name.toLowerCase() === lowerKey) ?? null;
+  const directPath = templatePath(key);
+  if (directPath && existsSync(directPath)) {
+    try {
+      return JSON.parse(readFileSync(directPath, "utf-8"));
+    } catch {}
+  }
+  const files = readdirSync(TEMPLATES_DIR).filter((f) => f.endsWith(".json"));
+  const templates = [];
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(TEMPLATES_DIR, file), "utf-8");
+      const tpl = JSON.parse(content);
+      if (tpl.id?.toLowerCase() === lowerKey || tpl.name.toLowerCase() === lowerKey) {
+        return tpl;
+      }
+      templates.push(tpl);
+    } catch {}
+  }
+  return templates.find((tpl) => tpl.name.toLowerCase().includes(lowerKey)) ?? null;
+}
+function templatePath(id) {
+  return /^[a-zA-Z0-9_-]+$/.test(id) ? join(TEMPLATES_DIR, `${id}.json`) : null;
+}
+var templatesRouter = new Hono3;
+templatesRouter.get("/", (c) => {
+  ensureTemplatesDir();
+  const files = readdirSync(TEMPLATES_DIR).filter((f) => f.endsWith(".json"));
+  const templates = [];
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(TEMPLATES_DIR, file), "utf-8");
+      const parsed = JSON.parse(content);
+      templates.push(parsed);
+    } catch {}
+  }
+  return c.json({ ok: true, templates });
+});
+templatesRouter.get("/slots", (c) => {
+  ensureTemplatesDir();
+  const account = c.req.query("account") || "default";
+  const articleCoverId = getSlotDefaultTemplateId("article_cover", account);
+  const newspicCoverId = getSlotDefaultTemplateId("newspic_cover", account);
+  const newspicContentId = getSlotDefaultTemplateId("newspic_content", account);
+  return c.json({
+    ok: true,
+    account,
+    slots: {
+      article_cover: {
+        id: articleCoverId,
+        template: findTemplateByKeyOrName(articleCoverId)
+      },
+      newspic_cover: {
+        id: newspicCoverId,
+        template: findTemplateByKeyOrName(newspicCoverId)
+      },
+      newspic_content: {
+        id: newspicContentId,
+        template: findTemplateByKeyOrName(newspicContentId)
+      }
+    }
+  });
+});
+templatesRouter.post("/slots", async (c) => {
+  ensureTemplatesDir();
+  const body = await c.req.json();
+  if (!body.slot || !body.templateId) {
+    return c.json({ ok: false, error: "slot and templateId are required" }, 400);
+  }
+  const tpl = findTemplateByKeyOrName(body.templateId);
+  if (!tpl) {
+    return c.json({ ok: false, error: `Template '${body.templateId}' not found` }, 404);
+  }
+  const account = body.account || "default";
+  setSlotDefaultTemplateId(body.slot, tpl.id || body.templateId, account);
+  return c.json({
+    ok: true,
+    slot: body.slot,
+    account,
+    templateId: tpl.id || body.templateId,
+    template: tpl
+  });
+});
+templatesRouter.get("/default", (c) => {
+  ensureTemplatesDir();
+  const defaultId = getDefaultTemplateId();
+  let template = null;
+  if (defaultId) {
+    template = findTemplateByKeyOrName(defaultId);
+  }
+  return c.json({ ok: true, defaultTemplateId: defaultId, template });
+});
+templatesRouter.post("/default", async (c) => {
+  ensureTemplatesDir();
+  const body = await c.req.json();
+  const id = body.templateId || body.templateKey;
+  if (!id) {
+    return c.json({ ok: false, error: "templateId is required" }, 400);
+  }
+  const tpl = findTemplateByKeyOrName(id);
+  if (!tpl) {
+    return c.json({ ok: false, error: "Template not found" }, 404);
+  }
+  setDefaultTemplateId(tpl.id || id);
+  return c.json({ ok: true, defaultTemplateId: tpl.id || id, template: tpl });
+});
+templatesRouter.get("/resolve/:key", (c) => {
+  ensureTemplatesDir();
+  const key = c.req.param("key");
+  const tpl = findTemplateByKeyOrName(key);
+  if (!tpl) {
+    return c.json({ ok: false, error: `Template matching '${key}' not found` }, 404);
+  }
+  return c.json({ ok: true, template: tpl });
+});
+templatesRouter.get("/:id", (c) => {
+  ensureTemplatesDir();
+  const id = c.req.param("id");
+  const filePath = templatePath(id);
+  if (!filePath)
+    return c.json({ ok: false, error: "Invalid template id" }, 400);
+  if (!existsSync(filePath)) {
+    return c.json({ ok: false, error: "Template not found" }, 404);
+  }
+  const content = readFileSync(filePath, "utf-8");
+  return c.json({ ok: true, template: JSON.parse(content) });
+});
+templatesRouter.post("/", async (c) => {
+  ensureTemplatesDir();
+  const body = await c.req.json();
+  if (!body.name) {
+    return c.json({ ok: false, error: "Template name is required" }, 400);
+  }
+  try {
+    validateTemplateAssets(body.images);
+  } catch (error) {
+    return c.json({ ok: false, error: error instanceof Error ? error.message : "无效的模板素材" }, 400);
+  }
+  const id = body.id || `tpl_${Date.now()}_${Math.random().toString(36).substring(2, 7)}`;
+  const templateToSave = {
+    ...body,
+    id
+  };
+  const filePath = templatePath(id);
+  if (!filePath)
+    return c.json({ ok: false, error: "Invalid template id" }, 400);
+  writeFileSync(filePath, JSON.stringify(templateToSave, null, 2), "utf-8");
+  return c.json({ ok: true, template: templateToSave });
+});
+templatesRouter.delete("/:id", (c) => {
+  ensureTemplatesDir();
+  const id = c.req.param("id");
+  const filePath = templatePath(id);
+  if (!filePath)
+    return c.json({ ok: false, error: "Invalid template id" }, 400);
+  if (existsSync(filePath)) {
+    unlinkSync(filePath);
+    return c.json({ ok: true, message: "Template deleted" });
+  }
+  return c.json({ ok: false, error: "Template not found" }, 404);
+});
+
+// src/server/routes/render.ts
+var renderRouter = new Hono3;
+renderRouter.onError((error, c) => {
+  if (error.message.startsWith("模板素材 "))
+    return c.json({ ok: false, error: error.message }, 422);
+  if (error instanceof RangeError)
+    return c.json({ ok: false, error: error.message }, 400);
+  console.error("渲染失败", error);
+  return c.json({ ok: false, error: "Render failed" }, 500);
+});
+function inferSlot(route, kind, aspectRatio) {
+  if (route === "wechat-article" || kind === "article_cover" || aspectRatio === "wechat-cover-2.35") {
+    return "article_cover";
+  }
+  if (route === "wechat-newspic") {
+    if (kind === "content" || kind === "pages") {
+      return "newspic_content";
+    }
+    return "newspic_cover";
+  }
+  if (kind === "cover") {
+    return "article_cover";
+  }
+  return;
+}
+function resolveTypesetResult(body) {
+  if (body.result) {
+    return {
+      templateId: body.result.config?.id,
+      templateName: body.result.config?.name,
+      slot: body.result.config?.slot,
+      result: body.result
+    };
+  }
+  let markdown = body.markdown || body.text;
+  if (!markdown && body.title) {
+    markdown = `# ${body.title}`;
+  }
+  if (!markdown) {
+    markdown = `# 示例标题
+正文内容`;
+  }
+  const targetKey = body.templateId || body.templateKey || body.template;
+  let baseConfig = null;
+  if (targetKey) {
+    baseConfig = findTemplateByKeyOrName(targetKey);
+    if (!baseConfig)
+      throw new RangeError(`Template '${targetKey}' not found`);
+  }
+  const resolvedSlot = body.slot || inferSlot(body.route, body.kind, body.config?.aspectRatio);
+  if (!baseConfig && resolvedSlot) {
+    const slotDefaultId = getSlotDefaultTemplateId(resolvedSlot, body.account || "default");
+    if (slotDefaultId) {
+      baseConfig = findTemplateByKeyOrName(slotDefaultId);
+    }
+  }
+  if (!baseConfig) {
+    const defaultId = getDefaultTemplateId();
+    if (defaultId) {
+      baseConfig = findTemplateByKeyOrName(defaultId);
+    }
+  }
+  if (!baseConfig) {
+    const isCover = resolvedSlot === "article_cover" || body.route === "wechat-article";
+    baseConfig = getDefaultConfig(isCover ? "wechat-cover-2.35" : "longform-3-4");
+  }
+  const overrides = body.preserveTemplateStyle && baseConfig.id ? {} : body.config;
+  const effectiveConfig = {
+    ...baseConfig,
+    ...overrides || {},
+    algorithm: {
+      ...baseConfig.algorithm,
+      ...overrides?.algorithm || {}
+    },
+    theme: {
+      ...baseConfig.theme,
+      ...overrides?.theme || {}
+    },
+    typography: {
+      ...baseConfig.typography,
+      ...overrides?.typography || {}
+    },
+    chrome: { ...baseConfig.chrome, ...overrides?.chrome }
+  };
+  const resolvedImages = applyTemplateImages(body.images || [], effectiveConfig.images, body.templateImageOverrides);
+  let result;
+  while (true) {
+    try {
+      result = runTypeset({
+        markdown,
+        images: resolvedImages,
+        config: effectiveConfig,
+        highlightWords: body.highlightWords || [],
+        minPages: body.minPages,
+        maxPages: body.maxPages,
+        pageFillRatios: body.pageFillRatios
+      });
+      break;
+    } catch (error) {
+      const theme = effectiveConfig.coverTheme;
+      if (!theme || body.kind !== "cover" || !(error instanceof Error) || !/exceeds maxPages|cannot fit/.test(error.message))
+        throw error;
+      const title = theme.typography.title;
+      if (!Number.isFinite(title.fontSize) || !Number.isFinite(title.minFontSize) || title.minFontSize <= 0) {
+        throw new RangeError("Invalid cover theme font size");
+      }
+      if (title.fontSize <= title.minFontSize)
+        throw error;
+      effectiveConfig.coverTheme = {
+        ...theme,
+        typography: { ...theme.typography, title: {
+          ...title,
+          fontSize: Math.max(title.minFontSize, Math.floor(title.fontSize * 0.9))
+        } }
+      };
+    }
+  }
+  return {
+    templateId: baseConfig.id,
+    templateName: baseConfig.name,
+    slot: resolvedSlot,
+    result
+  };
+}
+renderRouter.post("/", async (c) => {
+  const body = await c.req.json();
+  const resolved = resolveTypesetResult(body);
+  return c.json({
+    ok: true,
+    templateId: resolved.templateId,
+    templateName: resolved.templateName,
+    slot: resolved.slot,
+    result: resolved.result
+  });
+});
+renderRouter.post("/png", async (c) => {
+  const body = await c.req.json();
+  const { result } = resolveTypesetResult(body);
+  const targetPageNumber = body.pageNumber ?? 1;
+  const targetPage = result.pages.find((p) => p.pageNumber === targetPageNumber) || result.pages[0];
+  if (!targetPage) {
+    return c.json({ ok: false, error: "No page available to render" }, 404);
+  }
+  const pngBuffer = await renderPageToPng(targetPage, result.canvasSpec, result.config, result.pageCount);
+  return new Response(new Uint8Array(pngBuffer), {
+    status: 200,
+    headers: {
+      "Content-Type": "image/png",
+      "Content-Length": String(pngBuffer.length),
+      "Content-Disposition": `inline; filename="typeset-${result.canvasSpec.id}-p${targetPage.pageNumber}.png"`,
+      "Cache-Control": "no-cache"
+    }
+  });
+});
+renderRouter.post("/export", async (c) => {
+  const body = await c.req.json();
+  const { result } = resolveTypesetResult(body);
+  const pngOutputs = await renderTypesetResultToPngs(result);
+  return c.json({
+    ok: true,
+    pageCount: pngOutputs.length,
+    pages: pngOutputs.map((item) => ({
+      pageNumber: item.pageNumber,
+      dataUrl: `data:image/png;base64,${item.buffer.toString("base64")}`,
+      byteLength: item.buffer.length,
+      imageIds: result.pages.find((page) => page.pageNumber === item.pageNumber).images.map((image) => image.id),
+      bodyImageCount: result.pages.find((page) => page.pageNumber === item.pageNumber).images.filter((image) => !image.templateAssetKey).length,
+      bodyImageSources: result.pages.find((page) => page.pageNumber === item.pageNumber).images.filter((image) => !image.templateAssetKey).map((image) => image.src),
+      bodyImageIds: result.pages.find((page) => page.pageNumber === item.pageNumber).images.filter((image) => !image.templateAssetKey).map((image) => image.id),
+      imageCount: result.pages.find((page) => page.pageNumber === item.pageNumber).images.length,
+      imageSources: result.pages.find((page) => page.pageNumber === item.pageNumber).images.map((image) => image.src)
+    }))
+  });
+});
+
+export { validateTemplateAssets, applyTemplateImages, getDefaultConfig, runTypeset, renderRouter, resolveTypesetResult };