@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/agent/providers/claude/background-work-kinds.js

@@ -0,0 +1,96 @@
+/**
+ * The complete census of background work a Claude Code session can hold open.
+ *
+ * WHY THIS FILE EXISTS
+ *
+ * `deriveAgentStateBucket` ends in `return "done"`. That makes "done" the
+ * FALLTHROUGH: any kind of background work nobody taught the system about
+ * becomes invisible by construction, not by decision. Monitors and crons sat in
+ * that blind spot for the life of the feature — a session with an armed monitor
+ * reported zero background tasks, bucketed as "done", and looked idle while it
+ * was actively watching.
+ *
+ * The fix is not "remember to add a pattern". It is to enumerate what we
+ * SILENCE rather than what we want, so an unlisted kind is merely noisy (a
+ * failing build) instead of invisible (a lying UI).
+ *
+ * HOW IT FAILS LOUDLY
+ *
+ * `BACKGROUND_WORK_KINDS` is declared `satisfies Record<BackgroundWorkKind, …>`.
+ * Add a member to the union without adding its entry here and the TYPE CHECK
+ * fails. Add an entry claiming `tracked: true` without a start pattern that
+ * actually extracts its id and `background-work-kinds.test.ts` fails.
+ *
+ * ⚠️ A PATTERN IS NOT ENOUGH — THE TOOL NAME MUST BE GATED IN TOO
+ *
+ * `trackBackgroundShellStart` in `providers/claude/agent.ts` only forwards a
+ * tool_result to the parser when its tool name is in `BACKGROUND_WORK_TOOL_NAMES`.
+ * The first version of this file shipped monitor and cron patterns while that
+ * gate still read `toolName !== "Bash"`, so both were dead code in production
+ * and every test passed because the tests called the parser directly. A kind is
+ * only really tracked when it has: a start pattern, a retirement path, an entry
+ * here, AND its tool name in that set — proven by an integration test that goes
+ * through `handleToolResult`.
+ *
+ * SAMPLES ARE CAPTURES, NOT TRANSCRIPTIONS
+ *
+ * Every `sample` below was pasted verbatim out of a live session's tool_result
+ * on 2026-08-22. Do not tidy them. This repo has already shipped a regex that
+ * passed 21 green tests against hand-typed fixtures while being broken in
+ * production, because the real text was prose and every fixture was a clean
+ * one-liner. If you add a kind, capture its real string first.
+ */
+export const BACKGROUND_WORK_KINDS = {
+    shell: {
+        tracked: true,
+        label: "background shell",
+        sample: "Command running in background with ID: beuhoixae. Output is being written to: /tmp/x/beuhoixae.output. You will be notified when it completes.",
+        expectedId: "beuhoixae",
+        retiredBy: [
+            "<task-notification> with a terminal <status>",
+            '"Successfully stopped task: <id>" in a TaskStop tool_result',
+        ],
+        trackedBy: "ClaudeBackgroundTaskTracker.noteToolResultText",
+        toolName: "Bash",
+    },
+    monitor: {
+        tracked: true,
+        label: "monitor",
+        sample: "Monitor started (task b6dxcqe9y, timeout 20000ms). You will be notified on each event. Keep working — do not poll or sleep.",
+        expectedId: "b6dxcqe9y",
+        // Confirmed live: the monitor's completion arrives as the SAME
+        // <task-notification> envelope, same <task-id>, <status>completed</status>.
+        // Only its START was ever invisible.
+        retiredBy: [
+            "<task-notification> with a terminal <status>",
+            '"Successfully stopped task: <id>" in a TaskStop tool_result',
+        ],
+        trackedBy: "ClaudeBackgroundTaskTracker.noteToolResultText",
+        toolName: "Monitor",
+    },
+    cron: {
+        tracked: true,
+        label: "scheduled job",
+        sample: "Scheduled recurring job b8df03d3 (Every Wednesday at 4:23 AM). Session-only (not written to disk, dies when Claude exits). Auto-expires after 7 days. Use CronDelete to cancel sooner.",
+        expectedId: "b8df03d3",
+        // A cron emits NO task-notification. "Cancelled job <id>." in a later
+        // tool_result is its only retirement signal — note the glued-on period.
+        retiredBy: [
+            '"Cancelled job <id>." in a later tool_result',
+            '"Successfully stopped task: <id>" in a TaskStop tool_result',
+        ],
+        trackedBy: "ClaudeBackgroundTaskTracker.noteToolResultText",
+        toolName: "CronCreate",
+    },
+    scheduled_wakeup: {
+        tracked: false,
+        label: "scheduled wakeup",
+        silencedBecause: "ScheduleWakeup only exists inside /loop dynamic mode, and invoking it to capture its announcement would schedule a real wakeup of the capturing session. No verbatim capture has been taken yet, and this module's rule is that a pattern is written from a real string or not at all. A /loop session's transcript must be captured before this can move to tracked:true. Until then a dynamic /loop between wakeups buckets as done.",
+    },
+    subagent: {
+        tracked: false,
+        label: "subagent",
+        silencedBecause: "Live subagents DO keep the parent alive, but not through this tracker: they arrive as their own agent snapshots and are attributed to the delegation root in workspace-directory.applyAgentBucketContributions (server) and countActiveChildrenByParent (app). Counting them here as well would double-count them.",
+    },
+};
+//# sourceMappingURL=background-work-kinds.js.map

