@xamukavila/pxpipe 0.8.0

package/dist/stats.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Aggregate metrics over a stream of TrackEvents. Pure data-layer module —
+ * the dashboard's `/api/stats.json` endpoint imports `aggregateEventsFile`
+ * + `summaryToJson` from here. There is no longer a CLI entrypoint; the
+ * live dashboard at http://127.0.0.1:47821/ surfaces everything this used
+ * to print.
+ *
+ * Node-only (uses node:fs). Streams the file line-by-line so a 100 MB log
+ * doesn't blow the heap. The aggregator itself (`newSummary` / `fold`) is
+ * pure — fed a sequence of TrackEvents and produces a Summary — so a
+ * Workers-side dashboard could reuse it later by extracting it into core/.
+ */
+import type { TrackEvent } from './core/tracker.js';
+export interface Summary {
+    total: number;
+    ok2xx: number;
+    err4xx: number;
+    err5xx: number;
+    compressed: number;
+    passthrough: number;
+    /** Sum of orig_chars across compressed requests — the bytes we removed
+     *  from the text path by rendering to PNG. */
+    origCharsTotal: number;
+    imageBytesTotal: number;
+    /** Aggregated Anthropic token usage. */
+    inputTokensTotal: number;
+    outputTokensTotal: number;
+    cacheCreateTokensTotal: number;
+    cacheReadTokensTotal: number;
+    /** Number of events whose cache_read_tokens > 0 — i.e. the prompt cache
+     *  actually hit. */
+    cacheHitEvents: number;
+    /** Number of events that carried any usage data at all. Denominator for
+     *  cacheHitEvents. */
+    eventsWithUsage: number;
+    durationMs: number[];
+    firstByteMs: number[];
+    skipReasons: Map<string, number>;
+    byCwd: Map<string, {
+        count: number;
+        origChars: number;
+        imageBytes: number;
+    }>;
+    /** system_sha8 → number of times seen. High repeat count = cache should
+     *  be doing its job. */
+    systemShaHist: Map<string, number>;
+    unknownTags: Map<string, number>;
+}
+export declare function newSummary(): Summary;
+export declare function fold(s: Summary, ev: TrackEvent): Summary;
+export declare function renderTextReport(s: Summary): string;
+/**
+ * Stream an events JSONL file and fold every row into a Summary. Returns the
+ * Summary plus a parsed/dropped tally so callers can detect empty/garbage
+ * inputs. The dashboard wraps this for the /api/stats.json endpoint.
+ *
+ * Note: this is a full re-read on every call. The dashboard already has a
+ * 50-event ring buffer of the *recent* slice; stats need the full history
+ * to compute cache-hit-rate over thousands of requests. ~1.5 MB JSONL
+ * streams in well under 100 ms on an SSD.
+ */
+export declare function aggregateEventsFile(file: string): Promise<{
+    summary: Summary;
+    parsed: number;
+    dropped: number;
+} | undefined>;
+/**
+ * Convert a Summary to a JSON-serializable shape for the dashboard's
+ * /api/stats.json endpoint. JSON.stringify drops Map entries silently, so
+ * we materialize the top-N entries of each map into plain [key, value]
+ * tuples. Caps each map at 20 entries to keep the response bounded.
+ */
+export declare function summaryToJson(s: Summary): Record<string, unknown>;
+//# sourceMappingURL=stats.d.ts.map

package/dist/stats.js

