@xamukavila/pxpipe 0.8.0

package/dist/core/baseline.d.ts

@@ -0,0 +1,80 @@
+/**
+ * Cache-aware baseline math for the unproxied counterfactual.
+ * Workers-safe: no node:, no Buffer, no process.*. Pure number math.
+ * See docs/CACHING_AND_SAVINGS.md for the full derivation and audit history.
+ */
+/** Documented Anthropic price ratios: cc_5m = 1.25×, cr = 0.1× base input. One-line change if rates change. */
+export declare const CACHE_CREATE_RATE = 1.25;
+export declare const CACHE_READ_RATE = 0.1;
+/** Anthropic prompt-cache TTL (seconds). Kept for callers that display provider
+ *  docs, but savings math does not use TTL to infer a hypothetical text-cache
+ *  hit: text is considered warm only when the actual request reports cr > 0. */
+export declare const CACHE_TTL_SEC = 300;
+/** This session's previous usage-bearing turn, used only for warm split sizing. */
+export interface BaselineWarmthPrev {
+    /** Completion time of that turn, in wall-clock seconds. */
+    ts: number;
+    /** Cacheable-prefix tokens measured that turn (0 if the probe missed). */
+    cacheable: number;
+    /** Hash of the image-bound/static text prefix. If it changes, do not reuse the
+     *  prior prefix size for this row's text reused/grown split. */
+    prefixSha?: string;
+}
+/**
+ * Decide whether the TEXT counterfactual's prefix was warm this turn.
+ *
+ * Strict accounting rule: the imagined text path gets the same observed cache
+ * state as the real image path. `cr > 0` is server proof that the request read a
+ * warm prefix, so the text baseline is warm too. `cr === 0` means the actual
+ * request did not read cache, so the text baseline is priced cold too. We do not
+ * use wall-clock TTL to claim that text would have been warm while images were
+ * cold; that would be an unobservable counterfactual and can create negative
+ * rows from cache assumptions rather than token savings.
+ *
+ * When cr proves warmth, a completed same-prefix prior is used only to estimate
+ * how much of the text prefix was reused vs grown. If none is available, assume
+ * full reuse of this turn's cacheable prefix; this is conservative for savings.
+ *
+ * @param prev       this session's previous usage-bearing turn, or undefined.
+ * @param nowSec     request-start wall-clock seconds, used only to reject prior
+ *                   rows that had not completed before this request was sent.
+ * @param cacheable  this turn's cacheable-prefix tokens (the full-reuse credit
+ *                   when warm only via cr, since cr proves a read but not the split).
+ * @param cr         observed cache-read tokens this turn; the only warm/cold signal.
+ * @param ttlSec     legacy parameter; no longer decides warm/cold. It only
+ *                   bounds whether a prior prefix size is used for reused/grown
+ *                   splitting after cr > 0 has already proved warmth.
+ * @param prefixSha  stable-prefix fingerprint for the text counterfactual. A
+ *                   prior prefix size is reused only when this matches.
+ */
+export declare function deriveBaselineWarmth(prev: BaselineWarmthPrev | undefined, nowSec: number, cacheable: number, cr: number, ttlSec?: number, prefixSha?: string): {
+    warm: boolean;
+    prevCacheable: number;
+};
+/**
+ * Weighted input cost for the unproxied TEXT counterfactual (see docs/CACHING_AND_SAVINGS.md).
+ *
+ * Warmth matters: a TEXT prefix is only a cheap cache-read when a warm cache
+ * actually existed this turn. The previous warmth-FREE version always priced
+ * the cacheable prefix at CACHE_READ_RATE, which fabricated a "free read" on
+ * cold/TTL-expiry turns where text would in fact have paid a 1.25× create —
+ * that produced a phantom loss vs the imaged path (which DOES pay the create).
+ *
+ *   cold turn (first turn / >5min since this session's last turn):
+ *     text has no warm cache either ⇒ cacheable×CACHE_CREATE_RATE + coldTail×1.0
+ *   warm turn (a prior turn cached the prefix within TTL):
+ *     text append-caches ⇒ reused×CACHE_READ_RATE + grown×CACHE_CREATE_RATE + coldTail×1.0
+ *     where reused = min(prevCacheable, cacheable), grown = cacheable − reused.
+ *     This is what TEXT pays regardless of whether pxpipe's image busted its
+ *     own cache on a growth turn — so the real growth loss is preserved.
+ *
+ * Saving = baseline_eff − actual_eff; can be negative (honestly reported, not floored).
+ *
+ * @param baselineCacheable  tokens up to the last cache_control marker. ≤0 ⇒ credit nothing.
+ * @param warm               was a warm cache available for this session this turn?
+ * @param prevCacheable      cacheable prefix size on this session's previous turn (warm only).
+ */
+export declare function computeBaselineInputEff(baseline: number, baselineCacheable: number, inputTokens: number, cc: number, cr: number, warm?: boolean, prevCacheable?: number): number;
+/** Weighted input cost pxpipe actually paid this turn. */
+export declare function computeActualInputEff(inputTokens: number, cc: number, cr: number): number;
+//# sourceMappingURL=baseline.d.ts.map