package/dist/server/server/agent/providers/claude/feature-definitions.d.ts

@@ -0,0 +1,8 @@
+import type { AgentFeature, AgentFeatureToggle } from "../../agent-sdk-types.js";
+export declare const CLAUDE_FAST_MODE_FEATURE: Omit<AgentFeatureToggle, "value">;
+export declare function claudeModelSupportsFastMode(modelId: string | null | undefined): boolean;
+export declare function buildClaudeFeatures(input: {
+    modelId: string | null | undefined;
+    fastModeEnabled: boolean;
+}): AgentFeature[];
+//# sourceMappingURL=feature-definitions.d.ts.map

package/dist/server/server/agent/providers/claude/feature-definitions.js

@@ -0,0 +1,24 @@
+import { claudeManifestModelSupportsFastMode } from "./model-manifest.js";
+export const CLAUDE_FAST_MODE_FEATURE = {
+    type: "toggle",
+    id: "fast_mode",
+    label: "Fast",
+    description: "Lower latency Opus responses at higher token cost",
+    tooltip: "Toggle fast mode",
+    icon: "zap",
+};
+export function claudeModelSupportsFastMode(modelId) {
+    return claudeManifestModelSupportsFastMode(modelId);
+}
+export function buildClaudeFeatures(input) {
+    if (!claudeModelSupportsFastMode(input.modelId)) {
+        return [];
+    }
+    return [
+        {
+            ...CLAUDE_FAST_MODE_FEATURE,
+            value: input.fastModeEnabled,
+        },
+    ];
+}
+//# sourceMappingURL=feature-definitions.js.map

package/dist/server/server/agent/providers/claude/hook-handler.d.ts

@@ -0,0 +1,37 @@
+import type { Logger } from "pino";
+import { type HookEvent, type PermissionHookEvent } from "@hyperdrive.bot/fleet-protocol/messages";
+export interface PermissionDecision {
+    behavior: "allow" | "deny";
+    message?: string;
+}
+export interface PermissionRequest {
+    event: PermissionHookEvent;
+    requestId: string;
+    resolve: (decision: PermissionDecision) => void;
+}
+export type HookEventHandler = (event: HookEvent, permissionRequestId?: string) => void | Promise<void>;
+export declare class HookHandlerServer {
+    private server;
+    private socketPath;
+    private httpPort;
+    private agentId;
+    private handler;
+    private readonly pendingPermissions;
+    private readonly logger;
+    private requestCounter;
+    constructor(logger: Logger);
+    registerHandler(handler: HookEventHandler): void;
+    unregisterHandler(): void;
+    start(agentId: string): Promise<void>;
+    stop(): Promise<void>;
+    getAddress(): string;
+    /**
+     * Called by ClaudeAgentSession when the WebSocket permission decision arrives.
+     * Returns true if the request was found and resolved.
+     */
+    resolvePermission(requestId: string, decision: PermissionDecision): boolean;
+    private handleRequest;
+    private handlePermissionEvent;
+    private dispatchEvent;
+}
+//# sourceMappingURL=hook-handler.d.ts.map

