pagyra-js 0.0.1

package/scripts/playground-browser-server.ts

@@ -0,0 +1,57 @@
+#!/usr/bin/env tsx
+import express from "express";
+import path from "node:path";
+import { mkdir } from "node:fs/promises";
+import { buildBrowserBundle } from "./browser-build.js";
+
+const PORT = Number.parseInt(process.env.PORT ?? "", 10) || 5177;
+const PUBLIC_DIR = path.resolve("playground", "public");
+const ENTRY = "playground/browser-entry.ts";
+const OUTFILE = "playground/public/vendor/pagyra-playground-browser.js";
+
+async function start() {
+  await mkdir(path.dirname(path.resolve(OUTFILE)), { recursive: true });
+  const buildResult = await buildBrowserBundle({
+    entry: ENTRY,
+    outfile: OUTFILE,
+    minify: false,
+    sourcemap: true,
+    watch: true,
+    onRebuild(error) {
+      if (error) {
+        console.error("[playground bundle] rebuild failed:", error);
+      } else {
+        console.log("[playground bundle] rebuild finished.");
+      }
+    },
+  });
+
+  const app = express();
+
+  app.get("/mode.js", (_req, res) => {
+    res.type("application/javascript");
+    res.send('window.__PLAYGROUND_MODE = "browser";');
+  });
+
+  // Expose shared assets (fonts, images) for the browser bundle.
+  app.use("/assets", express.static(path.resolve("assets")));
+  app.use(express.static(PUBLIC_DIR));
+
+  const server = app.listen(PORT, () => {
+    console.log(`[playground:browser] serving http://localhost:${PORT}`);
+  });
+
+  const cleanup = async () => {
+    server.close(() => console.log("[playground:browser] server stopped"));
+    await buildResult.stop?.();
+    process.exit();
+  };
+
+  process.once("SIGINT", cleanup);
+  process.once("SIGTERM", cleanup);
+}
+
+start().catch((error) => {
+  console.error("[playground:browser] failed to start:", error);
+  process.exit(1);
+});

package/scripts/probe-roboto.ts

@@ -0,0 +1,6 @@
+import { readFile } from "node:fs/promises";
+import { parseTtfBuffer } from "../src/pdf/font/ttf-lite.js";
+
+const data = await readFile("assets/fonts/Roboto-Regular.ttf");
+const metrics = parseTtfBuffer(data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength));
+console.log("glyphId", metrics.cmap.getGlyphId(0x25AA));

package/scripts/render-playground-example.ts

