@unotest/web 0.42.0 → 0.43.1

package/dist/dsl/index.d.ts

@@ -4,8 +4,8 @@ import { Matcher, RegexLiteral, JudgeRequest, JudgeVerdict, SoftFailureRecord }
 import { ExecutionWalker, ExecutionEvent, RunResult, RunOptions } from '@unotest/dsl/executor';
 export { ExecutionError, ExecutionEvent, RunOptions, RunResult } from '@unotest/dsl/executor';
 import { SandboxConfig } from '../config/schema.js';
-import { RuntimeExecState } from '@unotest/core';
-export { L as LintDiagnostic, b as LintOptions, a as LintSeverity, l as lintAst } from '../linter-Yf4gPe5J.js';
+import { UnotestError, RuntimeExecState } from '@unotest/core';
+export { L as LintDiagnostic, b as LintOptions, a as LintSeverity, l as lintAst } from '../linter-BWSAYBQy.js';
 import 'zod';
 import '@unotest/dsl';
 
@@ -69,6 +69,50 @@ declare function chainGetByTitle(loc: LocatorValue, text: Matcher, options?: {
     exact?: boolean;
 }): LocatorValue;
 
+/** Configuration invalid or missing. Surfaces during config load / validation. */
+declare class ConfigError extends UnotestError {
+}
+/** A host the run would reach came from the BASE `.env` while a named
+ *  environment is active (#199). Silence here is the whole defect: the
+ *  overlay says "dev", the request goes to the production host the base
+ *  file names, and nothing in the output says which host was used. The
+ *  message names the variable, BOTH files, and the two ways out. */
+declare class EnvOverlayHostError extends ConfigError {
+    constructor(context: {
+        name: string;
+        /** Where the name becomes a host, quoted as the author wrote it —
+         *  `apiCall {base: "API_BASE_CHAT"}`, `goto(APP_URL)`, `baseUrl`. */
+        usage: string;
+        envName: string;
+        /** Project-relative file the value actually came from. */
+        baseFile: string;
+        /** The overlay that does NOT set it — where it belongs. */
+        overlayFile: string;
+    });
+}
+
+/**
+ * What a host-using call site may ask. A narrow port (ISP) so the linter
+ * and the DSL runtime depend on the QUESTION, not on the config layer:
+ * `rejectAsHost` answers with the refusal message, or undefined when the
+ * name is fine to use as a host here.
+ */
+interface HostVariableCheck {
+    rejectAsHost(name: string, usage: string): EnvOverlayHostError | undefined;
+}
+/** The policy as the places that switch environments need it: the same
+ *  question, plus "the same rule, for a different environment". `forEnv`
+ *  carries the config-derived `shared` list ACROSS, which is why the MCP
+ *  server and the child it spawns cannot end up with different lists. */
+interface HostPolicy extends HostVariableCheck {
+    forEnv(envName?: string): HostPolicy;
+    /** The base-URL variable is a host by construction — `APP_BASE_URL`
+     *  becomes `config.baseUrl`, which every relative `goto` resolves
+     *  against. Asked without naming it, so no consumer keeps a second
+     *  literal of the name. */
+    rejectBaseUrl(usage: string): EnvOverlayHostError | undefined;
+}
+
 interface Logger {
     info(msg: string, ...rest: unknown[]): void;
     warn(msg: string, ...rest: unknown[]): void;
@@ -82,6 +126,12 @@ interface Logger {
 interface VariableStore {
     has(name: string): boolean;
     get(name: string): string | undefined;
+    /** Host policy for the environment this store resolves against (#199).
+     *  Optional like `describeSources`: a store built without a project
+     *  behind it (test fakes, ad-hoc runtimes) carries none and the rule is
+     *  then off. `withHostPolicy` (config/env-host-guard.ts) is what puts
+     *  one on a store. */
+    hostPolicy?: HostPolicy;
     /** One-line, human/agent-readable summary of WHERE lookups searched
      *  (active environment + layer files, missing ones flagged). Optional so
      *  test fakes stay two-method; consumed by "variable not found" errors. */
@@ -197,6 +247,11 @@ declare class TestRuntime {
     enterCall(maxCallDepth: number): void;
     exitCall(): void;
     get callDepth(): number;
+    /** Host policy of this run — read off the variable store, which is
+     *  where the project's environment already lives (#199). Deliberately
+     *  NOT a separate injected field: a field the two runtime-building
+     *  sites could forget to pass is a rule that switches itself off. */
+    get hostPolicy(): HostPolicy | undefined;
     setVar(name: string, value: DslValue): void;
     getVar(name: string): DslValue;
     hasVar(name: string): boolean;
@@ -289,6 +344,8 @@ interface ActiveRuntime {
     createdAt: number;
     /** Active TTL timer (only when state is paused-failure). */
     ttlTimer: NodeJS.Timeout | null;
+    /** The runtime's own last-rites hook — see `register`. */
+    onAbort?: () => Promise<void>;
 }
 interface RuntimeSummary {
     id: string;
@@ -336,6 +393,13 @@ declare class TestRuntimeManager {
         testRuntime: TestRuntime;
         generator: AsyncGenerator<ExecutionEvent, RunResult>;
         runOptions: RunOptions;
+        /** Last thing this runtime gets to do when it is aborted, awaited
+         *  inside `abort()`. It exists because an abort on a PAUSE never comes
+         *  back through the orchestrator: the CLI kills the process right
+         *  after `abort` resolves (a paused executor cannot unwind itself), so
+         *  anything the run still owes the disk has to be settled here (#194
+         *  tail). */
+        onAbort?: () => Promise<void>;
     }): string;
     pump(id: string): Promise<ExecutionEvent | RunResult>;
     /** The run's verdict — the executor's own, corrected for the one thing