package/dist/server/server/agent/providers/claude/hook-handler.js

@@ -0,0 +1,193 @@
+import fs from "node:fs";
+import http from "node:http";
+import path from "node:path";
+import { HookEventSchema, } from "@hyperdrive.bot/fleet-protocol/messages";
+import { resolvePaseoHome } from "../../../paseo-home.js";
+function readRequestBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on("data", (chunk) => chunks.push(chunk));
+        req.on("end", () => resolve(Buffer.concat(chunks).toString("utf8")));
+        req.on("error", reject);
+    });
+}
+function sendJson(res, statusCode, body) {
+    const json = JSON.stringify(body);
+    res.writeHead(statusCode, {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(json),
+    });
+    res.end(json);
+}
+export class HookHandlerServer {
+    constructor(logger) {
+        this.server = null;
+        this.socketPath = null;
+        this.httpPort = null;
+        this.agentId = null;
+        this.handler = null;
+        this.pendingPermissions = new Map();
+        this.requestCounter = 0;
+        this.logger = logger;
+    }
+    registerHandler(handler) {
+        this.handler = handler;
+    }
+    unregisterHandler() {
+        this.handler = null;
+    }
+    async start(agentId) {
+        this.agentId = agentId;
+        const server = http.createServer((req, res) => {
+            this.handleRequest(req, res).catch((err) => {
+                this.logger.error({ err }, "hook-handler: unhandled request error");
+                if (!res.headersSent) {
+                    sendJson(res, 500, { error: "internal server error" });
+                }
+            });
+        });
+        this.server = server;
+        await new Promise((resolve, reject) => {
+            server.on("error", reject);
+            if (process.platform === "win32") {
+                server.listen({ host: "127.0.0.1", port: 0 }, () => {
+                    const addr = server.address();
+                    this.httpPort = addr.port;
+                    resolve();
+                });
+            }
+            else {
+                const sockDir = path.join(resolvePaseoHome(), "sockets");
+                fs.mkdirSync(sockDir, { recursive: true });
+                const sockPath = path.join(sockDir, `agent-hook-${agentId}.sock`);
+                // Remove stale socket file from a prior unclean exit
+                try {
+                    fs.unlinkSync(sockPath);
+                }
+                catch {
+                    // file didn't exist — that's fine
+                }
+                this.socketPath = sockPath;
+                server.listen(sockPath, () => {
+                    resolve();
+                });
+            }
+        });
+        this.logger.debug({ address: this.getAddress(), agentId }, "hook-handler: server started");
+    }
+    async stop() {
+        // Resolve all pending permissions with deny before shutting down
+        for (const [, resolve] of this.pendingPermissions) {
+            resolve({ behavior: "deny", message: "daemon shutting down" });
+        }
+        this.pendingPermissions.clear();
+        if (this.server) {
+            await new Promise((resolve, reject) => {
+                this.server.close((err) => {
+                    if (err) {
+                        reject(err);
+                        return;
+                    }
+                    resolve();
+                });
+            });
+            this.server = null;
+        }
+        if (this.socketPath) {
+            try {
+                fs.unlinkSync(this.socketPath);
+            }
+            catch {
+                // already gone
+            }
+            this.socketPath = null;
+        }
+        this.logger.debug({ agentId: this.agentId }, "hook-handler: server stopped");
+    }
+    getAddress() {
+        if (process.platform === "win32" && this.httpPort !== null) {
+            return `http://127.0.0.1:${this.httpPort}`;
+        }
+        if (this.socketPath) {
+            return this.socketPath;
+        }
+        throw new Error("HookHandlerServer has not been started");
+    }
+    /**
+     * Called by ClaudeAgentSession when the WebSocket permission decision arrives.
+     * Returns true if the request was found and resolved.
+     */
+    resolvePermission(requestId, decision) {
+        const resolver = this.pendingPermissions.get(requestId);
+        if (!resolver) {
+            return false;
+        }
+        this.pendingPermissions.delete(requestId);
+        resolver(decision);
+        return true;
+    }
+    async handleRequest(req, res) {
+        let body;
+        try {
+            body = await readRequestBody(req);
+        }
+        catch (err) {
+            this.logger.warn({ err }, "hook-handler: failed to read request body");
+            sendJson(res, 400, { error: "failed to read body" });
+            return;
+        }
+        let parsed;
+        try {
+            parsed = JSON.parse(body);
+        }
+        catch {
+            sendJson(res, 400, { error: "invalid JSON" });
+            return;
+        }
+        const result = HookEventSchema.safeParse(parsed);
+        if (!result.success) {
+            this.logger.warn({ issues: result.error.issues }, "hook-handler: invalid HookEvent payload");
+            sendJson(res, 400, { error: "invalid payload", detail: result.error.issues });
+            return;
+        }
+        const event = result.data;
+        this.logger.debug({ kind: event.kind, agentId: "agent_id" in event ? event.agent_id : undefined }, "hook-handler: received event");
+        if (event.kind === "permission") {
+            await this.handlePermissionEvent(event, res);
+        }
+        else {
+            // Fire-and-forget: respond immediately, then dispatch async
+            sendJson(res, 200, {});
+            Promise.resolve()
+                .then(() => this.dispatchEvent(event))
+                .catch((err) => {
+                this.logger.error({ err, kind: event.kind }, "hook-handler: observation handler error");
+            });
+        }
+    }
+    async handlePermissionEvent(event, res) {
+        const requestId = `hook-perm-${this.agentId}-${++this.requestCounter}`;
+        const decision = await new Promise((resolve) => {
+            this.pendingPermissions.set(requestId, resolve);
+            Promise.resolve()
+                .then(() => this.dispatchEvent(event, requestId))
+                .catch((err) => {
+                this.logger.error({ err }, "hook-handler: permission dispatch error");
+                const existing = this.pendingPermissions.get(requestId);
+                if (existing) {
+                    this.pendingPermissions.delete(requestId);
+                    resolve({ behavior: "deny", message: "handler dispatch failed" });
+                }
+            });
+        });
+        sendJson(res, 200, decision);
+    }
+    dispatchEvent(event, permissionRequestId) {
+        if (!this.handler) {
+            this.logger.debug({ kind: event.kind }, "hook-handler: no handler registered, ignoring event");
+            return;
+        }
+        return this.handler(event, permissionRequestId);
+    }
+}
+//# sourceMappingURL=hook-handler.js.map