@@ -0,0 +1,121 @@
+#!/usr/bin/env tsx
+import fs from 'fs/promises';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { renderHtmlToPdf } from '../src/html-to-pdf.js';
+import { DEFAULT_PAGE_WIDTH_PX, DEFAULT_PAGE_HEIGHT_PX } from '../src/units/page-utils.js';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+async function main() {
+  // Parse command line arguments
+  const args = process.argv.slice(2);
+  let debugLevel: string | undefined;
+  let debugCats: string[] | undefined;
+  let examplePathArg: string | undefined;
+  let pageWidth: number | undefined;
+  let pageHeight: number | undefined;
+  let margins: { top: number; right: number; bottom: number; left: number } | undefined;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === '--debug-level' && i + 1 < args.length) {
+      debugLevel = args[i + 1] as any; // will validate later
+      i++;
+    } else if (arg === '--debug-cats' && i + 1 < args.length) {
+      debugCats = args[i + 1].split(',').map(cat => cat.trim()).filter(Boolean);
+      i++;
+    } else if (arg === '--page-width' && i + 1 < args.length) {
+      pageWidth = parseFloat(args[i + 1]);
+      i++;
+    } else if (arg === '--page-height' && i + 1 < args.length) {
+      pageHeight = parseFloat(args[i + 1]);
+      i++;
+    } else if (arg === '--margins' && i + 1 < args.length) {
+      const marginValues = args[i + 1].split(',').map(m => parseFloat(m.trim()));
+      if (marginValues.length === 1) {
+        margins = { top: marginValues[0], right: marginValues[0], bottom: marginValues[0], left: marginValues[0] };
+      } else if (marginValues.length === 2) {
+        margins = { top: marginValues[0], right: marginValues[1], bottom: marginValues[0], left: marginValues[1] };
+      } else if (marginValues.length === 4) {
+        margins = { top: marginValues[0], right: marginValues[1], bottom: marginValues[2], left: marginValues[3] };
+      } else {
+        console.warn('Invalid --margins argument. Expected 1, 2, or 4 comma-separated numbers (e.g., "10", "10,20", "10,20,30,40").');
+      }
+      i++;
+    } else if (!arg.startsWith('--')) {
+      examplePathArg = arg;
+    }
+  }
+
+  const repoRoot = path.resolve(__dirname, '..');
+  const examplesDir = path.join(repoRoot, 'playground', 'public', 'examples');
+  // Allow passing an example path or filename as the first argument. If it's a filename,
+  // resolve it under playground/public/examples. Otherwise use the default demo.
+  const arg = examplePathArg;
+  let examplePath: string;
+  if (arg) {
+    // Try a few sensible resolutions for the provided argument.
+    const candidateAbsolute = path.isAbsolute(arg) ? arg : path.join(repoRoot, arg);
+    const candidateExamples = path.join(examplesDir, arg);
+    try {
+      await fs.stat(candidateAbsolute);
+      examplePath = candidateAbsolute;
+    } catch {
+      try {
+        await fs.stat(candidateExamples);
+        examplePath = candidateExamples;
+      } catch {
+        const withHtml = candidateExamples.endsWith('.html') ? '' : '.html';
+        const candidateWithExt = candidateExamples + withHtml;
+        try {
+          await fs.stat(candidateWithExt);
+          examplePath = candidateWithExt;
+        } catch {
+          // Fallback: resolve under examplesDir (may still error later when reading)
+          examplePath = candidateExamples;
+        }
+      }
+    }
+  } else {
+    examplePath = path.join(examplesDir, 'svg-radial-transform-demo.html');
+  }
+  const outDir = path.join(repoRoot, 'playground', 'exports');
+  await fs.mkdir(outDir, { recursive: true });
+
+  const html = await fs.readFile(examplePath, 'utf8');
+
+  const finalPageWidth = pageWidth ?? DEFAULT_PAGE_WIDTH_PX;
+  const finalPageHeight = pageHeight ?? DEFAULT_PAGE_HEIGHT_PX;
+
+  console.log('Rendering playground example to PDF:', examplePath);
+  // Provide resource/asset roots so example-relative and absolute (/images/...) URLs resolve
+  const resourceBaseDir = path.dirname(examplePath);
+  const assetRootDir = path.join(repoRoot, 'playground', 'public');
+
+  const pdf = await renderHtmlToPdf({
+    html,
+    css: '',
+    viewportWidth: finalPageWidth,
+    viewportHeight: finalPageHeight,
+    pageWidth: finalPageWidth,
+    pageHeight: finalPageHeight,
+    margins: margins ?? { top: 0, right: 0, bottom: 0, left: 0 },
+    debug: !!(debugLevel || debugCats),
+    debugLevel: debugLevel as any,
+    debugCats,
+    resourceBaseDir,
+    assetRootDir,
+  });
+
+  const outName = path.basename(examplePath).replace(/\.html?$/i, '') + '.pdf';
+  const outPath = path.join(outDir, outName);
+  await fs.writeFile(outPath, pdf);
+  console.log('PDF written to:', outPath);
+}
+
+main().catch(err => {
+  console.error('Error rendering playground example:', err instanceof Error ? err.stack : err);
+  process.exit(1);
+});

package/scripts/run-glyph-atlas-tuner-runner.mjs

