openmerit 0.1.4 → 0.1.6-preview.0

package/dist/frontier.js

@@ -1,56 +0,0 @@
-/** Pareto frontier over (score up, price down, latency down) + best-fit/fallback picks. */
-import { pointKey } from "./routes.js";
-function effectivePrice(point) {
-    return point.priceKnown === false ? Number.POSITIVE_INFINITY : point.price;
-}
-/** a dominates b if a is no worse on every objective and strictly better on one. */
-export function dominates(a, b) {
-    const aLat = a.latencyMs ?? Number.POSITIVE_INFINITY;
-    const bLat = b.latencyMs ?? Number.POSITIVE_INFINITY;
-    const aPrice = effectivePrice(a);
-    const bPrice = effectivePrice(b);
-    const noWorse = a.score >= b.score && aPrice <= bPrice && aLat <= bLat;
-    const better = a.score > b.score || aPrice < bPrice || aLat < bLat;
-    return noWorse && better;
-}
-/**
- * Non-dominated set, cheapest first. When no point carries latency this
- * reduces to the classic "strictly increasing score as price rises" chain
- * from the original model-search prototype.
- */
-export function paretoFrontier(points) {
-    const fr = points.filter((p) => !points.some((q) => q !== p && dominates(q, p)));
-    return fr.sort((a, b) => effectivePrice(a) - effectivePrice(b) || b.score - a.score);
-}
-/** Simple 2-objective chain (score vs price only), cheapest first. */
-export function scorePriceChain(points) {
-    const pts = [...points].sort((a, b) => effectivePrice(a) - effectivePrice(b) || b.score - a.score);
-    const chain = [];
-    let best = -1;
-    for (const p of pts) {
-        if (p.score > best) {
-            chain.push(p);
-            best = p.score;
-        }
-    }
-    return chain;
-}
-/** Highest score; ties broken by lower price then lower latency. */
-export function pickBest(points) {
-    return [...points].sort((a, b) => b.score - a.score || effectivePrice(a) - effectivePrice(b) ||
-        (a.latencyMs ?? 1e18) - (b.latencyMs ?? 1e18))[0];
-}
-/**
- * Fallback for `best`: prefer the cheapest frontier point that still clears
- * `minScore`; otherwise the next-best scoring point overall. Never returns
- * `best` itself.
- */
-export function pickFallback(points, best, minScore) {
-    const others = points.filter((p) => pointKey(p) !== pointKey(best));
-    if (others.length === 0)
-        return undefined;
-    const fr = paretoFrontier(others).filter((p) => p.score >= minScore);
-    if (fr.length > 0)
-        return fr[0]; // cheapest adequate frontier point
-    return pickBest(others);
-}

package/dist/harness.js

@@ -1 +0,0 @@
-export {};

package/dist/integrations.js

@@ -1,19 +0,0 @@
-/** Stable boundaries for trace inputs and telemetry outputs. */
-import { randomUUID } from "node:crypto";
-import { appendJsonl, paths } from "./store.js";
-import { ingestNewTraces } from "./traces.js";
-export class PiTraceObservationSource {
-    sessionsDir;
-    id = "pi-jsonl";
-    constructor(sessionsDir) {
-        this.sessionsDir = sessionsDir;
-    }
-    read() { return ingestNewTraces(this.sessionsDir); }
-}
-export class LocalJsonlEventSink {
-    id = "local-jsonl";
-    emit(event) { appendJsonl(paths.events(), event); }
-}
-export function meritEvent(type, payload, source = "openmerit") {
-    return { schemaVersion: 1, id: randomUUID(), ts: new Date().toISOString(), source, type, payload };
-}

package/dist/invoice-eval.js

