@reticlehq/server 3.8.2 → 3.10.0

package/dist/language/flows/fields/flow-secret-field.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { z } from 'zod';
 import { AnchorKind } from '@reticlehq/core';
 import { CALL_SECRETS_ARG, callSecrets } from '../../../surface/tools/tool-kit.js';
@@ -14,12 +15,15 @@ import { CALL_SECRETS_ARG, callSecrets } from '../../../surface/tools/tool-kit.j
  * to find the env var because the runner passed a role or a label instead.
  */
 export function anchorFieldName(anchor) {
-    if (AnchorKind.TESTID === anchor.kind)
+    if (AnchorKind.TESTID === anchor.kind) {
         return anchor.value;
-    if (AnchorKind.ROLE === anchor.kind)
+    }
+    if (AnchorKind.ROLE === anchor.kind) {
         return anchor.name;
-    if (AnchorKind.SIGNAL === anchor.kind)
+    }
+    if (AnchorKind.SIGNAL === anchor.kind) {
         return anchor.name;
+    }
     return undefined;
 }
 /**
@@ -39,6 +43,16 @@ export const SECRET_NAME_ARG = 'secret';
 export const SECRET_FIELD_ARG = 'secretField';
 /** The prefix every secret's variable carries. */
 const SECRET_ENV_PREFIX = 'RETICLE_SECRET_';
+/** Any character outside ASCII. */
+const NON_ASCII = /[^\p{ASCII}]/u;
+/** The word in the variable of a field whose name is not ASCII. */
+const NON_ASCII_FIELD = 'FIELD';
+const NON_ASCII_DIGEST_LENGTH = 8;
+/**
+ * The variable name an ASCII field gets. Up to 3.9.0 a non-ASCII field got this name too, and a
+ * flow saved then still names it.
+ */
+const asciiSecretEnvKey = (field) => `${SECRET_ENV_PREFIX}${field.replace(/[^a-zA-Z0-9]+/g, '_').toUpperCase()}`;
 /**
  * The environment variable that supplies one redacted field.
  *
@@ -51,7 +65,16 @@ const SECRET_ENV_PREFIX = 'RETICLE_SECRET_';
  * rules must not be able to drift. It used to sit in `replay.ts`, one import away from the sentence
  * saying it had to stay together.
  */
-export const secretEnvKey = (field) => `${SECRET_ENV_PREFIX}${field.replace(/[^a-zA-Z0-9]+/g, '_').toUpperCase()}`;
+export function secretEnvKey(field) {
+    if (!NON_ASCII.test(field)) {
+        return asciiSecretEnvKey(field);
+    }
+    // A name in another script has no ASCII letters to keep: "Пароль" and "Гасло" both became
+    // `RETICLE_SECRET__`, so one field's value was typed into the other. A short hash of the name
+    // keeps each field's variable distinct and the same on every machine.
+    const digest = createHash('sha256').update(field.normalize('NFC').toLowerCase()).digest('hex');
+    return `${SECRET_ENV_PREFIX}${NON_ASCII_FIELD}_${digest.slice(0, NON_ASCII_DIGEST_LENGTH).toUpperCase()}`;
+}
 /** The schema of that argument, shared by every tool that replays a flow. */
 export { CALL_SECRETS_ARG };
 export const callSecretsArg = z
@@ -64,30 +87,35 @@ export const callSecretsArg = z
  */
 export function secretValue(envKey, env) {
     for (const [key, value] of Object.entries(callSecrets() ?? {})) {
-        if (envKey === (key.startsWith(SECRET_ENV_PREFIX) ? key : secretEnvKey(key)))
+        if (envKey === (key.startsWith(SECRET_ENV_PREFIX) ? key : secretEnvKey(key))) {
             return value;
+        }
     }
     return env[envKey];
 }
 const SECRET_OCCURRENCE = /^(?:[2-9]|[1-9][0-9]+)$/;
 /** The field's own saved variable name, or its original key for legacy and invalid metadata. */
 export function secretKeyForFill(args, field) {
-    if (args?.['value'] !== REDACTED_FILL)
+    if (args?.['value'] !== REDACTED_FILL) {
         return undefined;
+    }
     const named = args[SECRET_NAME_ARG];
     const base = secretEnvKey(field);
-    // A flow can supply this field's occurrence, never an unrelated environment variable.
-    return 'string' === typeof named &&
-        named.startsWith(`${base}_`) &&
-        SECRET_OCCURRENCE.test(named.slice(base.length + 1))
-        ? named
-        : base;
+    // A flow can supply this field's occurrence, never an unrelated environment variable. The name
+    // an earlier version gave a non-ASCII field is still this field's.
+    if ('string' !== typeof named) {
+        return base;
+    }
+    const own = (key) => named === key ||
+        (named.startsWith(`${key}_`) && SECRET_OCCURRENCE.test(named.slice(key.length + 1)));
+    return own(base) || own(asciiSecretEnvKey(field)) ? named : base;
 }
 function* secretSteps(steps) {
     for (const step of steps) {
         yield step;
-        if (step.steps !== undefined)
+        if (step.steps !== undefined) {
             yield* secretSteps(step.steps);
+        }
     }
 }
 /** Allocate recorded fills' names while preserving legacy placeholders and existing suffixes. */