@@ -0,0 +1,113 @@
+/**
+ * Runner that imports compiled JS from dist and runs the atlas tuner.
+ * Use after building the project: `npm run build`
+ *
+ * Run with: `node scripts/run-glyph-atlas-tuner-runner.mjs`
+ *
+ * This avoids ts-node resolution issues by using the compiled output.
+ */
+
+import fs from "fs";
+import path from "path";
+
+import { parseTtfFont } from "../dist/src/pdf/font/ttf-lite.js";
+import { getGlyphMask, clearGlyphMaskCache } from "../dist/src/pdf/font/glyph-cache.js";
+import { pickAtlasSettingsFromSamples } from "../dist/src/pdf/font/glyph-atlas-tuner.js";
+
+async function sampleFromFont(fontPath, opts = {}) {
+  const samples = [];
+  const maxGlyphs = opts.maxGlyphs ?? 200;
+  const fontSizePx = opts.fontSizePx ?? 64;
+
+  try {
+    const metrics = parseTtfFont(fontPath);
+    const glyphCount = metrics.glyphMetrics ? metrics.glyphMetrics.size : Math.max(256, maxGlyphs);
+    const limit = Math.min(maxGlyphs, glyphCount);
+
+    if (metrics.glyphMetrics && metrics.glyphMetrics.size > 0) {
+      let i = 0;
+      for (const [gid] of metrics.glyphMetrics) {
+        if (i >= limit) break;
+        try {
+          const mask = getGlyphMask(metrics, gid, fontSizePx, 4);
+          if (mask && mask.width > 0 && mask.height > 0) {
+            samples.push({ width: mask.width, height: mask.height });
+            i++;
+          }
+        } catch (e) {
+          // ignore
+        }
+      }
+    } else {
+      for (let gid = 0; gid < limit; gid++) {
+        try {
+          const mask = getGlyphMask(metrics, gid, fontSizePx, 4);
+          if (mask && mask.width > 0 && mask.height > 0) {
+            samples.push({ width: mask.width, height: mask.height });
+          }
+        } catch (e) {}
+      }
+    }
+
+    clearGlyphMaskCache();
+  } catch (err) {
+    console.error("Failed to parse font", fontPath, err && err.message ? err.message : err);
+  }
+
+  return samples;
+}
+
+function syntheticSamples() {
+  const arr = [];
+  for (let i = 0; i < 40; i++) arr.push({ width: 8, height: 10 });
+  for (let i = 0; i < 40; i++) arr.push({ width: 20 + (i % 10), height: 24 + (i % 8) });
+  for (let i = 0; i < 20; i++) arr.push({ width: 48 + (i % 16), height: 56 + (i % 10) });
+  for (let i = 0; i < 6; i++) arr.push({ width: 128, height: 140 });
+  return arr;
+}
+
+async function run() {
+  const fontDir = path.resolve(process.cwd(), "assets", "fonts");
+  let fontFiles = [];
+  try {
+    const files = fs.readdirSync(fontDir);
+    fontFiles = files.filter((f) => /\.(ttf|otf|woff2?)$/i.test(f)).map((f) => path.join(fontDir, f));
+  } catch (e) {
+    console.warn("No bundled fonts found in assets/fonts — continuing with synthetic samples only");
+  }
+
+  console.log("Found fonts:", fontFiles.map((p) => path.basename(p)));
+  const allSamples = [];
+
+  for (const fontPath of fontFiles) {
+    console.log("Sampling font:", path.basename(fontPath));
+    const s = await sampleFromFont(fontPath, { maxGlyphs: 200, fontSizePx: 64 });
+    console.log(`  -> collected ${s.length} samples from ${path.basename(fontPath)}`);
+    allSamples.push(...s);
+  }
+
+  const synth = syntheticSamples();
+  console.log("Adding", synth.length, "synthetic samples");
+  allSamples.push(...synth);
+
+  if (allSamples.length === 0) {
+    console.warn("No samples gathered — returning conservative defaults");
+    console.log("Suggested settings: pageSize=2048, padding=1");
+    return;
+  }
+
+  const settings = pickAtlasSettingsFromSamples(allSamples, { candidates: [1024, 2048, 4096], paddings: [0, 1, 2, 3] });
+  console.log("Tuner result:", settings);
+  console.log("");
+  console.log("Recommended values to apply to MaxRects packer:");
+  console.log(`  pageSize: ${settings.pageSize}`);
+  console.log(`  padding:  ${settings.padding}`);
+  console.log(`Estimated pages: ${settings.estimatedPages}, wastedRatio: ${settings.wastedRatio.toFixed(3)}`);
+  console.log("");
+  console.log("If you want me to apply these settings to src/pdf/font/glyph-atlas-maxrects.ts I can do that now.");
+}
+
+run().catch((err) => {
+  console.error("Error running tuner runner:", err);
+  process.exit(1);
+});

