/**
 * On-disk artifact constants: the project history, flow files, replay/drift status, the recorder
 * lifecycle, heal outcomes, and the structured-annotation vocabulary.
 */
/**
 * Schema version stamped into project.json so a reader can reject/upgrade old files.
 */
export declare const PROJECT_FILE_VERSION = 1;
/**
 * Structured outcome when reading project.json fails (never thrown to the agent).
 * Mirrors ContractReadError. NOTE: recordRun self-heals a MALFORMED file (starts fresh) so a
 * corrupt history never wedges the agent; only the READ path (reticle_project) surfaces MALFORMED.
 */
export declare const ProjectReadError: {
    readonly MISSING: "project-missing";
    readonly MALFORMED: "project-malformed";
    /**
     * Readable, and written by a version of Reticle this one does not know.
     *
     * Kept apart from MALFORMED because the two need opposite handling. A malformed file has nothing
     * left to lose, so recording a run repairs it. A file from another version is intact, and
     * repairing it would overwrite history a later release could still read.
     */
    readonly WRONG_VERSION: "project-wrong-version";
};
export type ProjectReadError = (typeof ProjectReadError)[keyof typeof ProjectReadError];
/** How a run record was produced. */
export declare const RunKind: {
    readonly FLOW_REPLAY: "flow_replay";
    readonly MANUAL: "manual";
};
export type RunKind = (typeof RunKind)[keyof typeof RunKind];
/**
 * The persisted outcome of a run. Distinct from ReplayStatus (a wire/replay
 * concept of ok|drift|error): RunStatus is the history concept and adds pass/fail. The replay
 * site maps ReplayStatus.OK→PASS, DRIFT→DRIFT, ERROR→ERROR.
 */
export declare const RunStatus: {
    readonly PASS: "pass";
    readonly DRIFT: "drift";
    readonly ERROR: "error";
    readonly FAIL: "fail";
};
export type RunStatus = (typeof RunStatus)[keyof typeof RunStatus];
/**
 * Bounds on project.json so the file stays small + diffable. recordRun keeps the
 * last PER_NAME runs of any single name, then caps the whole list to TOTAL most-recent overall.
 */
export declare const PROJECT_RUN_CAP: {
    readonly PER_NAME: 50;
    readonly TOTAL: 200;
};
/** Maximum distinct route identities retained in project.json. */
export declare const PROJECT_ROUTE_CAP = 200;
/** Schema version stamped onto on-disk flow files (.reticle/flows/<name>.json). */
export declare const FLOW_FILE_VERSION = 1;
/** How a flow step is anchored to the live DOM at replay time (semantic, never a volatile ref). */
export declare const AnchorKind: {
    readonly TESTID: "testid";
    readonly ROLE: "role";
    readonly SIGNAL: "signal";
    readonly COMPONENT: "component";
};
export type AnchorKind = (typeof AnchorKind)[keyof typeof AnchorKind];
/**
 * The role marker for a DEGRADED step — one recorded with no resolvable
 * testid. It is kept (never dropped) but a volatile eXX ref is NEVER persisted in its place;
 * the step carries this placeholder ROLE anchor + degraded:true, a legible "add a data-testid
 * here" marker that a human/self-healing pass re-binds. Satisfies the anchor min(1).
 */
export declare const DEGRADED_ANCHOR_ROLE = "unresolved";
/** Structured failure codes for flow disk ops (returned, never thrown as free strings). */
export declare const FlowErrorCode: {
    readonly INVALID_NAME: "flow_invalid_name";
    readonly NOT_FOUND: "flow_not_found";
    readonly PARSE_FAILED: "flow_parse_failed";
    readonly NO_RECORDING: "flow_no_recording";
};
export type FlowErrorCode = (typeof FlowErrorCode)[keyof typeof FlowErrorCode];
/** A flow name must be a single safe path segment (no '/', '\\', '..', leading dot). */
/**
 * ONE safe path segment: the guard for anything that becomes a single directory or file name.
 *
 * Session ids and run ids are this. They are joined into `.reticle/sessions/<id>/` and written to,
 * and a session LABEL is supplied by the tab — so a separator here is a tab choosing where on disk
 * Reticle writes. Flow names were this too until they became namespaced, and the two guards shared
 * one pattern; widening the flow pattern silently widened these, which a test caught immediately.
 * They answer different questions and now have different patterns: a flow name may be a path, a
 * session id may never be one.
 */
export declare const SAFE_SEGMENT_PATTERN: RegExp;
/**
 * A flow name: one or more `/`-separated segments.
 *
 * Namespaced because the replay grammar addresses documents by path — `onboarding/signup` is how a
 * composite names the sub-journey it invokes, and the protocol's `FlowNameSchema` has said so since
 * grammar v2. This pattern is the PERSISTENCE half, and while it stayed single-segment
 * `reticle_flow_save` refused every name the language is built on. Found by driving a composite:
 * recording worked, closing the boundary worked, saving it was refused.
 *
 * Traversal is impossible by CONSTRUCTION rather than by a filter. No segment may contain a dot at
 * all, so `..` cannot be spelled; every segment must START with a letter or digit, so a leading,
 * trailing or doubled separator cannot either. That is stronger than checking for `..`, because
 * there is no encoding of it left to miss.
 */
