@dna113p/machines 0.1.0 → 0.3.0

package/dist/src/agent-limits.js

@@ -0,0 +1,212 @@
+import { AgentLimitError, agentLimitOf } from "./agent-limit.js";
+export const defaultProbeMs = 15 * 60_000;
+// A provider's reset time is when its window ends, not when it accepts requests again.
+const resetMarginMs = 60_000;
+// Short sleeps measured against the clock notice a reset that passed while the computer was suspended.
+const tickMs = 60_000;
+const handoffNote = [
+    "Note: a previous Agent working on this assignment was interrupted by a usage limit and may have",
+    "left partial work in the workspace. Inspect the current state and continue the same assignment",
+    "rather than starting over.",
+].join(" ");
+export function createLimitMemory() {
+    return new Map();
+}
+/**
+ * Runs one role's request on the first candidate that is not at a usage limit.
+ * A limited candidate hands the same request to the next one; when all are
+ * limited the request waits for a reset within the policy, or fails.
+ * A request with `limits: "report"` is tried on the bound candidate alone, and
+ * its limit is thrown at once.
+ */
+export function limitAwareRunner(role, candidates, memory, policy) {
+    const bound = candidates[0];
+    if (bound === undefined)
+        throw new Error(`Agent role "${role}" needs at least one preset`);
+    const now = policy.now ?? Date.now;
+    const sleep = policy.sleep ?? timerSleep;
+    const named = (name) => name === role ? name : `${name} (role ${role})`;
+    const limited = (name, retrying) => {
+        const remembered = memory.get(name);
+        return remembered !== undefined && remembered.until > now() && retrying?.has(remembered) !== true;
+    };
+    // The state decides what its limit means, so nothing is swapped, waited for, or reported as an update.
+    const reported = async (request, report) => {
+        const known = memory.get(bound.name);
+        if (known !== undefined && known.until > now()) {
+            throw new AgentLimitError(`${named(bound.name)} is at its usage limit (${resetText(known)})`, known.limit);
+        }
+        try {
+            const event = await bound.runner(request, report);
+            if (known !== undefined && memory.get(bound.name) === known)
+                memory.delete(bound.name);
+            return event;
+        }
+        catch (cause) {
+            const limit = agentLimitOf(cause);
+            if (limit === undefined)
+                throw cause;
+            // The run's other roles skip this preset, and the limit names it.
+            throw new AgentLimitError(cause instanceof Error ? cause.message : String(cause), remember(bound, limit).limit, { cause });
+        }
+    };
+    return async (request, report) => {
+        if (request.limits === "report")
+            return reported(request, report);
+        // A state is announced after its Agent starts, in the same tick. Observers
+        // attach an update to the announced state, so none is reported before then.
+        const tell = async (update) => {
+            await Promise.resolve();
+            report?.(update);
+        };
+        let interrupted = false;
+        let lastFailure;
+        let deadline;
+        // A wait is reported once, and lasts until a candidate gets past its limit.
+        let waiting = false;
+        let retrying = new Set();
+        for (;;) {
+            let passedOver;
+            for (const [index, candidate] of candidates.entries()) {
+                if (limited(candidate.name, retrying)) {
+                    passedOver ??= candidate;
+                    continue;
+                }
+                if (passedOver !== undefined && !interrupted && !waiting) {
+                    // Another role of this run found the limit, so this one names the preset it runs on instead.
+                    // After a wait the preset is named when the Agent resumes.
+                    await tell(swapped(named(passedOver.name), "is at", memory.get(passedOver.name), passedOver, candidate));
+                }
+                passedOver = undefined;
+                const resume = () => {
+                    if (!waiting)
+                        return;
+                    waiting = false;
+                    report?.({
+                        type: "limit",
+                        status: "resumed",
+                        agent: bound.name,
+                        ...(candidate === bound ? {} : { to: candidate.name }),
+                        text: `${named(bound.name)} waited for a usage limit to reset; continuing${candidate === bound ? "" : ` with ${candidate.name}`}`,
+                    });
+                };
+                const tried = memory.get(candidate.name);
+                let limit;
+                try {
+                    const event = await candidate.runner(interrupted ? withHandoffNote(request) : request, 
+                    // A limited turn can still report its identity and the provider's message; a tool call is work.
+                    !waiting ? report : (update) => {
+                        if (update.type === "tool")
+                            resume();
+                        report?.(update);
+                    });
+                    resume();
+                    // What was remembered for a preset that answers is out of date, also for the run's other roles.
+                    if (tried !== undefined && memory.get(candidate.name) === tried)
+                        memory.delete(candidate.name);
+                    return event;
+                }
+                catch (cause) {
+                    limit = agentLimitOf(cause);
+                    if (limit === undefined)
+                        throw cause;
+                    lastFailure = cause;
+                }
+                interrupted = true;
+                const remembered = remember(candidate, limit);
+                const next = candidates.slice(index + 1).find((later) => !limited(later.name, retrying));
+                // Also while a wait is reported: each probe that moves on to another preset is a swap.
+                if (next !== undefined)
+                    await tell(swapped(named(candidate.name), "reached", remembered, candidate, next));
+            }
+            const limits = candidates.flatMap((candidate) => {
+                const remembered = memory.get(candidate.name);
+                return remembered === undefined ? [] : [{ candidate, remembered }];
+            });
+            const started = now();
+            deadline ??= started + policy.maxWaitMs;
+            const closes = deadline;
+            const wakes = policy.maxWaitMs <= 0 ? [] : limits.flatMap(({ remembered }) => {
+                if (remembered.known) {
+                    return remembered.until <= closes ? [{ remembered, at: remembered.until + resetMarginMs }] : [];
+                }
+                // The last probe of a limit with no stated reset is at the deadline.
+                return started < closes ? [{ remembered, at: Math.min(remembered.until, closes) }] : [];
+            });
+            if (wakes.length === 0)
+                throw exhausted(role, limits, policy.maxWaitMs, lastFailure);
+            const wakeAt = Math.min(...wakes.map((wake) => wake.at));
+            // A reset that passed while a later candidate was working needs no wait.
+            if (!waiting && wakeAt > now()) {
+                waiting = true;
+                const resets = wakes.filter((wake) => wake.remembered.known).map((wake) => wake.remembered.until);
+                const until = timestamp(resets.length === 0 ? closes : Math.min(...resets));
+                const others = candidates.slice(1).map((candidate) => candidate.name);
+                await tell({
+                    type: "limit",
+                    status: "waiting",
+                    agent: bound.name,
+                    until,
+                    text: `${named(bound.name)}${others.length === 0
+                        ? " reached its usage limit"
+                        : ` and its fallback${others.length === 1 ? "" : "s"} (${others.join(", ")}) reached their usage limits`}; ${resets.length === 0 ? `no reset is stated, retrying until ${until}` : `waiting for the reset at ${until}`}`,
+                });
+            }
+            for (let remaining = wakeAt - now(); remaining > 0; remaining = wakeAt - now()) {
+                await sleep(Math.min(remaining, tickMs));
+            }
+            retrying = new Set(wakes.filter((wake) => wake.at <= wakeAt).map((wake) => wake.remembered));
+        }
+    };
+    function remember(candidate, limit) {
+        const at = now();
+        // A reset that has already passed says nothing about when to try again.
+        const known = limit.resetsAt !== undefined && limit.resetsAt > at;
+        const remembered = {
+            limit: { ...limit, agent: candidate.name },
+            until: known ? limit.resetsAt : at + policy.probeMs,
+            known,
+        };
+        memory.set(candidate.name, remembered);
+        return remembered;
+    }
+}
+function withHandoffNote(request) {
+    return { ...request, prompt: `${request.prompt}\n\n${handoffNote}` };
+}
+function swapped(subject, verb, remembered, from, to) {
+    return {
+        type: "limit",
+        status: "swapped",
+        agent: from.name,
+        to: to.name,
+        text: `${subject} ${verb} its usage limit (${resetText(remembered)}); continuing with ${to.name}`,
+    };
+}
+function exhausted(role, limits, maxWaitMs, cause) {
+    const described = limits.map(({ candidate, remembered }) => {
+        const details = [candidate.harness ?? remembered.limit.harness, remembered.limit.kind, resetText(remembered)];
+        return `${candidate.name} (${details.filter((detail) => detail !== undefined).join(", ")})`;
+    });
+    const reason = maxWaitMs <= 0
+        ? "waiting for a reset is off"
+        : `none is available within the ${formatMinutes(maxWaitMs)} wait limit`;
+    const known = limits.filter(({ remembered }) => remembered.known)
+        .sort((left, right) => left.remembered.until - right.remembered.until);
+    const earliest = (known[0] ?? limits[0])?.remembered.limit ?? { harness: "unknown" };
+    return new AgentLimitError(`Agent role "${role}" is at a usage limit on every allowed preset: ${described.join("; ")}; ${reason}`, earliest, { limits: limits.map(({ remembered }) => remembered.limit), ...(cause === undefined ? {} : { cause }) });
+}
+function resetText(remembered) {
+    return remembered?.known === true ? `resets ${timestamp(remembered.until)}` : "reset unknown";
+}
+function timestamp(time) {
+    return new Date(time).toISOString().replace(/\.\d{3}Z$/u, "Z");
+}
+function formatMinutes(milliseconds) {
+    const minutes = Math.round(milliseconds / 6_000) / 10;
+    return `${minutes}-minute`;
+}
+// The timer stays referenced: a waiting run is working, and must keep its process alive.
+function timerSleep(milliseconds) {
+    return new Promise((resolve) => { setTimeout(resolve, milliseconds); });
+}