package/dist/server/server/agent/providers/claude/hooks/event-translator.d.ts

@@ -0,0 +1,49 @@
+import type { AgentProvider, AgentStreamEvent, AgentPermissionRequest } from "../../../agent-sdk-types.js";
+import type { HookEvent, PermissionHookEvent, SessionStartHookEvent } from "@hyperdrive.bot/fleet-protocol/messages";
+/**
+ * Translator context — minimal surface the pump must expose so the translator
+ * can route side-effects (permission requests, session-start capture) without
+ * importing the full ClaudeAgentSession (would create a circular import).
+ *
+ * The pump owns: pendingPermissions map, claudeSessionId capture, transcript
+ * tailer startup, turnId allocation. The translator only converts wire shapes
+ * and asks the pump to do the side-effecting work via these callbacks.
+ */
+export interface TranslatorContext {
+    readonly provider: AgentProvider;
+    readonly turnId?: string;
+    /**
+     * Called when a permission-request HookEvent arrives. The pump should:
+     *  1. Register a pending waiter keyed on agent_id + a generated request id
+     *  2. Wire the waiter so the hook subprocess receives the eventual decision
+     *  3. Return the AgentPermissionRequest shape so the translator can emit it
+     *     in the permission_requested stream event
+     *
+     * Returning null suppresses the stream event (e.g. caller chose to handle
+     * the permission flow outside the normal event channel).
+     */
+    registerPermissionRequest(event: PermissionHookEvent): AgentPermissionRequest | null;
+    /**
+     * Called once when the SessionStart hook arrives. The pump should capture
+     * `session_id` into `claudeSessionId` and start the TranscriptTailer for
+     * `transcript_path`. This replaces today's `system.init` parse at
+     * agent.ts:3107-3118 for the PTY path.
+     */
+    onSessionStart?(event: SessionStartHookEvent): void;
+}
+/**
+ * Translate a daemon-internal HookEvent into zero-or-more AgentStreamEvent(s)
+ * that the pump can emit verbatim via its existing emitStreamEvent path.
+ *
+ * Returns:
+ *   - `[]` when the event was handled entirely via side-effect callbacks
+ *     (session-start, permission registered without an emit, etc.)
+ *   - One or more AgentStreamEvent shapes that the pump should emit
+ *   - `null` if the event could not be translated (caller may log/skip)
+ *
+ * The translator is pure (modulo `ctx.*` callbacks): no global state, no I/O.
+ * Tool-call mapping is delegated to `tool-call-mapper.ts` so the shapes stay
+ * identical across SDK and PTY transports.
+ */
+export declare function translateHookEvent(event: HookEvent, ctx: TranslatorContext): AgentStreamEvent[] | null;
+//# sourceMappingURL=event-translator.d.ts.map