export declare const FLOW_NAME_PATTERN: RegExp;
/**
 * The outcome of replaying an on-disk flow by re-resolving its
 * semantic anchors against the live DOM. `drift` (an anchor missed → contract changed) is
 * cleanly separated from `error` (the flow could not load or an action failed) and `ok`.
 */
export declare const ReplayStatus: {
    readonly OK: "ok";
    readonly DRIFT: "drift";
    readonly ERROR: "error";
};
export type ReplayStatus = (typeof ReplayStatus)[keyof typeof ReplayStatus];
/**
 * Why an anchor failed to resolve at replay time (the "whose fault is
 * it" reason kind). Drives the human `reason` sentence and whether a nearest-match is offered.
 */
export declare const DriftReason: {
    readonly TESTID_NOT_FOUND: "testid_not_found";
    readonly SIGNAL_NOT_OBSERVED: "signal_not_observed";
    readonly COMPONENT_NOT_FOUND: "component_not_found";
    readonly STATE_MISMATCH: "state_mismatch";
    /**
     * The step carries DEGRADED_ANCHOR_ROLE — no anchor was ever resolvable, so nothing was queried.
     * Distinct from TESTID_NOT_FOUND deliberately: "your element disappeared" and "this step never had
     * an element bound to it" need different fixes, and reporting the second as the first sent heal
     * hunting for the nearest testid to the literal word "unresolved".
     */
    readonly ANCHOR_DEGRADED: "anchor_degraded";
    /**
     * The step's anchor resolved and its action ran; the testid its `expect.element` names was absent
     * afterwards. Distinct from TESTID_NOT_FOUND for the same reason ANCHOR_DEGRADED is: "the element
     * you clicked is gone" and "the thing you asserted afterwards never appeared" need different
     * fixes, and reporting the second as the first sends the caller looking for a renamed anchor on a
     * step whose anchor was fine.
     */
    readonly EXPECT_ELEMENT_NOT_FOUND: "expect_element_not_found";
};
export type DriftReason = (typeof DriftReason)[keyof typeof DriftReason];
/**
 * Did the step's anchor resolve and its action RUN, leaving only the declared consequence unmet?
 *
 * The three reasons below all mean the same thing about the app's state: the element was found, the
 * action was dispatched, and the page is where the step left it. Only the assertion failed. The
 * other reasons mean the anchor itself was never resolved, so the page is somewhere the flow never
 * described and every later step would run against a state nobody predicted.
 *
 * That difference is what lets a replay CONTINUE past a failure without turning one wrong result
 * into several — see the sweep option on replayFlow. Halting on both was correct while there was no
 * way to tell them apart; it stopped a 6-step bug sweep at its first defect and reported the other
 * five as `notAttempted`.
 */
export declare function isConsequenceDrift(reason: DriftReason): boolean;
/** Default timeout (ms) a signal anchor waits to be observed at replay. */
export declare const FLOW_SIGNAL_TIMEOUT_MS = 4000;
/**
 * The structured annotation kinds a human can attach while recording.
 * FIRST CUT: only these four structured kinds compile to flow fields (via a toolbar menu +
 * a signal <select> drawn from registered capabilities). Free natural-language annotation →
 * predicate compilation is explicitly OUT this cut (no NL parser). `wait-for` / `ignore-region`
 * from the plan grammar are also future — only the four requested kinds ship here.
 */
export declare const AnnotationKind: {
    readonly ASSERT_SIGNAL: "assert-signal";
    readonly ASSERT_VISIBLE: "assert-visible";
    readonly ASSERT_STATE: "assert-state";
    readonly ASSERT_NET: "assert-net";
    readonly MARK_DYNAMIC: "mark-dynamic";
    readonly SUCCESS_STATE: "success-state";
    readonly INTENT: "intent";
};
export type AnnotationKind = (typeof AnnotationKind)[keyof typeof AnnotationKind];
/** Recorder lifecycle phases (drives the toolbar UI + the capture gate). */
export declare const RecorderPhase: {
    readonly IDLE: "idle";
    readonly RECORDING: "recording";
    readonly ANNOTATING: "annotating";
};
export type RecorderPhase = (typeof RecorderPhase)[keyof typeof RecorderPhase];
/**
 * Structured codes for the recorded-save server tool (returned, never thrown).
 */