package/dist/core/baseline.js

@@ -0,0 +1,101 @@
+/**
+ * Cache-aware baseline math for the unproxied counterfactual.
+ * Workers-safe: no node:, no Buffer, no process.*. Pure number math.
+ * See docs/CACHING_AND_SAVINGS.md for the full derivation and audit history.
+ */
+/** Documented Anthropic price ratios: cc_5m = 1.25×, cr = 0.1× base input. One-line change if rates change. */
+export const CACHE_CREATE_RATE = 1.25;
+export const CACHE_READ_RATE = 0.1;
+/** Anthropic prompt-cache TTL (seconds). Kept for callers that display provider
+ *  docs, but savings math does not use TTL to infer a hypothetical text-cache
+ *  hit: text is considered warm only when the actual request reports cr > 0. */
+export const CACHE_TTL_SEC = 300;
+/**
+ * Decide whether the TEXT counterfactual's prefix was warm this turn.
+ *
+ * Strict accounting rule: the imagined text path gets the same observed cache
+ * state as the real image path. `cr > 0` is server proof that the request read a
+ * warm prefix, so the text baseline is warm too. `cr === 0` means the actual
+ * request did not read cache, so the text baseline is priced cold too. We do not
+ * use wall-clock TTL to claim that text would have been warm while images were
+ * cold; that would be an unobservable counterfactual and can create negative
+ * rows from cache assumptions rather than token savings.
+ *
+ * When cr proves warmth, a completed same-prefix prior is used only to estimate
+ * how much of the text prefix was reused vs grown. If none is available, assume
+ * full reuse of this turn's cacheable prefix; this is conservative for savings.
+ *
+ * @param prev       this session's previous usage-bearing turn, or undefined.
+ * @param nowSec     request-start wall-clock seconds, used only to reject prior
+ *                   rows that had not completed before this request was sent.
+ * @param cacheable  this turn's cacheable-prefix tokens (the full-reuse credit
+ *                   when warm only via cr, since cr proves a read but not the split).
+ * @param cr         observed cache-read tokens this turn; the only warm/cold signal.
+ * @param ttlSec     legacy parameter; no longer decides warm/cold. It only
+ *                   bounds whether a prior prefix size is used for reused/grown
+ *                   splitting after cr > 0 has already proved warmth.
+ * @param prefixSha  stable-prefix fingerprint for the text counterfactual. A
+ *                   prior prefix size is reused only when this matches.
+ */
+export function deriveBaselineWarmth(prev, nowSec, cacheable, cr, ttlSec = CACHE_TTL_SEC, prefixSha) {
+    const age = prev !== undefined ? nowSec - prev.ts : Number.POSITIVE_INFINITY;
+    const samePrefix = prev === undefined
+        || prev.prefixSha === undefined
+        || prefixSha === undefined
+        || prev.prefixSha === prefixSha;
+    // cr is the only warm/cold signal. A prior only refines the warm split.
+    if (!(cr > 0))
+        return { warm: false, prevCacheable: 0 };
+    // Fresh prior: use its real prefix size for the reused/grown split. Without
+    // one, cr proves warmth but not the split, so assume full reuse.
+    const freshPrior = prev !== undefined && age >= 0 && age < ttlSec && samePrefix;
+    return { warm: true, prevCacheable: freshPrior ? prev.cacheable : cacheable };
+}
+/**
+ * Weighted input cost for the unproxied TEXT counterfactual (see docs/CACHING_AND_SAVINGS.md).
+ *
+ * Warmth matters: a TEXT prefix is only a cheap cache-read when a warm cache
+ * actually existed this turn. The previous warmth-FREE version always priced
+ * the cacheable prefix at CACHE_READ_RATE, which fabricated a "free read" on
+ * cold/TTL-expiry turns where text would in fact have paid a 1.25× create —
+ * that produced a phantom loss vs the imaged path (which DOES pay the create).
+ *
+ *   cold turn (first turn / >5min since this session's last turn):
+ *     text has no warm cache either ⇒ cacheable×CACHE_CREATE_RATE + coldTail×1.0
+ *   warm turn (a prior turn cached the prefix within TTL):
+ *     text append-caches ⇒ reused×CACHE_READ_RATE + grown×CACHE_CREATE_RATE + coldTail×1.0
+ *     where reused = min(prevCacheable, cacheable), grown = cacheable − reused.
+ *     This is what TEXT pays regardless of whether pxpipe's image busted its
+ *     own cache on a growth turn — so the real growth loss is preserved.
+ *
+ * Saving = baseline_eff − actual_eff; can be negative (honestly reported, not floored).
+ *
+ * @param baselineCacheable  tokens up to the last cache_control marker. ≤0 ⇒ credit nothing.
+ * @param warm               was a warm cache available for this session this turn?
+ * @param prevCacheable      cacheable prefix size on this session's previous turn (warm only).
+ */
+export function computeBaselineInputEff(baseline, baselineCacheable, inputTokens, cc, cr, warm = false, prevCacheable = 0) {
+    if (baseline <= 0)
+        return 0;
+    // Probe miss: can't split prefix from tail, so credit nothing (same as actual).
+    if (baselineCacheable <= 0)
+        return computeActualInputEff(inputTokens, cc, cr);
+    const cacheable = Math.min(baselineCacheable, baseline);
+    const coldTail = baseline - cacheable;
+    if (warm) {
+        // Text reads the prefix it already had cached (0.10×) and creates only the
+        // growth since last turn (1.25×). Independent of the image path's cache.
+        const reused = Math.min(Math.max(prevCacheable, 0), cacheable);
+        const grown = cacheable - reused;
+        return reused * CACHE_READ_RATE + grown * CACHE_CREATE_RATE + coldTail * 1.0;
+    }
+    // Cold (first turn / TTL expiry): no warm cache for text either, so it
+    // re-creates the whole cacheable prefix at the create rate — same event the
+    // imaged path pays. Removes the phantom "free read" that fabricated a loss.
+    return cacheable * CACHE_CREATE_RATE + coldTail * 1.0;
+}
+/** Weighted input cost pxpipe actually paid this turn. */
+export function computeActualInputEff(inputTokens, cc, cr) {
+    return inputTokens + cc * CACHE_CREATE_RATE + cr * CACHE_READ_RATE;
+}
+//# sourceMappingURL=baseline.js.map