@@ -1,33 +0,0 @@
-/** Reuse the audited invoice benchmark scorer for its pinned image/prompt cases. */
-import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
-import { INVOICE_BENCHMARK_PROMPT, parseInvoiceJson, projectVisibleInvoice, scoreInvoice, } from "./invoice-score.js";
-function root() { return join(dirname(fileURLToPath(import.meta.url)), ".."); }
-export async function knownInvoiceScore(task, images, answer) {
-    if (images.length !== 1 || images[0].mimeType !== "image/jpeg")
-        return null;
-    const benchDir = join(root(), "benchmark", "invoice_ocr");
-    const piPrompt = readFileSync(join(root(), "examples", "invoice-prompt.txt"), "utf8").trim();
-    if (task.trim() !== INVOICE_BENCHMARK_PROMPT.trim() && task.trim() !== piPrompt)
-        return null;
-    const manifest = JSON.parse(readFileSync(join(benchDir, "data", "manifest.json"), "utf8"));
-    const inputHash = createHash("sha256").update(Buffer.from(images[0].data, "base64")).digest("hex");
-    const row = manifest.rows.find((r) => createHash("sha256")
-        .update(readFileSync(join(benchDir, "data", r.image))).digest("hex") === inputHash);
-    if (!row)
-        return null;
-    const expected = JSON.parse(readFileSync(join(benchDir, "data", row.ground_truth), "utf8"));
-    let actual = null;
-    try {
-        actual = parseInvoiceJson(answer);
-    }
-    catch { /* invalid JSON scores zero */ }
-    const result = scoreInvoice(projectVisibleInvoice(expected), projectVisibleInvoice(actual));
-    return {
-        score: result.exact_leaf_accuracy,
-        why: `pinned ${row.invoice_id}: audited exact-leaf ${result.exact_leaf_accuracy.toFixed(3)}, ` +
-            `exact document=${result.exact_document}`,
-    };
-}

package/dist/invoice-score.js