export declare const RecordedSaveError: {
    readonly NO_RECORDED_FLOW: "flow_no_recorded";
    readonly INVALID_NAME: "flow_invalid_name";
};
export type RecordedSaveError = (typeof RecordedSaveError)[keyof typeof RecordedSaveError];
/**
 * Outcome of reticle_flow_heal (distinct from ReplayStatus — adds heal verbs).
 * Rebinds testid anchors only (role/name/signal re-anchoring is future). A confident nearest-match
 * is required before any disk write — the "never silently rewrite" invariant.
 */
/**
 * Whether a suite should run this flow at all.
 *
 * Absent means `active` — every flow already on disk stays exactly as it was.
 *
 * `quarantined` exists because a permanently failing flow is worse than no flow: measured on this
 * repo's own ledger, one flow has failed 366 of 366 runs and is still replayed on every suite. That
 * is not a regression signal, it is noise, and noise is what teaches people to stop reading the
 * suite. Quarantine takes it out of the verdict while keeping it VISIBLE and owned -- a silent skip
 * would just be the same problem with the evidence removed.
 *
 * `draft` is for a flow being authored: saved, not yet part of anybody's verdict.
 */
export declare const FlowStatus: {
    readonly ACTIVE: "active";
    readonly QUARANTINED: "quarantined";
    readonly DRAFT: "draft";
};
export type FlowStatus = (typeof FlowStatus)[keyof typeof FlowStatus];
export declare const HealStatus: {
    readonly HEALED: "healed";
    readonly DRIFT: "drift";
    readonly UNHEALABLE: "unhealable";
    readonly NOTHING_TO_HEAL: "nothing_to_heal";
    readonly CONSEQUENCE_BROKEN: "consequence_broken";
    readonly UNFALSIFIABLE: "unfalsifiable";
    readonly ERROR: "error";
};
export type HealStatus = (typeof HealStatus)[keyof typeof HealStatus];
/**
 * Minimum normalized confidence (0,1] a nearest-match rebind must clear before it is
 * eligible to be APPLIED (or surfaced as a confident proposal). Below this, drift is reported but
 * NEVER auto-rewritten — the "never silently rewrite" invariant has a single numeric home here.
 */
export declare const HEAL_CONFIDENCE_MIN = 0.5;
/**
 * What a structured annotation binds to. STEP folds onto the LAST captured
 * step's expect (assert-signal / assert-visible); FLOW folds onto the flow header (mark-dynamic →
 * dynamic[], success-state → success).
 */
export declare const AnnotationTarget: {
    readonly STEP: "step";
    readonly FLOW: "flow";
};
export type AnnotationTarget = (typeof AnnotationTarget)[keyof typeof AnnotationTarget];
/**
 * Structured failure codes for the annotate compiler/tool (returned, never
 * thrown / free strings). NO_ACTIVE_RECORDING = annotate with nothing recording; NO_STEP_TO_
 * ANNOTATE = an assert-* with zero captured steps yet; UNKNOWN_KIND = kind ∉ AnnotationKind (or a
 * free natural-language string — see AnnotationSchema's FUTURE note); MISSING_FIELD = e.g. a
 * success-state with neither signal nor testid.
 */
export declare const AnnotationErrorCode: {
    readonly NO_ACTIVE_RECORDING: "annotate_no_recording";
    readonly NO_STEP_TO_ANNOTATE: "annotate_no_step";
    readonly UNKNOWN_KIND: "annotate_unknown_kind";
    readonly MISSING_FIELD: "annotate_missing_field";
};
export type AnnotationErrorCode = (typeof AnnotationErrorCode)[keyof typeof AnnotationErrorCode];
/** Leading word of the compiled-predicate confirmation ("will assert …"). */
export declare const COMPILED_PREDICATE_PREFIX = "will";
/**
 * How a suite kept its flows apart from each other.
 *
 * Sequential replay runs every flow in ONE live session, so each starts wherever the last one left
 * the app. MEASURED on the bench app: four flows that click a nav item behind a sign-in, and never
 * sign in, pass sequentially because an earlier flow signed in — and fail under per-flow leases,
 * which is the correct answer. The same corpus reported 13/34 and 11/34 with nothing changed but
 * this, and both numbers were reproducible.
 *
 * Resetting between sequential flows was tried and reverted (see flow-tools.ts): storageState
 * restores cookies and localStorage but not sessionStorage, which leaves an app holding two thirds
 * of an auth session. So the modes genuinely differ, and the verdict names which one it is rather
 * than letting two incomparable numbers look like a regression.
 */
export declare const SuiteIsolation: {
    /** Every flow replayed in the agent's live session, in order. State carries between them. */
    readonly SHARED_SESSION: "shared-session";
    /** Every flow got its own leased context, seeded once. Flows cannot affect each other. */
    readonly PER_FLOW_LEASE: "per-flow-lease";
};
export type SuiteIsolation = (typeof SuiteIsolation)[keyof typeof SuiteIsolation];