package/dist/src/agent-protocol.d.ts

@@ -0,0 +1,6 @@
+import type { AgentRequest, Event } from "./index.ts";
+export declare function agentPrompt(request: AgentRequest): string;
+export declare function readAgentEvent(output: string, options: {
+    readonly adapter: string;
+    readonly includeMessage: boolean;
+}): Event;

package/dist/src/agent-protocol.js

@@ -0,0 +1,40 @@
+export function agentPrompt(request) {
+    return [
+        request.prompt,
+        "",
+        "You are already executing one Agent state inside a Machine. Complete this assigned state using the available tools.",
+        "Do not re-delegate this assignment or start the parent workflow again unless the assignment explicitly requires bounded nested work.",
+        "Return evidence and an allowed outcome to the owning Machine; it controls verification, transitions, and Human decisions.",
+        `Allowed outcome types: ${request.outcomes.join(", ")}.`,
+        "When finished, end your final response with exactly one line in this form:",
+        'MACHINES_EVENT {"type":"completed"}',
+        "Replace completed with exactly one allowed outcome type.",
+        "Include additional JSON fields only when the task asks for them.",
+    ].join("\n");
+}
+export function readAgentEvent(output, options) {
+    const matches = [...output.matchAll(/^MACHINES_EVENT (.+)$/gmu)];
+    const encoded = matches.at(-1)?.[1];
+    if (encoded === undefined) {
+        throw new Error(`${options.adapter} Agent finished without returning a Machines event`);
+    }
+    let event;
+    try {
+        event = JSON.parse(encoded);
+    }
+    catch (cause) {
+        throw new Error(`${options.adapter} Agent returned invalid event JSON`, { cause });
+    }
+    if (!isEvent(event)) {
+        throw new Error(`${options.adapter} Agent returned an invalid Machines event`);
+    }
+    const message = output.replace(/^MACHINES_EVENT .+$(?:\r?\n)?/gmu, "").trim();
+    return options.includeMessage && message !== "" ? { ...event, message } : event;
+}
+function isEvent(value) {
+    return value !== null
+        && typeof value === "object"
+        && !Array.isArray(value)
+        && "type" in value
+        && typeof value.type === "string";
+}

