humanish 0.106.1 → 0.108.0

package/dist/lab/routing.js

@@ -1,8 +1,8 @@
 import { actorRegistry } from "../actors/registry.js";
 import { isLoopbackUrl } from "./parse/subject.js";
-// Hard cap on fan-out lanes (per the ratified design). No HUMANISH_MAX_LANES escape above this
-// until a reference panel demands it — N concurrent paid desktops is real money.
-export const MAX_CUA_LANES = 16;
+// Hard cap on computer-use participants. No setting raises it: each participant is a paid desktop,
+// and they all run at once.
+export const MAX_COMPUTER_USE_PARTICIPANTS = 16;
 // Run kinds whose evidence is the participant's screenshots. An actor that declares it produces none
 // cannot run on them: a code-only actor would claim a GUI flow it only reached through a shell.
 const SCREENSHOT_RUN_KINDS = new Set([
@@ -36,7 +36,7 @@ export function actorResolvesToScriptedBrowser(type) {
 export function registeredScriptedBrowserActors() {
     return registeredActorsOn("scripted-browser");
 }
-/** True when `type` resolves to a registered terminal actor (the "terminal" lane). Exported so
+/** True when `type` resolves to a registered terminal actor (the "terminal" run kind). Exported so
  *  the engine + tests can resolve the dispatch the same way the parser does. */
 export function actorResolvesToTerminal(type) {
     return actorResolvesTo(type, "terminal");
@@ -45,11 +45,11 @@ export function registeredTerminalActors() {
     return registeredActorsOn("terminal");
 }
 /**
- * The declared fan-out lane count on the computer-use route: a `lanes[]` roster's length, else
+ * The declared fan-out participant count on the computer-use route: a `lanes[]` roster's length, else
  * a homogeneous `count`, else 1. The single source of truth shared by the parser, the engine,
- * and the pre-flight plan so the lane count is computed ONE way everywhere.
+ * and the pre-flight plan so the participant count is computed the same way everywhere.
  */
-export function cuaLaneCount(config) {
+export function computerUseParticipantCount(config) {
     const actor = config.actors[0];
     if (actor?.lanes !== undefined) {
         return actor.lanes.length;
@@ -57,31 +57,30 @@ export function cuaLaneCount(config) {
     return actor?.count ?? 1;
 }
 /**
- * A participant's id: its declared roster id, else `lane-NN` (independent lanes) or `role-NN`
- * (shared-world seats) from its 0-based position. The parser's filled email recipients and the
- * routes that name participants both call this, so a filled recipient names a participant that
+ * A participant's id: its declared roster id, else `lane-NN` (independent participants) or `role-NN`
+ * (shared-world participants) from its 0-based position. The parser's filled email recipients and
+ * the routes that name participants both call this, so a filled recipient names a participant that
  * runs.
  */
 export function participantIdAt(index, declared, kind) {
     return declared ?? `${kind === "seat" ? "role" : "lane"}-${String(index + 1).padStart(2, "0")}`;
 }
 /**
- * True when this config routes to the computer-use backend: an app-url subject whose first
- * actor resolves to a registered computer-use actor, or a clone subject on a hosted desktop
- * whose first actor does. Single source of truth — routeOf and the warning logic
- * both use it. (The app-url branch used to be unconditionally true; it narrowed when the
- * scripted-browser lane arrived. Behavior-preserving for every parse-valid config —
- * routeOf keeps a bare app-url fallback to the cua backend so library-API configs
- * with unknown actors still hit its fail-closed ACTOR_UNSUPPORTED.)
+ * True when this config routes to the computer-use backend: an app-url subject whose first actor
+ * resolves to a registered computer-use actor, or a clone subject on a hosted desktop whose first
+ * actor does. Single source of truth: routeOf and the warning logic both use it. (The app-url
+ * branch also checks the first actor, so a scripted-browser actor routes elsewhere. routeOf keeps a
+ * bare app-url fallback to the computer-use route so library-API configs with unknown actors still
+ * hit its fail-closed ACTOR_UNSUPPORTED.)
  */
 export function isComputerUseComposition(config) {
     // local-app drives the cua loop in-process (a custom executor + a non-vision provider), so it
-    // routes to the cua backend exactly like an app-url subject with a computer-use actor.
+    // routes to the computer-use route exactly like an app-url subject with a computer-use actor.
     if (config.subject.source === "app-url" || config.subject.source === "local-app") {
         return actorResolvesToComputerUse(config.actors[0]?.type);
     }
-    // desktop-cli hands the participant a terminal instead of a served page (#495), but it is the
-    // same lane: same desktop, same actor, same prompt fields. Leaving it out of this predicate told
+    // desktop-cli hands the participant a terminal instead of a served page, but it is the
+    // same route: same desktop, same actor, same prompt fields. Leaving it out of this predicate told
     // adopters their mission and persona were inert on the one route whose whole point is that a
     // person reads a screen.
     if (config.subject.source === "desktop-cli") {
@@ -95,34 +94,34 @@ export function isComputerUseComposition(config) {
         actorResolvesToComputerUse(config.actors[0]?.type));
 }
 /**
- * True when this config routes to the SHARED-WORLD backend (#164): a clone or local-tree subject
- * on a hosted desktop whose first actor resolves to a computer-use actor AND that declares the
+ * True when this config routes to the shared-world route: a clone or local-tree subject
+ * on a hosted desktop whose first actor resolves to a computer-use actor and that declares the
  * `shared-world` topology. Mirror of isComputerUseComposition; the single source of truth shared by
- * routeOf (which checks it BEFORE the cua route) and the warning logic. Every
+ * routeOf (which checks it before the computer-use route) and the warning logic. Every
  * shared-world study runs its participants at once (`execution.concurrency` >= 2). The same
- * clone/local-tree × e2b-desktop × computer-use composition WITHOUT `topology: shared-world` stays per-lane-worlds
- * (the cua route) — the topology declaration is the override switch.
+ * clone/local-tree × e2b-desktop × computer-use composition without `topology: shared-world` stays per-lane-worlds
+ * (the computer-use route); the topology declaration is the override switch.
  */
 export function isSharedWorldComposition(config) {
     return (isProvisionedSharedWorldComposition(config) || isExternalPublicSharedWorldComposition(config));
 }
 /** The getHost provisioned-subject shared-world shape (clone/local-tree served + exposed in-sandbox). */
-function isProvisionedSharedWorldComposition(config) {
+export function isProvisionedSharedWorldComposition(config) {
     return ((config.subject.source === "clone" || config.subject.source === "local-tree") &&
         config.subject.topology === "shared-world" &&
         config.execution?.target === "e2b-desktop" &&
         actorResolvesToComputerUse(config.actors[0]?.type));
 }
 /**
- * The EXTERNAL-PUBLIC shared-world shape (#164 phase 2): a real PUBLIC deployment used DIRECTLY as
- * the shared plane — `source: app-url` + `topology: shared-world` + a computer-use actor on
- * e2b-desktop + `policies.allowPublicTargets: true`. NO getHost, NO clone, NO subject sandbox, NO
+ * The external-public shared-world shape: a real public deployment used directly as
+ * the shared plane: `source: app-url` + `topology: shared-world` + a computer-use actor on
+ * e2b-desktop + `policies.allowPublicTargets: true`. No getHost, no clone, no subject sandbox, no
  * seed. The operator-ownership attestation `subject.publicTarget` is required (validated in
- * externalPublicSharedWorldValidationReason, not here — this predicate is the router only, so a
+ * externalPublicSharedWorldValidationReason, not here; this predicate is the router only, so a
  * half-declared external-public config still routes here to get its precise fail-closed reason
- * rather than silently downgrading to the per-lane cua route).
+ * rather than silently downgrading to the per-participant computer-use route).
  */
-function isExternalPublicSharedWorldComposition(config) {
+export function isExternalPublicSharedWorldComposition(config) {
     return (config.subject.source === "app-url" &&
         config.subject.topology === "shared-world" &&
         config.execution?.target === "e2b-desktop" &&
@@ -130,11 +129,11 @@ function isExternalPublicSharedWorldComposition(config) {
         config.policies?.allowPublicTargets === true);
 }
 /**
- * Resolve a shared-world seat's entry URL from `serve.url` + a role's `entry` (relative path or
- * same-origin absolute URL). Returns null when the combination is not a same-origin loopback URL
- * (the load-bearing public-safety boundary — a seat only ever drives the in-sandbox app).
+ * Resolve a shared-world participant's entry URL from `serve.url` and its roster entry's `entry`
+ * (a relative path or a same-origin absolute URL). Returns null when the result is not a
+ * same-origin loopback URL, so a participant only ever drives the in-sandbox app.
  */
-export function resolveSeatUrl(serveUrl, entry) {
+export function resolveEntryUrl(serveUrl, entry) {
     if (entry === undefined || entry === "") {
         return isLoopbackUrl(serveUrl) ? serveUrl : null;
     }
@@ -156,7 +155,7 @@ export function resolveSeatUrl(serveUrl, entry) {
 /**
  * True when this config routes to the scripted-browser backend: an app-url subject whose
  * first actor resolves to a registered scripted-browser actor (execution.target local or
- * absent — the parse layer enforces that pairing). Mirror of isComputerUseComposition; the single
+ * absent; the parse layer enforces that pairing). Mirror of isComputerUseComposition; the single
  * source of truth for routeOf and the warning logic.
  */
 export function isScriptedBrowserComposition(config) {
@@ -172,43 +171,42 @@ export function isProvisionedScriptedBrowserComposition(config) {
 }
 /**
  * True when this config routes to the terminal-product backend: a terminal-product subject whose
- * first actor resolves to a registered terminal actor (execution.target e2b-terminal or absent —
+ * first actor resolves to a registered terminal actor (execution.target e2b-terminal or absent;
  * the parse layer enforces that pairing). Mirror of isComputerUseComposition/isScriptedBrowserComposition;
  * the single source of truth for routeOf and the warning logic.
  */
 export function isTerminalProductComposition(config) {
     return (config.subject.source === "terminal-product" && actorResolvesToTerminal(config.actors[0]?.type));
 }
-// The package's older names for these predicates. routeOf is the route decision; each of these
-// says whether a config composes that route with a registered actor of its kind.
-/** @deprecated Use `routeOf`. This goes in the next minor. */
-export function routesToComputerUse(config) {
-    return isComputerUseComposition(config);
-}
-/** @deprecated Use `routeOf`. This goes in the next minor. */
-export function routesToSharedWorld(config) {
-    return isSharedWorldComposition(config);
-}
-/** @deprecated Use `routeOf`. This goes in the next minor. */
-export function routesToProvisionedSharedWorld(config) {
-    return isProvisionedSharedWorldComposition(config);
-}
-/** @deprecated Use `routeOf`. This goes in the next minor. */
-export function routesToExternalPublicSharedWorld(config) {
-    return isExternalPublicSharedWorldComposition(config);
-}
 /**
- * @deprecated Every shared-world study runs its participants at once since the sequential
- * shared-world route was removed. Use `routeOf`; this alias goes in the next minor.
+ * The route a config takes. It never refuses: a config no route can run still gets the route
+ * whose own checks refuse it with the most precise reason.
  */
-export function routesToConcurrentSharedWorld(config) {
-    return isSharedWorldComposition(config);
-}
-/** @deprecated Use `routeOf`. This goes in the next minor. */
-export function routesToScriptedBrowser(config) {
-    return isScriptedBrowserComposition(config);
-}
-/** @deprecated Use `routeOf`. This goes in the next minor. */
-export function routesToTerminalProduct(config) {
-    return isTerminalProductComposition(config);
+export function routeOf(config) {
+    const source = config.subject.source;
+    // A scripted-browser actor on a loopback app or a provisioned clone replays committed steps.
+    if (isScriptedBrowserComposition(config))
+        return "scripted";
+    // A terminal-product subject goes to the terminal route even with an unregistered actor, so that
+    // route refuses the actor instead of another route running something else.
+    if (isTerminalProductComposition(config) || source === "terminal-product")
+        return "terminal";
+    // Checked before computer use: the same composition without the topology declaration runs
+    // independent participants.
+    if (isSharedWorldComposition(config))
+        return "shared-world";
+    // A CLI studied at a desktop is a computer-use study whose subject is a terminal window.
+    if (source === "desktop-cli")
+        return "computer-use";
+    // Every other app-url, clone, local-app or local-tree config goes to computer use, including
+    // ones with an unknown actor: that route refuses the actor, where the preview route would run
+    // no participant at all.
+    if (isComputerUseComposition(config) ||
+        source === "app-url" ||
+        source === "clone" ||
+        source === "local-app" ||
+        source === "local-tree")
+        return "computer-use";
+    // this-repo runs the synthetic preview.
+    return "preview";
 }

package/dist/lab/run-lab-events.d.ts

@@ -1,6 +1,6 @@
 import type { CuaParticipantPlan } from "../routes/computer-use/types.js";
 import type { SubjectPhaseEvent } from "../subject/steps.js";
-import type { RunLabOptions } from "../run-lab.js";
+import type { InternalRunLabOptions } from "../run-lab.js";
 import type { LabRoute } from "./plan.js";
 import type { LabConfig } from "./types.js";
 /** One participant, as the options' callbacks see it. */
@@ -46,11 +46,11 @@ export type LabEvent = {
 };
 /**
  * The literal values to scrub from an onEvent warning: the provider keys and the declared subject
- * env from every env the run could read (the `env` option, each bag's env, process.env), and the
+ * env from every env the run could read (the `env` option and process.env), and the
  * analysis API key. A callback can hold any of them, and its warning is appended after the route
  * sanitized its own.
  */
-export declare function knownSecretValues(config: LabConfig, options: RunLabOptions, forwardedEnv: Readonly<Record<string, string | undefined>> | undefined): string[];
+export declare function knownSecretValues(config: LabConfig, options: InternalRunLabOptions, forwardedEnv: Readonly<Record<string, string | undefined>> | undefined): string[];
 /**
  * The emitter the route hook bags call, or undefined without onEvent. It calls onEvent and never
  * waits for it: a throw or a rejected promise becomes a run warning, scrubbed of `secretValues`.
@@ -58,12 +58,4 @@ export declare function knownSecretValues(config: LabConfig, options: RunLabOpti
 export declare function labEventEmitter(onEvent: ((event: LabEvent) => void | Promise<void>) | undefined, warnings: string[], secretValues: () => string[]): ((event: LabEvent) => void) | undefined;
 /** The computer-use participant plan as a `plan` event: ids, personas, devices and digests. */
 export declare function planEvent(plan: CuaParticipantPlan): LabEvent;
-/** A participant as the route hooks pass it, with the route's own field names. */
-type HookParticipant = {
-    laneId: string;
-    laneIndex: number;
-    laneCount: number;
-};
-export declare const participantOf: (participant: HookParticipant) => ParticipantRef;
 export declare function phaseEvent(event: SubjectPhaseEvent, target: SetupTarget): LabEvent;
-export {};

package/dist/lab/run-lab-events.js

@@ -4,20 +4,12 @@
 import { redactText, scrubLiterals, toErrorMessage } from "../evidence/redaction.js";
 /**
  * The literal values to scrub from an onEvent warning: the provider keys and the declared subject
- * env from every env the run could read (the `env` option, each bag's env, process.env), and the
+ * env from every env the run could read (the `env` option and process.env), and the
  * analysis API key. A callback can hold any of them, and its warning is appended after the route
  * sanitized its own.
  */
 export function knownSecretValues(config, options, forwardedEnv) {
-    const sources = [
-        forwardedEnv,
-        options.env,
-        options.cuaHooks?.env,
-        options.scriptedHooks?.env,
-        options.terminalHooks?.env,
-        options.sharedWorldHooks?.env,
-        process.env,
-    ];
+    const sources = [forwardedEnv, options.env, process.env];
     const names = ["OPENAI_API_KEY", "E2B_API_KEY", "CODEX_API_KEY", ...(config.subject.env ?? [])];
     const values = new Set();
     const add = (value) => {
@@ -28,7 +20,6 @@ export function knownSecretValues(config, options, forwardedEnv) {
     for (const env of sources)
         for (const name of names)
             add(env?.[name]);
-    add(options.automaticAnalysis?.deps?.apiKey);
     return [...values];
 }
 /**
@@ -77,11 +68,6 @@ export function planEvent(plan) {
         })),
     };
 }
-export const participantOf = (participant) => ({
-    id: participant.laneId,
-    index: participant.laneIndex,
-    count: participant.laneCount,
-});
 export function phaseEvent(event, target) {
     return {
         type: "subject-phase",

package/dist/lab/run-lab-homes.d.ts

@@ -0,0 +1,76 @@
+import type { CuaExecutor, CuaProvider } from "../actors/computer-use/loop.js";
+import type { E2BDesktopSandbox } from "../substrates/e2b/sdk.js";
+import type { AdapterScorerModule } from "./adapter-scorer-loader.js";
+import type { LabEvent, ParticipantRef, SetupTarget } from "./run-lab-events.js";
+import type { LabConfig } from "./types.js";
+/** What `createProvider` receives for each participant. */
+export interface ProviderContext {
+    readonly config: LabConfig;
+    readonly participant: ParticipantRef;
+    readonly executor: CuaExecutor;
+}
+export type ProviderFactory = (ctx: ProviderContext) => Promise<CuaProvider>;
+/** The caller's executor for an in-process run, built once for the run's single participant. */
+export interface InProcessDriver {
+    executor: (ctx: {
+        config: LabConfig;
+        appUrl: string;
+    }) => Promise<CuaExecutor>;
+}
+interface StreamEventIds {
+    participantId: string;
+    /**
+     * The id of this participant's entry in run.json `simulations[]` (`sim-001`), which
+     * `streams[].simId` also holds.
+     */
+    recordId: string;
+    streamId: string;
+}
+type StreamEventFields = (StreamEventIds & {
+    type: "ready";
+    sandboxId: string;
+    /** Runtime only: carries an auth key and must never be persisted. */
+    url: string;
+}) | (StreamEventIds & {
+    type: "ended";
+});
+export type StreamEvent = StreamEventFields & {
+    /**
+     * @deprecated Use `recordId`, which holds the same value. Reading it warns once per process; the
+     * next minor removes it.
+     */
+    readonly simId: string;
+};
+/** A stream event as the routes report it, with `simId` as a getter over `recordId`. */
+export declare function streamEvent(fields: StreamEventFields): StreamEvent;
+/** The options with a typed home, common to every route. */
+export interface RunLabHomes {
+    /** Keys and subject env for the run. Defaults to process.env. */
+    env?: Readonly<Record<string, string | undefined>>;
+    /**
+     * Scores the assembled evidence: computer use, shared world and terminal. A scorer written for
+     * one context passes through `browserScorer` or `terminalScorer`; one that narrows `ctx` at
+     * runtime passes as it is.
+     */
+    scorer?: AdapterScorerModule;
+    /** E2B only. Runs after the sandbox exists and before provisioning, once per target. */
+    prepareDesktop?: (desktop: E2BDesktopSandbox, target: SetupTarget) => Promise<void>;
+    /**
+     * Passive. Never awaited; a throw or a rejected promise becomes a run warning. It observes and
+     * changes no output: subject phases still go to stderr.
+     */
+    onEvent?: (event: LabEvent) => void | Promise<void>;
+    /** Awaited after a participant's live stream starts, and again after its sandbox is gone. */
+    onStream?: (event: StreamEvent) => Promise<void> | void;
+    /** Cancels post-run analysis only. */
+    analysisSignal?: AbortSignal;
+}
+/** Brain and in-process driving. An in-process executor needs a provider: it returns no frame. */
+export type RunLabDriving = {
+    inProcess?: undefined;
+    createProvider?: ProviderFactory;
+} | {
+    inProcess: InProcessDriver;
+    createProvider: ProviderFactory;
+};
+export {};

package/dist/lab/run-lab-homes.js

@@ -0,0 +1,7 @@
+// The public RunLabOptions homes that every route reads: env, scorer, prepareDesktop, onEvent,
+// onStream and analysisSignal, and the brain and in-process driving computer use takes.
+import { withDeprecatedFields } from "./deprecated-fields.js";
+/** A stream event as the routes report it, with `simId` as a getter over `recordId`. */
+export function streamEvent(fields) {
+    return withDeprecatedFields({ ...fields }, { name: "StreamEvent", code: "HUMANISH_STREAM_EVENT_FIELD_DEPRECATED" }, { simId: { replacement: "recordId", read: () => fields.recordId } });
+}

package/dist/lab/run-lab-options.d.ts

@@ -1,82 +1,28 @@
-import type { CuaExecutor, CuaProvider } from "../actors/computer-use/loop.js";
-import { type CuaActorLabHooks } from "../routes/computer-use/types.js";
-import type { E2BDesktopSandbox } from "../substrates/e2b/sdk.js";
-import type { AdapterScorerModule } from "./adapter-scorer-loader.js";
-import type { LabOutcome, RunLabOptions } from "../run-lab.js";
+import type { InternalRunLabOptions, LabOutcome, RunLabOptions } from "../run-lab.js";
 import { type LabRoute } from "./plan.js";
 import type { LabConfig } from "./types.js";
-import { type LabEvent, type ParticipantRef, type SetupTarget } from "./run-lab-events.js";
-/** What `createProvider` receives for each participant. */
-export interface ProviderContext {
-    readonly config: LabConfig;
-    readonly participant: ParticipantRef;
-    readonly executor: CuaExecutor;
-}
-type ProviderFactory = (ctx: ProviderContext) => Promise<CuaProvider>;
-type StreamEvent = 
-/** Runtime only: `url` carries an auth key and must never be persisted. */
-{
-    type: "ready";
-    participantId: string;
-    sandboxId: string;
-    simId: string;
-    streamId: string;
-    url: string;
-} | {
-    type: "ended";
-    participantId: string;
-    simId: string;
-    streamId: string;
-};
-/** The options with a typed home, common to every route. */
-export interface RunLabHomes {
-    /** Keys and subject env for the run. Defaults to process.env. */
-    env?: Readonly<Record<string, string | undefined>>;
-    /** Scores the assembled evidence: computer use, shared world and terminal. */
-    scorer?: AdapterScorerModule;
-    /** E2B only. Runs after the sandbox exists and before provisioning, once per target. */
-    prepareDesktop?: (desktop: E2BDesktopSandbox, target: SetupTarget) => Promise<void>;
-    /**
-     * Passive. Never awaited; a throw or a rejected promise becomes a run warning. It observes and
-     * changes no output: subject phases still go to stderr.
-     */
-    onEvent?: (event: LabEvent) => void | Promise<void>;
-    /** Awaited after a participant's live stream starts, and again after its sandbox is gone. */
-    onStream?: (event: StreamEvent) => Promise<void> | void;
-    /** Cancels post-run analysis only. */
-    analysisSignal?: AbortSignal;
-}
-/** Brain and in-process driving. An in-process executor needs a provider: it returns no frame. */
-export type RunLabDriving = {
-    inProcess?: undefined;
-    createProvider?: ProviderFactory;
-} | {
-    inProcess: {
-        executor: (ctx: {
-            config: LabConfig;
-            appUrl: string;
-        }) => Promise<CuaExecutor>;
-    };
-    createProvider: ProviderFactory;
-};
+import { type LabEvent } from "./run-lab-events.js";
 type Refusal = {
     ok: false;
-    code: "HUMANISH_LAB_OPTION_CONFLICT" | "HUMANISH_LAB_OPTION_UNSUPPORTED";
+    code: "HUMANISH_STUDY_OPTION_UNSUPPORTED";
     message: string;
 };
 type Normalized = {
     ok: true;
-    /** The options with every new field mapped into the old bags and removed. */
-    options: RunLabOptions;
+    /** The options the route reads: onEvent removed, env copied. */
+    options: InternalRunLabOptions;
     /** Filled by onEvent failures while the run runs; runLab appends them to the result. */
     warnings: string[];
+    /** Calls onEvent and never waits for it, or undefined without onEvent. The routes report through it. */
+    emit: ((event: LabEvent) => void) | undefined;
 };
+/** The refusal for a field a JavaScript caller passed that RunLabOptions no longer has. */
+export declare function removedOptionRefusal(options: RunLabOptions): Refusal | undefined;
 /**
- * Refuse what the route cannot honor, then map the new options into the old bags. Nothing here
- * touches the filesystem, so a refusal leaves no run directory, receipt or sandbox.
+ * Refuse what the route cannot honor, copy env, and build the emitter onEvent receives through.
+ * Nothing here touches the filesystem, so a refusal leaves no run directory, receipt or sandbox.
  */
-export declare function normalizeRunLabOptions(config: LabConfig, route: LabRoute, options: RunLabOptions): Normalized | Refusal;
-export declare function scorerHooks(scorer: AdapterScorerModule): Pick<CuaActorLabHooks, "score" | "deriveFeedback" | "deriveArtifacts">;
+export declare function normalizeRunLabOptions(config: LabConfig, route: LabRoute, options: InternalRunLabOptions): Normalized | Refusal;
 /** A refusal in the route's own result envelope, before any run exists. */
 export declare function optionRefusalOutcome(config: LabConfig, route: LabRoute, options: RunLabOptions, refusal: Refusal): LabOutcome;
 export {};