@@ -1,124 +0,0 @@
-/** Runtime-safe copy of the audited invoice benchmark's exact scoring rules. */
-export const INVOICE_BENCHMARK_PROMPT = `Extract the invoice into the required JSON schema using only the image.
-
-Rules:
-- Copy names, identifiers, and descriptions exactly as printed.
-- Return dates as YYYY-MM-DD, regardless of the printed date format.
-- Return currency as its three-letter ISO code.
-- Return monetary values and quantities as JSON numbers without currency symbols or grouping separators.
-- Preserve line-item order and include every printed line item exactly once.
-- Use null only when a scalar field is not present. Never infer a missing value.
-- document_total_net is the subtotal/net amount before tax; document_total_amount is the final amount including tax.
-- Return only the schema-conforming JSON object.`;
-export const EXCLUDED_INVOICE_QUALITY_FIELDS = new Set(["po_number"]);
-function isPlainObject(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-/** Match the Python equality semantics used by the original audited scorer. */
-function pyEqual(a, b) {
-    if (typeof a === "boolean" || typeof b === "boolean") {
-        if (typeof a === "boolean" && typeof b === "boolean")
-            return a === b;
-        if (typeof a === "number" && typeof b === "boolean")
-            return a === Number(b);
-        if (typeof a === "boolean" && typeof b === "number")
-            return Number(a) === b;
-        return false;
-    }
-    if (typeof a === "number" && typeof b === "number")
-        return a === b;
-    if (typeof a === "string" && typeof b === "string")
-        return a === b;
-    if (a === null || b === null)
-        return a === b;
-    if (Array.isArray(a) && Array.isArray(b)) {
-        return a.length === b.length && a.every((value, index) => pyEqual(value, b[index]));
-    }
-    if (isPlainObject(a) && isPlainObject(b)) {
-        const aKeys = Object.keys(a);
-        const bKeys = Object.keys(b);
-        return aKeys.length === bKeys.length && aKeys.every((key) => key in b && pyEqual(a[key], b[key]));
-    }
-    return false;
-}
-function flatten(value, path = "") {
-    if (isPlainObject(value)) {
-        let flattened = {};
-        for (const [key, child] of Object.entries(value)) {
-            const childPath = path ? `${path}.${key}` : key;
-            flattened = Object.assign(flattened, flatten(child, childPath));
-        }
-        return flattened;
-    }
-    if (Array.isArray(value)) {
-        if (value.length === 0)
-            return { [`${path}.__length__`]: 0 };
-        let flattened = { [`${path}.__length__`]: value.length };
-        for (let index = 0; index < value.length; index++) {
-            flattened = Object.assign(flattened, flatten(value[index], `${path}[${index}]`));
-        }
-        return flattened;
-    }
-    return { [path]: value };
-}
-function exactValue(expected, actual) {
-    if (typeof expected === "boolean" || typeof actual === "boolean") {
-        return typeof expected === typeof actual && expected === actual;
-    }
-    if (typeof expected === "number" && typeof actual === "number")
-        return expected === actual;
-    return typeof expected === typeof actual && expected === actual;
-}
-export function scoreInvoice(expected, actual) {
-    if (actual === null) {
-        const expectedFlat = flatten(expected);
-        return {
-            exact_document: false,
-            matched_leaves: 0,
-            total_union_leaves: Object.keys(expectedFlat).length,
-            exact_leaf_accuracy: 0,
-            scalar_accuracy: 0,
-            line_item_accuracy: 0,
-        };
-    }
-    const expectedFlat = flatten(expected);
-    const actualFlat = flatten(actual);
-    const paths = new Set([...Object.keys(expectedFlat), ...Object.keys(actualFlat)]);
-    let matches = 0;
-    for (const path of paths) {
-        if (path in expectedFlat && path in actualFlat && exactValue(expectedFlat[path], actualFlat[path])) {
-            matches += 1;
-        }
-    }
-    const scalarPaths = Object.keys(expectedFlat).filter((path) => !path.startsWith("line_items"));
-    const itemPaths = [...paths].filter((path) => path.startsWith("line_items"));
-    const scalarMatches = scalarPaths.filter((path) => path in actualFlat && exactValue(expectedFlat[path], actualFlat[path])).length;
-    const itemMatches = itemPaths.filter((path) => path in expectedFlat && path in actualFlat && exactValue(expectedFlat[path], actualFlat[path])).length;
-    return {
-        exact_document: pyEqual(expected, actual),
-        matched_leaves: matches,
-        total_union_leaves: paths.size,
-        exact_leaf_accuracy: paths.size ? matches / paths.size : 1,
-        scalar_accuracy: scalarPaths.length ? scalarMatches / scalarPaths.length : 1,
-        line_item_accuracy: itemPaths.length ? itemMatches / itemPaths.length : 1,
-    };
-}
-export function parseInvoiceJson(content) {
-    let stripped = content.trim();
-    if (stripped.startsWith("```")) {
-        const lines = stripped.split(/\r\n|\r|\n/);
-        stripped = lines.slice(1, -1).join("\n");
-    }
-    const parsed = JSON.parse(stripped);
-    if (!isPlainObject(parsed))
-        throw new TypeError("Model output is not a JSON object");
-    return parsed;
-}
-export function projectVisibleInvoice(document) {
-    if (document === null || document === undefined)
-        return document;
-    const projected = structuredClone(document);
-    for (const field of EXCLUDED_INVOICE_QUALITY_FIELDS)
-        delete projected[field];
-    return projected;
-}

package/dist/judge.js

@@ -1,43 +0,0 @@
-/** Judge: score a model's answer against a rubric. */
-import { directChatClient } from "./llm.js";
-export const JUDGE_PREFS = ["openai/gpt-4o-mini", "openai/gpt-4o"];
-const JUDGE_PROMPT = `You are grading a model's answer.
-TASK: {task}
-RUBRIC: {rubric}
-ANSWER: {answer}
-Return ONLY json: {{"score": <0..1>, "why": "<one line>"}}`;
-/** Extract the first {...} JSON object from model output. */
-export function parseObj(txt) {
-    const m = txt.match(/\{.*\}/s) ?? txt.match(/\{[^}]*\}/s);
-    if (!m)
-        throw new Error("no json object found");
-    return JSON.parse(m[0]);
-}
-export async function judge(key, judgeModel, task, rubric, answer, client = directChatClient(key)) {
-    const { content } = await client.chat(judgeModel, JUDGE_PROMPT.replace("{task}", task)
-        .replace("{rubric}", rubric)
-        .replace("{answer}", answer.slice(0, 16000)), 1024, 0);
-    try {
-        const j = parseObj(content);
-        return { score: Number(j.score ?? 0), why: String(j.why ?? "") };
-    }
-    catch {
-        return { score: 0, why: "unparseable judge output" };
-    }
-}
-/** Grade OCR answers against the actual uploaded pixels, not answer text alone. */
-export async function judgeWithImages(key, judgeModel, task, rubric, answer, images, client = directChatClient(key)) {
-    const prompt = `You are grading an answer to a visual task. Inspect the attached image carefully.\n` +
-        `TASK: ${task}\nRUBRIC: ${rubric}\nANSWER: ${answer.slice(0, 16000)}\n` +
-        `For invoice extraction, check every visible field and line item against the image. ` +
-        `Penalize missing, invented, or mistyped values and invalid JSON. ` +
-        `Return ONLY json: {"score": <0..1>, "why": "<one line>"}`;
-    const { content } = await client.chatWithImages(judgeModel, prompt, images, 1024);
-    try {
-        const j = parseObj(content);
-        return { score: Number(j.score ?? 0), why: String(j.why ?? "") };
-    }
-    catch {
-        return { score: 0, why: "unparseable visual judge output" };
-    }
-}

