@zhijiewang/openharness 2.30.0 → 2.31.0

package/dist/harness/traces.js

@@ -19,6 +19,15 @@ export class SessionTracer {
     activeSpans = new Map();
     spanCounter = 0;
     otlp;
+    /**
+     * Pending spans that have ended but not yet been POSTed to OTLP. Drained
+     * by a microtask-debounced flush (one POST per microtask boundary even if
+     * many spans end in the same tick) and by the public `flush()` method.
+     */
+    otlpBuffer = [];
+    otlpFlushScheduled = false;
+    /** In-flight fetches so `flush()` can await any POSTs already on the wire. */
+    otlpInFlight = new Set();
     constructor(sessionId, otlp) {
         this.sessionId = sessionId;
         this.otlp = otlp;
@@ -56,19 +65,60 @@ export class SessionTracer {
             this.shipSpanOTLP(span);
         return span;
     }
-    /** Fire-and-forget POST of a single span to the configured OTLP HTTP endpoint. Errors swallowed — telemetry must never crash the agent. */
+    /**
+     * Buffer the span for OTLP shipping. The actual POST is deferred to a
+     * microtask so multiple spans ending in the same tick coalesce into a
+     * single batch POST instead of one fetch each. Errors are swallowed —
+     * telemetry must never crash the agent.
+     */
     shipSpanOTLP(span) {
         if (!this.otlp)
             return;
-        const payload = exportTraceOTLP(this.sessionId, [span]);
-        fetch(this.otlp.endpoint, {
+        this.otlpBuffer.push(span);
+        if (this.otlpFlushScheduled)
+            return;
+        this.otlpFlushScheduled = true;
+        queueMicrotask(() => {
+            this.otlpFlushScheduled = false;
+            this.drainOTLPBuffer();
+        });
+    }
+    /** Send whatever is in `otlpBuffer` as a single fire-and-forget POST. The
+     * returned promise is tracked in `otlpInFlight` so `flush()` can await it. */
+    drainOTLPBuffer() {
+        if (!this.otlp || this.otlpBuffer.length === 0)
+            return;
+        const batch = this.otlpBuffer;
+        this.otlpBuffer = [];
+        const payload = exportTraceOTLP(this.sessionId, batch);
+        const p = fetch(this.otlp.endpoint, {
             method: "POST",
             headers: { "Content-Type": "application/json", ...(this.otlp.headers ?? {}) },
             body: JSON.stringify(payload),
-        }).catch(() => {
-            /* swallow — telemetry must not interfere with the agent */
+        }).then(() => undefined, () => undefined);
+        this.otlpInFlight.add(p);
+        p.finally(() => {
+            this.otlpInFlight.delete(p);
         });
     }
+    /**
+     * Drain any pending OTLP buffer and await every in-flight POST. Call this at
+     * session end so spans aren't dropped on `process.exit`. No-op when OTLP is
+     * not configured. Errors are swallowed (already, by `drainOTLPBuffer`).
+     */
+    async flush() {
+        if (!this.otlp)
+            return;
+        // Drain any not-yet-shipped buffer first; cancel pending microtask flush
+        // (the buffer becomes empty so the microtask would no-op anyway, but
+        // clearing the flag is explicit).
+        this.otlpFlushScheduled = false;
+        this.drainOTLPBuffer();
+        // Wait for every fetch we've kicked off (microtask-shipped or just now).
+        if (this.otlpInFlight.size > 0) {
+            await Promise.allSettled(Array.from(this.otlpInFlight));
+        }
+    }
     /** Get all completed spans */
     getSpans() {
         return [...this.spans];
@@ -170,8 +220,22 @@ export function formatTrace(spans) {
     lines.push(`Total: ${spans.length} spans, ${totalMs}ms, ${errors} errors`);
     return lines.join("\n");
 }
+/**
+ * Coerce an arbitrary string (UUID with hyphens, "span-N", etc.) into a fixed-length
+ * lowercase hex string suitable for OTLP. OTLP collectors (Jaeger, Tempo, OTel
+ * Collector) validate that traceId is 32 hex chars and spanId is 16 hex chars and
+ * reject anything containing `-` or non-hex letters. We strip non-hex chars, then
+ * pad-left with zeros (or truncate from the left) to the target length.
+ */
+function toHexId(input, length) {
+    const hex = input.toLowerCase().replace(/[^0-9a-f]/g, "");
+    if (hex.length === 0)
+        return "0".repeat(length);
+    return hex.length >= length ? hex.slice(0, length) : hex.padStart(length, "0");
+}
 /** Export trace in OpenTelemetry-compatible format */
 export function exportTraceOTLP(sessionId, spans) {
+    const traceId = toHexId(sessionId, 32);
     return {
         resourceSpans: [
             {
@@ -185,9 +249,9 @@ export function exportTraceOTLP(sessionId, spans) {
                     {
                         scope: { name: "openharness.agent" },
                         spans: spans.map((s) => ({
-                            traceId: sessionId.padEnd(32, "0").slice(0, 32),
-                            spanId: s.spanId.padEnd(16, "0").slice(0, 16),
-                            parentSpanId: s.parentSpanId?.padEnd(16, "0").slice(0, 16),
+                            traceId,
+                            spanId: toHexId(s.spanId, 16),
+                            parentSpanId: s.parentSpanId ? toHexId(s.parentSpanId, 16) : undefined,
                             name: s.name,
                             startTimeUnixNano: s.startTime * 1_000_000,
                             endTimeUnixNano: s.endTime * 1_000_000,

package/dist/main.js

@@ -1111,6 +1111,62 @@ program
     .action(async () => {
     await runInitWizard({ exitOnDone: true });
 });
+// ── project — per-project state management ──
+//
+// `oh project purge [path]` — delete all openHarness state for a project
+//
+// Mirrors Claude Code's `claude project purge`. Removes the entire `.oh/`
+// directory at the target path plus the workspace-trust entry (if any).
+// Sessions, credentials, plugins, telemetry, traces, and global config are
+// NOT touched — they're global-and-cross-project. Default UX prints the
+// deletion plan and asks for confirmation; --dry-run previews; --yes skips
+// the prompt. `--all` is deferred (openHarness has no project registry, so
+// "all projects" isn't well-defined without a session-cwd scan).
+const projectCmd = program.command("project").description("Manage per-project openHarness state");
+projectCmd
+    .command("purge [path]")
+    .description("Delete all openHarness state for a project (config, rules, memory, skills, agents, plans, checkpoints, trust entry). Sessions, credentials, plugins, telemetry, and global config are NOT touched. Defaults to the current directory.")
+    .option("--dry-run", "Preview what would be deleted without touching the filesystem")
+    .option("-y, --yes", "Skip the confirmation prompt")
+    .action(async (pathArg, opts) => {
+    const { planPurge, formatPurgePlan, executePurge } = await import("./harness/project-purge.js");
+    const target = pathArg ?? process.cwd();
+    if (!existsSync(target)) {
+        process.stderr.write(`Error: path does not exist: ${target}\n`);
+        process.exit(1);
+    }
+    const plan = planPurge(target);
+    console.log(formatPurgePlan(plan));
+    if (plan.entries.length === 0) {
+        return;
+    }
+    if (opts.dryRun) {
+        console.log("\n(dry-run — no files were deleted)");
+        return;
+    }
+    if (!opts.yes) {
+        const readline = await import("node:readline/promises");
+        const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+        try {
+            const answer = (await rl.question("\nProceed with deletion? [y/N] ")).trim();
+            if (!/^y(es)?$/i.test(answer)) {
+                console.log("Aborted.");
+                return;
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }
+    const result = executePurge(plan);
+    console.log(`\nDeleted ${result.deleted} of ${plan.entries.length} target(s).`);
+    if (result.errors.length > 0) {
+        console.log(`${result.errors.length} error(s):`);
+        for (const err of result.errors)
+            console.log(`  ⚠ ${err}`);
+        process.exit(1);
+    }
+});
 // ── auth (audit B6) — provider-agnostic credential management ──
 //
 // `oh auth login [provider] --key <value>`  — set API key for a provider

package/dist/providers/anthropic.js

@@ -134,6 +134,10 @@ export class AnthropicProvider {
         let currentToolId = "";
         let currentToolName = "";
         let currentToolArgs = "";
+        // Persist across chunk boundaries: a TCP/TLS framing boundary can land
+        // between the SSE `event:` and `data:` lines, leaving the event type
+        // staged for the next chunk's first `data:` line.
+        let currentEvent = "";
         while (true) {
             const { done, value } = await reader.read();
             if (done)
@@ -141,7 +145,6 @@ export class AnthropicProvider {
             buffer += decoder.decode(value, { stream: true });
             const lines = buffer.split("\n");
             buffer = lines.pop() ?? "";
-            let currentEvent = "";
             for (const line of lines) {
                 const trimmed = line.trim();
                 if (trimmed.startsWith("event:")) {

package/dist/repl.js

@@ -2,6 +2,7 @@
  * Imperative REPL — extracted business logic from React REPL.tsx.
  * Uses TerminalRenderer for display instead of Ink.
  */
+import { readdirSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { getCommandEntries } from "./commands/index.js";
 import { roll } from "./cybergotchi/bones.js";
@@ -185,7 +186,6 @@ export async function startREPL(config) {
                 const dir = lastSep >= 0 ? expanded.slice(0, lastSep + 1) : ".";
                 const prefix = lastSep >= 0 ? expanded.slice(lastSep + 1) : expanded;
                 try {
-                    const { readdirSync, statSync } = require("node:fs");
                     const entries = readdirSync(dir)
                         .filter((name) => name.toLowerCase().startsWith(prefix.toLowerCase()))
                         .slice(0, 10);

package/dist/services/AgentDispatcher.js

@@ -161,6 +161,13 @@ export class AgentDispatcher {
                 if (filtered.length > 0)
                     taskTools = filtered;
             }
+            // Plumb cwd through config.workingDir so parallel runTask calls don't
+            // race on the global process.cwd(). The query loop seeds ToolContext
+            // with this value; built-in tools (FileRead, Glob, Bash, …) honor it.
+            // Previously this method called `process.chdir(worktreePath)` and a
+            // matching `process.chdir(originalCwd)` in `finally` — but since
+            // `process.cwd()` is process-wide, two concurrent tasks would clobber
+            // each other's directory mid-execution.
             const config = {
                 provider: this.provider,
                 tools: taskTools,
@@ -169,6 +176,7 @@ export class AgentDispatcher {
                 model: this.model,
                 maxTurns: 20,
                 abortSignal: this.abortSignal,
+                workingDir: worktreePath ?? cwd,
             };
             // Inject blocker results as context
             let promptWithContext = task.prompt;
@@ -184,37 +192,16 @@ export class AgentDispatcher {
                     promptWithContext = `${blockerContext}\n\n---\n\n${task.prompt}`;
                 }
             }
-            const originalCwd = process.cwd();
-            if (worktreePath) {
-                try {
-                    process.chdir(worktreePath);
-                }
-                catch {
-                    /* ignore */
-                }
-            }
             let output = "";
             let errorMessage = null;
-            try {
-                for await (const event of query(promptWithContext, config)) {
-                    if (event.type === "text_delta")
-                        output += event.content;
-                    if (event.type === "error") {
-                        errorMessage = event.message;
-                        break;
-                    }
-                    forwardChildEvent(event, taskCallId, this.emitChildEvent);
-                }
-            }
-            finally {
-                if (worktreePath) {
-                    try {
-                        process.chdir(originalCwd);
-                    }
-                    catch {
-                        /* ignore */
-                    }
+            for await (const event of query(promptWithContext, config)) {
+                if (event.type === "text_delta")
+                    output += event.content;
+                if (event.type === "error") {
+                    errorMessage = event.message;
+                    break;
                 }
+                forwardChildEvent(event, taskCallId, this.emitChildEvent);
             }
             if (errorMessage !== null) {
                 result = { id: task.id, output: `Error: ${errorMessage}`, isError: true, durationMs: Date.now() - start };

package/dist/services/StreamingToolExecutor.js

@@ -2,6 +2,8 @@
  * Tool execution during LLM streaming — concurrent tool execution
  * with permission checks and queue management.
  */
+import { getAffectedFiles } from "../harness/checkpoints.js";
+import { emitHook, emitHookWithOutcome } from "../harness/hooks.js";
 import { findToolByName } from "../Tool.js";
 import { checkPermission } from "../types/permissions.js";
 const MAX_CONCURRENCY = 10;
@@ -54,23 +56,69 @@ export class StreamingToolExecutor {
             tracked.status = "completed";
             return;
         }
+        const argsPreview = JSON.stringify(tracked.toolCall.arguments).slice(0, 1000);
         // Permission check
         const perm = checkPermission(this.permissionMode, tool.riskLevel, tool.isReadOnly(tracked.toolCall.arguments), tool.name, tracked.toolCall.arguments);
-        if (!perm.allowed && perm.reason === "needs-approval" && this.askUser) {
-            const { formatToolArgs } = await import("../utils/tool-summary.js");
-            const description = formatToolArgs(tool.name, tracked.toolCall.arguments);
-            const allowed = await this.askUser(tool.name, description, tool.riskLevel);
-            if (!allowed) {
-                tracked.result = { output: "Permission denied.", isError: true };
+        if (!perm.allowed) {
+            if (perm.reason === "needs-approval") {
+                // Hook: permissionRequest — give configured hooks first say. If they
+                // explicitly allow/deny, that wins; otherwise fall through to the
+                // interactive prompt or to a fail-closed deny in headless mode.
+                const hookOutcome = await emitHookWithOutcome("permissionRequest", {
+                    toolName: tool.name,
+                    toolArgs: argsPreview,
+                    toolInputJson: JSON.stringify(tracked.toolCall.arguments).slice(0, 1000),
+                    permissionMode: this.permissionMode,
+                    permissionAction: "ask",
+                });
+                const denyAndEmit = (source, reason, output) => {
+                    emitHook("permissionDenied", {
+                        toolName: tool.name,
+                        toolArgs: argsPreview,
+                        permissionMode: this.permissionMode,
+                        denySource: source,
+                        denyReason: reason,
+                    });
+                    tracked.result = { output, isError: true };
+                    tracked.status = "completed";
+                };
+                if (hookOutcome.permissionDecision === "allow") {
+                    // Hook granted — proceed.
+                }
+                else if (hookOutcome.permissionDecision === "deny" || !hookOutcome.allowed) {
+                    const reason = hookOutcome.reason ? `: ${hookOutcome.reason}` : "";
+                    denyAndEmit("hook", hookOutcome.reason ?? "hook denied", `Permission denied by hook${reason}`);
+                    return;
+                }
+                else if (this.askUser) {
+                    const { formatToolArgs } = await import("../utils/tool-summary.js");
+                    const description = formatToolArgs(tool.name, tracked.toolCall.arguments);
+                    const allowed = await this.askUser(tool.name, description, tool.riskLevel);
+                    if (!allowed) {
+                        denyAndEmit("user", "user declined", "Permission denied by user.");
+                        return;
+                    }
+                }
+                else {
+                    // Headless mode with no hook decision and no interactive prompt.
+                    denyAndEmit("headless", "no hook decision and no interactive prompt available", "Permission denied: needs-approval (no interactive prompt available; configure a permissionRequest hook to gate this tool)");
+                    return;
+                }
+            }
+            else {
+                // Auto-mode policy block (deny / acceptEdits / etc) — symmetric event.
+                emitHook("permissionDenied", {
+                    toolName: tool.name,
+                    toolArgs: argsPreview,
+                    permissionMode: this.permissionMode,
+                    denySource: "policy",
+                    denyReason: perm.reason,
+                });
+                tracked.result = { output: `Denied: ${perm.reason}`, isError: true };
                 tracked.status = "completed";
                 return;
             }
         }
-        else if (!perm.allowed) {
-            tracked.result = { output: `Denied: ${perm.reason}`, isError: true };
-            tracked.status = "completed";
-            return;
-        }
         // Validate input
         const parsed = tool.inputSchema.safeParse(tracked.toolCall.arguments);
         if (!parsed.success) {
@@ -84,6 +132,17 @@ export class StreamingToolExecutor {
             tracked.status = "completed";
             return;
         }
+        // Hook: preToolUse — last gate before execution. A hook that returns
+        // false (exit code 1 / { allowed: false }) blocks the call.
+        const preAllowed = emitHook("preToolUse", {
+            toolName: tool.name,
+            toolArgs: argsPreview,
+        });
+        if (!preAllowed) {
+            tracked.result = { output: "Blocked by preToolUse hook.", isError: true };
+            tracked.status = "completed";
+            return;
+        }
         // Execute with per-call context (streaming output chunks + abort signal)
         const callId = tracked.toolCall.id;
         const callContext = {
@@ -138,6 +197,33 @@ export class StreamingToolExecutor {
             if (toolSpanId)
                 callContext.tracer?.endSpan(toolSpanId, "error", { error: tracked.result.output });
         }
+        // Hook: postToolUse / postToolUseFailure (mutually exclusive — strict CC parity)
+        if (tracked.result) {
+            const outputPreview = tracked.result.output.slice(0, 1000);
+            if (tracked.result.isError) {
+                emitHook("postToolUseFailure", {
+                    toolName: tool.name,
+                    toolArgs: argsPreview,
+                    toolOutput: outputPreview,
+                    toolError: "ReportedError",
+                    errorMessage: outputPreview,
+                });
+            }
+            else {
+                emitHook("postToolUse", {
+                    toolName: tool.name,
+                    toolArgs: argsPreview,
+                    toolOutput: outputPreview,
+                });
+                // Emit fileChanged hook for file-modifying tools
+                if (["Edit", "Write", "MultiEdit"].includes(tool.name)) {
+                    const filePaths = getAffectedFiles(tool.name, parsed.data);
+                    for (const fp of filePaths) {
+                        emitHook("fileChanged", { filePath: fp, toolName: tool.name });
+                    }
+                }
+            }
+        }
         tracked.status = "completed";
         this.processQueue(); // Process next queued tools
     }

package/dist/tools/CronTool/index.d.ts

@@ -6,13 +6,13 @@ declare const createSchema: z.ZodObject<{
     schedule: z.ZodString;
     prompt: z.ZodString;
 }, "strip", z.ZodTypeAny, {
-    action: "create";
     name: string;
+    action: "create";
     prompt: string;
     schedule: string;
 }, {
-    action: "create";
     name: string;
+    action: "create";
     prompt: string;
     schedule: string;
 }>;

package/dist/tools/DiagnosticsTool/index.d.ts

@@ -6,8 +6,8 @@ declare const inputSchema: z.ZodObject<{
     line: z.ZodOptional<z.ZodNumber>;
     character: z.ZodOptional<z.ZodNumber>;
 }, "strip", z.ZodTypeAny, {
-    action: "diagnostics" | "definition" | "references" | "hover";
     file_path: string;
+    action: "diagnostics" | "definition" | "references" | "hover";
     line?: number | undefined;
     character?: number | undefined;
 }, {

package/dist/tools/FileReadTool/index.js

@@ -59,10 +59,9 @@ export const FileReadTool = {
                 return { output: `Error: ${filePath} is a directory, not a file.`, isError: true };
             }
             const ext = path.extname(filePath).toLowerCase();
-            // Image files: return as base64
+            // Image files: return as base64 (auto-downscaled if oversized)
             if (IMAGE_EXTENSIONS.has(ext)) {
-                const buffer = await fs.readFile(filePath);
-                const base64 = buffer.toString("base64");
+                const raw = await fs.readFile(filePath);
                 const mimeTypes = {
                     ".png": "image/png",
                     ".jpg": "image/jpeg",
@@ -72,7 +71,11 @@ export const FileReadTool = {
                     ".bmp": "image/bmp",
                     ".svg": "image/svg+xml",
                 };
-                return { output: `__IMAGE__:${mimeTypes[ext] ?? "image/png"}:${base64}`, isError: false };
+                const mediaType = mimeTypes[ext] ?? "image/png";
+                const { downscaleIfLarge } = await import("../../utils/image-downscale.js");
+                const { buffer } = await downscaleIfLarge(raw, mediaType);
+                const base64 = buffer.toString("base64");
+                return { output: `__IMAGE__:${mediaType}:${base64}`, isError: false };
             }
             // PDF files: extract text per page (basic extraction)
             if (ext === ".pdf") {

package/dist/tools/GrepTool/index.d.ts

@@ -17,9 +17,9 @@ declare const inputSchema: z.ZodObject<{
     "-n": z.ZodOptional<z.ZodBoolean>;
 }, "strip", z.ZodTypeAny, {
     pattern: string;
+    path?: string | undefined;
     type?: string | undefined;
     "-i"?: boolean | undefined;
-    path?: string | undefined;
     context?: number | undefined;
     glob?: string | undefined;
     offset?: number | undefined;
@@ -32,9 +32,9 @@ declare const inputSchema: z.ZodObject<{
     "-n"?: boolean | undefined;
 }, {
     pattern: string;
+    path?: string | undefined;
     type?: string | undefined;
     "-i"?: boolean | undefined;
-    path?: string | undefined;
     context?: number | undefined;
     glob?: string | undefined;
     offset?: number | undefined;

package/dist/tools/ImageReadTool/index.js

@@ -1,6 +1,7 @@
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
 import { z } from "zod";
+import { downscaleIfLarge } from "../../utils/image-downscale.js";
 const SUPPORTED_TYPES = {
     ".png": "image/png",
     ".jpg": "image/jpeg",
@@ -37,7 +38,11 @@ export const ImageReadTool = {
             };
         }
         try {
-            const buffer = await fs.readFile(filePath);
+            const raw = await fs.readFile(filePath);
+            // Auto-downscale to ≤2000px on the longest dimension. PDFs and
+            // missing-sharp installs pass through unchanged. Aspect + format
+            // preserved by sharp.
+            const { buffer } = await downscaleIfLarge(raw, mediaType);
             const base64 = buffer.toString("base64");
             return {
                 output: `${IMAGE_PREFIX}:${mediaType}:${base64}`,

package/dist/tools/PowerShellTool/index.js

@@ -1,4 +1,4 @@
-import { execSync } from "node:child_process";
+import { execFileSync } from "node:child_process";
 import { z } from "zod";
 const inputSchema = z.object({
     command: z.string().describe("PowerShell command to execute"),
@@ -21,7 +21,16 @@ export const PowerShellTool = {
         }
         const timeout = input.timeout ?? 120_000;
         try {
-            const output = execSync(`powershell.exe -NoProfile -NonInteractive -Command "${input.command.replace(/"/g, '\\"')}"`, { encoding: "utf-8", timeout, maxBuffer: 10 * 1024 * 1024, windowsHide: true });
+            // execFileSync(file, args[]) spawns powershell.exe directly without a
+            // cmd.exe wrapper, so cmd.exe metachars (& | < > ^ %VAR%) are inert.
+            // The user's command is passed as a single -Command arg; PowerShell
+            // parses it as PowerShell, not as a doubly-parsed shell string.
+            const output = execFileSync("powershell.exe", ["-NoProfile", "-NonInteractive", "-Command", input.command], {
+                encoding: "utf-8",
+                timeout,
+                maxBuffer: 10 * 1024 * 1024,
+                windowsHide: true,
+            });
             return { output: output.trim(), isError: false };
         }
         catch (err) {

package/dist/utils/image-downscale.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Image auto-downscale — bound the longest dimension to a fixed maximum
+ * before encoding the image as base64 for the model.
+ *
+ * Why: most providers reject or downsample images above ~1568-2048px on
+ * the longest side. Shipping a 4000px screenshot wastes input tokens, can
+ * exceed the request size limit, and historically broke the session
+ * outright when an oversized image landed in the conversation history.
+ *
+ * The function is a no-op for images already within bounds, for formats
+ * sharp doesn't process (PDF, SVG), and when sharp itself isn't installed
+ * (it's an `optionalDependency` so unsupported platforms still install).
+ * Any sharp error returns the original buffer unchanged — we never break a
+ * tool call over a downscale failure.
+ */
+/** @internal Test-only reset of the lazy sharp cache. */
+export declare function _resetSharpCacheForTest(): void;
+export type DownscaleResult = {
+    /** The (possibly resized) buffer to encode. */
+    buffer: Buffer;
+    /** True if a resize actually happened; false for passthrough. */
+    downscaled: boolean;
+    /** Set when sharp wasn't available — caller may want to surface a one-time hint. */
+    reason?: "sharp-unavailable" | "unsupported-format" | "within-bounds" | "sharp-error";
+};
+/**
+ * Downscale `buffer` so its longest dimension is ≤ `maxDimension` (default 2000).
+ * Aspect ratio preserved. Format preserved (PNG stays PNG, JPEG stays JPEG, etc.).
+ *
+ * Pure pass-through for: PDF, SVG, BMP (sharp doesn't handle reliably),
+ * already-small images, missing sharp, and any sharp error.
+ */
+export declare function downscaleIfLarge(buffer: Buffer, mediaType: string, maxDimension?: number): Promise<DownscaleResult>;
+//# sourceMappingURL=image-downscale.d.ts.map