package/scripts/run-glyph-atlas-tuner.ts

@@ -0,0 +1,141 @@
+/**
+ * Run glyph atlas tuner (sample fonts + synthetic) and print recommended atlas settings.
+ *
+ * Usage (from repo root):
+ *  - With ts-node (recommended):
+ *      npx ts-node scripts/run-glyph-atlas-tuner.ts
+ *  - Or via node if you have ts-node registered:
+ *      node -r ts-node/register scripts/run-glyph-atlas-tuner.ts
+ *
+ * Notes:
+ *  - This script imports project modules (TS sources). When running with ts-node,
+ *    TypeScript files are resolved directly (we import .ts paths here to avoid
+ *    Node ESM resolving .js which caused ERR_MODULE_NOT_FOUND).
+ *
+ * What it does:
+ *  - Loads fonts from ./assets/fonts
+ *  - For each font samples up to N glyphs (attempts to rasterize glyph masks at fontSizePx)
+ *  - Adds synthetic samples (small/medium/large)
+ *  - Runs pickAtlasSettingsFromSamples(...) and prints the chosen settings
+ */
+
+import fs from "fs";
+import path from "path";
+
+// IMPORTANT: import the .ts modules (ts-node resolves .ts imports). This avoids Node ESM looking for .js files.
+import { parseTtfFont } from "../src/pdf/font/ttf-lite.ts";
+import { getGlyphMask, clearGlyphMaskCache } from "../src/pdf/font/glyph-cache.ts";
+import { pickAtlasSettingsFromSamples } from "../src/pdf/font/glyph-atlas-tuner.ts";
+
+async function sampleFromFont(fontPath: string, opts: { maxGlyphs?: number; fontSizePx?: number } = {}) {
+  const samples: Array<{ width: number; height: number }> = [];
+  const maxGlyphs = opts.maxGlyphs ?? 200;
+  const fontSizePx = opts.fontSizePx ?? 64;
+
+  try {
+    const metrics = parseTtfFont(fontPath);
+    // Try to sample from glyphMetrics map if available
+    const glyphCount = metrics.glyphMetrics ? metrics.glyphMetrics.size : Math.max(256, maxGlyphs);
+    const limit = Math.min(maxGlyphs, glyphCount);
+
+    // Prefer to sample glyph IDs present in the metrics map
+    if (metrics.glyphMetrics && metrics.glyphMetrics.size > 0) {
+      let i = 0;
+      for (const [gid] of metrics.glyphMetrics) {
+        if (i >= limit) break;
+        try {
+          const mask = getGlyphMask(metrics as any, gid, fontSizePx, 4);
+          if (mask && mask.width > 0 && mask.height > 0) {
+            samples.push({ width: mask.width, height: mask.height });
+            i++;
+          }
+        } catch (e) {
+          // ignore glyphs that fail during rasterization
+        }
+      }
+    } else {
+      // Fallback: try glyph ids 0..limit-1
+      for (let gid = 0; gid < limit; gid++) {
+        try {
+          const mask = getGlyphMask(metrics as any, gid, fontSizePx, 4);
+          if (mask && mask.width > 0 && mask.height > 0) {
+            samples.push({ width: mask.width, height: mask.height });
+          }
+        } catch (e) {
+          // continue
+        }
+      }
+    }
+
+    // Clear any packed atlas/cache artifacts between fonts to avoid skew
+    clearGlyphMaskCache();
+  } catch (err) {
+    console.error("Failed to parse font", fontPath, err instanceof Error ? err.message : err);
+  }
+
+  return samples;
+}
+
+function syntheticSamples(): Array<{ width: number; height: number }> {
+  // Provide a sensible mixture of sizes: small glyphs, punctuation, medium letters, large capitals
+  const arr: Array<{ width: number; height: number }> = [];
+  // many small
+  for (let i = 0; i < 40; i++) arr.push({ width: 8, height: 10 });
+  // medium
+  for (let i = 0; i < 40; i++) arr.push({ width: 20 + (i % 10), height: 24 + (i % 8) });
+  // larger
+  for (let i = 0; i < 20; i++) arr.push({ width: 48 + (i % 16), height: 56 + (i % 10) });
+  // some very large glyphs (accents, icons)
+  for (let i = 0; i < 6; i++) arr.push({ width: 128, height: 140 });
+  return arr;
+}
+
+async function run() {
+  const fontDir = path.resolve(process.cwd(), "assets", "fonts");
+  let fontFiles: string[] = [];
+  try {
+    const files = fs.readdirSync(fontDir);
+    fontFiles = files
+      .filter((f) => /\.(ttf|otf|woff2?)$/i.test(f))
+      .map((f) => path.join(fontDir, f));
+  } catch (e) {
+    console.warn("No bundled fonts found in assets/fonts — continuing with synthetic samples only");
+  }
+
+  console.log("Found fonts:", fontFiles.map((p) => path.basename(p)));
+  const allSamples: Array<{ width: number; height: number }> = [];
+
+  for (const fontPath of fontFiles) {
+    console.log("Sampling font:", path.basename(fontPath));
+    const s = await sampleFromFont(fontPath, { maxGlyphs: 200, fontSizePx: 64 });
+    console.log(`  -> collected ${s.length} samples from ${path.basename(fontPath)}`);
+    allSamples.push(...s);
+  }
+
+  // add synthetic
+  const synth = syntheticSamples();
+  console.log("Adding", synth.length, "synthetic samples");
+  allSamples.push(...synth);
+
+  if (allSamples.length === 0) {
+    console.warn("No samples gathered — returning conservative defaults");
+    console.log("Suggested settings: pageSize=2048, padding=1");
+    return;
+  }
+
+  // Run tuner
+  const settings = pickAtlasSettingsFromSamples(allSamples, { candidates: [1024, 2048, 4096], paddings: [0, 1, 2, 3] });
+  console.log("Tuner result:", settings);
+  console.log("");
+  console.log("If you want to apply these settings to the MaxRects packer in-code, the recommended values are:");
+  console.log(`  pageSize: ${settings.pageSize}`);
+  console.log(`  padding:  ${settings.padding}`);
+  console.log(`Estimated pages: ${settings.estimatedPages}, wastedRatio: ${settings.wastedRatio.toFixed(3)}`);
+  console.log("");
+  console.log("To apply, update the MaxRects packer defaults in src/pdf/font/glyph-atlas-maxrects.ts (constructor or export) or pass these values when constructing the packer.");
+}
+
+run().catch((err) => {
+  console.error("Error running tuner script:", err);
+  process.exit(1);
+});

