@basein/runner 0.2.12 → 0.3.1

package/dist/bin/investigate.js

@@ -17,6 +17,7 @@
  * declined and what mode armed; the service knows the baseline, the ledger and
  * whether a run ever became a recording. Both lists are printed, worst first.
  */
+import { ReadClock, jsonText, readWithin, serviceProblem, underMcp, unreachable } from "./service-read.js";
 const num = (v) => {
     if (v === undefined || v === null || v === "")
         return undefined;
@@ -170,8 +171,8 @@ export const DECLINES = {
         fix: "wait for the calculation, or start one with `bir scenario calc <runId>`, then run the prompt again.",
     },
     similarity: {
-        cause: "the prompt was a hit on the recording but below the steering threshold (BIR_REPLAY_MIN_SIMILARITY, default 0.92).",
-        fix: "phrase the prompt closer to the recorded one, or lower BIR_REPLAY_MIN_SIMILARITY.",
+        cause: "the prompt was a hit on the recording but below the steering threshold (BIR_MIN_STEER_SIMILARITY, default 0.92).",
+        fix: "phrase the prompt closer to the recorded one, or lower BIR_MIN_STEER_SIMILARITY.",
     },
     coverage: {
         cause: "no step of the scenario could run anywhere: its tools are neither wrapped MCP servers registered in this session nor built-ins.",
@@ -435,16 +436,22 @@ export function renderService(out, s, viewerIsOwner) {
     renderFindings(out, s.findings ?? [], "Service findings");
 }
 // ── the command ───────────────────────────────────────────────────────────────
-async function fetchInvestigation(deps, id, limit) {
-    const reply = await deps.service(`/investigate/${id}${limit ? `?limit=${limit}` : ""}`);
-    if ("error" in reply)
-        return { note: `service not consulted: ${reply.error}` };
+async function fetchInvestigation(deps, id, limit, clock) {
+    const reply = await clock.within(deps.service(`/investigate/${id}${limit ? `?limit=${limit}` : ""}`));
+    if ("error" in reply) {
+        return { note: `service not consulted: ${serviceProblem(reply.error)}`, unreachable: unreachable(reply.error) };
+    }
     if (reply.status === 404)
         return { note: `the service has nothing for ${id} (not yours, or never reached it)` };
     if (reply.status !== 200)
         return { note: `service answered HTTP ${reply.status}` };
     return { data: reply.body };
 }
+/** A turn without its raw journal lines, which only a person reading the whole record wants. */
+function withoutEvents(turn) {
+    const { events, ...rest } = turn;
+    return { ...rest, eventCount: events.length };
+}
 /** Which id the service should be asked about for a turn. */
 function serviceIdFor(turn) {
     return (turn.reported?.ticket ??
@@ -463,9 +470,10 @@ export async function investigateCommand(args, deps) {
             params.set("limit", String(args.limit));
         if (args.user)
             params.set("user", args.user);
-        const reply = await deps.service(`/investigate/executions${params.size ? `?${params}` : ""}`);
+        const reply = await readWithin(deps.service(`/investigate/executions${params.size ? `?${params}` : ""}`));
         if ("error" in reply) {
-            out(`Could not reach the service: ${reply.error}`);
+            const words = serviceProblem(reply.error);
+            out(`Could not reach the service: ${words}${words === reply.error ? "" : ` (${reply.error})`}`);
             return 1;
         }
         if (reply.status === 403) {
@@ -482,7 +490,7 @@ export async function investigateCommand(args, deps) {
         }
         const body = reply.body;
         if (args.json) {
-            out(JSON.stringify(body, null, 2));
+            out(jsonText(body));
             return 0;
         }
         const rows = body.executions ?? [];
@@ -503,7 +511,7 @@ export async function investigateCommand(args, deps) {
         const limit = args.limit ?? 20;
         const recent = turns.slice(-limit).reverse();
         if (args.json) {
-            out(JSON.stringify(recent, null, 2));
+            out(jsonText(underMcp() ? recent.map(withoutEvents) : recent));
             return 0;
         }
         if (recent.length === 0) {
@@ -550,14 +558,31 @@ export async function investigateCommand(args, deps) {
     }
     const findings = turn ? localFindings(turn) : [];
     const serviceId = turn ? serviceIdFor(turn) : id;
-    const service = await fetchInvestigation(deps, serviceId, args.limit);
+    // Both reads below share one bound, so a slow "no" followed by a held
+    // second try still ends inside the time the `bir` MCP server allows a
+    // reading tool — with the journal half, which needed no service at all.
+    const clock = new ReadClock();
+    const service = await fetchInvestigation(deps, serviceId, args.limit, clock);
     // A matched turn's own run id is unknown to the service; when the scenario
-    // lookup fails, the matched run is still worth a try.
-    const fallbackId = turn && service.note && turn.matched?.runId && serviceId !== turn.matched.runId ? turn.matched.runId : undefined;
-    const second = fallbackId ? await fetchInvestigation(deps, fallbackId, args.limit) : undefined;
+    // lookup fails, the matched run is still worth a try — unless the service
+    // could not be reached at all, when a second try only doubles the wait, or
+    // the bound is spent.
+    const fallbackId = turn &&
+        service.note &&
+        !service.unreachable &&
+        turn.matched?.runId &&
+        serviceId !== turn.matched.runId &&
+        clock.remaining() > 0
+        ? turn.matched.runId
+        : undefined;
+    const second = fallbackId ? await fetchInvestigation(deps, fallbackId, args.limit, clock) : undefined;
     const chosen = service.data ? service : second?.data ? second : service;
     if (args.json) {
-        out(JSON.stringify({ turn: turn ?? null, findings, service: chosen.data ?? null, note: chosen.note ?? null }, null, 2));
+        // For a model (the `bir` MCP server), the turn goes without its raw
+        // journal lines: every field they carry is already parsed into the turn,
+        // and a long turn's lines are most of the output.
+        const shown = turn ? (underMcp() ? withoutEvents(turn) : turn) : null;
+        out(jsonText({ turn: shown, findings, service: chosen.data ?? null, note: chosen.note ?? null }));
         return 0;
     }
     if (turn) {

package/dist/bin/scenario-edit.d.ts

@@ -143,7 +143,13 @@ export interface ScenarioEditArgs {
 }
 /** The `bir scenario` words this module answers; `list` and `replay` stay in bir.ts. */
 export declare const SCENARIO_EDIT_SUBCOMMANDS: ReadonlySet<string>;
-/** The `bir` MCP server's tools that only read: always offered (D2). */
+/**
+ * The `bir` MCP server's tools that only read. Offered with scenario editing
+ * on, or where the server's environment has `BIR_SCENARIO_TOOLS=read` — no
+ * longer in every session: their definitions ride along with every request a
+ * session makes, and only somebody working on a scenario ever calls them (the
+ * same answers are `bir scenario show` and `bir investigate` in a terminal).
+ */
 export declare const READ_TOOLS: readonly ["scenario_show", "scenario_edits", "investigate"];
 /** The ones that change a scenario: offered only after `bir scenario editing on` (D2). */
 export declare const EDIT_TOOLS: readonly ["scenario_check", "scenario_edit", "scenario_undo"];

package/dist/bin/scenario-edit.js

@@ -31,6 +31,7 @@
 import { normalizePath } from "../control/paths.js";
 import { SCENARIO_SERVER_KEY, editingEnabled, projectRecord, readSidecar, setEditing, writeSidecar, } from "../config/generate.js";
 import { errText } from "../util/log.js";
+import { ReadClock, jsonText, readWithin, serviceProblem } from "./service-read.js";
 /** The `bir scenario` words this module answers; `list` and `replay` stay in bir.ts. */
 export const SCENARIO_EDIT_SUBCOMMANDS = new Set([
     "show",
@@ -41,7 +42,13 @@ export const SCENARIO_EDIT_SUBCOMMANDS = new Set([
     "calc",
     "editing",
 ]);
-/** The `bir` MCP server's tools that only read: always offered (D2). */
+/**
+ * The `bir` MCP server's tools that only read. Offered with scenario editing
+ * on, or where the server's environment has `BIR_SCENARIO_TOOLS=read` — no
+ * longer in every session: their definitions ride along with every request a
+ * session makes, and only somebody working on a scenario ever calls them (the
+ * same answers are `bir scenario show` and `bir investigate` in a terminal).
+ */
 export const READ_TOOLS = ["scenario_show", "scenario_edits", "investigate"];
 /** The ones that change a scenario: offered only after `bir scenario editing on` (D2). */
 export const EDIT_TOOLS = ["scenario_check", "scenario_edit", "scenario_undo"];
@@ -91,7 +98,7 @@ async function show(args, deps) {
     if (!target)
         return usageError(deps, "show");
     const byScenario = target.startsWith("scn_");
-    const reply = await deps.service("GET", byScenario ? `/scenarios/${seg(target)}` : `/recordings/runs/${seg(target)}/scenario`);
+    const reply = await readWithin(deps.service("GET", byScenario ? `/scenarios/${seg(target)}` : `/recordings/runs/${seg(target)}/scenario`));
     if ("error" in reply || reply.status !== 200) {
         return explain(reply, args, deps, {
             verb: "Could not read the scenario",
@@ -102,7 +109,7 @@ async function show(args, deps) {
         });
     }
     if (args.step === undefined) {
-        out(JSON.stringify(reply.body, null, 2));
+        out(jsonText(reply.body));
         return 0;
     }
     const served = reply.body;
@@ -119,7 +126,7 @@ async function show(args, deps) {
         out(`${scenario.id ?? target} has no step ${args.step}${indexes.length ? ` (its steps are ${Math.min(...indexes)}–${Math.max(...indexes)})` : " (it has no steps)"}.`);
         return 1;
     }
-    out(JSON.stringify({ scenarioId: scenario.id ?? null, chainRevision: scenario.chainRevision ?? null, ...step }, null, 2));
+    out(jsonText({ scenarioId: scenario.id ?? null, chainRevision: scenario.chainRevision ?? null, ...step }));
     return 0;
 }
 /**
@@ -184,7 +191,7 @@ async function checkOrEdit(args, deps, save) {
             return explain(reply, args, deps, { verb: "Not checked", ...explained });
         const report = reply.body?.report;
         if (args.json) {
-            out(JSON.stringify(reply.body, null, 2));
+            out(jsonText(reply.body));
             return report?.ok || report?.noChange ? 0 : 1;
         }
         if (!report) {
@@ -225,7 +232,7 @@ async function checkOrEdit(args, deps, save) {
         return explain(reply, args, deps, { verb: "Not saved", ...explained });
     }
     if (args.json) {
-        out(JSON.stringify(reply.body, null, 2));
+        out(jsonText(reply.body));
         return refused ? 1 : 0;
     }
     if (answer?.report)
@@ -489,7 +496,7 @@ function refusal(out, report, opening, hint) {
 }
 // ── edits / undo ──────────────────────────────────────────────────────────────
 async function fetchEdits(scenarioId, deps) {
-    const reply = await deps.service("GET", `/scenarios/${seg(scenarioId)}/edits`);
+    const reply = await readWithin(deps.service("GET", `/scenarios/${seg(scenarioId)}/edits`));
     if ("error" in reply || reply.status !== 200)
         return { reply };
     const edits = reply.body?.edits;
@@ -500,15 +507,18 @@ async function listEdits(args, deps) {
     const target = args.positionals[1];
     if (!target)
         return usageError(deps, "edits");
-    const resolved = await resolveTarget(target, args, deps);
+    // A `run_` id is two reads — which scenario, then its history — inside one
+    // bound: the `bir` MCP server gives a reading tool one read's worth of time.
+    const clock = new ReadClock();
+    const resolved = await resolveTarget(target, args, deps, clock);
     if ("code" in resolved)
         return resolved.code;
-    const reply = await deps.service("GET", `/scenarios/${seg(resolved.id)}/edits`);
+    const reply = await clock.within(deps.service("GET", `/scenarios/${seg(resolved.id)}/edits`));
     if ("error" in reply || reply.status !== 200) {
         return explain(reply, args, deps, { verb: "Could not read the history", target });
     }
     if (args.json) {
-        out(JSON.stringify(reply.body, null, 2));
+        out(jsonText(reply.body));
         return 0;
     }
     const edits = reply.body?.edits ?? [];
@@ -626,7 +636,7 @@ async function undo(args, deps) {
         });
     }
     if (args.json) {
-        out(JSON.stringify(reply.body, null, 2));
+        out(jsonText(reply.body));
         return refused ? 1 : 0;
     }
     if (answer?.report)
@@ -687,7 +697,7 @@ async function calc(args, deps) {
     if ("error" in reply)
         return explain(reply, args, deps, { verb: "Could not start calculation", target });
     if (args.json) {
-        out(JSON.stringify(reply.body ?? null, null, 2));
+        out(jsonText(reply.body ?? null));
         return reply.status === 202 ? 0 : 1;
     }
     const { status, body } = reply;
@@ -771,11 +781,19 @@ function describeEditing(out, sidecar, cwd) {
     if (!hasScenarioServer(sidecar, cwd)) {
         out("  (no `bir` MCP server is installed here, so no tool is offered at all — `bir install --replay` adds it)");
     }
-    out(`  the bir MCP server offers  ${READ_TOOLS.join(", ")}  (they read)`);
-    if (on)
+    // The reading tools come with the switch too: they are for whoever is
+    // working on a scenario, and every other session would pay for their
+    // definitions on every request without ever calling them.
+    if (on) {
+        out(`  the bir MCP server offers  run_scenario, ${READ_TOOLS.join(", ")}  (they read)`);
         out(`                        and  ${EDIT_TOOLS.join(", ")}  (they change a scenario)`);
-    else
+    }
+    else {
+        out("  the bir MCP server offers  run_scenario");
         out(`  \`bir scenario editing on\` adds ${EDIT_TOOLS.join(", ")}  (they change a scenario)`);
+        out(`                        and  ${READ_TOOLS.join(", ")}  (they read)`);
+        out("  (BIR_SCENARIO_TOOLS=read in the server's environment offers the reading ones alone)");
+    }
     out("  The `bir scenario` commands work either way: this switch decides only the MCP tools.");
 }
 function hasScenarioServer(sidecar, cwd) {
@@ -796,7 +814,7 @@ function usageError(deps, sub, why) {
  * `{error, details}` shape (with `extra` beside them when there is more to say).
  */
 function localFailure(args, deps, code, text, extra = {}) {
-    deps.out(args.json ? JSON.stringify({ error: code, details: text, ...extra }, null, 2) : text);
+    deps.out(args.json ? jsonText({ error: code, details: text, ...extra }) : text);
     return 1;
 }
 /**
@@ -822,10 +840,10 @@ function noWholeRunScenario(target, segments, args, deps) {
  * `scn_` id (D7). A `run_` id reaches only the run's **whole-run** scenario; a
  * `scn_` id is used as it is — sub-task scenarios have nothing else.
  */
-async function resolveTarget(target, args, deps) {
+async function resolveTarget(target, args, deps, clock = new ReadClock()) {
     if (target.startsWith("scn_"))
         return { id: target };
-    const reply = await deps.service("GET", `/recordings/runs/${seg(target)}/scenario`);
+    const reply = await clock.within(deps.service("GET", `/recordings/runs/${seg(target)}/scenario`));
     if ("error" in reply || reply.status !== 200) {
         return {
             code: explain(reply, args, deps, {
@@ -849,14 +867,18 @@ async function resolveTarget(target, args, deps) {
 function explain(reply, args, deps, e) {
     const { out } = deps;
     if ("error" in reply) {
+        // In words, not the transport's ("fetch failed"): this is what reaches a
+        // model through the `bir` MCP server. A person at a terminal also gets the
+        // raw reason in brackets, for a bug report.
+        const words = serviceProblem(reply.error);
         if (args.json)
-            out(JSON.stringify({ error: "service_unreachable", details: reply.error }, null, 2));
+            out(jsonText({ error: "service_unreachable", details: words }));
         else
-            out(`Could not reach the service: ${reply.error}`);
+            out(`Could not reach the service: ${words}${words === reply.error ? "" : ` (${reply.error})`}`);
         return 1;
     }
     if (args.json) {
-        out(JSON.stringify(reply.body ?? null, null, 2));
+        out(jsonText(reply.body ?? null));
         return 1;
     }
     const body = (reply.body && typeof reply.body === "object" ? reply.body : {});

package/dist/bin/scenario-liveness.d.ts

@@ -0,0 +1,194 @@
+/**
+ * scenario-liveness — the two things `bir-scenario` does besides answering MCP:
+ * it tells its project's recorder that a delivery tool is live
+ * (`POST /scenario/hello`), and it brings back a recorder that died
+ * mid-session (`bir-hooks revive`).
+ *
+ * WHY HELLO. A direct plan tells the model to call `mcp__bir__run_scenario`
+ * before any other tool. The control server used to announce one whenever the
+ * MCP config listed the `bir` server — but a configured server is not a
+ * connected one: a stale node path, a crash, the server disabled in `/mcp`, or
+ * a session run with `BIR_OFF=1` (which lists no tools) all leave the model
+ * told to call a tool it does not have. So this server says, on `initialize`,
+ * on `tools/list`, when the off switch flips, whenever its recorder changes,
+ * and every {@link HELLO_EVERY_MS} while it runs: this pid, this version, this
+ * many tools, off or not. The control server announces a direct plan only on
+ * the word of a live pid that lists a tool.
+ *
+ * WHY REVIVE. Every hook but SessionStart is an HTTP post to the recorder.
+ * With the recorder gone — killed by an antivirus, out of memory — Claude Code
+ * shows a hook error on every prompt and tool call until the next session
+ * start, `/clear` or compaction, because nothing else starts one mid-session.
+ * This server is the one long-lived process in every session of an installed
+ * project, wrapped servers or none, so it starts `bir-hooks revive --cwd <dir>`
+ * (which runs the ordinary ensure, under the ordinary start lock).
+ *
+ * NEITHER MAY COST THE SESSION ANYTHING.
+ *   - A hello is fire-and-forget: nothing on the MCP path awaits it, it is
+ *     bounded by {@link HELLO_TIMEOUT_MS}, one is in flight at a time, and a
+ *     recorder that cannot take it (not up yet, busy, an older version with no
+ *     such route) costs a retry later, never an error.
+ *   - A revive is a detached child that is never waited for, and it is started
+ *     only when the discovery file names a pid that is DEAD and the recorder's
+ *     address REFUSES the connection. A recorder that is alive but slow is never
+ *     replaced (that is how duplicates that cannot bind were made). A missing
+ *     discovery file is never revived either: `bir down` removes it, and a
+ *     recorder somebody stopped on purpose stays stopped. Only an installed
+ *     project is revived, at most once per {@link REVIVE_EVERY_MS} per process
+ *     (after a random wait of up to {@link REVIVE_JITTER_MS}, so the several
+ *     processes of a session that see the same death do not all start one),
+ *     less often each time a revive did not bring a recorder back, and not in
+ *     the server's first {@link REVIVE_GRACE_MS}, while the SessionStart hook
+ *     is starting the recorder itself.
+ *   - Neither writes a byte to stdout (the host's JSON-RPC stream), and
+ *     neither throws.
+ */
+/** A hello waits no longer than this for the recorder's answer. */
+export declare const HELLO_TIMEOUT_MS = 1000;
+/** A hello is repeated this often while the server runs (the recorder trusts one for 30 min). */
+export declare const HELLO_EVERY_MS: number;
+/**
+ * How often the discovery file is looked at: whether the recorder changed (a
+ * hello is owed to the new one) or died (a revive may be). One `stat`, and a
+ * parse only when the file changed.
+ */
+export declare const WATCH_EVERY_MS = 2000;
+/** At most one revive per this long per process; doubled each time one did not help. */
+export declare const REVIVE_EVERY_MS = 30000;
+/** The longest a revive waits, at random, before it looks again and starts. */
+export declare const REVIVE_JITTER_MS = 5000;
+/** The longest wait between revives that did not bring a recorder back. */
+export declare const REVIVE_MAX_EVERY_MS: number;
+/**
+ * No revive in a server's first this-long: it starts with the session, and so
+ * does the SessionStart hook, whose own ensure (up to 11 s, ensure-hook.ts) is
+ * what starts the recorder then — typically over a dead record left from
+ * before a reboot. Reviving beside it would only race it.
+ */
+export declare const REVIVE_GRACE_MS = 12000;
+/** How long the "does anything listen there" probe waits before calling the recorder busy. */
+export declare const REFUSED_PROBE_MS = 2000;
+/** What a hello says. */
+export interface HelloBody {
+    pid: number;
+    version: string;
+    /** How many tools this server lists now (0 when off). */
+    tools: number;
+    off: boolean;
+}
+/** A discovery record as written, its pid not yet checked. */
+export interface RecorderRecord {
+    url: string;
+    token: string;
+    pid: number;
+}
+/** How a request to the recorder's address ended. */
+export type Reach = "answered" | "refused" | "timeout" | "error";
+/**
+ * This project's discovery record, whether or not its pid is alive — the
+ * shared reader drops a dead pid's record, and a dead pid is exactly what a
+ * revive needs to see. Parsed again only when the file changed. Never throws.
+ */
+export declare function readRecorderRecord(cwd: string): RecorderRecord | undefined;
+/** Whether `cwd` is a project `bir setup`/`bir install` put the runner in. Never throws. */
+export declare function projectInstalled(cwd: string): boolean;
+/**
+ * Start `bir-hooks revive --cwd <cwd>` from this package, detached, and forget
+ * it: it reads nothing, writes nothing we could see, and exits by itself.
+ */
+export declare function launchRevive(cwd: string): Promise<void>;
+export interface LivenessOptions {
+    /** The project this server runs for. */
+    cwd: string;
+    /** What this server lists now. Called for every hello. */
+    state: () => {
+        tools: number;
+        off: boolean;
+    };
+    now?: () => number;
+    random?: () => number;
+    fetch?: typeof fetch;
+    record?: (cwd: string) => RecorderRecord | undefined;
+    alive?: (pid: number) => boolean;
+    installed?: (cwd: string) => boolean;
+    launch?: (cwd: string) => Promise<void> | void;
+    sleep?: (ms: number) => Promise<void>;
+    env?: NodeJS.ProcessEnv;
+    /** Default {@link REVIVE_GRACE_MS}. */
+    reviveGraceMs?: number;
+}
+/** See the module comment. One per `bir-scenario` process. */
+export declare class ScenarioLiveness {
+    private readonly opts;
+    private readonly cwd;
+    private readonly now;
+    private readonly random;
+    private readonly fetchImpl;
+    private readonly record;
+    private readonly alive;
+    private readonly installed;
+    private readonly launch;
+    private readonly sleep;
+    private readonly env;
+    private timer;
+    private stopped;
+    /** No revive before this (see {@link REVIVE_GRACE_MS}). */
+    private readonly reviveFrom;
+    private helloBusy;
+    /** A hello asked for while one was in flight: sent when it ends, with the state as it is then. */
+    private helloOwed;
+    /** The recorder the last hello was answered by (`url#pid`). */
+    private reached;
+    /** The recorder the last hello was sent to, answered or not. */
+    private tried;
+    private lastHelloAt;
+    private helloFailures;
+    private helloNotBefore;
+    private reviveBusy;
+    private reviveNotBefore;
+    /** Revives started since a recorder was last seen alive. */
+    private revivesInARow;
+    /** When this process last started one (0: never). */
+    private lastReviveAt;
+    /** Revives started by this process. */
+    revives: number;
+    /** Hellos a recorder answered. */
+    hellos: number;
+    constructor(opts: LivenessOptions);
+    /** Watch the discovery file every {@link WATCH_EVERY_MS}, on a timer that never keeps the process alive. */
+    start(everyMs?: number): void;
+    /** The host is gone: nothing more is sent or started. */
+    stop(): void;
+    /**
+     * Tell the recorder what this server lists, now — or, while a hello is in
+     * flight, as soon as it ends. Returns at once; never throws.
+     */
+    hello(why: string): void;
+    /**
+     * Something on the MCP path found no recorder (`run_scenario` found no live
+     * discovery file, or its request was refused): look now rather than at the
+     * next tick. Returns at once; never throws.
+     */
+    recorderGone(why: string): void;
+    /** One look at the discovery file. Exposed for tests; never throws. */
+    tick(): Promise<void>;
+    /**
+     * Where a hello goes, the way `run_scenario`'s request does: `BIR_CONTROL_URL`
+     * (with `BIR_CONTROL_TOKEN`, or the discovery file's token), else the
+     * discovery file — whose pid must be alive.
+     */
+    private target;
+    private state;
+    private sendHello;
+    /** Whether anything listens at `url`: only a refused connection counts as nothing. */
+    private probe;
+    /**
+     * A recorder is up: the revives before it helped (or were not needed), so the
+     * next death waits the plain {@link REVIVE_EVERY_MS} since the last one, not
+     * a doubled wait.
+     */
+    private recorderSeenAlive;
+    /** Start a revive if — and only if — the recorder is dead, refused and this project's. */
+    private checkRevive;
+}
+//# sourceMappingURL=scenario-liveness.d.ts.map