package/dist/server/server/agent/providers/claude/hooks/event-translator.js

@@ -0,0 +1,151 @@
+import { mapClaudeRunningToolCall, mapClaudeCompletedToolCall } from "../tool-call-mapper.js";
+/**
+ * Translate a daemon-internal HookEvent into zero-or-more AgentStreamEvent(s)
+ * that the pump can emit verbatim via its existing emitStreamEvent path.
+ *
+ * Returns:
+ *   - `[]` when the event was handled entirely via side-effect callbacks
+ *     (session-start, permission registered without an emit, etc.)
+ *   - One or more AgentStreamEvent shapes that the pump should emit
+ *   - `null` if the event could not be translated (caller may log/skip)
+ *
+ * The translator is pure (modulo `ctx.*` callbacks): no global state, no I/O.
+ * Tool-call mapping is delegated to `tool-call-mapper.ts` so the shapes stay
+ * identical across SDK and PTY transports.
+ */
+export function translateHookEvent(event, ctx) {
+    switch (event.kind) {
+        case "pre-tool":
+            return translatePreTool(event, ctx);
+        case "post-tool":
+            return translatePostTool(event, ctx);
+        case "permission":
+            return translatePermission(event, ctx);
+        case "session-start":
+            ctx.onSessionStart?.(event);
+            return [];
+        case "session-end":
+            return translateSessionEnd(event, ctx);
+        case "status-line":
+            return translateStatusLine(event, ctx);
+        case "assistant_message_delta":
+            return translateAssistantDelta(event, ctx);
+        case "usage_update":
+            return translateUsageUpdate(event, ctx);
+        default: {
+            // Exhaustiveness guard suppressed: the HookEvent union has grown new
+            // variants (PreCompactionHookEvent, etc.) without translator coverage.
+            // Falling through to null keeps runtime safe; tracked in docs/tech-debt.md.
+            return null;
+        }
+    }
+}
+function deriveCallId(event) {
+    // The hook payload does not (today) carry tool_use_id. Derive a stable
+    // synthetic id from agent_id + tool_name + the JSON-serialized input so the
+    // running event and the matching completed event collapse to the same row.
+    // This is a best-effort scheme — when the real hook bridge starts forwarding
+    // tool_use_id (Phase 1+), prefer that field over this fallback.
+    const hashSource = `${event.agent_id}:${event.tool_name}:${safeStringify(event.tool_input)}`;
+    return synthHash(hashSource);
+}
+function safeStringify(value) {
+    try {
+        return JSON.stringify(value);
+    }
+    catch {
+        return String(value);
+    }
+}
+function synthHash(input) {
+    // FNV-1a 32-bit — small, deterministic, no crypto dep needed for a
+    // tool-call correlation id.
+    let hash = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        hash ^= input.charCodeAt(i);
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return `hook-${(hash >>> 0).toString(16).padStart(8, "0")}`;
+}
+function translatePreTool(event, ctx) {
+    const item = mapClaudeRunningToolCall({
+        callId: deriveCallId(event),
+        name: event.tool_name,
+        input: event.tool_input,
+    });
+    if (!item)
+        return [];
+    return [{ type: "timeline", item, provider: ctx.provider, turnId: ctx.turnId }];
+}
+function translatePostTool(event, ctx) {
+    const item = mapClaudeCompletedToolCall({
+        callId: deriveCallId(event),
+        name: event.tool_name,
+        input: event.tool_input,
+        output: event.tool_response,
+    });
+    if (!item)
+        return [];
+    return [{ type: "timeline", item, provider: ctx.provider, turnId: ctx.turnId }];
+}
+function translatePermission(event, ctx) {
+    const request = ctx.registerPermissionRequest(event);
+    if (!request)
+        return [];
+    return [
+        {
+            type: "permission_requested",
+            provider: ctx.provider,
+            request,
+            turnId: ctx.turnId,
+        },
+    ];
+}
+function translateSessionEnd(_event, ctx) {
+    // session-end currently carries no usage payload in our HookEvent schema.
+    // Emit a turn_completed marker without usage so the client UI can settle
+    // the active turn. Usage updates flow through usage_update events from the
+    // TranscriptTailer.
+    return [{ type: "turn_completed", provider: ctx.provider, turnId: ctx.turnId }];
+}
+function translateStatusLine(event, ctx) {
+    // status-line provides a free-form statusText — Claude Code typically formats
+    // it as e.g. "ctx: 12%  in 1.2k out 0.4k". We do not parse the string here;
+    // the contextWindowUsedTokens signal is sourced from usage_update events
+    // (transcript tailer). status-line currently surfaces only as a heartbeat —
+    // we emit an empty usage_updated so the UI knows the agent is alive.
+    void event;
+    const usage = {};
+    return [{ type: "usage_updated", provider: ctx.provider, usage, turnId: ctx.turnId }];
+}
+function translateAssistantDelta(event, ctx) {
+    const text = event.delta.text;
+    if (!text)
+        return [];
+    // The pump appends assistant text deltas to the current turn's
+    // assistant_message timeline item. We surface them as a `timeline` event
+    // with a partial assistant_message item so the existing rendering path on
+    // the client treats them identically to SDK-path deltas.
+    return [
+        {
+            type: "timeline",
+            provider: ctx.provider,
+            turnId: ctx.turnId,
+            item: {
+                type: "assistant_message",
+                text,
+            },
+        },
+    ];
+}
+function translateUsageUpdate(event, ctx) {
+    const u = event.usage;
+    const usage = {
+        inputTokens: u.input_tokens,
+        outputTokens: u.output_tokens,
+        cachedInputTokens: (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0) || undefined,
+        totalCostUsd: u.total_cost_usd,
+    };
+    return [{ type: "usage_updated", provider: ctx.provider, usage, turnId: ctx.turnId }];
+}
+//# sourceMappingURL=event-translator.js.map

