@xamukavila/pxpipe 0.8.0

package/dist/core/png.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Minimal PNG encoder (grayscale + RGB, 8-bit, filter=None, single IDAT).
+ * Pure Uint8Array — uses CompressionStream (Node 18+, Workers, browsers); no Buffer/node:zlib.
+ */
+/** Encode a single-channel (grayscale) buffer as PNG bytes. pixels is row-major, length = width × height. */
+export declare function encodeGrayPng(pixels: Uint8Array, width: number, height: number): Promise<Uint8Array>;
+/** Encode an RGB (3 bytes/pixel, R,G,B) buffer as PNG bytes (colorType 2 = truecolor). length = width × height × 3. */
+export declare function encodeRgbPng(pixels: Uint8Array, width: number, height: number): Promise<Uint8Array>;
+/** Base64-encode bytes. Chunks to avoid call-stack blow-up from String.fromCharCode(...bigArray). */
+export declare function bytesToBase64(bytes: Uint8Array): string;
+//# sourceMappingURL=png.d.ts.map

package/dist/core/png.js

@@ -0,0 +1,132 @@
+/**
+ * Minimal PNG encoder (grayscale + RGB, 8-bit, filter=None, single IDAT).
+ * Pure Uint8Array — uses CompressionStream (Node 18+, Workers, browsers); no Buffer/node:zlib.
+ */
+// ---- CRC32 ---------------------------------------------------------------
+const CRC_TABLE = (() => {
+    const t = new Uint32Array(256);
+    for (let n = 0; n < 256; n++) {
+        let c = n;
+        for (let k = 0; k < 8; k++)
+            c = c & 1 ? 0xedb88320 ^ (c >>> 1) : c >>> 1;
+        t[n] = c >>> 0;
+    }
+    return t;
+})();
+function crc32(bytes) {
+    let c = 0xffffffff;
+    for (let i = 0; i < bytes.length; i++)
+        c = CRC_TABLE[(c ^ bytes[i]) & 0xff] ^ (c >>> 8);
+    return (c ^ 0xffffffff) >>> 0;
+}
+// ---- Helpers -------------------------------------------------------------
+function concat(parts) {
+    let total = 0;
+    for (const p of parts)
+        total += p.length;
+    const out = new Uint8Array(total);
+    let off = 0;
+    for (const p of parts) {
+        out.set(p, off);
+        off += p.length;
+    }
+    return out;
+}
+function u32be(n) {
+    const b = new Uint8Array(4);
+    new DataView(b.buffer).setUint32(0, n >>> 0, false);
+    return b;
+}
+const TYPE_BYTES = (s) => {
+    const b = new Uint8Array(s.length);
+    for (let i = 0; i < s.length; i++)
+        b[i] = s.charCodeAt(i);
+    return b;
+};
+function chunk(type, data) {
+    const typeB = TYPE_BYTES(type);
+    const crcSrc = concat([typeB, data]);
+    return concat([u32be(data.length), typeB, data, u32be(crc32(crcSrc))]);
+}
+// ---- Deflate via Web Streams ---------------------------------------------
+async function deflateZlib(input) {
+    // 'deflate' = RFC 1950 zlib-wrapped — what PNG IDAT needs. 'deflate-raw' (RFC 1951) would be wrong.
+    const cs = new CompressionStream('deflate');
+    const writer = cs.writable.getWriter();
+    // TS 5.7 narrows Uint8Array<ArrayBufferLike> away from BufferSource; safe since we never use SharedArrayBuffer.
+    void writer.write(input);
+    void writer.close();
+    const reader = cs.readable.getReader();
+    const chunks = [];
+    while (true) {
+        const { value, done } = await reader.read();
+        if (done)
+            break;
+        if (value)
+            chunks.push(value);
+    }
+    return concat(chunks);
+}
+// ---- Encode --------------------------------------------------------------
+const PNG_SIGNATURE = new Uint8Array([0x89, 0x50, 0x4e, 0x47, 0x0d, 0x0a, 0x1a, 0x0a]);
+/** Encode a single-channel (grayscale) buffer as PNG bytes. pixels is row-major, length = width × height. */
+export async function encodeGrayPng(pixels, width, height) {
+    if (pixels.length !== width * height) {
+        throw new Error(`encodeGrayPng: pixels.length=${pixels.length} != ${width}×${height}=${width * height}`);
+    }
+    // IHDR: width(4) height(4) bitDepth=8 colorType=0(gray) compress=0 filter=0 interlace=0
+    const ihdr = new Uint8Array(13);
+    ihdr.set(u32be(width), 0);
+    ihdr.set(u32be(height), 4);
+    ihdr[8] = 8;
+    ihdr[9] = 0; // colorType 0 = grayscale; bytes 10-12 already zero
+    // Prepend per-scanline filter byte (0 = None).
+    const stride = width + 1;
+    const raw = new Uint8Array(stride * height);
+    for (let y = 0; y < height; y++) {
+        raw[y * stride] = 0; // filter: None
+        raw.set(pixels.subarray(y * width, (y + 1) * width), y * stride + 1);
+    }
+    const compressed = await deflateZlib(raw);
+    return concat([
+        PNG_SIGNATURE,
+        chunk('IHDR', ihdr),
+        chunk('IDAT', compressed),
+        chunk('IEND', new Uint8Array(0)),
+    ]);
+}
+/** Encode an RGB (3 bytes/pixel, R,G,B) buffer as PNG bytes (colorType 2 = truecolor). length = width × height × 3. */
+export async function encodeRgbPng(pixels, width, height) {
+    if (pixels.length !== width * height * 3) {
+        throw new Error(`encodeRgbPng: pixels.length=${pixels.length} != ${width}×${height}×3=${width * height * 3}`);
+    }
+    const ihdr = new Uint8Array(13);
+    ihdr.set(u32be(width), 0);
+    ihdr.set(u32be(height), 4);
+    ihdr[8] = 8; // bit depth per channel
+    ihdr[9] = 2; // colorType 2 = truecolor RGB; bytes 10-12 already zero
+    // Prepend per-scanline filter byte (0 = None).
+    const stride = width * 3 + 1;
+    const raw = new Uint8Array(stride * height);
+    for (let y = 0; y < height; y++) {
+        raw[y * stride] = 0; // filter: None
+        raw.set(pixels.subarray(y * width * 3, (y + 1) * width * 3), y * stride + 1);
+    }
+    const compressed = await deflateZlib(raw);
+    return concat([
+        PNG_SIGNATURE,
+        chunk('IHDR', ihdr),
+        chunk('IDAT', compressed),
+        chunk('IEND', new Uint8Array(0)),
+    ]);
+}
+/** Base64-encode bytes. Chunks to avoid call-stack blow-up from String.fromCharCode(...bigArray). */
+export function bytesToBase64(bytes) {
+    let binary = '';
+    const CHUNK = 0x8000;
+    for (let i = 0; i < bytes.length; i += CHUNK) {
+        binary += String.fromCharCode(...bytes.subarray(i, i + CHUNK));
+    }
+    return btoa(binary);
+}
+//# sourceMappingURL=png.js.map