package/dist/src/agy.d.ts

@@ -0,0 +1,11 @@
+import type { AgentRunner } from "./index.ts";
+export interface AgyAgentOptions {
+    readonly env?: Readonly<Record<string, string>>;
+    readonly harness?: string;
+    readonly model?: string;
+    readonly effort?: "low" | "medium" | "high";
+    /** Explicitly opt in to auto-approving all AGY tool permission requests. */
+    readonly dangerouslySkipPermissions?: boolean;
+    readonly output?: "capture" | "stream";
+}
+export declare function agyAgent(command?: string, args?: readonly string[], options?: AgyAgentOptions): AgentRunner;

package/dist/src/agy.js

@@ -0,0 +1,168 @@
+import { spawn } from "node:child_process";
+import { createInterface } from "node:readline";
+import * as v from "valibot";
+import { agentPrompt, readAgentEvent } from "./agent-protocol.js";
+export function agyAgent(command = "agy", args = [], options = {}) {
+    return async (request, report) => {
+        if (request.cwd === undefined) {
+            throw new Error("agy Agent requires a working directory");
+        }
+        if (request.outcomes.length === 0) {
+            throw new Error("agy Agent requires at least one allowed outcome");
+        }
+        const harness = options.harness ?? (command === "agy" ? "agy" : command);
+        const env = { ...process.env, ...options.env };
+        const model = options.model ?? env.AGY_MODEL ?? env.MACHINES_AGENT_MODEL;
+        const effort = options.effort ?? env.AGY_EFFORT ?? env.MACHINES_AGENT_EFFORT;
+        const outputMode = options.output ?? "stream";
+        report?.({
+            type: "identity",
+            harness,
+            ...(model === undefined ? {} : { model }),
+            ...(effort === undefined ? {} : { thinking: effort }),
+        });
+        const cliArgs = [
+            ...args,
+            "--print",
+            agentPrompt(request),
+            "--output-format",
+            "stream-json",
+            "--disable-slash-commands",
+            ...(options.dangerouslySkipPermissions === true ? ["--dangerously-skip-permissions"] : []),
+            ...(model === undefined ? [] : ["--model", model]),
+            ...(effort === undefined ? [] : ["--effort", effort]),
+        ];
+        const child = spawn(command, cliArgs, {
+            cwd: request.cwd,
+            env,
+            stdio: ["pipe", "pipe", "pipe"],
+        });
+        let stderr = "";
+        child.stderr.setEncoding("utf8");
+        child.stderr.on("data", (chunk) => {
+            stderr += chunk;
+            if (outputMode === "stream")
+                process.stderr.write(chunk);
+        });
+        try {
+            await waitForSpawn(child);
+            return await runSession(child, outputMode, report);
+        }
+        catch (cause) {
+            const message = cause instanceof Error ? cause.message : String(cause);
+            const detail = stderr.trim();
+            throw new Error(`agy Agent "${command}" failed in "${request.cwd}": ${message}${detail === "" ? "" : `\n${detail}`}`, { cause });
+        }
+        finally {
+            child.kill();
+        }
+    };
+}
+async function runSession(child, outputMode, report) {
+    const exited = new Promise((resolve, reject) => {
+        child.once("close", (code, signal) => {
+            if (code === 0)
+                resolve();
+            else
+                reject(new Error(signal === null
+                    ? `Process exited with code ${code}`
+                    : `Process terminated by ${signal}`));
+        });
+        child.once("error", reject);
+    });
+    // Observe failures immediately, while stdout may still be draining.
+    void exited.catch(() => { });
+    const lines = createInterface({ input: child.stdout });
+    let displayedOutput = "";
+    let finalResponse;
+    const emitOutput = (text) => {
+        if (text === "")
+            return;
+        displayedOutput += text;
+        report?.({ type: "output", text });
+        if (outputMode === "stream")
+            process.stdout.write(text);
+    };
+    try {
+        for await (const line of lines) {
+            const record = decodeRecord(line);
+            if (record === undefined)
+                continue;
+            if (record.event === "result") {
+                finalResponse = record.result.response;
+            }
+            else {
+                const step = record.step_update;
+                if (step.step_type === "agent_response") {
+                    emitOutput(step.text_delta);
+                }
+                else {
+                    const id = String(step.step_index ?? step.tool_name ?? "tool");
+                    const title = step.tool_name ?? step.tool_info?.name ?? "tool";
+                    const status = step.state === "ACTIVE"
+                        ? "in_progress"
+                        : (step.state === "DONE" ? "completed" : undefined);
+                    report?.({ type: "tool", id, title, ...(status === undefined ? {} : { status }) });
+                }
+            }
+        }
+        await exited;
+        // The final response owns the outcome; earlier deltas may contain progress
+        // or a preliminary event. Fall back only when no final response was sent.
+        const response = finalResponse ?? displayedOutput;
+        if (finalResponse !== undefined && !displayedOutput.endsWith(finalResponse)) {
+            if (finalResponse.startsWith(displayedOutput)) {
+                emitOutput(finalResponse.slice(displayedOutput.length));
+            }
+            else {
+                const separator = displayedOutput !== "" && !displayedOutput.endsWith("\n") ? "\n" : "";
+                emitOutput(separator + finalResponse);
+            }
+        }
+        if (outputMode === "stream" && displayedOutput !== "" && !displayedOutput.endsWith("\n")) {
+            process.stdout.write("\n");
+        }
+        return readAgentEvent(response, { adapter: "agy", includeMessage: outputMode === "capture" });
+    }
+    finally {
+        lines.close();
+    }
+}
+// Unknown events and malformed records are ignored at the transport boundary.
+// Only these validated fields can reach the harness-neutral AgentUpdate API.
+const recordSchema = v.variant("event", [
+    v.object({
+        event: v.literal("step_update"),
+        step_update: v.variant("step_type", [
+            v.object({ step_type: v.literal("agent_response"), text_delta: v.string() }),
+            v.object({
+                step_type: v.literal("tool"),
+                step_index: v.nullish(v.union([v.string(), v.number()])),
+                tool_name: v.nullish(v.string()),
+                tool_info: v.nullish(v.object({ name: v.nullish(v.string()) })),
+                state: v.nullish(v.string()),
+            }),
+        ]),
+    }),
+    v.object({
+        event: v.literal("result"),
+        result: v.object({ response: v.string() }),
+    }),
+]);
+function decodeRecord(line) {
+    let value;
+    try {
+        value = JSON.parse(line);
+    }
+    catch {
+        return undefined;
+    }
+    const result = v.safeParse(recordSchema, value);
+    return result.success ? result.output : undefined;
+}
+function waitForSpawn(child) {
+    return new Promise((resolve, reject) => {
+        child.once("spawn", resolve);
+        child.once("error", reject);
+    });
+}