@@ -0,0 +1,248 @@
+/**
+ * Aggregate metrics over a stream of TrackEvents. Pure data-layer module —
+ * the dashboard's `/api/stats.json` endpoint imports `aggregateEventsFile`
+ * + `summaryToJson` from here. There is no longer a CLI entrypoint; the
+ * live dashboard at http://127.0.0.1:47821/ surfaces everything this used
+ * to print.
+ *
+ * Node-only (uses node:fs). Streams the file line-by-line so a 100 MB log
+ * doesn't blow the heap. The aggregator itself (`newSummary` / `fold`) is
+ * pure — fed a sequence of TrackEvents and produces a Summary — so a
+ * Workers-side dashboard could reuse it later by extracting it into core/.
+ */
+import * as fs from 'node:fs';
+import * as readline from 'node:readline';
+export function newSummary() {
+    return {
+        total: 0,
+        ok2xx: 0,
+        err4xx: 0,
+        err5xx: 0,
+        compressed: 0,
+        passthrough: 0,
+        origCharsTotal: 0,
+        imageBytesTotal: 0,
+        inputTokensTotal: 0,
+        outputTokensTotal: 0,
+        cacheCreateTokensTotal: 0,
+        cacheReadTokensTotal: 0,
+        cacheHitEvents: 0,
+        eventsWithUsage: 0,
+        durationMs: [],
+        firstByteMs: [],
+        skipReasons: new Map(),
+        byCwd: new Map(),
+        systemShaHist: new Map(),
+        unknownTags: new Map(),
+    };
+}
+export function fold(s, ev) {
+    s.total++;
+    if (ev.status >= 200 && ev.status < 300)
+        s.ok2xx++;
+    else if (ev.status >= 400 && ev.status < 500)
+        s.err4xx++;
+    else if (ev.status >= 500)
+        s.err5xx++;
+    if (ev.compressed === true) {
+        s.compressed++;
+        if (typeof ev.orig_chars === 'number')
+            s.origCharsTotal += ev.orig_chars;
+        if (typeof ev.image_bytes === 'number')
+            s.imageBytesTotal += ev.image_bytes;
+    }
+    else if (ev.compressed === false) {
+        s.passthrough++;
+        if (ev.reason)
+            s.skipReasons.set(ev.reason, (s.skipReasons.get(ev.reason) ?? 0) + 1);
+    }
+    if (typeof ev.duration_ms === 'number')
+        s.durationMs.push(ev.duration_ms);
+    if (typeof ev.first_byte_ms === 'number')
+        s.firstByteMs.push(ev.first_byte_ms);
+    const hasUsage = typeof ev.input_tokens === 'number' ||
+        typeof ev.cache_read_tokens === 'number' ||
+        typeof ev.cache_create_tokens === 'number' ||
+        typeof ev.output_tokens === 'number';
+    if (hasUsage) {
+        s.eventsWithUsage++;
+        s.inputTokensTotal += ev.input_tokens ?? 0;
+        s.outputTokensTotal += ev.output_tokens ?? 0;
+        s.cacheCreateTokensTotal += ev.cache_create_tokens ?? 0;
+        s.cacheReadTokensTotal += ev.cache_read_tokens ?? 0;
+        if ((ev.cache_read_tokens ?? 0) > 0)
+            s.cacheHitEvents++;
+    }
+    if (ev.cwd) {
+        const k = ev.cwd;
+        const e = s.byCwd.get(k) ?? { count: 0, origChars: 0, imageBytes: 0 };
+        e.count++;
+        e.origChars += ev.orig_chars ?? 0;
+        e.imageBytes += ev.image_bytes ?? 0;
+        s.byCwd.set(k, e);
+    }
+    if (ev.system_sha8) {
+        s.systemShaHist.set(ev.system_sha8, (s.systemShaHist.get(ev.system_sha8) ?? 0) + 1);
+    }
+    if (ev.unknown_static_tags) {
+        for (const t of ev.unknown_static_tags) {
+            s.unknownTags.set(t, (s.unknownTags.get(t) ?? 0) + 1);
+        }
+    }
+    return s;
+}
+function percentile(sorted, p) {
+    if (sorted.length === 0)
+        return 0;
+    const idx = Math.min(sorted.length - 1, Math.floor((p / 100) * sorted.length));
+    return sorted[idx];
+}
+/** Format a number with thousands separators. Used for big token counts. */
+function fmtN(n) {
+    return n.toLocaleString('en-US');
+}
+function fmtPct(num, denom) {
+    if (denom === 0)
+        return '   —';
+    return ((num / denom) * 100).toFixed(1).padStart(4) + '%';
+}
+// ---- text report ----------------------------------------------------------
+export function renderTextReport(s) {
+    const lines = [];
+    const sortedDur = [...s.durationMs].sort((a, b) => a - b);
+    const sortedFB = [...s.firstByteMs].sort((a, b) => a - b);
+    lines.push('━━━ pxpipe stats ━━━');
+    lines.push('');
+    lines.push(`requests:       ${fmtN(s.total)}`);
+    lines.push(`  2xx:          ${fmtN(s.ok2xx).padStart(8)}   ` +
+        `4xx: ${fmtN(s.err4xx).padStart(6)}   5xx: ${fmtN(s.err5xx).padStart(6)}`);
+    lines.push(`  compressed:   ${fmtN(s.compressed).padStart(8)}  (${fmtPct(s.compressed, s.total)})`);
+    lines.push(`  passthrough:  ${fmtN(s.passthrough).padStart(8)}  (${fmtPct(s.passthrough, s.total)})`);
+    lines.push('');
+    lines.push('latency (ms):');
+    lines.push(`  duration  p50=${percentile(sortedDur, 50)}  p95=${percentile(sortedDur, 95)}  p99=${percentile(sortedDur, 99)}`);
+    lines.push(`  first-byte p50=${percentile(sortedFB, 50)}  p95=${percentile(sortedFB, 95)}  p99=${percentile(sortedFB, 99)}`);
+    lines.push('');
+    lines.push('compression:');
+    lines.push(`  orig text rendered: ${fmtN(s.origCharsTotal)} chars`);
+    lines.push(`  image bytes:        ${fmtN(s.imageBytesTotal)} B`);
+    const ratio = s.origCharsTotal > 0 ? (s.imageBytesTotal / s.origCharsTotal).toFixed(3) : '—';
+    lines.push(`  bytes/char ratio:   ${ratio}`);
+    lines.push('');
+    lines.push('Anthropic token usage:');
+    lines.push(`  input:         ${fmtN(s.inputTokensTotal).padStart(12)}`);
+    lines.push(`  output:        ${fmtN(s.outputTokensTotal).padStart(12)}`);
+    lines.push(`  cache create:  ${fmtN(s.cacheCreateTokensTotal).padStart(12)}`);
+    lines.push(`  cache read:    ${fmtN(s.cacheReadTokensTotal).padStart(12)}`);
+    const totalIn = s.inputTokensTotal + s.cacheCreateTokensTotal + s.cacheReadTokensTotal;
+    lines.push(`  cache hit rate (by tokens):  ${fmtPct(s.cacheReadTokensTotal, totalIn)}`);
+    lines.push(`  cache hit rate (by events):  ${fmtPct(s.cacheHitEvents, s.eventsWithUsage)}`);
+    lines.push('');
+    if (s.skipReasons.size > 0) {
+        lines.push('top skip reasons:');
+        const top = [...s.skipReasons.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
+        for (const [reason, count] of top) {
+            lines.push(`  ${count.toString().padStart(6)}  ${reason}`);
+        }
+        lines.push('');
+    }
+    if (s.byCwd.size > 0) {
+        lines.push('top working dirs (by request count):');
+        const top = [...s.byCwd.entries()].sort((a, b) => b[1].count - a[1].count).slice(0, 10);
+        for (const [cwd, e] of top) {
+            const cratio = e.origChars > 0 ? (e.imageBytes / e.origChars).toFixed(2) : '—';
+            lines.push(`  ${e.count.toString().padStart(6)}  ratio=${cratio}  ${cwd}`);
+        }
+        lines.push('');
+    }
+    if (s.systemShaHist.size > 0) {
+        lines.push('top system prompts (system_sha8, high count = cache reuse):');
+        const top = [...s.systemShaHist.entries()].sort((a, b) => b[1] - a[1]).slice(0, 5);
+        for (const [sha, count] of top) {
+            lines.push(`  ${count.toString().padStart(6)}  ${sha}`);
+        }
+        const unique = s.systemShaHist.size;
+        const reuseRate = s.total > 0 ? (((s.total - unique) / s.total) * 100).toFixed(1) : '—';
+        lines.push(`  unique prompts: ${unique}    reuse rate: ${reuseRate}%`);
+        lines.push('');
+    }
+    if (s.unknownTags.size > 0) {
+        lines.push('⚠  unknown tag-shaped blocks observed in static slab:');
+        const top = [...s.unknownTags.entries()].sort((a, b) => b[1] - a[1]);
+        for (const [tag, count] of top) {
+            lines.push(`  ${count.toString().padStart(6)}  <${tag}>`);
+        }
+        lines.push('  → consider adding these to DYNAMIC_BLOCK_TAGS in src/core/transform.ts');
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+// ---- file-backed aggregation (used by the dashboard) ----------------------
+/**
+ * Stream an events JSONL file and fold every row into a Summary. Returns the
+ * Summary plus a parsed/dropped tally so callers can detect empty/garbage
+ * inputs. The dashboard wraps this for the /api/stats.json endpoint.
+ *
+ * Note: this is a full re-read on every call. The dashboard already has a
+ * 50-event ring buffer of the *recent* slice; stats need the full history
+ * to compute cache-hit-rate over thousands of requests. ~1.5 MB JSONL
+ * streams in well under 100 ms on an SSD.
+ */
+export async function aggregateEventsFile(file) {
+    if (!fs.existsSync(file))
+        return undefined;
+    const stream = fs.createReadStream(file, { encoding: 'utf8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    const summary = newSummary();
+    let parsed = 0;
+    let dropped = 0;
+    for await (const line of rl) {
+        if (!line.trim())
+            continue;
+        try {
+            const ev = JSON.parse(line);
+            fold(summary, ev);
+            parsed++;
+        }
+        catch {
+            dropped++;
+        }
+    }
+    return { summary, parsed, dropped };
+}
+/**
+ * Convert a Summary to a JSON-serializable shape for the dashboard's
+ * /api/stats.json endpoint. JSON.stringify drops Map entries silently, so
+ * we materialize the top-N entries of each map into plain [key, value]
+ * tuples. Caps each map at 20 entries to keep the response bounded.
+ */
+export function summaryToJson(s) {
+    const topN = (m, n = 20) => [...m.entries()].slice(0, n);
+    const sortedDur = [...s.durationMs].sort((a, b) => a - b);
+    const sortedFB = [...s.firstByteMs].sort((a, b) => a - b);
+    return {
+        total: s.total,
+        ok2xx: s.ok2xx,
+        err4xx: s.err4xx,
+        err5xx: s.err5xx,
+        compressed: s.compressed,
+        passthrough: s.passthrough,
+        origCharsTotal: s.origCharsTotal,
+        imageBytesTotal: s.imageBytesTotal,
+        inputTokensTotal: s.inputTokensTotal,
+        outputTokensTotal: s.outputTokensTotal,
+        cacheCreateTokensTotal: s.cacheCreateTokensTotal,
+        cacheReadTokensTotal: s.cacheReadTokensTotal,
+        cacheHitEvents: s.cacheHitEvents,
+        eventsWithUsage: s.eventsWithUsage,
+        durationP50: percentile(sortedDur, 50),
+        durationP95: percentile(sortedDur, 95),
+        firstByteP50: percentile(sortedFB, 50),
+        firstByteP95: percentile(sortedFB, 95),
+        skipReasons: topN(s.skipReasons),
+        byCwd: topN(s.byCwd),
+        systemShaHist: topN(s.systemShaHist),
+        unknownTags: topN(s.unknownTags),
+    };
+}
+//# sourceMappingURL=stats.js.map

package/dist/worker.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Cloudflare Workers entrypoint. Identical proxy logic to the Node build,
+ * just wired up through the Worker `fetch` export.
+ *
+ * Deploy:
+ *   npx wrangler deploy
+ *
+ * Dev:
+ *   npx wrangler dev
+ *
+ * Config lives in wrangler.toml.
+ */
+export interface Env {
+    /** Optional single upstream base for every API family. Family-specific env vars override it. */
+    PXPIPE_UPSTREAM?: string;
+    ANTHROPIC_UPSTREAM?: string;
+    /** Optional override — if set, replaces whatever x-api-key the client sent. */
+    ANTHROPIC_API_KEY?: string;
+    OPENAI_UPSTREAM?: string;
+    /** Optional override — if set, replaces whatever Authorization the client sent. */
+    OPENAI_API_KEY?: string;
+    COMPRESS?: string;
+    COMPRESS_TOOLS?: string;
+    COMPRESS_REMINDERS?: string;
+    COMPRESS_TOOL_RESULTS?: string;
+    MIN_COMPRESS_CHARS?: string;
+    MIN_REMINDER_CHARS?: string;
+    MIN_TOOL_RESULT_CHARS?: string;
+    COLS?: string;
+    /** R2 multi-column packing — default 1 (off). 2 squeezes ~2× source rows
+     *  per image; OCR-verify before flipping in production. */
+    MULTI_COL?: string;
+    /** Experiment, default off: deterministic prose compression (drop EN/PT
+     *  articles/fillers) on image-bound text before rendering. Flipping it
+     *  changes image bytes (= prompt-cache key); keep constant per deployment.
+     *  See TransformOptions.caveman / src/core/caveman.ts. */
+    CAVEMAN?: string;
+    /** When "0" / "false", disable per-request event JSON logs. Default-on.
+     *  Cloudflare ingests console.log as Workers Logs; pipe via Logpush to
+     *  R2/S3 for the same JSONL shape Node writes to disk. */
+    PXPIPE_TRACK?: string;
+    /** Shared secret callers must present via the `x-pxpipe-secret` header
+     *  whenever an API-key override is configured. Without this gate a
+     *  discovered workers.dev URL is an open key-spender: the Worker would
+     *  attach your key to any stranger's request. Set with:
+     *    npx wrangler secret put PXPIPE_WORKER_SECRET */
+    PXPIPE_WORKER_SECRET?: string;
+}
+declare const _default: {
+    fetch(req: Request, env: Env, _ctx: ExecutionContext): Promise<Response>;
+};
+export default _default;
+//# sourceMappingURL=worker.d.ts.map

package/dist/worker.js

@@ -0,0 +1,102 @@
+/**
+ * Cloudflare Workers entrypoint. Identical proxy logic to the Node build,
+ * just wired up through the Worker `fetch` export.
+ *
+ * Deploy:
+ *   npx wrangler deploy
+ *
+ * Dev:
+ *   npx wrangler dev
+ *
+ * Config lives in wrangler.toml.
+ */
+import { createProxy } from './core/proxy.js';
+import { toTrackEvent, JsonLogTracker, noopTracker } from './core/tracker.js';
+/** Compare SHA-256 digests instead of the raw strings so the comparison
+ *  can't leak a prefix-match timing signal. */
+async function secretsMatch(a, b) {
+    const enc = new TextEncoder();
+    const [da, db] = await Promise.all([
+        crypto.subtle.digest('SHA-256', enc.encode(a)),
+        crypto.subtle.digest('SHA-256', enc.encode(b)),
+    ]);
+    const va = new Uint8Array(da);
+    const vb = new Uint8Array(db);
+    let diff = 0;
+    for (let i = 0; i < va.length; i++)
+        diff |= (va[i] ?? 0) ^ (vb[i] ?? 0);
+    return diff === 0;
+}
+const truthy = (v, fallback) => v == null ? fallback : v === '1' || v.toLowerCase() === 'true';
+export default {
+    async fetch(req, env, _ctx) {
+        // ── Caller auth ────────────────────────────────────────────────────
+        // If this deployment injects API keys, never serve anonymous callers:
+        // workers.dev URLs are discoverable, and without this gate anyone who
+        // finds the URL spends this deployment's API credits.
+        if (env.ANTHROPIC_API_KEY || env.OPENAI_API_KEY) {
+            if (!env.PXPIPE_WORKER_SECRET) {
+                return new Response(JSON.stringify({
+                    error: 'refusing to proxy: an API key override is configured but PXPIPE_WORKER_SECRET is not, ' +
+                        'which would let anyone who finds this URL spend the configured key. ' +
+                        'Run `npx wrangler secret put PXPIPE_WORKER_SECRET` and send the value as the x-pxpipe-secret header.',
+                }), { status: 503, headers: { 'content-type': 'application/json' } });
+            }
+            const presented = req.headers.get('x-pxpipe-secret') ?? '';
+            if (!(await secretsMatch(presented, env.PXPIPE_WORKER_SECRET))) {
+                return new Response(JSON.stringify({ error: 'missing or invalid x-pxpipe-secret header' }), { status: 401, headers: { 'content-type': 'application/json' } });
+            }
+            // Don't forward the shared secret upstream.
+            req = new Request(req);
+            req.headers.delete('x-pxpipe-secret');
+        }
+        const transform = {
+            compress: truthy(env.COMPRESS, true),
+            compressTools: truthy(env.COMPRESS_TOOLS, true),
+            compressReminders: truthy(env.COMPRESS_REMINDERS, true),
+            compressToolResults: truthy(env.COMPRESS_TOOL_RESULTS, true),
+            minCompressChars: env.MIN_COMPRESS_CHARS ? Number(env.MIN_COMPRESS_CHARS) : 2000,
+            // 500 chars — CPU/latency floor only, not a correctness guard. The
+            // No floors — the content-aware `isCompressionProfitable()` gate
+            // decides per-block based on actual pixel cost vs text cost. Host
+            // can still set a floor via env if they want observability buckets
+            // (e.g. MIN_TOOL_RESULT_CHARS=200 to skip absurdly small dumps).
+            minReminderChars: env.MIN_REMINDER_CHARS ? Number(env.MIN_REMINDER_CHARS) : 0,
+            minToolResultChars: env.MIN_TOOL_RESULT_CHARS ? Number(env.MIN_TOOL_RESULT_CHARS) : 0,
+            cols: env.COLS ? Number(env.COLS) : 100,
+            // R2 multi-column ON (2 cols) — single-col drops below break-even on
+            // real tool-doc slabs. Override via MULTI_COL=1 if OCR misreads layout.
+            multiCol: env.MULTI_COL ? Math.max(1, Number(env.MULTI_COL) | 0) : 2,
+            caveman: truthy(env.CAVEMAN, false),
+        };
+        const trackingOn = truthy(env.PXPIPE_TRACK, true);
+        // Workers Logs ingests stdout as separate log lines. Emit one JSON line
+        // per event so downstream (Logpush → R2/S3) reads the same JSONL shape
+        // the Node host writes to disk.
+        const tracker = trackingOn ? new JsonLogTracker((s) => console.log(s)) : noopTracker;
+        const sharedUpstream = env.PXPIPE_UPSTREAM;
+        const config = {
+            upstream: env.ANTHROPIC_UPSTREAM ?? sharedUpstream ?? 'https://api.anthropic.com',
+            apiKey: env.ANTHROPIC_API_KEY,
+            openAIUpstream: env.OPENAI_UPSTREAM ?? sharedUpstream ?? 'https://api.openai.com',
+            openAIApiKey: env.OPENAI_API_KEY,
+            transform,
+            onRequest: (e) => {
+                // Terse human-readable line (separate from the JSON event below;
+                // shows up in `wrangler tail`).
+                const tag = e.info?.compressed
+                    ? `compressed ${e.info.origChars}ch → ${e.info.imageCount}img/${e.info.imageBytes}B`
+                    : (e.info?.reason ?? '');
+                const cacheRead = e.usage?.cache_read_input_tokens ?? 0;
+                console.log(`${e.method} ${e.path} → ${e.status} (${e.durationMs}ms) ${tag} cache_read=${cacheRead}`);
+                if (e.info?.unknownStaticTags && e.info.unknownStaticTags.length > 0) {
+                    console.warn(`[pxpipe warn] unknown tag(s) in static slab: ${e.info.unknownStaticTags.join(', ')}`);
+                }
+                tracker.emit(toTrackEvent(e));
+            },
+        };
+        const handle = createProxy(config);
+        return handle(req);
+    },
+};
+//# sourceMappingURL=worker.js.map

package/package.json

@@ -0,0 +1,96 @@
+{
+  "name": "@xamukavila/pxpipe",
+  "version": "0.8.0",
+  "description": "Token-saving proxy for Claude Code: renders bulky context (system prompt, tool docs, old history) as dense PNGs to cut input tokens. Runs on Node and Cloudflare Workers.",
+  "type": "module",
+  "bin": {
+    "pxpipe": "bin/cli.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/core/index.d.ts",
+      "import": "./dist/core/index.js"
+    },
+    "./transform": {
+      "types": "./dist/core/library.d.ts",
+      "import": "./dist/core/library.js"
+    },
+    "./measurement": {
+      "types": "./dist/core/measurement.d.ts",
+      "import": "./dist/core/measurement.js"
+    },
+    "./applicability": {
+      "types": "./dist/core/applicability.d.ts",
+      "import": "./dist/core/applicability.js"
+    },
+    "./proxy": {
+      "types": "./dist/core/proxy.d.ts",
+      "import": "./dist/core/proxy.js"
+    },
+    "./node": {
+      "types": "./dist/node.d.ts",
+      "import": "./dist/node.js"
+    },
+    "./worker": {
+      "types": "./dist/worker.d.ts",
+      "import": "./dist/worker.js"
+    }
+  },
+  "files": [
+    "bin/",
+    "dist/",
+    "!dist/**/*.map",
+    "README.md",
+    "LICENSE"
+  ],
+  "keywords": [
+    "claude",
+    "claude-code",
+    "anthropic",
+    "fable-5",
+    "proxy",
+    "token-optimization",
+    "prompt-cache",
+    "vision-tokens",
+    "cloudflare-workers"
+  ],
+  "engines": {
+    "node": ">=18"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@cloudflare/workers-types": "^4.20240512.0",
+    "@napi-rs/canvas": "^0.1.53",
+    "@types/node": "^20.12.0",
+    "esbuild": "^0.28.1",
+    "tsx": "^4.10.0",
+    "typescript": "^5.4.0",
+    "vite": "^8.0.16",
+    "vitest": "^4.1.6",
+    "wrangler": "^4.92.0"
+  },
+  "dependencies": {
+    "gpt-tokenizer": "^3.4.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/XamuAvila/pxpipe.git"
+  },
+  "homepage": "https://github.com/XamuAvila/pxpipe#readme",
+  "bugs": {
+    "url": "https://github.com/XamuAvila/pxpipe/issues"
+  },
+  "scripts": {
+    "build": "node scripts/build.mjs",
+    "build:atlas": "tsx scripts/gen-atlas.ts",
+    "dev:node": "tsx watch src/node.ts",
+    "dev:worker": "wrangler dev",
+    "deploy:worker": "wrangler deploy",
+    "restart": "bash scripts/restart.sh",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:restart": "bash tests/restart.test.sh",
+    "vendor:ui": "node scripts/vendor-ui.mjs"
+  }
+}