package/scripts/top-ts-files.ps1

@@ -0,0 +1,39 @@
+# Top 10 arquivos .ts por numero de linhas (recursivo, com progresso)
+$Path = "."      # diretorio inicial
+$Top = 10        # quantidade a exibir
+$Pattern = "*.ts"
+$SkipPattern = '(\\|/)(?:node_modules|dist|\.git|bin|obj|\.venv|\.tox)(\\|/)'
+
+Write-Host "Buscando arquivos $Pattern em $Path..." -ForegroundColor Cyan
+
+# filtra apenas .ts e ignora pastas grandes
+$files = Get-ChildItem -LiteralPath $Path -Recurse -File -Filter $Pattern -Force |
+          Where-Object { $_.FullName -notmatch $SkipPattern }
+
+$total = $files.Count
+
+$i = 0
+$results = New-Object System.Collections.Generic.List[object]
+
+foreach ($f in $files) {
+  $i++
+  Write-Progress -Activity "Contando linhas..." -Status $f.FullName -PercentComplete (($i / $total) * 100)
+  try {
+    $lineCount = [int]([System.Linq.Enumerable]::Count([System.IO.File]::ReadLines($f.FullName)))
+    $results.Add([pscustomobject]@{
+      Lines     = $lineCount
+      SizeBytes = $f.Length
+      Path      = $f.FullName
+    })
+  } catch {
+    Write-Warning "Falha ao ler: $($f.FullName) -> $($_.Exception.Message)"
+  }
+}
+
+Write-Progress -Activity "Contando linhas..." -Completed
+Write-Host "`nTop $Top arquivos $Pattern por numero de linhas:`n" -ForegroundColor Green
+
+$results |
+  Sort-Object Lines -Descending |
+  Select-Object -First $Top |
+  Format-Table Lines, SizeBytes, Path -AutoSize