package/dist/core/caveman.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Caveman pass — deterministic, rule-based prose compression for text bound
+ * to the optical (PNG) channel.
+ *
+ * Why: image cost is pixel-area billing (`width × height / 750`), and pixel
+ * area at fixed density is proportional to char count — so every char dropped
+ * BEFORE rendering compounds with the render savings. Articles, filler
+ * adverbs, and politeness phrases carry near-zero gist, which is the only
+ * fidelity level the optical channel promises anyway (FINDINGS.md: pxpipe is
+ * a lossy gist-compressor).
+ *
+ * The trade-off (FINDINGS.md capacity argument): natural-language redundancy
+ * is the error-correcting code of the lossy optical read — telegraphic text
+ * gives the language prior less signal to repair under-resolved glyphs. This
+ * pass is therefore an opt-in EXPERIMENT (`PXPIPE_CAVEMAN=1`) until the A/B
+ * harness shows gist/verbatim recall does not regress.
+ *
+ * Hard requirements:
+ *  - DETERMINISTIC and idempotent. The slab image bytes are the prompt-cache
+ *    key; any nondeterminism here busts the cache every turn. No LLM, no
+ *    randomness, no locale/config dependence.
+ *  - VERBATIM-SAFE. Never touches: fenced/indented code, markdown table
+ *    rows, inline `code` spans, double-quoted spans, or any token that is
+ *    not purely alphabetic — ids, hashes, paths, URLs, env vars, numbers,
+ *    ALL-CAPS and CamelCase tokens all pass through untouched. Only whole
+ *    lowercase (or Capitalized) words from the curated EN/PT lists drop.
+ */
+/**
+ * Deterministically strip low-information words from prose. Code (fenced,
+ * indented, inline), table rows, quoted spans, and every non-alphabetic
+ * token pass through byte-exact. Line structure is preserved (no line merges
+ * or splits) so renderer row accounting and paging stay comparable.
+ *
+ * Callers gate on `classifyContent(text) === 'other'` — running this over
+ * JSON/logs would be a no-op waste of CPU at best.
+ */
+export declare function cavemanize(text: string): string;
+//# sourceMappingURL=caveman.d.ts.map