package/dist/server/server/agent/providers/claude/image-compression.d.ts

@@ -0,0 +1,10 @@
+import type { Logger } from "pino";
+export type CompressibleImageMimeType = "image/jpeg" | "image/png" | "image/gif" | "image/webp";
+export interface CompressedImage {
+    data: string;
+    mediaType: "image/jpeg";
+    originalBytes: number;
+    compressedBytes: number;
+}
+export declare function compressImageForApi(base64Data: string, sourceMimeType: CompressibleImageMimeType, logger?: Logger): Promise<CompressedImage>;
+//# sourceMappingURL=image-compression.d.ts.map

package/dist/server/server/agent/providers/claude/image-compression.js

@@ -0,0 +1,32 @@
+import sharp from "sharp";
+const MAX_WIDTH_PX = 1280;
+const JPEG_QUALITY = 60;
+export async function compressImageForApi(base64Data, sourceMimeType, logger) {
+    const input = Buffer.from(base64Data, "base64");
+    const originalBytes = input.byteLength;
+    try {
+        const output = await sharp(input, { animated: sourceMimeType === "image/gif" })
+            .resize({ width: MAX_WIDTH_PX, withoutEnlargement: true })
+            .jpeg({ quality: JPEG_QUALITY })
+            .toBuffer();
+        return {
+            data: output.toString("base64"),
+            mediaType: "image/jpeg",
+            originalBytes,
+            compressedBytes: output.byteLength,
+        };
+    }
+    catch (error) {
+        logger?.warn({ err: error, sourceMimeType, originalBytes }, "Image compression failed; passing image through unchanged");
+        if (sourceMimeType === "image/jpeg") {
+            return {
+                data: base64Data,
+                mediaType: "image/jpeg",
+                originalBytes,
+                compressedBytes: originalBytes,
+            };
+        }
+        throw error;
+    }
+}
+//# sourceMappingURL=image-compression.js.map