agentic-mermaid 0.1.1 → 0.2.0

package/dist/chunk-FDM43XU7.js

@@ -0,0 +1,615 @@
+import {
+  BUILTIN_RESOURCE_MEDIA_TYPES,
+  RESOURCE_MANIFEST,
+  applyPngColorProfile,
+  graphemes,
+  inlineFontVarForRaster,
+  inspectPngDimensions,
+  omitPngOutputOptions,
+  pngNapiRuntimeProvenance,
+  prepareRenderInput,
+  prepareSvgForPngRasterization,
+  projectNativePngOutputPolicyInput,
+  renderPngGraphicalProjection,
+  snapshotHostBackendPolicy,
+  snapshotResourceManifest
+} from "./chunk-BJYMBT4I.js";
+
+// src/agent/png.ts
+import { fileURLToPath } from "url";
+import { tmpdir as tmpdir2 } from "os";
+import { basename, dirname as dirname2, join as join4 } from "path";
+import { existsSync, mkdtempSync as mkdtempSync2, rmSync as rmSync2, writeFileSync as writeFileSync2 } from "fs";
+import { Resvg } from "@resvg/resvg-js";
+
+// src/agent/font-coverage.ts
+import { readdirSync, readFileSync, statSync } from "fs";
+import { join } from "path";
+
+// src/agent/font-coverage-core.ts
+import { decodeXML } from "entities";
+var CMAP = 1668112752;
+var TTCF = 1953784678;
+var OTTO = 1330926671;
+var TRUE = 1953658213;
+function parseFont(bytes) {
+  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+  try {
+    if (view.getUint32(0) === TTCF) {
+      const faces = [];
+      for (let i = 0; i < view.getUint32(8); i++) faces.push(parseSfnt(view, view.getUint32(12 + i * 4)));
+      return faces.filter((face2) => face2.length > 0);
+    }
+    const face = parseSfnt(view, 0);
+    return face.length > 0 ? [face] : [];
+  } catch {
+    return [];
+  }
+}
+function parseSfnt(view, base) {
+  const version = view.getUint32(base);
+  if (version !== 65536 && version !== OTTO && version !== TRUE) return [];
+  const tables = view.getUint16(base + 4);
+  for (let i = 0; i < tables; i++) {
+    const record = base + 12 + i * 16;
+    if (view.getUint32(record) === CMAP) return parseCmap(view, view.getUint32(record + 8));
+  }
+  return [];
+}
+function parseCmap(view, offset) {
+  const lookups = [];
+  const count = view.getUint16(offset + 2);
+  for (let i = 0; i < count; i++) {
+    const record = offset + 4 + i * 8;
+    const platform = view.getUint16(record);
+    const encoding = view.getUint16(record + 2);
+    if (!(platform === 0 || platform === 3 && (encoding === 1 || encoding === 10))) continue;
+    const subtable = offset + view.getUint32(record + 4);
+    const format = view.getUint16(subtable);
+    if (format === 4) lookups.push(format4(view, subtable));
+    else if (format === 12) lookups.push(format12(view, subtable));
+    else if (format === 6) lookups.push(format6(view, subtable));
+    else if (format === 0) lookups.push(format0(view, subtable));
+  }
+  return lookups;
+}
+function format4(view, subtable) {
+  const count = view.getUint16(subtable + 6) / 2;
+  const ends = subtable + 14;
+  const starts = ends + count * 2 + 2;
+  const deltas = starts + count * 2;
+  const offsets = deltas + count * 2;
+  return { has(codepoint) {
+    if (codepoint > 65535) return false;
+    let low = 0, high = count - 1;
+    while (low < high) {
+      const mid = low + high >> 1;
+      if (view.getUint16(ends + mid * 2) < codepoint) low = mid + 1;
+      else high = mid;
+    }
+    if (view.getUint16(starts + low * 2) > codepoint || codepoint === 65535) return false;
+    const rangeOffset = view.getUint16(offsets + low * 2);
+    if (rangeOffset === 0) return (codepoint + view.getInt16(deltas + low * 2) & 65535) !== 0;
+    const glyphOffset = offsets + low * 2 + rangeOffset + (codepoint - view.getUint16(starts + low * 2)) * 2;
+    if (glyphOffset + 2 > view.byteLength) return false;
+    const glyph = view.getUint16(glyphOffset);
+    return glyph !== 0 && (glyph + view.getInt16(deltas + low * 2) & 65535) !== 0;
+  } };
+}
+function format12(view, subtable) {
+  const count = view.getUint32(subtable + 12);
+  const groups = subtable + 16;
+  return { has(codepoint) {
+    let low = 0, high = count - 1;
+    while (low <= high) {
+      const mid = low + high >> 1;
+      const at = groups + mid * 12;
+      if (codepoint < view.getUint32(at)) high = mid - 1;
+      else if (codepoint > view.getUint32(at + 4)) low = mid + 1;
+      else return view.getUint32(at + 8) + codepoint - view.getUint32(at) !== 0;
+    }
+    return false;
+  } };
+}
+function format6(view, subtable) {
+  const first = view.getUint16(subtable + 6);
+  const count = view.getUint16(subtable + 8);
+  return { has: (codepoint) => codepoint >= first && codepoint < first + count && view.getUint16(subtable + 10 + (codepoint - first) * 2) !== 0 };
+}
+function format0(view, subtable) {
+  return { has: (codepoint) => codepoint < 256 && view.getUint8(subtable + 6 + codepoint) !== 0 };
+}
+function extractSvgTextContent(svg) {
+  let text = "";
+  for (const match of svg.matchAll(/<text\b[^>]*>([\s\S]*?)<\/text>/g)) text += match[1].replace(/<[^>]*>/g, "");
+  return decodeXML(text);
+}
+function ignorable(codepoint) {
+  return codepoint <= 32 || codepoint === 127 || codepoint >= 8203 && codepoint <= 8207 || codepoint === 8232 || codepoint === 8233 || codepoint >= 65024 && codepoint <= 65039 || codepoint === 65279;
+}
+function script(codepoint) {
+  if (codepoint >= 11904 && codepoint <= 40959 || codepoint >= 44032 && codepoint <= 55295 || codepoint >= 63744 && codepoint <= 64255 || codepoint >= 131072 && codepoint <= 262143) return "CJK";
+  if (codepoint >= 9728 && codepoint <= 10175 || codepoint >= 126976 && codepoint <= 129791) return "emoji";
+  if (codepoint >= 1424 && codepoint <= 1535) return "Hebrew";
+  if (codepoint >= 1536 && codepoint <= 1919) return "Arabic";
+  if (codepoint >= 2304 && codepoint <= 2431) return "Devanagari";
+  return "other";
+}
+function findUncoveredScriptsFromBuffers(svg, fontBuffers) {
+  const faces = fontBuffers.flatMap(parseFont);
+  const byScript = /* @__PURE__ */ new Map();
+  for (const cluster of graphemes(extractSvgTextContent(svg))) {
+    const codepoints = [...cluster].map((char) => char.codePointAt(0)).filter((codepoint) => !ignorable(codepoint));
+    if (codepoints.length === 0) continue;
+    const oneFaceCovers = faces.some((face) => codepoints.every((codepoint) => face.some((lookup) => lookup.has(codepoint))));
+    const shapingUncertain = cluster.includes("\u200D") || /\p{Mark}/u.test(cluster);
+    if (oneFaceCovers && !shapingUncertain) continue;
+    for (const codepoint of codepoints) {
+      const bucket = byScript.get(script(codepoint)) ?? /* @__PURE__ */ new Set();
+      bucket.add(codepoint);
+      byScript.set(script(codepoint), bucket);
+    }
+  }
+  return [...byScript].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([name, values]) => ({
+    script: name,
+    chars: [...values].sort((a, b) => a - b).map((codepoint) => String.fromCodePoint(codepoint))
+  }));
+}
+
+// src/agent/font-coverage.ts
+var FONT_EXT = /\.(ttf|otf|ttc|otc)$/i;
+function fontFilesUnder(directory, depth = 4) {
+  if (depth < 0) return [];
+  let entries;
+  try {
+    entries = readdirSync(directory).sort();
+  } catch {
+    return [];
+  }
+  const files = [];
+  for (const entry of entries) {
+    const path = join(directory, entry);
+    try {
+      const stat = statSync(path);
+      if (stat.isDirectory()) files.push(...fontFilesUnder(path, depth - 1));
+      else if (FONT_EXT.test(entry)) files.push(path);
+    } catch {
+    }
+  }
+  return files;
+}
+function fontBuffersUnder(directories) {
+  const buffers = [];
+  for (const directory of directories) {
+    for (const file of fontFilesUnder(directory)) {
+      try {
+        buffers.push(new Uint8Array(readFileSync(file)));
+      } catch {
+      }
+    }
+  }
+  return buffers;
+}
+function findUncoveredScripts(svg, callerFontDirectories, verifiedFontBuffers) {
+  return findUncoveredScriptsFromBuffers(svg, [
+    ...verifiedFontBuffers,
+    ...fontBuffersUnder(callerFontDirectories)
+  ]);
+}
+
+// src/shared/png-font-warnings.ts
+function buildPngFontWarnings(uncovered, options = {}) {
+  return uncovered.map(({ script: script2, chars }) => {
+    const examples = chars.slice(0, 5).join(" ");
+    const uncertainty = options.systemFontsMayCover ? " They are absent from bundled/caller-provided fonts; an installed system font may cover them, so final shaping is machine-dependent." : " They may draw as tofu or fail to shape as one grapheme.";
+    return {
+      code: "PNG_FONT_COVERAGE",
+      script: script2,
+      chars: [...chars],
+      message: `no known loaded face covers ${chars.length} ${script2} character${chars.length === 1 ? "" : "s"} (${examples}) in one grapheme cluster.${uncertainty} Supply fontDirs (CLI: --font-dirs <dir>) with a face that covers the cluster.`
+    };
+  });
+}
+
+// src/node-resource-resolver.ts
+import { createHash } from "crypto";
+import {
+  closeSync,
+  constants as fsConstants,
+  fstatSync,
+  lstatSync,
+  openSync,
+  readSync,
+  realpathSync
+} from "fs";
+import { isAbsolute, join as join2, relative, sep } from "path";
+var ResourceResolutionError = class extends Error {
+  code;
+  resourceId;
+  constructor(code, resourceId, message) {
+    super(`${code}: ${message}`);
+    this.name = "ResourceResolutionError";
+    this.code = code;
+    this.resourceId = resourceId;
+  }
+};
+function errnoCode(error) {
+  return typeof error === "object" && error !== null && "code" in error ? String(error.code) : void 0;
+}
+function sha256(bytes) {
+  return createHash("sha256").update(bytes).digest("hex");
+}
+function openedResourceDescriptorPath(platform, fd) {
+  if (platform === "linux") return `/proc/self/fd/${fd}`;
+  if (platform === "darwin") return `/dev/fd/${fd}`;
+  return void 0;
+}
+var NodeResourceResolver = class {
+  #root;
+  #manifest;
+  #maxResourceBytes;
+  #mediaTypes;
+  #byId;
+  constructor(packageRoot, manifest, options = {}) {
+    let manifestSnapshot;
+    try {
+      manifestSnapshot = snapshotResourceManifest(manifest);
+    } catch (error) {
+      const detail = error instanceof Error ? error.message.replace(/^INVALID_RESOURCE_MANIFEST:\s*/, "") : String(error);
+      throw new ResourceResolutionError("INVALID_RESOURCE_MANIFEST", "resource-manifest", detail);
+    }
+    const maxResourceBytes = options.maxResourceBytes ?? 16 * 1024 * 1024;
+    if (!Number.isSafeInteger(maxResourceBytes) || maxResourceBytes <= 0) {
+      throw new ResourceResolutionError("INVALID_RESOURCE_MANIFEST", "resource-manifest", "maxResourceBytes must be a positive safe integer");
+    }
+    try {
+      this.#root = realpathSync(packageRoot);
+    } catch {
+      throw new ResourceResolutionError("RESOURCE_MISSING", "resource-manifest", `package root does not exist: ${packageRoot}`);
+    }
+    this.#manifest = manifestSnapshot;
+    this.#maxResourceBytes = maxResourceBytes;
+    this.#mediaTypes = Object.freeze({ ...options.mediaTypes ?? BUILTIN_RESOURCE_MEDIA_TYPES });
+    this.#byId = new Map(this.#manifest.resources.map((entry) => [entry.identity.id, entry]));
+  }
+  list() {
+    return this.#manifest.resources;
+  }
+  #securePath(entry, declaredPath, missingCode) {
+    const segments = declaredPath.split("/");
+    let candidate = this.#root;
+    for (const segment of segments) {
+      candidate = join2(candidate, segment);
+      let stat;
+      try {
+        stat = lstatSync(candidate);
+      } catch (error) {
+        if (errnoCode(error) === "ENOENT") {
+          throw new ResourceResolutionError(missingCode, entry.identity.id, `declared path is missing: ${declaredPath}`);
+        }
+        throw error;
+      }
+      if (stat.isSymbolicLink()) {
+        throw new ResourceResolutionError("RESOURCE_SYMLINK_REJECTED", entry.identity.id, `symlink component is forbidden: ${declaredPath}`);
+      }
+    }
+    const escaped = relative(this.#root, candidate);
+    if (escaped === ".." || escaped.startsWith(`..${sep}`) || isAbsolute(escaped)) {
+      throw new ResourceResolutionError("RESOURCE_PATH_ESCAPE", entry.identity.id, `path escapes package root: ${declaredPath}`);
+    }
+    return candidate;
+  }
+  #openSecureFile(entry, declaredPath, missingCode) {
+    const absolutePath = this.#securePath(entry, declaredPath, missingCode);
+    let fd;
+    try {
+      fd = openSync(absolutePath, fsConstants.O_RDONLY | fsConstants.O_NOFOLLOW);
+    } catch (error) {
+      const code = errnoCode(error);
+      if (code === "ENOENT") throw new ResourceResolutionError(missingCode, entry.identity.id, `declared path is missing: ${declaredPath}`);
+      if (code === "ELOOP") throw new ResourceResolutionError("RESOURCE_SYMLINK_REJECTED", entry.identity.id, `symlink component is forbidden: ${declaredPath}`);
+      throw error;
+    }
+    try {
+      const openedStat = fstatSync(fd);
+      if (!openedStat.isFile()) {
+        throw new ResourceResolutionError("RESOURCE_NOT_REGULAR", entry.identity.id, `resource is not a regular file: ${declaredPath}`);
+      }
+      const descriptorPath = openedResourceDescriptorPath(process.platform, fd);
+      if (descriptorPath) {
+        const openedPath = realpathSync(descriptorPath);
+        if (openedPath !== descriptorPath && !openedPath.startsWith(`${descriptorPath}${sep}`)) {
+          const escaped = relative(this.#root, openedPath);
+          if (escaped === ".." || escaped.startsWith(`..${sep}`) || isAbsolute(escaped)) {
+            throw new ResourceResolutionError("RESOURCE_PATH_ESCAPE", entry.identity.id, `opened file escapes package root: ${declaredPath}`);
+          }
+        }
+      }
+      const rootedPath = this.#securePath(entry, declaredPath, missingCode);
+      const rootedStat = lstatSync(rootedPath);
+      if (!rootedStat.isFile()) {
+        throw new ResourceResolutionError("RESOURCE_NOT_REGULAR", entry.identity.id, `resource is not a regular file: ${declaredPath}`);
+      }
+      if (openedStat.dev !== rootedStat.dev || openedStat.ino !== rootedStat.ino) {
+        throw new ResourceResolutionError("RESOURCE_PATH_ESCAPE", entry.identity.id, `opened file identity no longer matches the rooted path: ${declaredPath}`);
+      }
+      return fd;
+    } catch (error) {
+      closeSync(fd);
+      throw error;
+    }
+  }
+  resolve(resourceId) {
+    const entry = this.#byId.get(resourceId);
+    if (!entry) throw new ResourceResolutionError("UNKNOWN_RESOURCE", resourceId, `resource is not installed: ${resourceId}`);
+    if (entry.bytes > this.#maxResourceBytes) {
+      throw new ResourceResolutionError("RESOURCE_SIZE_LIMIT", resourceId, `${entry.bytes} exceeds the ${this.#maxResourceBytes}-byte host limit`);
+    }
+    const licenseFd = this.#openSecureFile(entry, entry.license.noticePath, "RESOURCE_LICENSE_NOTICE_MISSING");
+    closeSync(licenseFd);
+    const fd = this.#openSecureFile(entry, entry.path, "RESOURCE_MISSING");
+    let bytes;
+    try {
+      const before = fstatSync(fd);
+      if (before.size !== entry.bytes) {
+        throw new ResourceResolutionError("RESOURCE_SIZE_MISMATCH", resourceId, `declared ${entry.bytes} bytes but found ${before.size}`);
+      }
+      const bounded = new Uint8Array(entry.bytes + 1);
+      let read = 0;
+      while (read < bounded.byteLength) {
+        const count = readSync(fd, bounded, read, bounded.byteLength - read, null);
+        if (count === 0) break;
+        read += count;
+      }
+      const after = fstatSync(fd);
+      if (read !== entry.bytes || after.size !== entry.bytes) {
+        throw new ResourceResolutionError("RESOURCE_SIZE_MISMATCH", resourceId, `declared ${entry.bytes} bytes but securely read ${read}`);
+      }
+      bytes = bounded.slice(0, read);
+    } finally {
+      closeSync(fd);
+    }
+    const mediaType = this.#mediaTypes[entry.mediaType];
+    if (!mediaType || !mediaType(bytes)) {
+      throw new ResourceResolutionError("RESOURCE_MEDIA_TYPE_MISMATCH", resourceId, `resource bytes do not match ${entry.mediaType}`);
+    }
+    const actualDigest = sha256(bytes);
+    if (actualDigest !== entry.sha256) {
+      throw new ResourceResolutionError("RESOURCE_DIGEST_MISMATCH", resourceId, `expected ${entry.sha256}, received ${actualDigest}`);
+    }
+    const snapshot = bytes.slice();
+    return Object.freeze({
+      entry,
+      readBytes: () => snapshot.slice()
+    });
+  }
+  verifyInstalled() {
+    const resources = [];
+    const diagnostics = [];
+    for (const entry of this.#manifest.resources) {
+      try {
+        resources.push(this.resolve(entry.identity.id));
+      } catch (error) {
+        if (!entry.required && error instanceof ResourceResolutionError && error.code === "RESOURCE_MISSING") {
+          diagnostics.push(Object.freeze({
+            code: "OPTIONAL_RESOURCE_MISSING",
+            resourceId: entry.identity.id,
+            message: error.message
+          }));
+          continue;
+        }
+        throw error;
+      }
+    }
+    return Object.freeze({
+      resources: Object.freeze(resources),
+      diagnostics: Object.freeze(diagnostics)
+    });
+  }
+};
+
+// src/agent/embedded-font-resources.ts
+import { tmpdir } from "os";
+import { dirname, join as join3 } from "path";
+import { mkdirSync, mkdtempSync, readFileSync as readFileSync2, rmSync, writeFileSync } from "fs";
+var registeredFiles;
+function verifyEmbeddedFontResourceFiles(manifest, files) {
+  const snapshot = snapshotResourceManifest(manifest);
+  const pathOwners = /* @__PURE__ */ new Map();
+  for (const entry of snapshot.resources) {
+    pathOwners.set(entry.path, { resourceId: entry.identity.id, missingCode: "RESOURCE_MISSING" });
+    if (!pathOwners.has(entry.license.noticePath)) {
+      pathOwners.set(entry.license.noticePath, {
+        resourceId: entry.identity.id,
+        missingCode: "RESOURCE_LICENSE_NOTICE_MISSING"
+      });
+    }
+  }
+  const root = mkdtempSync(join3(tmpdir(), "agentic-mermaid-embedded-resources-"));
+  try {
+    const materialized = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      const owner = pathOwners.get(file.manifestPath);
+      if (!owner) {
+        throw new ResourceResolutionError(
+          "UNKNOWN_RESOURCE",
+          file.manifestPath,
+          `embedded path is not declared by the font resource manifest: ${file.manifestPath}`
+        );
+      }
+      if (materialized.has(file.manifestPath)) {
+        throw new ResourceResolutionError(
+          "INVALID_RESOURCE_MANIFEST",
+          owner.resourceId,
+          `duplicate embedded path: ${file.manifestPath}`
+        );
+      }
+      let bytes;
+      try {
+        bytes = readFileSync2(file.embeddedPath);
+      } catch {
+        throw new ResourceResolutionError(
+          owner.missingCode,
+          owner.resourceId,
+          `embedded source is unavailable for declared path: ${file.manifestPath}`
+        );
+      }
+      const target = join3(root, file.manifestPath);
+      mkdirSync(dirname(target), { recursive: true, mode: 448 });
+      writeFileSync(target, bytes, { flag: "wx", mode: 256 });
+      materialized.add(file.manifestPath);
+    }
+    return new NodeResourceResolver(root, snapshot).verifyInstalled();
+  } finally {
+    try {
+      rmSync(root, { recursive: true, force: true });
+    } catch {
+    }
+  }
+}
+function verifyRegisteredEmbeddedFontResources(manifest) {
+  return registeredFiles ? verifyEmbeddedFontResourceFiles(manifest, registeredFiles) : void 0;
+}
+
+// src/agent/png.ts
+var cachedBundledFonts;
+var cleanupRegistered = false;
+function materializeVerifiedFontSnapshot(resources) {
+  const snapshotDirectory = mkdtempSync2(join4(tmpdir2(), "agentic-mermaid-fonts-"));
+  try {
+    const buffers = resources.map((resource) => resource.readBytes());
+    const files = buffers.map((bytes, index) => {
+      const file = join4(snapshotDirectory, `${index}-${basename(resources[index].entry.path)}`);
+      writeFileSync2(file, bytes, { flag: "wx", mode: 256 });
+      return file;
+    });
+    return Object.freeze({
+      snapshotDirectory,
+      buffers: Object.freeze(buffers),
+      files: Object.freeze(files)
+    });
+  } catch (error) {
+    try {
+      rmSync2(snapshotDirectory, { recursive: true, force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function resolveBundledFonts() {
+  if (cachedBundledFonts) return cachedBundledFonts;
+  const here = typeof import.meta.url === "string" ? fileURLToPath(import.meta.url) : __filename;
+  let dir = dirname2(here);
+  for (let i = 0; i < 6; i++) {
+    const candidate = join4(dir, "assets", "fonts");
+    if (existsSync(candidate)) {
+      const verified = new NodeResourceResolver(dir, RESOURCE_MANIFEST).verifyInstalled();
+      cachedBundledFonts = materializeVerifiedFontSnapshot(verified.resources);
+      break;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) break;
+    dir = parent;
+  }
+  if (!cachedBundledFonts) {
+    const embedded = verifyRegisteredEmbeddedFontResources(RESOURCE_MANIFEST);
+    if (embedded) cachedBundledFonts = materializeVerifiedFontSnapshot(embedded.resources);
+  }
+  if (!cachedBundledFonts) throw new Error("RESOURCE_MISSING: required bundled font manifest could not be located");
+  if (!cleanupRegistered) {
+    cleanupRegistered = true;
+    process.once("exit", () => {
+      try {
+        if (cachedBundledFonts) rmSync2(cachedBundledFonts.snapshotDirectory, { recursive: true, force: true });
+      } catch {
+      }
+    });
+  }
+  return cachedBundledFonts;
+}
+function renderMermaidPNG(input, opts = {}) {
+  return renderMermaidPNGWithReceipt(input, opts).png;
+}
+function renderMermaidPNGWithReceipt(input, opts = {}) {
+  return renderMermaidPNGWithReceiptForHost(input, opts, {});
+}
+function createMermaidPNGRenderer(hostOptions = {}) {
+  const backendPolicy = snapshotHostBackendPolicy(hostOptions.backendPolicy);
+  const host = Object.freeze({ ...backendPolicy ? { backendPolicy } : {} });
+  return Object.freeze({
+    renderMermaidPNG(input, opts = {}) {
+      return renderMermaidPNGWithReceiptForHost(input, opts, host).png;
+    },
+    renderMermaidPNGWithReceipt(input, opts = {}) {
+      return renderMermaidPNGWithReceiptForHost(input, opts, host);
+    }
+  });
+}
+function renderMermaidPNGWithReceiptForHost(input, opts, hostOptions) {
+  const preparedInput = prepareRenderInput(input);
+  const source = preparedInput.source;
+  const onWarning = opts.onWarning;
+  if (onWarning !== void 0 && typeof onWarning !== "function") {
+    throw new TypeError("PNG onWarning must be a function");
+  }
+  const outputOptions = projectNativePngOutputPolicyInput(opts);
+  const renderOptions = omitPngOutputOptions(opts);
+  const graphical = renderPngGraphicalProjection(
+    source,
+    renderOptions,
+    outputOptions,
+    { backendPolicy: hostOptions.backendPolicy, expectedFamilyId: preparedInput.expectedFamilyId }
+  );
+  const outputPolicy = graphical.outputPolicy;
+  const svg = prepareSvgForPngRasterization(
+    inlineFontVarForRaster(graphical.svg),
+    graphical.rasterDimensions
+  );
+  const bundledFonts = resolveBundledFonts();
+  const emit = onWarning ?? ((w) => process.stderr.write(`agentic-mermaid renderMermaidPNG: warning ${w.code}: ${w.message}
+`));
+  for (const warning of buildPngFontWarnings(findUncoveredScripts(
+    svg,
+    outputPolicy.fonts.callerDirectories,
+    bundledFonts.buffers
+  ), { systemFontsMayCover: outputPolicy.fonts.loadSystemFonts })) emit(warning);
+  const resvgOpts = {
+    background: graphical.rasterBackground,
+    // The shared contract already projected and pinned exact integer root
+    // dimensions. Rendering at zoom 1 avoids resvg-specific ratio rounding.
+    fitTo: { mode: "zoom", value: 1 },
+    font: {
+      loadSystemFonts: outputPolicy.fonts.loadSystemFonts,
+      // These private files were materialized from the exact verified byte
+      // snapshots. Explicit caller directories remain a host-controlled input.
+      fontFiles: [...bundledFonts.files],
+      fontDirs: [...outputPolicy.fonts.callerDirectories],
+      // Inter is the metrics font: src/text-metrics.ts is calibrated for it
+      // and the SVG @import requests it, so rasterizing with anything else
+      // (DejaVu is ~14% wider) pushes long labels outside their measured
+      // boxes. resvg falls back per-glyph across every loaded font, so
+      // DejaVu still covers glyphs Inter lacks (arrows, math, Armenian, …).
+      defaultFontFamily: outputPolicy.fonts.defaultFamily
+    }
+  };
+  const resvg = new Resvg(svg, resvgOpts);
+  const png = applyPngColorProfile(resvg.render().asPng());
+  const actualDimensions = inspectPngDimensions(png);
+  if (actualDimensions.width !== graphical.rasterDimensions.width || actualDimensions.height !== graphical.rasterDimensions.height) {
+    throw new Error(
+      `native PNG rasterizer returned ${actualDimensions.width}\xD7${actualDimensions.height}; expected ${graphical.rasterDimensions.width}\xD7${graphical.rasterDimensions.height}`
+    );
+  }
+  return {
+    png: new Uint8Array(png.buffer, png.byteOffset, png.byteLength),
+    receipt: graphical.receipt,
+    runtime: pngNapiRuntimeProvenance(outputPolicy.fonts)
+  };
+}
+
+export {
+  renderMermaidPNG,
+  renderMermaidPNGWithReceipt,
+  createMermaidPNGRenderer
+};
+//# sourceMappingURL=chunk-FDM43XU7.js.map