package/dist/llm.js

@@ -1,207 +0,0 @@
-/** Minimal provider clients for judge and strategist requests. */
-import { existsSync, mkdtempSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { spawn } from "node:child_process";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { paths } from "./store.js";
-import { legacyOpenRouterRoute } from "./routes.js";
-import { piProviderExtensionArgs } from "./pi-config.js";
-const OR = "https://openrouter.ai/api/v1";
-/** Load OPENROUTER_API_KEY from env or ~/.openmerit/.env. */
-export function loadKey() {
-    const envFile = paths.envFile();
-    if (existsSync(envFile)) {
-        for (const line of readFileSync(envFile, "utf8").split("\n")) {
-            const t = line.trim();
-            if (!t || t.startsWith("#") || !t.includes("="))
-                continue;
-            const [k, ...v] = t.split("=");
-            if (process.env[k.trim()] === undefined)
-                process.env[k.trim()] = v.join("=").trim();
-        }
-    }
-    const key = process.env.OPENROUTER_API_KEY;
-    if (!key)
-        throw new Error("missing OPENROUTER_API_KEY (env or ~/.openmerit/.env)");
-    return key;
-}
-async function request(key, path, body, baseUrl = OR, tries = 3) {
-    for (let attempt = 0; attempt < tries; attempt++) {
-        const res = await fetch(baseUrl + path, {
-            method: body === undefined ? "GET" : "POST",
-            headers: {
-                Authorization: `Bearer ${key}`,
-                ...(body === undefined ? {} : { "Content-Type": "application/json", "X-Title": "openmerit" }),
-            },
-            body: body === undefined ? undefined : JSON.stringify(body),
-        });
-        if (res.ok)
-            return (await res.json());
-        const detail = (await res.text()).slice(0, 400);
-        if ([429, 500, 502, 503].includes(res.status) && attempt < tries - 1) {
-            await new Promise((r) => setTimeout(r, 2000 * (attempt + 1)));
-            continue;
-        }
-        throw new Error(`OpenRouter HTTP ${res.status}: ${detail}`);
-    }
-    throw new Error("unreachable");
-}
-class OpenAICompatibleProvider {
-    id;
-    baseUrl;
-    key;
-    constructor(id, baseUrl, key) {
-        this.id = id;
-        this.baseUrl = baseUrl;
-        this.key = key;
-    }
-    model(model) { return this.id === "openrouter" ? model : model.split("/", 2).at(-1) ?? model; }
-    async chat(model, prompt, maxTokens, temperature) {
-        const r = await request(this.key, "/chat/completions", { model: this.model(model), messages: [{ role: "user", content: prompt }], max_tokens: maxTokens, temperature }, this.baseUrl);
-        return { content: r.choices[0]?.message?.content ?? "", usage: r.usage ?? {} };
-    }
-    async chatWithImages(model, prompt, images, maxTokens) {
-        const content = [{ type: "text", text: prompt }, ...images.map((image) => ({ type: "image_url", image_url: { url: `data:${image.mimeType};base64,${image.data}` } }))];
-        const r = await request(this.key, "/chat/completions", { model: this.model(model), messages: [{ role: "user", content }], max_tokens: maxTokens, temperature: 0 }, this.baseUrl);
-        return { content: r.choices[0]?.message?.content ?? "", usage: r.usage ?? {} };
-    }
-}
-class GeminiProvider {
-    key;
-    id = "google";
-    constructor(key) {
-        this.key = key;
-    }
-    async call(model, prompt, images = [], maxTokens) {
-        const name = model.split("/", 2).at(-1) ?? model;
-        const parts = [{ text: prompt }, ...images.map((image) => ({ inline_data: { mime_type: image.mimeType, data: image.data } }))];
-        const res = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/${encodeURIComponent(name)}:generateContent?key=${encodeURIComponent(this.key)}`, {
-            method: "POST", headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ contents: [{ role: "user", parts }], generationConfig: { maxOutputTokens: maxTokens, temperature: images.length ? 0 : undefined } }),
-        });
-        if (!res.ok)
-            throw new Error(`Google Gemini HTTP ${res.status}: ${(await res.text()).slice(0, 300)}`);
-        const raw = await res.json();
-        return { content: raw.candidates?.[0]?.content?.parts?.map((p) => p.text ?? "").join("") ?? "", usage: { prompt_tokens: raw.usageMetadata?.promptTokenCount, completion_tokens: raw.usageMetadata?.candidatesTokenCount, total_tokens: raw.usageMetadata?.totalTokenCount } };
-    }
-    chat(model, prompt, maxTokens) { return this.call(model, prompt, [], maxTokens); }
-    chatWithImages(model, prompt, images, maxTokens) { return this.call(model, prompt, images, maxTokens); }
-}
-export function providerFor(model, fallbackKey) {
-    const id = model.split("/", 1)[0] || "openrouter";
-    // OpenRouter model IDs are vendor/model (for example openai/gpt-4o-mini).
-    // Direct providers require an explicit opt-in to avoid routing those IDs
-    // away from OpenRouter when users have multiple credentials configured.
-    if (id === "openai" && process.env.OPENMERIT_DIRECT_PROVIDER === "openai" && process.env.OPENAI_API_KEY)
-        return new OpenAICompatibleProvider(id, "https://api.openai.com/v1", process.env.OPENAI_API_KEY);
-    if (id === "google" && process.env.OPENMERIT_DIRECT_PROVIDER === "google" && process.env.GEMINI_API_KEY)
-        return new GeminiProvider(process.env.GEMINI_API_KEY);
-    return new OpenAICompatibleProvider("openrouter", OR, fallbackKey);
-}
-export async function chat(key, model, prompt, maxTokens, temperature) {
-    return providerFor(model, key).chat(model, prompt, maxTokens, temperature);
-}
-/** Send a visual grading request through the same OpenRouter account. */
-export async function chatWithImages(key, model, prompt, images, maxTokens) {
-    return providerFor(model, key).chatWithImages(model, prompt, images, maxTokens);
-}
-export function directChatClient(key) {
-    const id = (model) => typeof model === "string" ? model : model.meritId;
-    return {
-        chat: (model, prompt, maxTokens, temperature) => chat(key, id(model), prompt, maxTokens, temperature),
-        chatWithImages: (model, prompt, images, maxTokens) => chatWithImages(key, id(model), prompt, images, maxTokens),
-    };
-}
-function textContent(content) {
-    if (typeof content === "string")
-        return content;
-    if (!Array.isArray(content))
-        return "";
-    return content.filter((part) => !!part && typeof part === "object" && part.type === "text")
-        .map((part) => part.text ?? "").join("\n");
-}
-/** Use pi's model registry and credential store without exposing provider secrets to OpenMerit. */
-export class PiCliChatClient {
-    executable;
-    onSpend;
-    providerExtensions;
-    id = "pi-cli";
-    constructor(executable = process.env.OPENMERIT_PI_BIN?.trim() || "pi", onSpend, providerExtensions = []) {
-        this.executable = executable;
-        this.onSpend = onSpend;
-        this.providerExtensions = providerExtensions;
-    }
-    chat(model, prompt, _maxTokens, _temperature) {
-        return this.run(model, prompt, []);
-    }
-    chatWithImages(model, prompt, images, _maxTokens) {
-        return this.run(model, prompt, images);
-    }
-    async run(target, prompt, images) {
-        const route = typeof target === "string" ? legacyOpenRouterRoute(target) : target;
-        const dir = mkdtempSync(join(tmpdir(), "openmerit-pi-chat-"));
-        try {
-            const imageArgs = images.map((image, index) => {
-                const suffix = { "image/jpeg": "jpg", "image/png": "png", "image/webp": "webp", "image/gif": "gif" }[image.mimeType];
-                if (!suffix)
-                    throw new Error(`unsupported pi image: ${image.mimeType}`);
-                const file = join(dir, `image-${index}.${suffix}`);
-                writeFileSync(file, Buffer.from(image.data, "base64"));
-                return `@${file}`;
-            });
-            const child = spawn(this.executable, [
-                "--provider", route.provider, "--model", route.modelId, "--mode", "json", "--offline",
-                "--no-extensions", ...piProviderExtensionArgs(this.providerExtensions),
-                "--no-tools", "--print", ...imageArgs, prompt,
-            ], { cwd: dir, stdio: ["ignore", "pipe", "pipe"] });
-            let stdout = "";
-            let stderr = "";
-            child.stdout.on("data", (chunk) => { stdout += chunk.toString("utf8"); });
-            child.stderr.on("data", (chunk) => { stderr += chunk.toString("utf8"); });
-            const code = await new Promise((resolve, reject) => {
-                child.on("error", reject);
-                child.on("close", (value) => resolve(value ?? 1));
-            });
-            let answer = "";
-            let promptTokens = 0;
-            let completionTokens = 0;
-            let totalTokens = 0;
-            let costUsd = 0;
-            let failed = false;
-            for (const line of stdout.split("\n")) {
-                if (!line.trim())
-                    continue;
-                let event;
-                try {
-                    event = JSON.parse(line);
-                }
-                catch {
-                    continue;
-                }
-                if (event.type !== "message_end" || event.message?.role !== "assistant")
-                    continue;
-                answer = textContent(event.message.content) || answer;
-                promptTokens += event.message.usage?.input ?? 0;
-                completionTokens += event.message.usage?.output ?? 0;
-                totalTokens += event.message.usage?.totalTokens ?? 0;
-                costUsd += event.message.usage?.cost?.total ?? 0;
-                if (event.message.stopReason === "error")
-                    failed = true;
-            }
-            if (code !== 0 || failed || !answer.trim()) {
-                throw new Error(`pi model call ${route.provider}/${route.modelId} failed: ` +
-                    (stderr.trim().slice(0, 240) || `exit ${code}, empty answer`));
-            }
-            this.onSpend?.(costUsd);
-            return { content: answer, usage: {
-                    prompt_tokens: promptTokens || undefined,
-                    completion_tokens: completionTokens || undefined,
-                    total_tokens: totalTokens || promptTokens + completionTokens || undefined,
-                    costUsd,
-                } };
-        }
-        finally {
-            rmSync(dir, { recursive: true, force: true });
-        }
-    }
-}

package/dist/pi-config.js

@@ -1,46 +0,0 @@
-/** Safe, explicit Pi subprocess configuration. */
-import { existsSync, realpathSync, statSync } from "node:fs";
-import { basename, isAbsolute } from "node:path";
-/**
- * Provider extensions execute as code. Require exact, existing, absolute files
- * and refuse OpenMerit itself so an isolated trial cannot recursively launch
- * another merit loop.
- */
-export function validatePiProviderExtensions(paths) {
-    const valid = [];
-    const errors = [];
-    for (const configured of [...new Set(paths)]) {
-        if (!isAbsolute(configured)) {
-            errors.push(`${configured}: path is not absolute`);
-            continue;
-        }
-        if (!existsSync(configured)) {
-            errors.push(`${configured}: file does not exist`);
-            continue;
-        }
-        let actual = configured;
-        try {
-            actual = realpathSync(configured);
-            if (!statSync(actual).isFile()) {
-                errors.push(`${configured}: path is not a file`);
-                continue;
-            }
-        }
-        catch (error) {
-            errors.push(`${configured}: ${error.message}`);
-            continue;
-        }
-        if (/^openmerit\.[cm]?[jt]s$/i.test(basename(actual))) {
-            errors.push(`${configured}: refusing to load OpenMerit recursively`);
-            continue;
-        }
-        valid.push(actual);
-    }
-    return { valid, errors };
-}
-export function piProviderExtensionArgs(paths) {
-    const checked = validatePiProviderExtensions(paths);
-    if (checked.errors.length)
-        throw new Error(`invalid pi.provider_extensions: ${checked.errors.join("; ")}`);
-    return checked.valid.flatMap((file) => ["--extension", file]);
-}