package/dist/core/caveman.js

@@ -0,0 +1,183 @@
+/**
+ * Caveman pass — deterministic, rule-based prose compression for text bound
+ * to the optical (PNG) channel.
+ *
+ * Why: image cost is pixel-area billing (`width × height / 750`), and pixel
+ * area at fixed density is proportional to char count — so every char dropped
+ * BEFORE rendering compounds with the render savings. Articles, filler
+ * adverbs, and politeness phrases carry near-zero gist, which is the only
+ * fidelity level the optical channel promises anyway (FINDINGS.md: pxpipe is
+ * a lossy gist-compressor).
+ *
+ * The trade-off (FINDINGS.md capacity argument): natural-language redundancy
+ * is the error-correcting code of the lossy optical read — telegraphic text
+ * gives the language prior less signal to repair under-resolved glyphs. This
+ * pass is therefore an opt-in EXPERIMENT (`PXPIPE_CAVEMAN=1`) until the A/B
+ * harness shows gist/verbatim recall does not regress.
+ *
+ * Hard requirements:
+ *  - DETERMINISTIC and idempotent. The slab image bytes are the prompt-cache
+ *    key; any nondeterminism here busts the cache every turn. No LLM, no
+ *    randomness, no locale/config dependence.
+ *  - VERBATIM-SAFE. Never touches: fenced/indented code, markdown table
+ *    rows, inline `code` spans, double-quoted spans, or any token that is
+ *    not purely alphabetic — ids, hashes, paths, URLs, env vars, numbers,
+ *    ALL-CAPS and CamelCase tokens all pass through untouched. Only whole
+ *    lowercase (or Capitalized) words from the curated EN/PT lists drop.
+ */
+// --- word lists -------------------------------------------------------------
+/** Multi-letter articles, EN + PT.
+ *  Deliberately EXCLUDES 'as': it is a PT plural article but also a
+ *  load-bearing EN conjunction ("treat as data") — dropping it inverts
+ *  meaning in the EN prose that dominates real slabs. */
+const ARTICLES = new Set([
+    // EN
+    'the',
+    'an',
+    // PT
+    'um',
+    'uma',
+    'uns',
+    'umas',
+    'os',
+]);
+/** Single-letter articles ('a' EN/PT, 'o' PT): drop only the exact-lowercase
+ *  form. An isolated capital "A"/"O" is more likely an option label, list
+ *  marker, or grade than an article. */
+const SINGLE_LETTER_ARTICLES = new Set(['a', 'o']);
+/** Intensity/filler adverbs and politeness words whose removal cannot invert
+ *  meaning. Deliberately EXCLUDES hedges that flip polarity when removed
+ *  ('quite': "not quite right" ≠ "not right") and quantifiers that carry
+ *  real information ('only', 'just', 'muito'/'muitos'). */
+const FILLERS = new Set([
+    // EN
+    'really',
+    'actually',
+    'basically',
+    'simply',
+    'essentially',
+    'certainly',
+    'definitely',
+    'obviously',
+    'literally',
+    'very',
+    'please',
+    'kindly',
+    // PT
+    'realmente',
+    'basicamente',
+    'simplesmente',
+    'essencialmente',
+    'certamente',
+    'definitivamente',
+    'obviamente',
+    'literalmente',
+]);
+/** Politeness/verbosity phrases rewritten before word drops. Applied only to
+ *  unprotected prose segments; each replacement is idempotent (its output
+ *  never re-matches its pattern). */
+const PHRASES = [
+    [/\bplease note that\b/gi, ''],
+    [/\bnote that\b/gi, ''],
+    [/\bkeep in mind that\b/gi, ''],
+    [/\bin order to\b/gi, 'to'],
+    [/\bas well as\b/gi, 'and'],
+    [/\bmake sure that\b/gi, 'ensure'],
+    // PT
+    [/\bpor favor\b/gi, ''],
+    [/\ba fim de\b/gi, 'para'],
+    [/\bnote que\b/gi, ''],
+    [/\btenha em mente que\b/gi, ''],
+];
+// --- protections ------------------------------------------------------------
+/** Fence opener/closer (``` or ~~~), optionally indented. */
+const FENCE_LINE = /^\s*(```|~~~)/;
+/** Markdown code by indentation (4 spaces or a tab). */
+const INDENTED_CODE = /^(?: {4}|\t)/;
+/** Markdown table row. */
+const TABLE_ROW = /^\s*\|/;
+/** Spans that must survive byte-exact even inside prose: inline `code`
+ *  and double-quoted strings (quoted error messages get grepped verbatim).
+ *  Single quotes are NOT protected — apostrophes ("don't") would open
+ *  phantom spans. Capture group so `split` keeps the spans. */
+const PROTECTED_SPAN = /(`[^`\n]+`|"[^"\n]*")/g;
+/** Letters-only token (Unicode-aware: PT diacritics included). Anything with
+ *  a digit, slash, dot, underscore, etc. never matches — that single check
+ *  protects ids, paths, URLs, hashes, numbers, and env vars. */
+const LETTERS_ONLY = /^\p{L}+$/u;
+// --- core -------------------------------------------------------------------
+function isDroppableWord(token) {
+    if (!LETTERS_ONLY.test(token))
+        return false;
+    const lower = token.toLowerCase();
+    const isLower = token === lower;
+    // Allow exact-lowercase and Capitalized ("The"); reject ALL-CAPS and
+    // mixed-case (PATH, iOS) — those read as identifiers, not grammar.
+    const isCapitalized = !isLower &&
+        token[0] === token[0].toUpperCase() &&
+        token.slice(1) === token.slice(1).toLowerCase();
+    if (!isLower && !isCapitalized)
+        return false;
+    if (ARTICLES.has(lower) || FILLERS.has(lower))
+        return true;
+    return isLower && SINGLE_LETTER_ARTICLES.has(lower);
+}
+/** Compress one unprotected prose segment. Preserves the segment's exact
+ *  leading/trailing whitespace (it may butt up against a protected span);
+ *  interior whitespace collapses to single spaces — acceptable for prose,
+ *  and the slab path runs `compactSlabWhitespace` afterwards anyway. */
+function compressSegment(seg) {
+    let s = seg;
+    for (const [re, sub] of PHRASES)
+        s = s.replace(re, sub);
+    const lead = s.match(/^\s*/)[0];
+    if (lead.length === s.length)
+        return s; // empty or all-whitespace
+    const trail = s.match(/\s*$/)[0];
+    const body = s.slice(lead.length, s.length - trail.length);
+    const words = body.split(/\s+/).filter((w) => w.length > 0 && !isDroppableWord(w));
+    return lead + words.join(' ') + trail;
+}
+function compressLine(line) {
+    if (INDENTED_CODE.test(line) || TABLE_ROW.test(line))
+        return line;
+    if (!/\p{L}/u.test(line))
+        return line; // nothing droppable, skip regex work
+    const parts = line.split(PROTECTED_SPAN);
+    let out = '';
+    for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        // Odd indexes are the captured protected spans — byte-exact passthrough.
+        out += i % 2 === 1 ? part : compressSegment(part);
+    }
+    return out;
+}
+/**
+ * Deterministically strip low-information words from prose. Code (fenced,
+ * indented, inline), table rows, quoted spans, and every non-alphabetic
+ * token pass through byte-exact. Line structure is preserved (no line merges
+ * or splits) so renderer row accounting and paging stay comparable.
+ *
+ * Callers gate on `classifyContent(text) === 'other'` — running this over
+ * JSON/logs would be a no-op waste of CPU at best.
+ */
+export function cavemanize(text) {
+    if (text.length === 0)
+        return text;
+    const lines = text.split('\n');
+    let inFence = false;
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (FENCE_LINE.test(line)) {
+            inFence = !inFence;
+            continue; // the fence marker itself stays verbatim
+        }
+        if (inFence)
+            continue;
+        const compressed = compressLine(line);
+        if (compressed !== line)
+            lines[i] = compressed;
+    }
+    return lines.join('\n');
+}
+//# sourceMappingURL=caveman.js.map