package/scripts/top-ts-files.sh

@@ -0,0 +1,37 @@
+#!/bin/bash
+
+# Top 10 arquivos .ts por número de linhas (recursivo, com progresso)
+PATH="."
+TOP=10
+PATTERN="*.ts"
+SKIP_PATTERN="(node_modules|dist|\.git|bin|obj|\.venv|\.tox)"
+
+echo "🔍 Buscando arquivos $PATTERN em $PATH..."
+
+# filtra apenas .ts e ignora pastas grandes
+files=$(find "$PATH" -type f -name "$PATTERN" 2>/dev/null | grep -v -E "$SKIP_PATTERN")
+
+total=$(echo "$files" | wc -l)
+if [ "$total" -eq 0 ]; then
+  echo "Nenhum arquivo $PATTERN encontrado (verifique filtros)."
+  exit 1
+fi
+
+i=0
+temp=$(mktemp)
+
+echo "$files" | while read -r f; do
+  i=$((i+1))
+  echo -ne "Contando linhas... $i/$total\r"
+  lines=$(wc -l < "$f" 2>/dev/null || echo 0)
+  size=$(stat -c%s "$f" 2>/dev/null || echo 0)
+  echo "$lines|$size|$f" >> "$temp"
+done
+
+echo ""
+echo "📊 Top $TOP arquivos $PATTERN por número de linhas:"
+echo ""
+
+sort -nr "$temp" | head -n $TOP | awk -F'|' '{printf "%-10s %-10s %s\n", $1, $2, $3}'
+
+rm "$temp"

package/scripts/woff2_info.ps1