package/dist/src/catalog.d.ts

@@ -14,6 +14,8 @@ export interface AgentPresetSummary {
     readonly harness?: string;
     readonly model?: string;
     readonly thinking?: string;
+    /** The presets that take over at a usage limit, in order; absent when none is configured. */
+    readonly fallback?: readonly string[];
     readonly source: string;
 }
 export interface LauncherLocation {
@@ -24,6 +26,7 @@ interface ResolvedAgentPresets {
     readonly agents: Readonly<Record<string, AgentRunner>>;
     readonly presets: Readonly<Record<string, AgentPreset>>;
     readonly sources: Readonly<Record<string, string>>;
+    readonly fallback?: readonly string[];
 }
 export declare function inspectMachines(location?: LauncherLocation): Promise<readonly MachineSummary[]>;
 export declare function inspectAgentPresets(location?: LauncherLocation): Promise<readonly AgentPresetSummary[]>;

package/dist/src/catalog.js

@@ -1,5 +1,16 @@
-import { loadAgentBindings } from "./agent-bindings.js";
+import { fallbackPresets, loadAgentBindings } from "./agent-bindings.js";
 import { acpAgent } from "./acp.js";
+import { AgentLimitError } from "./agent-limit.js";
+import { agyAgent } from "./agy.js";
+import { chatGptWebAgent } from "./chatgpt-web.js";
+import { claudeAgent } from "./claude.js";
+import { codexAgent } from "./codex.js";
+import { deepseekAgent } from "./deepseek.js";
+import { decisionAgent } from "./decision.js";
+import { jevAgent, jevProvider } from "./jev.js";
+import { layaAgent, layaProvider } from "./laya.js";
+import { vonAgent, vonProvider } from "./von.js";
+import { openRouterDecisionAgent, openRouterDecisionProvider } from "./openrouter.js";
 import { discoverMachines, machinesUserHome } from "./discovery.js";
 import { loadMachineModule, readAgentRoles, requireMachineDescription } from "./machine-module.js";
 export async function inspectMachines(location = {}) {
@@ -34,33 +45,104 @@ export async function inspectAgentPresets(location = {}) {
     const home = location.home ?? machinesUserHome();
     const configured = await configuredAgentPresets(cwd, home);
     return Object.entries(configured.presets)
-        .map(([name, preset]) => ({
-        name,
-        description: preset.description,
-        ...(preset.harness === undefined ? {} : { harness: preset.harness }),
-        ...(preset.model === undefined ? {} : { model: preset.model }),
-        ...(preset.thinking === undefined ? {} : { thinking: preset.thinking }),
-        source: configured.sources[name] ?? "unknown",
-    }))
+        .map(([name, preset]) => {
+        const fallback = fallbackPresets(name, preset, configured.fallback);
+        return {
+            name,
+            description: preset.description,
+            ...(preset.harness === undefined ? {} : { harness: preset.harness }),
+            ...(preset.model === undefined ? {} : { model: preset.model }),
+            ...(preset.thinking === undefined ? {} : { thinking: preset.thinking }),
+            ...(fallback === undefined ? {} : { fallback }),
+            source: configured.sources[name] ?? "unknown",
+        };
+    })
         .sort((left, right) => left.name.localeCompare(right.name));
 }
 export async function configuredAgentPresets(cwd, home) {
-    const configured = await loadAgentBindings(cwd, home, { acpAgent });
+    const configured = await loadAgentBindings(cwd, home, {
+        acpAgent, AgentLimitError, agyAgent, chatGptWebAgent, claudeAgent, codexAgent, deepseekAgent, decisionAgent, jevAgent, jevProvider,
+        openRouterDecisionAgent, openRouterDecisionProvider, layaAgent, layaProvider, vonAgent, vonProvider,
+    });
     const defaultRunner = acpAgent("npx", ["-y", "pi-acp"], {
         harness: "pi-acp",
         output: "capture",
     });
+    const agyRunner = agyAgent("agy", [], {
+        harness: "agy",
+        output: "capture",
+    });
+    const claudeRunner = claudeAgent("claude", [], { output: "capture" });
+    const codexRunner = codexAgent("codex", [], { output: "capture" });
+    const chatGptWebRunner = chatGptWebAgent({ output: "capture" });
+    const deepseekRunner = deepseekAgent("dsh", [], { output: "capture" });
+    const jevRunner = jevAgent();
+    const openRouterRunner = openRouterDecisionAgent();
+    const layaRunner = layaAgent();
+    const vonRunner = vonAgent();
     return {
-        agents: { default: defaultRunner, ...configured.agents },
+        agents: {
+            default: defaultRunner, agy: agyRunner, claude: claudeRunner, codex: codexRunner, "chatgpt-web": chatGptWebRunner, deepseek: deepseekRunner, jev: jevRunner,
+            "openrouter-decision": openRouterRunner, laya: layaRunner, von: vonRunner, ...configured.agents,
+        },
         presets: {
             default: {
                 description: "Runs the current Pi Agent through ACP",
                 harness: "pi-acp",
                 runner: defaultRunner,
             },
+            agy: {
+                description: "Runs the Antigravity CLI (agy)",
+                harness: "agy",
+                runner: agyRunner,
+            },
+            claude: {
+                description: "Runs the Claude Code CLI headlessly with its own login and permission rules",
+                harness: "claude",
+                runner: claudeRunner,
+            },
+            codex: {
+                description: "Runs the Codex CLI in a read-only sandbox",
+                harness: "codex",
+                runner: codexRunner,
+            },
+            "chatgpt-web": {
+                description: "Runs a new ChatGPT web conversation that works locally through rig-bridge",
+                harness: "chatgpt-web",
+                runner: chatGptWebRunner,
+            },
+            deepseek: {
+                description: "Runs DeepSeek Harness (dsh) through ACP",
+                harness: "dsh",
+                runner: deepseekRunner,
+            },
+            jev: {
+                description: "Classifies supplied evidence with Jev; does not execute tools",
+                harness: "jev",
+                runner: jevRunner,
+            },
+            "openrouter-decision": {
+                description: "Classifies supplied evidence through OpenRouter Decisions; does not execute tools",
+                harness: "openrouter-decision",
+                runner: openRouterRunner,
+            },
+            laya: {
+                description: "Classifies supplied evidence through a self-hosted Laya bridge; does not execute tools",
+                harness: "laya",
+                runner: layaRunner,
+            },
+            von: {
+                description: "Classifies supplied evidence through a self-hosted Von server; does not execute tools",
+                harness: "von",
+                runner: vonRunner,
+            },
             ...configured.presets,
         },
-        sources: { default: "built in", ...configured.sources },
+        sources: {
+            default: "built in", agy: "built in", claude: "built in", codex: "built in", "chatgpt-web": "built in", deepseek: "built in", jev: "built in",
+            "openrouter-decision": "built in", laya: "built in", von: "built in", ...configured.sources,
+        },
+        ...(configured.fallback === undefined ? {} : { fallback: configured.fallback }),
     };
 }
 function errorMessage(cause) {