package/dist/core/export.d.ts

@@ -0,0 +1,128 @@
+/**
+ * Core logic for `pxpipe export` — renders a source text to PNG pages, extracts
+ * a verbatim factsheet, builds a manifest and paste-ready prompt, and returns a
+ * token-cost report + list of artifacts to write.
+ *
+ * Pure-ish: no argv, no stdout, no process.exit, no fs calls — all I/O is
+ * delegated to the thin CLI runner in src/node.ts.
+ */
+export declare const DEFAULT_EXPORT_MODEL = "claude-sonnet-4-5";
+/** Default column width — dense content mode (312 cols = 1568 px). */
+export declare const DEFAULT_EXPORT_COLS: number;
+/**
+ * Match a relative file path against a glob pattern.
+ * Supported wildcards: `*` (non-separator), `**` (any including `/`), `?` (single non-sep).
+ * When the pattern contains no `/`, matching is against the basename only
+ * (e.g. `*.ts` matches `src/foo.ts`).
+ */
+export declare function matchGlob(pattern: string, filePath: string): boolean;
+/**
+ * Decide whether a relative file path should be included given include/exclude glob lists.
+ * - Exclude patterns are checked first; any match → exclude.
+ * - If include patterns are given, at least one must match.
+ * - If no include patterns are given, everything passes (unless excluded).
+ */
+export declare function shouldIncludeFile(filePath: string, include: string[], exclude: string[]): boolean;
+export interface ExportParsed {
+    targets: string[];
+    include: string[];
+    exclude: string[];
+    git: boolean;
+    diff: string | undefined;
+    stdin: boolean;
+    cols: number;
+    out: string;
+    model: string;
+    json: boolean;
+    open: boolean;
+}
+export type ExportArgvResult = {
+    kind: 'opts';
+    parsed: ExportParsed;
+} | {
+    kind: 'help';
+} | {
+    kind: 'error';
+    message: string;
+};
+/**
+ * Parse the argv array for the `export` subcommand.
+ * Returns a discriminated union so the caller (node.ts) decides
+ * whether to exit, print help, or proceed.
+ *
+ * @param defaultOut  Base output directory (default: $TMPDIR or /tmp).
+ */
+export declare function parseExportArgv(argv: string[], defaultOut?: string): ExportArgvResult;
+/**
+ * Per-image vision-token cost for a rendered PNG at the given pixel dimensions.
+ *
+ * - **Claude / Anthropic models** (`model.startsWith('claude')` or
+ *   `model.includes('anthropic')`): uses Anthropic's billing formula
+ *   `ceil(width × height / 750 × 1.10)` (the same formula and constants as
+ *   `imageTokensForRows` in transform.ts, reusing the exported
+ *   `ANTHROPIC_PIXELS_PER_TOKEN` / `IMAGE_COST_SAFETY_MARGIN` consts).
+ * - **GPT / o-series models**: delegates to `openAIVisionTokens` which uses the
+ *   GPT-4o tile-pricing formula (85 + 170 × tiles after scaling).
+ */
+export declare function exportImageTokens(model: string, width: number, height: number): number;
+export interface ExportTokenReport {
+    textTokens: number;
+    imageTokens: number;
+    percentSaved: number;
+    /** Count of unique identifier strings extracted across all pages (paths, SHAs, ids, …).
+     *  This is a count of items, not an LLM token count. */
+    factsheetItemCount: number;
+    /** Identifiers extracted across all pages that did not fit within the 64-item
+     *  factsheet budget. Zero when all extracted items were kept. */
+    factsheetDropped: number;
+}
+/**
+ * Estimate text vs image token cost for `sourceText` without rendering.
+ * Uses the same formula as the internal gate:
+ *   stripW = 2·PAD_X + cols·CELL_W
+ *   imageTokens = estimateImageCount(text, cols) × exportImageTokens(model, stripW, MAX_HEIGHT_PX)
+ *   textTokens = sourceText.length / REPORT_CHARS_PER_TOKEN
+ *
+ * `exportImageTokens` routes to the Anthropic billing formula (width×height/750×1.10)
+ * for Claude models, and to the GPT tile-pricing formula for GPT/o-series models.
+ *
+ * `factsheetItemCount` is the number of unique precision-critical identifier strings
+ * extracted across all pages (paths, SHAs, ids, …); it is NOT an LLM token count.
+ * `factsheetDropped` is the count of extracted identifiers that did not fit within
+ * the 64-item per-export budget.
+ */
+export declare function computeTokenReport(sourceText: string, cols: number, model: string): ExportTokenReport;
+export interface ExportPageInfo {
+    filename: string;
+    bytes: number;
+    width: number;
+    height: number;
+}
+export interface ExportManifest {
+    sourceChars: number;
+    files: string[];
+    pages: ExportPageInfo[];
+    cols: number;
+    model: string;
+    generatedAt: string;
+    tokenReport: ExportTokenReport;
+}
+export interface ExportArtifact {
+    filename: string;
+    data: Uint8Array;
+}
+export interface ExportResult {
+    manifest: ExportManifest;
+    artifacts: ExportArtifact[];
+}
+export interface ExportCoreOptions {
+    /** Relative file paths listed in the manifest and prompt (display only). */
+    sourceFiles: string[];
+    cols: number;
+    model: string;
+}
+export declare function buildPromptText(pageCount: number, factsheet: string, files: string[], droppedItems?: number): string;
+/** 8-char hex hash of the first 512 chars + length of `text`. */
+export declare function sourceShortHash(text: string): string;
+export declare function runExportCore(sourceText: string, opts: ExportCoreOptions): Promise<ExportResult>;
+//# sourceMappingURL=export.d.ts.map