@@ -0,0 +1,132 @@
+param(
+    # Caminho da fonte (TTF/OTF/WOFF/WOFF2)
+    [Parameter(Mandatory = $true)]
+    [string]$File,
+
+    # ttx (CLI da FontTools)
+    [string]$Ttx = "ttx",
+
+    # Nome base do arquivo de saída TTX (sem ou com .ttx)
+    # O script vai adicionar automaticamente o sufixo com o nome da fonte.
+    [string]$OutFile = "font_dump.ttx",
+
+    # Formato da saída do script
+    # xml      = só gera TTX XML (default)
+    # json     = converte o XML inteiro pra JSON
+    # fulljson = JSON completo sem compressão
+    # name     = só tabela name (metadados)
+    # cmap     = só cmap
+    # metrics  = só head / hhea / OS/2
+    [ValidateSet("xml", "json", "fulljson", "name", "cmap", "metrics")]
+    [string]$Format = "xml",
+
+    # Forçar overwrite
+    [switch]$Force
+)
+
+### 1. Resolve paths
+$fullPath = (Resolve-Path $File).Path
+
+# Nome da fonte baseado no arquivo (sem extensão)
+$fontBaseName = [System.IO.Path]::GetFileNameWithoutExtension($fullPath)
+
+# Se o usuário passou um caminho com diretório em $OutFile, respeita.
+# Caso contrário, usa o diretório do script.
+$outDir = Split-Path -Path $OutFile -Parent
+if ([string]::IsNullOrWhiteSpace($outDir)) {
+    $outDir = $PSScriptRoot
+}
+
+$outName = [System.IO.Path]::GetFileName($OutFile)
+
+# Se não tiver extensão, assume .ttx
+$outBase = [System.IO.Path]::GetFileNameWithoutExtension($outName)
+$outExt = [System.IO.Path]::GetExtension($outName)
+if ([string]::IsNullOrWhiteSpace($outExt)) {
+    $outExt = ".ttx"
+}
+
+# Monta o nome final com sufixo da fonte
+$finalOutName = "{0}-{1}{2}" -f $outBase, $fontBaseName, $outExt
+$ttxOut = Join-Path $outDir $finalOutName
+
+if ((Test-Path $ttxOut) -and (-not $Force)) {
+    Write-Output "[ERROR] Output file already exists: $ttxOut"
+    Write-Output "Use -Force to overwrite."
+    exit 1
+}
+
+if ($Force -and (Test-Path $ttxOut)) {
+    Remove-Item $ttxOut -Force
+}
+
+Write-Output "[INFO] Generating TTX to: $ttxOut"
+
+### 2. Gera o TTX (XML)
+$cmd = "$Ttx -o `"$ttxOut`" `"$fullPath`" 2>&1"
+$output = Invoke-Expression $cmd
+
+if (-not (Test-Path $ttxOut)) {
+    Write-Output "[ERROR] Failed to generate TTX dump."
+    Write-Output $output
+    exit 1
+}
+
+### 3. Se o usuário pediu só XML
+if ($Format -eq "xml") {
+    Write-Output "[DUMP] $((Resolve-Path $ttxOut).Path)"
+    exit 0
+}
+
+### 4. Carrega XML como objeto
+[xml]$xml = Get-Content $ttxOut
+
+### 5. Funções auxiliares
+function Convert-ToJsonCompact($obj) {
+    return ($obj | ConvertTo-Json -Depth 20 -Compress)
+}
+
+function Convert-ToJsonPretty($obj) {
+    return ($obj | ConvertTo-Json -Depth 20)
+}
+
+### 6. Modos especializados
+switch ($Format) {
+
+    "json" {
+        $json = Convert-ToJsonCompact $xml
+        Write-Output $json
+        exit 0
+    }
+
+    "fulljson" {
+        $json = Convert-ToJsonPretty $xml
+        Write-Output $json
+        exit 0
+    }
+
+    "name" {
+        $name = $xml.ttFont.name
+        $json = Convert-ToJsonPretty $name
+        Write-Output $json
+        exit 0
+    }
+
+    "cmap" {
+        $cmap = $xml.ttFont.cmap
+        $json = Convert-ToJsonPretty $cmap
+        Write-Output $json
+        exit 0
+    }
+
+    "metrics" {
+        $metrics = [ordered]@{
+            head = $xml.ttFont.head
+            hhea = $xml.ttFont.hhea
+            os2  = $xml.ttFont."OS_2"
+        }
+        $json = Convert-ToJsonPretty $metrics
+        Write-Output $json
+        exit 0
+    }
+}

package/src/browser-entry.ts

@@ -0,0 +1,14 @@
+/**
+ * Browser entrypoint: minimal surface that wires the BrowserEnvironment.
+ * Expect callers to provide HTML/CSS strings and optional fontConfig with preloaded ArrayBuffers.
+ */
+import { BrowserEnvironment } from "./environment/browser-environment.js";
+import { setGlobalEnvironment } from "./environment/global.js";
+import type { RenderHtmlOptions } from "./html-to-pdf.js";
+import { renderHtmlToPdf } from "./html-to-pdf.js";
+
+export async function renderHtmlToPdfBrowser(options: Omit<RenderHtmlOptions, "environment">): Promise<Uint8Array> {
+  const environment = new BrowserEnvironment();
+  setGlobalEnvironment(environment);
+  return renderHtmlToPdf({ ...options, environment });
+}