@@ -96,14 +124,17 @@ export function withDistinctSecretKeys(flow) {
     const used = new Set();
     for (const step of secretSteps(flow.steps)) {
         const field = anchorFieldName(step.anchor);
-        if (field === undefined)
+        if (field === undefined) {
             continue;
+        }
         const key = secretKeyForFill(step.args, field);
-        if (key === undefined)
+        if (key === undefined) {
             continue;
+        }
         reserved.add(key);
-        if (key !== secretEnvKey(field) || step.args?.[SECRET_NAME_ARG] === undefined)
+        if (key !== secretEnvKey(field) || step.args?.[SECRET_NAME_ARG] === undefined) {
             used.add(key);
+        }
     }
     const assign = (step) => {
         let out = step;
@@ -119,8 +150,9 @@ export function withDistinctSecretKeys(flow) {
                 occurrence += 1;
             }
             used.add(key);
-            if (key !== base)
+            if (key !== base) {
                 out = { ...step, args: { ...step.args, [SECRET_NAME_ARG]: key } };
+            }
         }
         return step.steps === undefined ? out : { ...out, steps: step.steps.map(assign) };
     };
@@ -138,23 +170,47 @@ export function withDistinctSecretKeys(flow) {
  * non-zero length, so an empty variable leaves the placeholder and must count as unsupplied here.
  * Two different answers to "is this supplied" is how the gate would pass and the replay still fail.
  */
+function* flattenAll(steps) {
+    for (const step of steps) {
+        yield step;
+        yield* flattenAll(step.steps ?? []);
+    }
+}
 export function unsuppliedSecrets(flow, env) {
     const out = [];
     const seen = new Set();
     for (const step of secretSteps(flow.steps ?? [])) {
         const field = anchorFieldName(step.anchor);
-        if (field === undefined)
+        if (field === undefined) {
             continue;
+        }
         const envKey = secretKeyForFill(step.args, field);
-        if (envKey === undefined)
+        if (envKey === undefined) {
             continue;
+        }
         const supplied = secretValue(envKey, env);
-        if (supplied !== undefined && supplied.length > 0)
+        if (supplied !== undefined && supplied.length > 0) {
             continue;
-        if (seen.has(envKey))
+        }
+        if (seen.has(envKey)) {
             continue;
+        }
         seen.add(envKey);
         out.push({ field, envKey });
     }
+    // A request step that acts as another account needs that account's session.
+    for (const step of flattenAll(flow.steps ?? [])) {
+        const account = step.request?.as;
+        if (account === undefined) {
+            continue;
+        }
+        const envKey = secretEnvKey(account);
+        const supplied = secretValue(envKey, env);
+        if ((supplied !== undefined && supplied.length > 0) || seen.has(envKey)) {
+            continue;
+        }
+        seen.add(envKey);
+        out.push({ field: account, envKey });
+    }
     return out;
 }

package/dist/language/flows/flow-anchor.d.ts

@@ -1,4 +1,4 @@
-import { AnchorKind, type Drift, type FlowAnchor, type QueryEmptyHint } from '@reticlehq/core';
+import { AnchorKind, type CommandResult, type Drift, type FlowAnchor, type QueryEmptyHint } from '@reticlehq/core';
 import type { FlowReplaySession, Sleep } from './flow-replay-types.js';
 /**
  * Finding a step's anchor again, and saying legibly why it could not be found.
@@ -33,6 +33,29 @@ export declare function nearestTestid(missing: string, present: string[]): strin
 export declare function nearestIsAmbiguous(missing: string, present: string[]): boolean;
 /** Build the legible-drift record for a testid anchor that resolved to zero live elements. */
 export declare function testidDrift(value: string, hint: QueryEmptyHint | undefined): Drift;
+/**
+ * How an anchor is ADDRESSED — the sentence that names it, and the label a result row carries.
+ *
+ * Two different strings, and neither can be derived from the other: `value` is a raw testid for one
+ * anchor kind and a human-readable label for the others, so one sentence cannot name both. Calling a
+ * role anchor `testid "button "View result""` sends the reader to edit a locator that does not exist
+ * on that step, which is the same misdirection the drift reason exists to remove.
+ *
+ * Derived from the anchor rather than passed in by the caller. The first version of the role fix took
+ * a `described` argument and wrote `ambiguousAnchorDrift(label, n, \`role anchor ${label}\`)` — the
+ * same string twice, so the `anchor` field and the sentence could drift apart with nothing to catch
+ * it, and the next anchor kind would have had to remember the convention on its own.
+ */
+/**
+ * How a role anchor reads in a message: `button "View result"`, or for a control with no accessible
+ * name, `button (no accessible name, #2 of 3)` — never `button "undefined"`.
+ */
+export declare function roleAnchorLabel(anchor: {
+    role: string;
+    name?: string | undefined;
+    nth?: number | undefined;
+    of?: number | undefined;
+}): string;
 /**
  * What the stale-ref retry found when it ran the locator again.
  *
@@ -106,10 +129,28 @@ export declare function queryOnce(session: FlowReplaySession, queryArgs: Record<
     refs: string[];
     hint?: QueryEmptyHint;
 }>;
-export declare function resolveQuery(session: FlowReplaySession, queryArgs: Record<string, unknown>, sleep: Sleep, now?: () => number): Promise<{
+export declare function resolveQuery(session: FlowReplaySession, queryArgs: Record<string, unknown>, sleep: Sleep, now?: () => number, read?: (result: CommandResult) => {
+    refs: string[];
+    hint?: QueryEmptyHint;
+}): Promise<{
     refs: string[];
     hint?: QueryEmptyHint;
 }>;
+/**
+ * Several queries for one control, pooled: each attempt runs every query and joins the refs, so
+ * the settle budget is spent once, not once for each query. A role anchor with `alsoRoles` uses it.
+ */
+export declare function resolveAnyQuery(session: FlowReplaySession, queries: readonly Record<string, unknown>[], sleep: Sleep, now?: () => number, read?: (result: CommandResult) => {
+    refs: string[];
+    hint?: QueryEmptyHint;
+}): Promise<{
+    refs: string[];
+    hint?: QueryEmptyHint;
+}>;
+/** `resolveQuery`'s reader for a nameless role anchor: only the matches with no accessible name. */
+export declare function readNamelessQuery(result: CommandResult): {
+    refs: string[];
+};
 /** Re-resolve a testid anchor. */
 export declare function resolveTestid(session: FlowReplaySession, value: string, sleep: Sleep): Promise<{
     refs: string[];
@@ -125,3 +166,20 @@ export declare function anchorLabel(anchor: FlowAnchor): string;
 export declare function componentQueryArgs(anchor: Extract<FlowAnchor, {
     kind: typeof AnchorKind.COMPONENT;
 }>): Record<string, unknown>;
+/** Query args for a NAMED role anchor — the handle that identifies an instance, not a JSX site. */
+export declare function roleQueryArgs(anchor: Extract<FlowAnchor, {
+    kind: typeof AnchorKind.ROLE;
+}>): Record<string, unknown>;
+/**
+ * Resolve a role anchor. ONE function for the first look and the re-resolve after a stale ref: the
+ * re-resolve used to count every control of the role, so a nameless anchor's position came back
+ * ambiguous on a working page.
+ *
+ * A nameless anchor's position counts only the nameless controls of its role (an icon-only edit
+ * button is the 2nd nameless button of its row, not the 5th button), so it reads only those.
+ */
+export declare function resolveRoleAnchor(session: FlowReplaySession, anchor: Extract<FlowAnchor, {
+    kind: typeof AnchorKind.ROLE;
+}>, sleep: Sleep): Promise<{
+    refs: string[];
+}>;

package/dist/language/flows/flow-anchor.js

@@ -1,5 +1,5 @@
 import { AnchorKind, DriftReason, ReticleCommand, QueryBy, asRecord, asString, } from '@reticlehq/core';
-import { queryRefs } from './replay.js';
+import { namelessRefs, queryRefs } from './replay.js';
 /**
  * Finding a step's anchor again, and saying legibly why it could not be found.
  *
@@ -20,16 +20,18 @@ export function editDistance(a, b) {
     const cols = t.length + 1;
     const prev = new Array(cols);
     const curr = new Array(cols);
-    for (let j = 0; j < cols; j++)
+    for (let j = 0; j < cols; j++) {
         prev[j] = j;
+    }
     for (let i = 1; i < rows; i++) {
         curr[0] = i;
         for (let j = 1; j < cols; j++) {
             const cost = s[i - 1] === t[j - 1] ? 0 : 1;
             curr[j] = Math.min((prev[j] ?? 0) + 1, (curr[j - 1] ?? 0) + 1, (prev[j - 1] ?? 0) + cost);
         }
-        for (let j = 0; j < cols; j++)
+        for (let j = 0; j < cols; j++) {
             prev[j] = curr[j] ?? 0;
+        }
     }
     return prev[cols - 1] ?? 0;
 }
@@ -58,8 +60,9 @@ export function nearestTestid(missing, present) {
             bestDistance = distance;
         }
     }
-    if (null === best)
+    if (null === best) {
         return null;
+    }
     return bestDistance <= Math.max(missing.length, best.length) / 2 ? best : null;
 }
 /**
@@ -90,8 +93,9 @@ const ANCHOR_SETTLE_MAX_ATTEMPTS = 40;
 /** Extract the live element refs + the zero-match near-miss hint from a QUERY command result. */
 function readQuery(result) {
     const refs = queryRefs(result);
-    if (!result.ok)
+    if (!result.ok) {
         return { refs };
+    }
     const payload = asRecord(result.result);
     const rawHint = payload['hint'];
     if ('object' === typeof rawHint && rawHint !== null) {
@@ -117,8 +121,9 @@ function readQuery(result) {
  * Such a drift is surfaced (with a nearest) but never auto-healed.
  */
 export function nearestIsAmbiguous(missing, present) {
-    if (present.length < 2)
+    if (present.length < 2) {
         return false;
+    }
     let min = Number.POSITIVE_INFINITY;
     let count = 0;
     for (const candidate of present) {
@@ -142,8 +147,9 @@ export function testidDrift(value, hint) {
         anchor: value,
         nearest: nearestTestid(value, present),
     };
-    if (nearestIsAmbiguous(value, present))
+    if (nearestIsAmbiguous(value, present)) {
         drift.ambiguous = true;
+    }
     return drift;
 }
 /**
@@ -159,6 +165,19 @@ export function testidDrift(value, hint) {
  * same string twice, so the `anchor` field and the sentence could drift apart with nothing to catch
  * it, and the next anchor kind would have had to remember the convention on its own.
  */
+/**
+ * How a role anchor reads in a message: `button "View result"`, or for a control with no accessible
+ * name, `button (no accessible name, #2 of 3)` — never `button "undefined"`.
+ */
+export function roleAnchorLabel(anchor) {
+    if (anchor.name !== undefined) {
+        return `${anchor.role} "${anchor.name}"`;
+    }
+    const at = anchor.nth !== undefined && anchor.of !== undefined
+        ? `, #${String(anchor.nth + 1)} of ${String(anchor.of)}`
+        : '';
+    return `${anchor.role} (no accessible name${at})`;
+}
 function anchorAddress(anchor) {
     if (anchor.kind === AnchorKind.TESTID) {
         return { described: `testid "${anchor.value}"`, label: anchor.value };
@@ -166,7 +185,7 @@ function anchorAddress(anchor) {
     if (anchor.kind === AnchorKind.ROLE) {
         // Kind named explicitly: `button "View result"` alone reads as a testid that happens to contain
         // a space, and the reader would go looking for a locator nothing on the step declares.
-        const label = `${anchor.role} "${String(anchor.name)}"`;
+        const label = roleAnchorLabel(anchor);
         return { described: `role anchor ${label}`, label };
     }
     // A component needs no such qualifier: `componentLabel` already answers
@@ -226,8 +245,9 @@ export function ambiguityDrift(anchor, refs) {
  * while the page still has exactly as many of them as when it was recorded. Otherwise undefined.
  */
 export function refFor(anchor, refs) {
-    if (1 === refs.length)
+    if (1 === refs.length) {
         return refs[0];
+    }
     const { nth, of } = { ...anchor };
     return 'number' === typeof nth && of === refs.length ? refs[nth] : undefined;
 }
@@ -246,8 +266,9 @@ export function refFor(anchor, refs) {
  */
 export function reresolved(anchor, refs) {
     const drift = ambiguityDrift(anchor, refs);
-    if (drift !== null)
+    if (drift !== null) {
         return { drift };
+    }
     const ref = refFor(anchor, refs);
     return ref === undefined ? undefined : { ref };
 }
@@ -268,8 +289,9 @@ export function expectElementDrift(value, hint) {
         anchor: value,
         nearest: nearestTestid(value, present),
     };
-    if (nearestIsAmbiguous(value, present))
+    if (nearestIsAmbiguous(value, present)) {
         drift.ambiguous = true;
+    }
     return drift;
 }
 /**
@@ -296,8 +318,9 @@ async function settleTick(session, sleep) {
         await new Promise((resolve) => {
             let done = false;
             const finish = () => {
-                if (done)
+                if (done) {
                     return;
+                }
                 done = true;
                 resolve();
             };
@@ -313,15 +336,34 @@ async function settleTick(session, sleep) {
 export async function queryOnce(session, queryArgs) {
     return readQuery(await session.command(ReticleCommand.QUERY, queryArgs));
 }
-export async function resolveQuery(session, queryArgs, sleep, now = Date.now) {
-    let last = readQuery(await session.command(ReticleCommand.QUERY, queryArgs));
+export async function resolveQuery(session, queryArgs, sleep, now = Date.now, read = readQuery) {
+    return await resolveAnyQuery(session, [queryArgs], sleep, now, read);
+}
+/**
+ * Several queries for one control, pooled: each attempt runs every query and joins the refs, so
+ * the settle budget is spent once, not once for each query. A role anchor with `alsoRoles` uses it.
+ */
+export async function resolveAnyQuery(session, queries, sleep, now = Date.now, read = readQuery) {
+    const look = async () => {
+        const reads = [];
+        for (const queryArgs of queries) {
+            reads.push(read(await session.command(ReticleCommand.QUERY, queryArgs)));
+        }
+        const hint = reads.find((read) => read.hint !== undefined)?.hint;
+        return { refs: reads.flatMap((read) => read.refs), ...(hint === undefined ? {} : { hint }) };
+    };
+    let last = await look();
     const deadline = now() + ANCHOR_SETTLE_BUDGET_MS;
     for (let attempt = 1; 0 === last.refs.length && now() < deadline && attempt < ANCHOR_SETTLE_MAX_ATTEMPTS; attempt += 1) {
         await settleTick(session, sleep);
-        last = readQuery(await session.command(ReticleCommand.QUERY, queryArgs));
+        last = await look();
     }
     return last;
 }
+/** `resolveQuery`'s reader for a nameless role anchor: only the matches with no accessible name. */
+export function readNamelessQuery(result) {
+    return { refs: namelessRefs(result) };
+}
 /** Re-resolve a testid anchor. */
 export function resolveTestid(session, value, sleep) {
     return resolveQuery(session, { by: QueryBy.TESTID, value }, sleep);
@@ -337,20 +379,83 @@ export function componentLabel(anchor) {
 }
 /** The value of a step's primary anchor, for labelling the result row. */
 export function anchorLabel(anchor) {
-    if (anchor.kind === AnchorKind.TESTID)
+    if (anchor.kind === AnchorKind.TESTID) {
         return anchor.value;
-    if (anchor.kind === AnchorKind.SIGNAL)
+    }
+    if (anchor.kind === AnchorKind.SIGNAL) {
         return anchor.name;
-    if (anchor.kind === AnchorKind.COMPONENT)
+    }
+    if (anchor.kind === AnchorKind.COMPONENT) {
         return componentLabel(anchor);
+    }
     return anchor.name ?? anchor.role;
 }
 /** QUERY args for a component auto-anchor — source (precise) + component name (coarse) as given. */
 export function componentQueryArgs(anchor) {
     const args = { by: QueryBy.COMPONENT };
-    if (anchor.component !== undefined)
+    if (anchor.component !== undefined) {
         args['component'] = anchor.component;
-    if (anchor.source !== undefined)
+    }
+    if (anchor.source !== undefined) {
         args['source'] = anchor.source;
+    }
+    if (anchor.text !== undefined) {
+        args['text'] = anchor.text;
+    }
+    // An older SDK ignores a role on a component query and answers as before.
+    if (anchor.role !== undefined) {
+        args['role'] = anchor.role;
+    }
     return args;
 }
+/** Query args for a NAMED role anchor — the handle that identifies an instance, not a JSX site. */
+export function roleQueryArgs(anchor) {
+    return {
+        by: QueryBy.ROLE,
+        value: anchor.role,
+        ...(anchor.name === undefined ? {} : { name: anchor.name }),
+    };
+}
+/** One query for each role the anchor accepts: its own role, then `alsoRoles`. */
+function roleQueries(anchor) {
+    return [anchor.role, ...(anchor.alsoRoles ?? [])].map((role) => roleQueryArgs({ ...anchor, role }));
+}
+/**
+ * Resolve a role anchor. ONE function for the first look and the re-resolve after a stale ref: the
+ * re-resolve used to count every control of the role, so a nameless anchor's position came back
+ * ambiguous on a working page.
+ *
+ * A nameless anchor's position counts only the nameless controls of its role (an icon-only edit
+ * button is the 2nd nameless button of its row, not the 5th button), so it reads only those.
+ */
+export async function resolveRoleAnchor(session, anchor, sleep) {
+    // Every role the anchor accepts (`alsoRoles`), pooled in one settle loop; a nameless anchor keeps
+    // only the matches with no accessible name.
+    const found = await resolveAnyQuery(session, roleQueries(anchor), sleep, Date.now, anchor.name === undefined ? readNamelessQuery : undefined);
+    if (found.refs.length > 0 || anchor.name === undefined || anchor.within === undefined) {
+        return found;
+    }
+    const refs = await refsWithin(session, anchor.role, anchor.within);
+    return refs.length > 0 ? { refs } : found;
+}
+/**
+ * The controls of `role` inside the recorded container chain, for a named control whose name is
+ * gone (a correct build may word a button differently). The chain is walked outermost first, and
+ * each container must be the only one of its role in the one before. When a container is not
+ * unique, its matches come back, so the caller reports the step as ambiguous and does not act.
+ */
+async function refsWithin(session, role, within) {
+    let scope;
+    for (const container of [...within].reverse()) {
+        const { refs } = await queryOnce(session, {
+            by: QueryBy.ROLE,
+            value: container,
+            ...(scope === undefined ? {} : { scope }),
+        });
+        if (1 !== refs.length) {
+            return refs;
+        }
+        scope = refs[0];
+    }
+    return (await queryOnce(session, { by: QueryBy.ROLE, value: role, scope })).refs;
+}

package/dist/language/flows/flow-classify.d.ts

@@ -19,6 +19,7 @@
  * Pure: no IO, no clock.
  */
 import type { FlowFile, FlowStep } from '@reticlehq/core';
+import { z } from 'zod';
 export declare const FlowAssertionGrade: {
     /** At least one step (or the success end-condition) asserts a signal/network consequence. */
     readonly ASSERTED: "asserted";
@@ -45,9 +46,28 @@ export interface FlowAssertionClassification {
      * intent but only presence-only checks is the dangerous case — it claims a goal it cannot verify.
      */
     intentVerified: boolean;
+    /**
+     * How many checks of each predicate kind the flow runs, over every step, sub-step and the success
+     * state, composites flattened. Absent when the flow checks nothing. A presence-only grade with
+     * this list says WHAT is checked, so the grade does not read as "checks nothing" (#1840).
+     */
+    checks?: Record<string, number>;
     /** Present for presence-only / assertion-free flows: how to make the flow a real test. */
     warning?: string;
 }
+/**
+ * The `assertions` block of the `reticle_flow_save` result. Declared here, next to the type it
+ * describes, because a validating profile removes a field that the output schema does not declare.
+ */
+export declare const FLOW_ASSERTIONS_OUTPUT: z.ZodOptional<z.ZodObject<{
+    grade: z.ZodString;
+    hasConsequenceAssertion: z.ZodBoolean;
+    totalSteps: z.ZodNumber;
+    consequenceSteps: z.ZodNumber;
+    weakSteps: z.ZodNumber;
+    checks: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    warning: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>>;
 /**
  * A step expect counts the same as a flow-level one, because replay now evaluates the same set.
  *