package/dist/core/proxy.d.ts

@@ -0,0 +1,81 @@
+/**
+ * pxpipe proxy as a single Web-standard fetch handler.
+ * Adapted by src/node.ts and src/worker.ts; uses only Request/Response/URL/fetch.
+ */
+import { type TransformOptions, type TransformInfo } from './transform.js';
+import type { Usage } from './types.js';
+export interface ProxyConfig {
+    /** 'cloudflare-ai-gateway': routes both families through gatewayBaseUrl;
+     *  OpenAI paths drop the `/v1` prefix to match gateway shape. */
+    provider?: 'cloudflare-ai-gateway';
+    /** Gateway base URL (account/gateway-scoped). Required when provider is set. */
+    gatewayBaseUrl?: string;
+    /** Extra headers injected on every upstream request (e.g. gateway auth). */
+    gatewayHeaders?: Record<string, string>;
+    /** Anthropic API base, no trailing slash. Defaults to api.anthropic.com. */
+    upstream?: string;
+    /** Override or supply an API key. If unset, we forward whatever the client sent. */
+    apiKey?: string;
+    /** OpenAI API base for GPT chat completions, no trailing slash. */
+    openAIUpstream?: string;
+    /** Override or supply an OpenAI API key. If unset, we forward Authorization. */
+    openAIApiKey?: string;
+    /** Pass a function to inject dynamic values per-request (e.g. live charsPerToken);
+     *  static object for Workers/tests. */
+    transform?: TransformOptions | (() => TransformOptions);
+    /** Called after every request — useful for logging / metrics in the host. */
+    onRequest?: (event: ProxyEvent) => void | Promise<void>;
+}
+export interface ProxyEvent {
+    method: string;
+    path: string;
+    /** Top-level request model when present. Used for telemetry/dashboard labels only. */
+    model?: string;
+    status: number;
+    /** Wall-clock ms from request start to event fire (≈ end of upstream body). */
+    durationMs: number;
+    /** Wall-clock ms from request start to upstream response headers. */
+    firstByteMs?: number;
+    info?: TransformInfo;
+    /** Usage block from Anthropic's response — input/output/cache tokens. */
+    usage?: Usage;
+    /** Model stop reason from the response ("end_turn", "tool_use", "max_tokens",
+     *  "refusal", …). "refusal" = safety classifier fired on the transformed request —
+     *  scorers must fail cost comparisons on refusal rows (refusals emit almost no
+     *  output and would otherwise look "cheaper"). OpenAI finish_reason ("stop",
+     *  "length", "content_filter", …) is normalized into the same field. */
+    stopReason?: string;
+    error?: string;
+    /** First ~2 KiB of the upstream 4xx body (not captured on 2xx or 5xx). */
+    errorBody?: string;
+    /** sha256[0..8] of the transformed outgoing body — set on every /v1/messages POST for correlation. */
+    reqBodySha8?: string;
+    /** Gzipped transformed body, populated only on 4xx. Node may write to sidecar (see reqBodySamplePath). */
+    reqBodyGz?: Uint8Array;
+    /** Set by the Node host instead of reqBodyGz when the body was written to a sidecar file. */
+    reqBodySamplePath?: string;
+    /** Ground-truth char counts from the response stream, independent of usage.output_tokens.
+     *  Absent when the body couldn't be scanned (5xx, unknown content-type). See OutputMeasurement. */
+    measurement?: OutputMeasurement;
+}
+/**
+ * Ground-truth char counts from the response stream, independent of usage.output_tokens.
+ * redactedBlockCount blocks are opaque server bytes — no char count available for those.
+ */
+export interface OutputMeasurement {
+    textChars: number;
+    thinkingChars: number;
+    toolUseChars: number;
+    redactedBlockCount: number;
+}
+/** Resolve upstream URLs from config. Pure — unit-testable. */
+export declare function resolveUpstreams(config: ProxyConfig): {
+    anthropic: string;
+    openai: string;
+    stripOpenAIV1: boolean;
+};
+/** Parse PXPIPE_GATEWAY_HEADERS — JSON object or `k=v;k2=v2`. */
+export declare function parseGatewayHeaders(spec: string | undefined): Record<string, string>;
+/** Build the proxy fetch handler. */
+export declare function createProxy(config?: ProxyConfig): (req: Request) => Promise<Response>;
+//# sourceMappingURL=proxy.d.ts.map