@abloh/core 1.0.1-staging.34778150979 → 1.0.1-staging.34799018111

package/dist/index.d.ts

@@ -1,3 +1,593 @@
+/**
+ * THE EXECUTABLE SCHEMA KERNEL: one declaration per wire boundary, everything else derived.
+ *
+ * WHY THIS EXISTS. The fact-divergence audit found the same shape declared twice on twenty-one
+ * boundaries: a producer writes the object, a consumer re-types it, and neither reads the other.
+ * They agree in one checkout and drift the moment one side changes - and because a customer runs a
+ * PINNED Action, a PINNED CLI or a PINNED GitHub App against a service that moved, the drift is not
+ * a same-build risk that a test comparing the two copies could catch. Two of these already cost
+ * real runs: a runner emitting a valid new state made the service discard every Angular and Deno
+ * upload, and an added field made a pinned GitHub App throw away a whole check.
+ *
+ * WHAT A CONTRACT DECLARES ONCE, and what is derived from it rather than written beside it:
+ *
+ *   the TypeScript type          `Infer<typeof C>` - the type IS the schema, not a copy of it
+ *   the consumer parser          `C.parse(value)` - one refusal grammar, one path syntax
+ *   the producer projection      `project(C, value)` - drops what the contract does not carry
+ *   every discriminator value    `C.fields.x.values` - the enum tuple, readable at runtime
+ *   every limit                  `C.fields.x.max` - the cap, readable by producer and consumer
+ *
+ * THE UNKNOWN-FIELD POSTURE IS DECLARED, NOT ASSUMED, and it is the single most important field on
+ * an object node. Two different boundaries want opposite answers and both are right:
+ *
+ *   `unknownFields: "refuse"` is an INGEST DOOR. The service stores what it accepts and serves it
+ *   to a customer surface, so a key it does not know is a producer attaching something the boundary
+ *   never agreed to carry - a source slice on a row that is supposed to be a path. Refusing is the
+ *   privacy posture and it must stay.
+ *
+ *   `unknownFields: "ignore"` is a PINNED CONSUMER reading a NEWER PRODUCER. The GitHub App parsing
+ *   the service's evidence object cannot refuse a field that did not exist when it was released;
+ *   that exact refusal discarded a whole check. Additive change is the normal direction of travel
+ *   on these boundaries, and a consumer that cannot survive it is a released-version outage.
+ *
+ * FAILURE IS A PATH AND A CAUSE, never a boolean. `runResult.fixLoop.summaries[3].verdict` tells a
+ * maintainer which field of which row, which is what the hand-written validators were already
+ * doing one string concatenation at a time.
+ *
+ * NOT A VALIDATION LIBRARY. It has exactly the node kinds these boundaries use. A boundary that
+ * needs something else adds the node here, once, rather than hand-writing its own validator again.
+ */
+/** Where in the document a value sat, in the syntax a maintainer reads in a refusal. */
+type WirePath = string;
+type WireResult<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: string;
+};
+/**
+ * A node in a wire contract.
+ *
+ * `kind` and the per-kind reflection fields are what make a contract READABLE rather than only
+ * runnable: the limits mechanism (F27, F55, F60) needs the cap as a number, and the vocabulary
+ * mechanism (F11, F23, F54, F85) needs the enum as a tuple. A validator that only validated would
+ * leave those facts owned somewhere else again.
+ */
+interface WireNode<T> {
+    readonly kind: string;
+    /** Parse an unknown value from the wire. `path` is where it sat, for the refusal sentence. */
+    parse(value: unknown, path?: WirePath): WireResult<T>;
+}
+type Infer<N> = N extends WireNode<infer T> ? T : never;
+interface WireEnum<V extends string> extends WireNode<V> {
+    readonly kind: "enum";
+    /** The closed vocabulary, in declaration order. THE tuple - readers derive, never re-type. */
+    readonly values: readonly V[];
+    readonly has: (value: string) => value is V;
+}
+/**
+ * A closed vocabulary.
+ *
+ * THE TUPLE IS THE VOCABULARY. `values` is exported so a producer can iterate it, a renderer can
+ * exhaustively map it and a test can enumerate it - which is what stops the second copy from being
+ * written. `ProposalsVerdict` is `Infer<typeof verdict>`, so a value added here reaches the type
+ * system, the parser and every render map in the same edit.
+ */
+declare function wireEnum<const V extends readonly string[]>(values: V): WireEnum<V[number]>;
+/**
+ * WHAT A TEXT BOUND IS COUNTED IN, said out loud.
+ *
+ * A LENGTH WITH NO UNIT IS TWO RULES (boundary contract divergence audit, the length-and-character
+ * class). `admitCandidate` counts a generated test in UTF-8 BYTES and the proofs acceptor counts the
+ * same test in JavaScript CHARACTERS, so a body that passed one measurement failed the other and the
+ * proof was lost after it had been paid for. The two numbers differ by up to a factor of four on
+ * text the model is free to write.
+ *
+ * A node states which it is, and a producer that has to agree with a door asks rather than assumes.
+ */
+type TextUnit = "characters" | "bytes";
+interface WireString extends WireNode<string> {
+    readonly kind: "string";
+    /** Maximum characters, or `undefined` when the boundary declares no bound. */
+    readonly max?: number;
+    readonly min: number;
+    /** A byte ceiling, for a boundary whose downstream ceiling is stated in bytes rather than characters. */
+    readonly maxBytes?: number;
+    /**
+     * WHICH UNIT THIS FIELD'S BOUND IS COUNTED IN, and the number in it.
+     *
+     * `undefined` on a node that declares no bound at all. A node declaring BOTH reports bytes, which
+     * is the tighter of the two for any text outside ASCII and is therefore the one a producer has to
+     * satisfy to be carried.
+     */
+    readonly bound?: {
+        readonly unit: TextUnit;
+        readonly max: number;
+    };
+    /** The grammar the boundary agreed the value is written in, when it declared one. */
+    readonly pattern?: RegExp;
+}
+/** How long a value is, in the unit the node declares. Never a second reading of the same rule. */
+declare function textLength(node: WireString, value: string): number;
+/** Whether a value fits, asked by a producer in the unit the door will count in. */
+declare function textFits(node: WireString, value: string): boolean;
+/**
+ * A string with the boundary's own bound on it.
+ *
+ * THE CAP IS PART OF THE CONTRACT, not a constant beside it. F60 is exactly this: the wire reason
+ * string's 200-character maximum was repeated three times in the service and twice in the CLI, so
+ * raising one producer's cap made the service refuse the whole draft. A producer reads
+ * `contract.fields.reason.max` and truncates to it; the door parses with the same node.
+ */
+declare function wireString(options?: {
+    max?: number;
+    min?: number;
+    maxBytes?: number;
+    pattern?: RegExp;
+    patternIs?: string;
+}): WireString;
+/** Printable single-line ASCII: the egress grammar every stored, signed or rendered string is held to. */
+declare const PRINTABLE_ASCII: RegExp;
+/** A full sha256, lower or upper case. The one spelling of "this is a digest, not a body". */
+declare const HEX_DIGEST_64: RegExp;
+/** A bounded printable string: the shape almost every egress field on these boundaries has. */
+declare function wirePrintable(options?: {
+    max: number;
+    min?: number;
+}): WireString;
+/**
+ * PRINTABLE SINGLE-LINE TEXT, which is what a field carrying somebody ELSE's words may be.
+ *
+ * {@link wirePrintable} is ASCII and is right for a vocabulary this product ships. It is wrong for a
+ * test's name or a path, which a customer or a model wrote: holding those to ASCII refused a whole
+ * live-progress update over a test named `café` (boundary contract divergence audit, D08 and D10).
+ * The property a rendered surface needs is that no line break, control character or lone surrogate
+ * reaches it, and that is what this refuses - nothing else.
+ */
+declare const PRINTABLE_TEXT: RegExp;
+declare function wirePrintableText(options: {
+    max: number;
+    min?: number;
+}): WireString;
+/** A sha256 identity. Never a body - see every contract's egress rule. */
+declare function wireDigest(): WireString;
+interface WireInteger extends WireNode<number> {
+    readonly kind: "integer";
+    readonly min?: number;
+    readonly max?: number;
+}
+declare function wireInteger(options?: {
+    min?: number;
+    max?: number;
+}): WireInteger;
+interface WireNumber extends WireNode<number> {
+    readonly kind: "number";
+    readonly min?: number;
+    readonly max?: number;
+}
+declare function wireNumber(options?: {
+    min?: number;
+    max?: number;
+}): WireNumber;
+interface WireBoolean extends WireNode<boolean> {
+    readonly kind: "boolean";
+}
+declare function wireBoolean(): WireBoolean;
+interface WireLiteral<V extends string> extends WireNode<V> {
+    readonly kind: "literal";
+    readonly value: V;
+}
+/**
+ * The schema discriminator itself: `"abloh-proposals/v1"` and its siblings.
+ *
+ * A CONTRACT NAMES ITSELF ON THE WIRE. That string is how a consumer tells a document it was
+ * released against from one it was not, which is the only durable answer to a pinned client meeting
+ * a newer service. It is declared here so the producer stamps and the consumer checks one value.
+ */
+declare function wireLiteral<const V extends string>(value: V): WireLiteral<V>;
+/**
+ * An object this contract carries but does not describe.
+ *
+ * DELIBERATE, AND NARROW. It says "there is an object here" and hands it to the one module that
+ * owns its shape. Used only where restating the cargo's rules would create the second authority
+ * this whole kernel exists to remove - the live-progress envelope's `evidence`, whose one authority
+ * is the ingest body parser, is the case it was written for.
+ */
+declare function wireRecord(): WireNode<Record<string, unknown>>;
+interface WireNullable<T> extends WireNode<T | null> {
+    readonly kind: "nullable";
+    readonly inner: WireNode<T>;
+}
+/**
+ * A field that may be `null` ON THE WIRE, which is not the same fact as being absent.
+ *
+ * `summary.model` is the case that decided the distinction: `null` says a mechanism wrote this
+ * candidate and no model did, and ABSENT would say this producer does not record who wrote it.
+ * A single "optional" would collapse two different answers into one.
+ */
+declare function wireNullable<T>(inner: WireNode<T>): WireNullable<T>;
+interface WireArray<T> extends WireNode<readonly T[]> {
+    readonly kind: "array";
+    readonly item: WireNode<T>;
+    /** The row bound the boundary agreed to, or `undefined` when it declared none. */
+    readonly max?: number;
+}
+declare function wireArray<T>(item: WireNode<T>, options?: {
+    max?: number;
+}): WireArray<T>;
+/**
+ * A field of an object contract: its node, and whether the wire may leave it out.
+ *
+ * `Optional` IS A LITERAL TYPE PARAMETER rather than a `boolean` property, because the inferred
+ * TypeScript type is derived from it. Widened to `boolean`, every field reads as required and the
+ * generated type stops matching the parser beside it - which would put the two back out of step in
+ * the one place this kernel exists to keep them together.
+ */
+interface WireField<T, Optional extends boolean = boolean> {
+    readonly node: WireNode<T>;
+    readonly optional: Optional;
+}
+declare function required<T>(node: WireNode<T>): WireField<T, false>;
+declare function optional<T>(node: WireNode<T>): WireField<T, true>;
+/**
+ * A field whose ABSENCE and whose MALFORMATION are the same answer: it is dropped, and the rest of
+ * the document is still read.
+ *
+ * NOT LAZINESS - IT IS A JUDGEMENT ABOUT WHAT THE DOCUMENT IS FOR, and it belongs to exactly the
+ * fields where acting on the rest is worth more than refusing over the part. The admission answer's
+ * approaching-limit warning is the case it was written for: refusing the whole body over a nudge
+ * nobody was owed would discard the loop guard and the wall notice with it, and discarding a
+ * refusal is admitting.
+ *
+ * USE IT ONLY WHERE THE FIELD CHANGES NOTHING THE CALLER DOES. A tolerated field that gated
+ * anything would be a silent default, which is the opposite of what this kernel is for.
+ */
+declare function tolerated<T>(node: WireNode<T>): WireField<T, true>;
+type WireFields = Record<string, WireField<unknown, boolean>>;
+type RequiredKeys<F extends WireFields> = {
+    [K in keyof F]: F[K]["optional"] extends true ? never : K;
+}[keyof F];
+type OptionalKeys<F extends WireFields> = {
+    [K in keyof F]: F[K]["optional"] extends true ? K : never;
+}[keyof F];
+type InferFields<F extends WireFields> = {
+    [K in RequiredKeys<F>]: Infer<F[K]["node"]>;
+} & {
+    [K in OptionalKeys<F>]?: Infer<F[K]["node"]>;
+};
+/** What a consumer does with a key the contract does not declare. See the file header. */
+type UnknownFieldPosture = "refuse" | "ignore";
+interface WireObject<F extends WireFields> extends WireNode<InferFields<F>> {
+    readonly kind: "object";
+    readonly fields: F;
+    readonly unknownFields: UnknownFieldPosture;
+    /** The declared key names, in declaration order - the field allowlist, derived not re-typed. */
+    readonly keys: readonly (keyof F & string)[];
+}
+declare function wireObject<const F extends WireFields>(fields: F, options: {
+    unknownFields: UnknownFieldPosture;
+}): WireObject<F>;
+interface WireUnion<T> extends WireNode<T> {
+    readonly kind: "union";
+    readonly discriminator: string;
+    /** Every variant's discriminator value: the closed tag vocabulary, readable at runtime. */
+    readonly tags: readonly string[];
+    readonly variant: (tag: string) => WireNode<unknown> | undefined;
+}
+/**
+ * A tagged union, keyed on a field both sides agree names the variant.
+ *
+ * THE TAG SET IS DERIVED FROM THE VARIANTS. F79 to F81 are three copies of the same discriminator:
+ * `engine-scenarios` writes the tag, `triage` re-declares it, and a prompt asks a model for a third
+ * spelling. One variant map makes the tag vocabulary, the parser and the prompt fragment the same
+ * fact, so a producer cannot emit a task that the resolver was never told about.
+ */
+declare function wireUnion<const M extends Record<string, WireNode<unknown>>>(discriminator: string, variants: M): WireUnion<Infer<M[keyof M]>>;
+/**
+ * The producer projection, derived from the same contract the consumer parses with.
+ *
+ * WHY PROJECT RATHER THAN SEND THE OBJECT. A producer's in-memory record is wider than what the
+ * boundary agreed to carry - it holds the model that wrote a candidate, the source slice, the local
+ * report. `project` keeps exactly the declared keys and drops the rest, which is the same rule the
+ * `unknownFields: "refuse"` door enforces from the other side. Written twice, the two rules drifted
+ * (F57: direct and live delivery projected different evidence from the same run).
+ *
+ * IT RETURNS A RESULT, not a value: a projection that cannot be parsed by its own contract is a
+ * producer bug and the caller finds out here rather than at the customer's door.
+ */
+declare function project<F extends WireFields>(contract: WireObject<F>, value: InferFields<F>): WireResult<InferFields<F>>;
+
+/** The block names itself on the wire. Producer stamps it, door checks it, neither owns a copy. */
+declare const PROPOSALS_BLOCK_SCHEMA = "abloh-proposals/v1";
+/**
+ * THE NAMES THIS DOCUMENT USED TO ANSWER TO, and why a door must still take them.
+ *
+ * The engine that writes these is MARIGOLD since the captain's naming ruling of 2026-08-31, and
+ * that name is internal - so the documents took the plain word instead of either name. A schema id
+ * is the one thing in a document that cannot be renamed by fiat: a customer's workflow pins the
+ * Action by SHA and the CLI it installs is resolved at run time, so `api.abloh.dev` meets producers
+ * released before this for as long as those pins stand, and a door that refused one would lose the
+ * WHOLE envelope - every package's completed evidence with it.
+ *
+ * THE PRODUCER STAMPS ONE VALUE AND THE DOOR TAKES THREE. That asymmetry is the point and it is the
+ * same one {@link RETIRED_EVIDENCE_OUTPUTS} and `RETIRED_REFUSAL_CODES` are built on: the write side
+ * moves in one release, the read side waits out the pins. It expires with them - see
+ * `EVIDENCE_REGROUPING_EXPIRY`, whose arithmetic this shares.
+ */
+declare const RETIRED_PROPOSALS_BLOCK_SCHEMAS: readonly string[];
+/** Whether a block's own `schema` is one this build reads, live name or retired one. */
+declare function readsProposalsBlockSchema(schema: unknown): boolean;
+/**
+ * The local proof sidecar's shape.
+ *
+ * `/v2` since 2026-08-28 (junction audit EVID-01 and EVID-02): a candidate row now carries its
+ * support files and its own model and prompt version, and a kill-matrix cell carries its execution
+ * count and its hold. Every `/v1` field is present and unchanged, so a reader written against `/v1`
+ * reads a `/v2` document; the version is what lets one tell whether the missing provenance on an old
+ * document means "no model wrote it" or "this producer did not record it".
+ */
+declare const PROPOSALS_SIDECAR_SCHEMA = "abloh-proposals-proofs/v2";
+/**
+ * The longest free sentence any marigold field carries onto the wire.
+ *
+ * IT IS NOT A DISPLAY LIMIT. The ingest door validates the field and fails the WHOLE draft when it
+ * is over length, so a producer that overran it would not lose the sentence - it would lose the
+ * run. F60: this number was declared three times in the service and twice in the CLI, each copy
+ * with a comment saying it mirrored one of the others.
+ */
+declare const WIRE_REASON_MAX = 200;
+/**
+ * THE LONGEST HOLD SENTENCE A PRODUCER MAY WRITE, and why it is not {@link WIRE_REASON_MAX}.
+ *
+ * WHAT WENT WRONG (boundary contract divergence audit, 2026-09-08, D02 / F5). `lightCheckHoldReason`
+ * composes a 225-character sentence for the one verdict a maintainer can actually act on - a test
+ * command that exits non-zero without running a test, which is a lint, format, typecheck or build
+ * stage standing in front of the runner, and the sentence names the config key that moves it. The
+ * loop counts that sentence into `funnel["light-check"].holdReasons` verbatim, and the ingest door
+ * held every hold-reason KEY to the 200-character reason bound. A `markedjs/marked` record was
+ * refused as carrying "an unprintable hold reason" after a complete measurement.
+ *
+ * THE SHORTENING IS NOT THE FIX AND WOULD HAVE RELOCATED THE DEFECT. Cutting the sentence at 200
+ * loses the half that names the key; making the producer refuse it loses the run at a different
+ * boundary. What was wrong is that a bound written for a generic diagnostic was applied to a
+ * vocabulary this product ships and has already decided the wording of - so the bound moves to fit
+ * the vocabulary, and both ends read the moved one.
+ *
+ * MEASURED, NOT CHOSEN: 225 is the longest sentence any closed hold reason in
+ * `@abloh/marigold` produces today, and `packages/marigold/src/hold-reason-vocabulary.test.ts`
+ * enumerates that vocabulary and asserts every member survives {@link boundHoldReason} BYTE FOR
+ * BYTE. Shorten this number below any shipped sentence and that test names the sentence it broke.
+ * The headroom above 225 is what stops an ordinary rewording of an existing sentence from being a
+ * wire change; a NEW sentence longer than the ceiling is one, under `RELEASE.md`'s order - the
+ * reading side ships first.
+ */
+declare const MEASURED_LONGEST_HOLD_REASON = 225;
+declare const WIRE_HOLD_REASON_MAX = 320;
+/**
+ * THE LONGEST ENDING SENTENCE A RUN MAY SEND, and why it is not {@link WIRE_REASON_MAX} either.
+ *
+ * WHAT WENT WRONG (the displayer divergence audit of 2026-09-12, A5). `proposals.reason` carries one
+ * of six closed sentences from `PROPOSALS_UNAVAILABLE_COPY` and nothing else - the audit's own words
+ * for the field are that nothing in it originates outside that table - and two of the six are
+ * abloh-owned, so their whole remedy is the ownership closing and a report id. That half was dropped
+ * at the copy table, so a maintainer read that a run proposed no tests and never that the reason was
+ * a defect in abloh nor what to quote when they asked about it.
+ *
+ * THE BOUND MOVES TO FIT THE VOCABULARY, which is exactly the reasoning above this line: a number
+ * written for a generic diagnostic was applied to a vocabulary this product ships and has already
+ * decided the wording of. `engine-error` with its closing is 218 characters and
+ * `spec-not-found` 236, against a 200-character bound written for a free sentence.
+ *
+ * MEASURED, NOT CHOSEN: 236 is the longest of the six today, and
+ * `apps/cli/src/marigold-multi-package.test.ts` enumerates that vocabulary and asserts every member
+ * fits. The headroom is what stops an ordinary rewording from being a wire change; a new sentence
+ * over the ceiling is one, under `RELEASE.md`'s order - the reading side ships first.
+ */
+declare const MEASURED_LONGEST_PROPOSALS_ENDING = 236;
+declare const WIRE_PROPOSALS_ENDING_MAX = 360;
+/**
+ * A hold reason in the representation both ends agree on.
+ *
+ * The key of `funnel[stage].holdReasons` and the summary row's own `holdReason` are the same fact
+ * written in two places, so they take the same node. It is the door's reading; {@link boundHoldReason}
+ * is the producer's, and the two are the same numbers because they are the same declaration.
+ */
+declare const holdReasonText: WireString;
+/**
+ * MAKE ANY REASON CARRYABLE, at the one place a producer records one.
+ *
+ * Most hold reasons are closed sentences and pass through untouched, which is the property the
+ * vocabulary test pins. A few are COMPOSED - an admission rule list joined with commas, a repair
+ * refusal quoting the rules it failed - and those have no bound of their own, so a producer that
+ * recorded one directly could overrun the wire exactly as the closed sentence did. Folding here
+ * means the funnel a run publishes is conformant by construction rather than by every call site
+ * remembering.
+ *
+ * FOLD THEN CUT, in that order: removing a character leaves the spaces around it, so collapsing
+ * first turns "failed <emoji> here" into a double space. The cut ends on a full stop so a reader
+ * can see the sentence was cut rather than that the producer stopped mid-word.
+ */
+declare function boundHoldReason(reason: string): string;
+/** Whether the v2 arm ran at all. */
+declare const proposalsFeatureState: WireEnum<"completed" | "disabled" | "not-run" | "unavailable">;
+type ProposalsFeatureState = Infer<typeof proposalsFeatureState>;
+declare const PROPOSALS_FEATURE_STATES: readonly ("completed" | "disabled" | "not-run" | "unavailable")[];
+/** What became of a gap the loop attempted. */
+declare const proposalsVerdict: WireEnum<"proven" | "rejected" | "not-attempted-budget">;
+type ProposalsVerdict = Infer<typeof proposalsVerdict>;
+declare const PROPOSALS_VERDICTS: readonly ("proven" | "rejected" | "not-attempted-budget")[];
+/**
+ * WHERE THE BUG THIS GAP STANDS FOR CAME FROM. A MECHANISM, NEVER A MODEL.
+ *
+ * `mechanical` is the deterministic path: a mutation operator rewrote one boundary in the source -
+ * a comparison, a literal, an arithmetic sign - and the suite did not notice the rewrite. What the
+ * gap asserts is therefore a boundary fact, checkable by reading the operator and the two texts
+ * beside each other.
+ *
+ * `planted-bug` is the agent bug pool: a defect was written into the file as a whole change rather
+ * than derived from an operator, the repository's own suite was run against it, and the suite
+ * passed. What the gap asserts is a behaviour the suite does not pin down, which is a wider claim
+ * than one boundary and cannot be read off an operator name.
+ *
+ * WHY THE TWO NAMES ARE MECHANISMS. Kenneth's rule of 2026-08-14: no surface a customer or their
+ * coding agent reads names the model that wrote anything. `model` and `promptVersion` stay on the
+ * summary as internal provenance and are not served; this field is what a reader is told instead,
+ * and it says how the bug was produced rather than by whom.
+ *
+ * `nearby` is the neighborhood slice (the captain's D7 of 2026-09-05): the gap is a whole-body
+ * gutting, so mechanically it is the first of these two, but it sits ONE CALL AWAY from the change
+ * rather than inside it. What it asserts is that a function the change calls, or that calls the
+ * change, has no test that notices it going away - and a reader offered a test for it needs to know
+ * that before they read the diff, because the file it names is one their change did not touch.
+ *
+ * NOTHING WITH THIS ORIGIN EVER SCORED AND NOTHING WITH IT EVER WILL. That is the permanent ruling
+ * of 2026-08-14 about code outside the change, and this field only says which population a proposal
+ * closed.
+ *
+ * Closed on purpose: a producer cannot invent a fourth origin and have it served. Adding this one
+ * is a wire change under `RELEASE.md`'s order - the control plane learns the value before a CLI
+ * that can emit it is released, or the whole block is refused.
+ */
+declare const proposalsGapOrigin: WireEnum<"mechanical" | "planted-bug" | "nearby">;
+type ProposalsGapOrigin = Infer<typeof proposalsGapOrigin>;
+declare const PROPOSALS_GAP_ORIGINS: readonly ("mechanical" | "planted-bug" | "nearby")[];
+/**
+ * What the whole suite did with the candidate present.
+ *
+ * Three of the four are about the CANDIDATE. `pre-red-unchanged` is about the REPOSITORY: its suite
+ * does not pass on its own inside the sealed environment, and the candidate changed nothing about
+ * that. It joined on 2026-08-23 with the exit proof's baseline - before it, a suite already red for
+ * its own reasons rejected every candidate in the package, and the block had no value that could
+ * say so (`docs/lessons/a-gate-measures-the-difference.md`). `regressed` is the only one that
+ * rejects, and it means the candidate made tests fail that PASSED WITHOUT IT.
+ */
+declare const proposalsSuiteState: WireEnum<"green" | "regressed" | "pre-red-unchanged" | "not-checked">;
+type ProposalsSuiteState = Infer<typeof proposalsSuiteState>;
+declare const PROPOSALS_SUITE_STATES: readonly ("green" | "regressed" | "pre-red-unchanged" | "not-checked")[];
+/** Whether the runner demonstrably collects a test at the candidate's path. */
+declare const proposalsDiscoveryState: WireEnum<"confirmed" | "unconfirmed">;
+type ProposalsDiscoveryState = Infer<typeof proposalsDiscoveryState>;
+declare const PROPOSALS_DISCOVERY_STATES: readonly ("confirmed" | "unconfirmed")[];
+/**
+ * The route-purity ladder, purest first. Ordinal by construction: a route's rung is the WORST
+ * contact on it, and the engine's `worstOf` depends on this array's order.
+ *
+ * A producer cannot invent a sixth rung and have it served: the rung decides what sentence a
+ * customer reads about their own code, and an unrecognised one would reach a surface with no copy
+ * for it. `unknown` is a real rung and is accepted as one - "we looked and could not tell" is a
+ * different fact from "nobody looked", and only the second is spelled by omitting the field.
+ */
+declare const routePurityRung: WireEnum<"pure-exported" | "exported-with-io" | "scaffolding-reachable" | "structurally-out-of-reach" | "unknown">;
+type RoutePurityRung = Infer<typeof routePurityRung>;
+declare const ROUTE_PURITY_RUNGS: readonly ("pure-exported" | "exported-with-io" | "scaffolding-reachable" | "structurally-out-of-reach" | "unknown")[];
+/** What the predictor did to this run's execution set. */
+declare const proposalsPredictorMode: WireEnum<"cold" | "shadow" | "skipping">;
+type ProposalsPredictorMode = Infer<typeof proposalsPredictorMode>;
+declare const PROPOSALS_PREDICTOR_MODES: readonly ("cold" | "shadow" | "skipping")[];
+/** Field length caps, so an oversized string can never bloat a stored or signed egress record. */
+declare const PROPOSALS_MUTANT_ID_MAX = 600;
+declare const PROPOSALS_FILE_PATH_MAX = 512;
+/**
+ * One offered (or refused) candidate, in the form that may leave the customer's machine.
+ *
+ * `unknownFields: "refuse"` IS THE PRIVACY POSTURE AND IT STAYS. What egresses is digests, counts,
+ * verdicts and named reasons - never a generated test body, never a source slice, never a runner
+ * report. A key this contract does not declare is a producer attaching something the boundary never
+ * agreed to carry, and the door refuses it by name.
+ */
+declare const proposalsSummary: WireObject<{
+    /** run-local mutant id, so a reader can join back to the mutant record */
+    readonly mutantId: WireField<string, false>;
+    /** cross-run gap identity, derived from what was mutated */
+    readonly gapId: WireField<string, false>;
+    /**
+     * How the bug this gap stands for was produced. A fact about the GAP, not about the candidate.
+     *
+     * ABSENT IS ACCEPTED AND MEANS `mechanical`. A block written before the field existed measured
+     * one population and it was the mechanical one, so reading absence as mechanical states what
+     * that run did rather than guessing.
+     */
+    readonly origin: WireField<"mechanical" | "planted-bug" | "nearby", true>;
+    /**
+     * WHERE THE GAP IS: the file and the first line of the span that was mutated.
+     *
+     * Absent on every block written before it existed, and empty-with-zero on a verdict whose gap
+     * the loop could not resolve - which is the "not recorded" the producer writes, so it is
+     * accepted rather than refused.
+     */
+    readonly file: WireField<string, true>;
+    readonly startLine: WireField<number, true>;
+    /** sha256 over the generated bundle; the bundle itself stays local */
+    readonly candidateDigest: WireField<string, false>;
+    readonly verdict: WireField<"proven" | "rejected" | "not-attempted-budget", false>;
+    /** the round that produced this candidate; round 1 means it worked first time */
+    readonly round: WireField<number, false>;
+    /**
+     * The per-test runner that executed it.
+     *
+     * NOT AN ENUM HERE. The runner vocabulary is the capability registry's, and closing over a copy
+     * of it is the exact defect that refused every Angular and deno upload. The door validates this
+     * against `RUNNER_CAPABILITIES`; see `runnerNameNode` below.
+     */
+    readonly runner: WireField<string, false>;
+    readonly model: WireField<string | null, false>;
+    readonly promptVersion: WireField<string, false>;
+    readonly suite: WireField<"green" | "regressed" | "pre-red-unchanged" | "not-checked", false>;
+    readonly discovery: WireField<"confirmed" | "unconfirmed", false>;
+    /** other gaps this same candidate closes, from the kill matrix */
+    readonly alsoClosesCount: WireField<number, false>;
+    /**
+     * Named reason when the verdict is not `proven`; never free-form model text.
+     *
+     * THE SAME NODE THE FUNNEL'S KEYS TAKE. The loop writes one `Hold.reason` into both places, so a
+     * sentence the funnel carries and this field refuses would be one fact with two bounds - which
+     * is D02 one field over.
+     */
+    readonly holdReason: WireField<string, true>;
+    /**
+     * How pure the shortest PUBLIC route to this gap's mutated line is.
+     *
+     * A closed rung or nothing: absent is a block written before the classifier existed, which is a
+     * fact about the producer rather than about the customer's code.
+     */
+    readonly routePurity: WireField<"pure-exported" | "exported-with-io" | "scaffolding-reachable" | "structurally-out-of-reach" | "unknown", true>;
+}>;
+/** The wire shape of a summary row: what the door accepts. See the header on producer narrowing. */
+type ProposalsSummaryWire = Infer<typeof proposalsSummary>;
+/** The declared key names - the door's field allowlist, derived and never re-typed. */
+declare const PROPOSALS_SUMMARY_FIELDS: readonly ("file" | "startLine" | "verdict" | "promptVersion" | "routePurity" | "mutantId" | "gapId" | "origin" | "candidateDigest" | "round" | "runner" | "model" | "suite" | "discovery" | "alsoClosesCount" | "holdReason")[];
+/**
+ * The proof-shape rules a `proven` verdict must satisfy, stated once for both sides.
+ *
+ * THE WORD IS SHORT FOR THREE FACTS AND NOTHING MORE, which is what {@link PROVEN_BASIS} spells out
+ * for every reader: a candidate asserting that the implementation file still CONTAINS a literal
+ * satisfied "fails on the mutant, passes on the original" perfectly well and was recorded proven
+ * having never called the function. The third fact is the one that rules that out, so a record that
+ * carries the control's outcome is held to it here rather than at a call site.
+ *
+ * RECOMPUTED RATHER THAN TRUSTED at the door, and asserted by the producer before it writes: a
+ * proven candidate must have been through the whole suite without breaking it AND have proven the
+ * runner collects its path.
+ *
+ * TWO SUITE STATES SATISFY THE FIRST since 2026-08-23, and the second is not a loophole. `green` is
+ * the suite passing with the candidate present. `pre-red-unchanged` is a suite that does not pass on
+ * its own inside the sealed environment and that the candidate did not change - a fact about the
+ * REPOSITORY, established by running the same suite in the same box with nothing generated in it.
+ * The only alternative to it is the false conviction it replaced: a package whose tests drive `git`
+ * is red inside an image that carries no `git`, so every candidate in it was rejected for 26
+ * failures it did not cause (`docs/lessons/a-gate-measures-the-difference.md`). What stays refused
+ * is `regressed`, the only state that says this candidate broke something.
+ */
+declare const PROVEN_BASIS: string;
+declare function provenShapeProblem(summary: {
+    verdict: string;
+    suite: string;
+    discovery: string;
+    /** The control's own outcome, where the reader holds it. See {@link PROVEN_BASIS}. */
+    textControl?: string;
+}): string | undefined;
+
 /**
  * WHY A BLOCK IN THE ARTIFACT DID NOT COMPLETE, AS A CLOSED CODE RATHER THAN AS PROSE.
  *
@@ -2546,6 +3136,13 @@ declare function setupStageLabel(stage: ReceiptStageName, road: ExecutionRoad):
  * Two spellings of one fact is what every table in this file exists to end, and it mattered here -
  * the road is now a fact the registry's own sentences read, and a fact whose words differ from the
  * plan's could never be filled in from the plan.
+ *
+ * AND THE LOCAL CLAUSE PROMISES WHAT REALLY HAPPENS (the round-2 maintainer review's A4, closed
+ * 2026-09-15). It read "The trial runs again here.", and on the road that stopped it does not: the
+ * command exits two lines later, and the only road that reruns in place is the demoted `--walk`
+ * loop. A maintainer on `honojs/hono` read it twice in succession and then watched the process end.
+ * What is true of both roads now is that the trial runs again on the next run of the command that
+ * ran it, which is the same shape the hosted clause has always had.
  */
 declare const SETUP_TRIAL_RERUN: Readonly<Record<ExecutionRoad, string>>;
 /** The five stages with their customer-facing labels, in execution order. */
@@ -2800,6 +3397,21 @@ declare function isValueOrigin(value: unknown): value is ValueOrigin;
  * nothing, and the two are different facts.
  */
 declare function parseValueOriginMap(raw: unknown): ValueOriginMap | null;
+/**
+ * THE RECEIPT `abloh init` WRITES ABOVE A VALUE THE MAINTAINER SUPPLIED.
+ *
+ * Deliberately says neither `--test-command` nor "at the prompt": a derivation that took an
+ * override cannot tell a flag from an answer, and a comment naming a flag the maintainer never
+ * typed is exactly the sort of confident wrong sentence every receipt here exists to avoid.
+ *
+ * IT IS THE PREFIX OF {@link SET_AT_THE_PROMPT} AND THE READING BELOW ASKS FOR IT, so both shapes
+ * of "you set this" answer {@link CUSTOMER_TYPED} with one rule. Until the ownership ruling of
+ * 2026-09-15 the reading asked for the longer one alone, so a value the maintainer had answered
+ * with `--environment-image`, `--runner` or `--test-command` read back as abloh's - which is this
+ * mechanism running BACKWARDS, putting abloh's name and a report identifier on a choice the
+ * maintainer made.
+ */
+declare const SET_BY_YOU = "set by you";
 /**
  * THE RECEIPT `abloh init` WRITES ABOVE A VALUE THE CUSTOMER TYPED.
  *
@@ -4024,6 +4636,15 @@ interface NativeDependencyFacts {
     attempts?: number;
     /** Everything added along the way, for `not-closed`. */
     added?: readonly string[];
+    /**
+     * WHO PINNED `environment.runtimeImage`, for the two problems whose remedy names it.
+     *
+     * Round-2 maintainer review C1: `abloh init` derives that image from the Node the repository
+     * declares, pins its digest, writes the receipt above the line - and the two codes below then told
+     * the maintainer to replace it with a better one. Absent is the maintainer's, which is the owner
+     * both codes carried before this existed.
+     */
+    origin?: ValueOrigin;
 }
 /**
  * A store of abloh's on this machine that cannot be made private. Two of the observations are made
@@ -6167,8 +6788,23 @@ interface MeasurementSkippedFacts {
     targetDetection: {
         summary: string;
     } | null;
+    /**
+     * A RUNNER WAS ESTABLISHED AND THE CHANGE HAS NO SOURCE LINE IN IT.
+     *
+     * WHAT IT FIXES (the round-2 maintainer review's A9). This family's remainder row is
+     * `baseline-skipped-unexplained` - "nothing was measured on this run, and abloh recorded no reason
+     * for it" - and it is abloh-owned, because failing to record a reason is a gap in this product.
+     * On a run whose change touches no source there IS a reason, the same run states it four lines
+     * further down in its own stage table (`the measured range changes no source line, so there is no
+     * suite to run against it`), and this family had no way to be told. So the run's own log said
+     * abloh had recorded no reason one screen above the reason.
+     *
+     * ABSENT RATHER THAN FALSE where the caller has not been taught to answer it, so a producer that
+     * does not pass it behaves exactly as every producer did before this existed.
+     */
+    emptyScope?: boolean;
 }
-type MeasurementSkippedCombination = "skipped-by-flag" | "detection-refused" | "baseline-unexplained" | "coverage-unexplained";
+type MeasurementSkippedCombination = "skipped-by-flag" | "detection-refused" | "empty-scope" | "baseline-unexplained" | "coverage-unexplained";
 interface TargetInventoryFacts {
     kind: "target-inventory";
     error: unknown;
@@ -6901,26 +7537,39 @@ interface InitLocalTrial {
      */
     unproven?: readonly string[];
     /**
-     * What an `abloh-failed` trial UNDID, repo-relative, where it undid anything.
+     * THE STAGES A CANCELLED TRIAL GOT THROUGH BEFORE THE MAINTAINER STOPPED IT, in the words the
+     * five-row report prints, and the answer to the round-2 maintainer review's A2.
      *
-     * The captain's ruling of 2026-09-12: a failure of abloh's own removes the files init wrote this
-     * run and puts an edited file of theirs back to its own bytes, and the closing sentence says what
-     * it removed. Absent where there was nothing to undo - a road that had already committed them, so
-     * they are the repository's now - and then the defect's own sentence stands alone rather than a
-     * second one claiming a removal that did not happen.
+     * NAMED BY THE CALLER for the reason `unproven` is: the caller has already read the child's own
+     * stages, and a second reading here is what lets this sentence and the rows above it disagree.
+     * ABSENT where the child left no ledger at all, and the row then says only that it was stopped -
+     * a count invented here would be the same false claim in the other direction.
+     *
+     * IT IS AN ACCOUNT AND NEVER A VERDICT. A stop still commits nothing and proves nothing; what
+     * these names buy the reader is knowing which part of the wait they paid for.
      */
-    removed?: readonly string[];
+    reached?: readonly string[];
 }
 type InitLocalTrialCombination = "no-trial" | "passed" | "failed" | "abloh-failed" | "skipped" | "cancelled" | "nothing-to-measure" | "incomplete";
-interface InitLocalCommit {
-    kind: "init-local-commit";
-    commitsLocally: boolean;
-    /** What the trial answered. The commit is this road's verdict, so only a pass earns one. */
-    trial: LocalTrialAnswer;
-    /** Why a `skipped` trial was skipped. See {@link InitLocalTrial.because}. */
-    because?: "asked-not-to" | "cancelled" | "nothing-committed-yet";
+/**
+ * WHETHER THE LOCAL ROAD'S COMMIT HAPPENED, and what git said where it did not.
+ *
+ * THE COMMIT IS THAT ROAD'S VERDICT (Kenneth's onboarding-flip decision): there is no pull request
+ * on it, so the trial on the maintainer's own machine is the whole admission and the commit is what
+ * records it. Where git refuses, the trial has already passed and the one thing left to do is a
+ * commit this machine would not take - a hook, an identity git has not been given, an index another
+ * process holds.
+ *
+ * IT REPLACES A SENTENCE NOBODY DECLARED (the captain's ruling of 2026-09-15). The reason was
+ * interpolated into a line the run composed itself, which is a user-facing failure message with no
+ * code, no owner and no remedy.
+ */
+interface InitCommit {
+    kind: "init-commit";
+    /** git's own words, where it refused. Null where the commit landed. */
+    problem: string | null;
 }
-type InitLocalCommitCombination = "not-local" | "proved" | "refused" | "abloh-failed" | "skipped" | "cancelled" | "nothing-to-measure" | "incomplete";
+type InitCommitCombination = "committed" | "refused";
 interface InitWorkspaceDraft {
     kind: "init-workspace-draft";
     workspacePackage: {
@@ -6942,11 +7591,6 @@ interface InitDerivedCommand {
     } | null;
 }
 type InitDerivedCommandCombination = "declined" | "opaque" | "none";
-interface InitUnattended {
-    kind: "init-unattended";
-    walled: boolean;
-}
-type InitUnattendedCombination = "walled" | "clean";
 interface InitAbortLockfile {
     kind: "init-abort-lockfile";
     /** what `init` recorded about resolving one, in whatever state it reached, or nothing */
@@ -7202,7 +7846,7 @@ interface SetupStatement {
     statement: "no-job-to-ride" | "trial-complete";
 }
 type SetupStatementCombination = SetupStatement["statement"];
-type SetupFacts = SetupAnswer | SetupJobReading | SetupStepPlacementFacts | SetupStepWritten | SetupCiStepsRead | SetupRideOutcome | SetupPullRequestStep | SetupToolFailure | SetupCallerJob | SetupTrialReceipt | SetupTrialContract | SetupTrialPlan | SetupReceiptProblem | SetupRewrites | SetupReportSize | SetupPrivateRegistry | SetupUnsatisfiableCheck | SetupScriptRun | InitPin | InitValidationPrepare | InitValidationLedger | InitLocalTrial | InitLocalCommit | InitWorkspaceDraft | InitDerivedCommand | InitUnattended | InitAbortLockfile | InitRestore | InitAbortFiles | InitAbort | InitAnswer | ManifestPin | ImageReference | NodeRuntime | SetupStatement;
+type SetupFacts = SetupAnswer | SetupJobReading | SetupStepPlacementFacts | SetupStepWritten | SetupCiStepsRead | SetupRideOutcome | SetupPullRequestStep | SetupToolFailure | SetupCallerJob | SetupTrialReceipt | SetupTrialContract | SetupTrialPlan | SetupReceiptProblem | SetupRewrites | SetupReportSize | SetupPrivateRegistry | SetupUnsatisfiableCheck | SetupScriptRun | InitPin | InitValidationPrepare | InitValidationLedger | InitLocalTrial | InitCommit | InitWorkspaceDraft | InitDerivedCommand | InitAbortLockfile | InitRestore | InitAbortFiles | InitAbort | InitAnswer | ManifestPin | ImageReference | NodeRuntime | SetupStatement;
 
 /**
  * THE THREE STATES A MEASUREMENT MAY BE IN, AND THE TWO THINGS THE THIRD ONE MAY BECOME.
@@ -9708,12 +10352,12 @@ declare const MESSAGE_MAPPINGS: {
             };
             passed: () => MessageOutcome<"local-trial-passed">;
             failed: () => MessageOutcome<"local-trial-already-reported">;
-            "abloh-failed": (facts: InitLocalTrial) => MessageOutcome<"local-trial-already-reported">;
+            "abloh-failed": () => MessageOutcome<"local-trial-already-reported">;
             skipped: () => {
                 kind: "message";
                 refusal: Refusal;
             };
-            cancelled: () => {
+            cancelled: (facts: InitLocalTrial) => {
                 kind: "message";
                 refusal: Refusal;
             };
@@ -9727,29 +10371,11 @@ declare const MESSAGE_MAPPINGS: {
             };
         };
     };
-    "init-local-commit": {
-        select: (facts: InitLocalCommit) => InitLocalCommitCombination;
+    "init-commit": {
+        select: (facts: InitCommit) => InitCommitCombination;
         rows: {
-            "not-local": () => MessageOutcome<"no-local-commit">;
-            proved: () => MessageOutcome<"contract-committed">;
-            refused: () => {
-                kind: "message";
-                refusal: Refusal;
-            };
-            "abloh-failed": () => MessageOutcome<"no-local-commit">;
-            skipped: () => {
-                kind: "message";
-                refusal: Refusal;
-            };
-            cancelled: () => {
-                kind: "message";
-                refusal: Refusal;
-            };
-            "nothing-to-measure": () => {
-                kind: "message";
-                refusal: Refusal;
-            };
-            incomplete: () => {
+            committed: () => MessageOutcome<"contract-committed">;
+            refused: (facts: InitCommit) => {
                 kind: "message";
                 refusal: Refusal;
             };
@@ -9776,16 +10402,6 @@ declare const MESSAGE_MAPPINGS: {
             };
         };
     };
-    "init-unattended": {
-        select: (facts: InitUnattended) => InitUnattendedCombination;
-        rows: {
-            clean: () => MessageOutcome<"unattended-clean">;
-            walled: () => {
-                kind: "message";
-                refusal: Refusal;
-            };
-        };
-    };
     "init-abort-lockfile": {
         select: (facts: InitAbortLockfile) => InitAbortLockfileCombination;
         rows: {
@@ -10149,6 +10765,10 @@ declare const MESSAGE_MAPPINGS: {
                 kind: "message";
                 refusal: Refusal;
             };
+            "empty-scope": () => {
+                kind: "message";
+                refusal: Refusal;
+            };
             "detection-refused": () => {
                 kind: "message";
                 refusal: Refusal;
@@ -12989,6 +13609,13 @@ interface CorepackCacheFacts {
  * `other`, whose sentence for a name holding a slash is "Your <it> has no step for it. Add one and
  * push.". That is abloh's failure worded as the maintainer's, on the one surface where a maintainer
  * has nothing else to read. See {@link admissionKeyIsAblohs}.
+ *
+ * AND THOSE TWO ARE THE HOSTED ROAD'S (his ruling of 2026-09-14). Both name the sealed container -
+ * the profile abloh applies to it, the shared memory it is given - and a local run has neither, so
+ * on that road the seventh would put abloh's name on a failure that happened on somebody's own
+ * machine. They take `other` there, whose local arm says abloh started nothing of its own and asks
+ * for the thing on this machine; every other reading that names a part of abloh keeps the seventh
+ * on both roads. See {@link admissionKeyIsHostedRoadOnly}.
  */
 type AdmissionNeed = "build" | "service" | "runtime" | "browser" | "system-library" | "other" | "inside-abloh";
 /**
@@ -13002,6 +13629,24 @@ type AdmissionNeed = "build" | "service" | "runtime" | "browser" | "system-libra
  * directions, which is what makes adding a row a decision about who repairs it.
  */
 declare function admissionKeyIsAblohs(key: string): boolean;
+/**
+ * DOES THIS PART OF ABLOH EXIST ONLY WHERE ABLOH BUILT THE CONTAINER?
+ *
+ * WHAT IT SCOPES (the captain's ruling of 2026-09-14). {@link admissionKeyIsAblohs} answers whose
+ * the module is, which is abloh's on both roads, and the seventh code then says the failure is
+ * abloh's - true where abloh applied the profile and set the size, and false on a machine where it
+ * applied neither. So the two readings above take the seventh code on the hosted road and the
+ * machine sentence on the local one, and every other reading that names a part of abloh keeps the
+ * seventh on both roads.
+ *
+ * IT IS A LIST AND THE DEFAULT IS OFF IT, because the two directions cost differently. A part of
+ * abloh left off it says the failure is abloh's on a local run, which sends a maintainer to
+ * support with an identifier and no false instruction; one wrongly on it tells them to make
+ * something available on their own machine for a failure abloh caused, which sends them chasing.
+ * So a new reading joins this list only once somebody has established that abloh does that thing
+ * on the hosted road alone.
+ */
+declare function admissionKeyIsHostedRoadOnly(key: string): boolean;
 /**
  * WHAT THE FAILING TESTS SAID, AND WHAT THE RUN ALREADY HAS, for the seven `baseline-need*` codes.
  *
@@ -13026,6 +13671,19 @@ interface AdmissionNeedFacts extends RoadFacts {
     /** whether the contract this run executed under already carries the key that supplies it */
     declared?: boolean;
 }
+/**
+ * THE SEVENTH CODE'S FACTS: what the reading landed on, which is abloh's either way.
+ *
+ * TWO CAUSES AND ONE OWNER (the captain's first ruling of 2026-09-15). The reading can land on a
+ * module of abloh's own, which has no key and no file a maintainer could edit; and it can land on a
+ * key whose VALUE abloh wrote, which a maintainer could edit and should not be asked to, because
+ * asking them to repair an abloh-authored value is the shape `value-origin.ts` exists to forbid.
+ * Both are abloh's, both quote the same identifier, and the sentence says which happened.
+ */
+interface AdmissionOwnFacts extends AdmissionNeedFacts {
+    /** the `abloh.yml` key abloh wrote the value under, where that is what the reading landed on */
+    key?: string;
+}
 /** The sixth code's facts: the thing it names has no one key behind it, so the key is observed. */
 interface AdmissionKeyFacts extends AdmissionNeedFacts {
     /** the `abloh.yml` key, or the file, the fix goes in. A slash means a file */
@@ -14011,7 +14669,7 @@ declare const REFUSAL_REGISTRY: {
         readonly ablohKind: "defect";
         readonly privacy: "local-only";
         readonly destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
-        readonly summary: (facts: AdmissionNeedFacts) => string;
+        readonly summary: (facts: AdmissionOwnFacts) => string;
         readonly remedy: (facts: {
             reportId?: string;
         }) => RefusalRemedy;
@@ -15639,18 +16297,32 @@ declare const REFUSAL_REGISTRY: {
             problem?: string;
         } & OriginFacts) => RefusalRemedy;
     };
-    readonly "native-dependency-unavailable": {
-        readonly factFamily: "native-dependency";
-        readonly stage: "environment";
-        readonly owner: "repository";
-        readonly privacy: "authored";
-        readonly destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
-        readonly summary: (facts?: {
+    readonly "native-dependency-unavailable": Omit<{
+        factFamily: "native-dependency";
+        stage: "environment";
+        owner: "repository";
+        privacy: "authored";
+        destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
+        summary: (facts: {
             item?: string;
             excerpt?: string;
         }) => string;
-        readonly remedy: (facts: never) => RefusalRemedy;
-        readonly evidence: readonly EvidenceSlot[];
+        remedy: (facts: never) => RefusalRemedy;
+        evidence: readonly EvidenceSlot[];
+    }, "owner" | "summary" | "remedy"> & {
+        readonly owner: (facts: {
+            item?: string;
+            excerpt?: string;
+        } & OriginFacts) => RefusalOwner;
+        readonly ablohKind: "defect";
+        readonly summary: (facts: {
+            item?: string;
+            excerpt?: string;
+        } & OriginFacts) => string;
+        readonly remedy: (facts: {
+            item?: string;
+            excerpt?: string;
+        } & OriginFacts) => RefusalRemedy;
     };
     readonly "native-index-unreadable": {
         readonly factFamily: "native-dependency";
@@ -15681,18 +16353,32 @@ declare const REFUSAL_REGISTRY: {
         }) => RefusalRemedy;
         readonly evidence: readonly EvidenceSlot[];
     };
-    readonly "native-package-unpinnable": {
-        readonly factFamily: "native-dependency";
-        readonly stage: "environment";
-        readonly owner: "repository";
-        readonly privacy: "authored";
-        readonly destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
-        readonly summary: (facts?: {
+    readonly "native-package-unpinnable": Omit<{
+        factFamily: "native-dependency";
+        stage: "environment";
+        owner: "repository";
+        privacy: "authored";
+        destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
+        summary: (facts: {
             item?: string;
             package?: string;
         }) => string;
-        readonly remedy: (facts: never) => RefusalRemedy;
-        readonly evidence: readonly EvidenceSlot[];
+        remedy: (facts: never) => RefusalRemedy;
+        evidence: readonly EvidenceSlot[];
+    }, "owner" | "summary" | "remedy"> & {
+        readonly owner: (facts: {
+            item?: string;
+            package?: string;
+        } & OriginFacts) => RefusalOwner;
+        readonly ablohKind: "defect";
+        readonly summary: (facts: {
+            item?: string;
+            package?: string;
+        } & OriginFacts) => string;
+        readonly remedy: (facts: {
+            item?: string;
+            package?: string;
+        } & OriginFacts) => RefusalRemedy;
     };
     readonly "native-dependency-not-closed": {
         readonly factFamily: "native-dependency";
@@ -19630,6 +20316,29 @@ declare const REFUSAL_REGISTRY: {
         readonly remedy: () => RefusalRemedy;
         readonly evidence: readonly EvidenceSlot[];
     };
+    /**
+     * THE CHANGE HAS NO SOURCE LINE IN IT, so there was no suite to run against it.
+     *
+     * WHAT IT REPLACES (the round-2 maintainer review's A9). This state took the remainder row,
+     * `baseline-skipped-unexplained` - "nothing was measured on this run, and abloh recorded no reason
+     * for it" - which is abloh-owned because failing to record a reason is a gap in this product. The
+     * reason exists, is correct, and the same run prints it four lines further down in its own stage
+     * table, so a maintainer read abloh disclaiming a reason one screen above the reason.
+     *
+     * OWNED BY THE REPOSITORY AND ASKING FOR NOTHING. Which commit a run measures is the repository's
+     * own history; there is no edit that makes a change with no source line in it measurable, and the
+     * next change that touches source has a suite to run.
+     */
+    readonly "baseline-skipped-empty-scope": {
+        readonly factFamily: "measurement-skipped";
+        readonly stage: "baseline";
+        readonly owner: "repository";
+        readonly privacy: "authored";
+        readonly destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
+        readonly summary: () => string;
+        readonly remedy: () => RefusalRemedy;
+        readonly evidence: readonly EvidenceSlot[];
+    };
     readonly "config-key-inert": Omit<{
         factFamily: "declared-key";
         stage: "environment";
@@ -19909,68 +20618,36 @@ declare const REFUSAL_REGISTRY: {
         readonly remedy: () => RefusalRemedy;
         readonly evidence: readonly EvidenceSlot[];
     };
-    /** The local road walled, so the contract abloh drafted was not recorded as this repository's. */
-    readonly "init-not-committed-after-wall": {
-        readonly factFamily: "init-local-commit";
-        readonly stage: "init";
-        readonly owner: "repository";
-        readonly privacy: "authored";
-        readonly destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
-        readonly summary: () => string;
-        readonly remedy: () => RefusalRemedy;
-        readonly evidence: readonly EvidenceSlot[];
-    };
-    /** Nobody ran the trial, because the maintainer said not to. */
-    readonly "init-not-committed-trial-skipped": {
-        readonly factFamily: "init-local-commit";
-        readonly stage: "init";
-        readonly owner: "command";
-        readonly privacy: "authored";
-        readonly destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
-        readonly summary: () => string;
-        readonly remedy: () => RefusalRemedy;
-        readonly evidence: readonly EvidenceSlot[];
-    };
     /**
-     * THE REPOSITORY HAS NO COMMIT YET, so there was nothing for the trial to measure.
+     * THE TRIAL PASSED AND git WOULD NOT TAKE THE COMMIT.
+     *
+     * WHAT IT REPLACES (the captain's ruling of 2026-09-15). The local road's commit is that road's
+     * verdict, and where git refuses it the run printed a sentence of its own with the reason
+     * interpolated into it - a user-facing failure message with no code, no owner and no remedy, which
+     * is what `scripts/failure-contract.test.ts` exists to stop. The state is real: a hook that
+     * refuses, an identity git has not been given, an index another process holds.
      *
-     * OWNED BY THE REPOSITORY AND NOT BY ABLOH, which is the whole of why this code exists. A trial
-     * measures the change the repository's own last commit made, and an unborn branch has no such
-     * commit - so `prepareValidationTree` failed on git's own "ambiguous argument 'HEAD'", and every
-     * maintainer who ran `abloh init` inside a repository they had just created was told "This is a
-     * failure in abloh, not something in your repository" with an identifier to quote at support.
+     * OWNED BY THE MACHINE. Nothing about the contract or the repository's own files is wrong - the
+     * trial had just proved them - and what stopped the commit is git as it is configured here.
+     *
+     * WHY THE NEXT ACTION IS TO COMMIT THEM: `abloh run` measures a clean tree, so a contract left
+     * uncommitted is one the maintainer's next run refuses under.
      */
-    readonly "init-not-committed-nothing-to-measure": {
-        readonly factFamily: "init-local-commit";
-        readonly stage: "init";
-        readonly owner: "repository";
-        readonly privacy: "authored";
-        readonly destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
-        readonly summary: () => string;
-        readonly remedy: () => RefusalRemedy;
-        readonly evidence: readonly EvidenceSlot[];
-    };
-    /** The maintainer stopped the trial, so there is no verdict for the commit to rest on. */
-    readonly "init-not-committed-trial-cancelled": {
-        readonly factFamily: "init-local-commit";
+    readonly "init-commit-refused": {
+        readonly factFamily: "init-commit";
         readonly stage: "init";
-        readonly owner: "command";
-        readonly privacy: "authored";
-        readonly destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
-        readonly summary: () => string;
-        readonly remedy: () => RefusalRemedy;
-        readonly evidence: readonly EvidenceSlot[];
-    };
-    /** It ran, refused nothing, and did not reach every stage. */
-    readonly "init-not-committed-trial-incomplete": {
-        readonly factFamily: "init-local-commit";
-        readonly stage: "init";
-        readonly owner: "repository";
-        readonly privacy: "authored";
+        readonly owner: "environment";
+        readonly privacy: "local-only";
         readonly destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
         readonly summary: () => string;
         readonly remedy: () => RefusalRemedy;
-        readonly evidence: readonly EvidenceSlot[];
+        readonly evidence: readonly [{
+            readonly key: "gitSaid";
+            readonly label: "what git said";
+            readonly egress: "local-only";
+            readonly maxBytes: 400;
+            readonly required: false;
+        }];
     };
     /** `--skip-validation`. The files are written and nothing has executed them. */
     readonly "local-trial-skipped": {
@@ -19983,33 +20660,6 @@ declare const REFUSAL_REGISTRY: {
         readonly remedy: () => RefusalRemedy;
         readonly evidence: readonly EvidenceSlot[];
     };
-    /**
-     * WHAT AN ABLOH-OWNED FAILURE UNDID, and why undoing is the ruled behaviour.
-     *
-     * THE CAPTAIN, 2026-09-12: "any failure of abloh's own, including abloh crashing midway: remove
-     * the files init wrote this run; a file the maintainer already had and init edited goes back to
-     * its previous bytes, never deleted". A run that produced no trial at all has proved nothing about
-     * this repository, so leaving abloh's own two files behind would hand a maintainer a contract
-     * their next `abloh run` measures under and that abloh has never executed.
-     *
-     * IT SAYS ONLY WHAT IT TOOK. The failure itself is `init-validation-not-prepared` or
-     * `init-validation-no-record`, each a defect carrying the identifier to quote, and both have
-     * already printed by the time this renders - so a second defect class here would mint a second
-     * identifier for one event. Where the undo took nothing, nothing is said.
-     */
-    readonly "local-trial-undone": {
-        readonly factFamily: "init-local-trial";
-        readonly stage: "init";
-        readonly owner: "abloh";
-        readonly ablohKind: "limitation";
-        readonly privacy: "authored";
-        readonly destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
-        readonly summary: (facts: {
-            removed?: readonly string[];
-        }) => string;
-        readonly remedy: () => RefusalRemedy;
-        readonly evidence: readonly EvidenceSlot[];
-    };
     /**
      * THE MAINTAINER STOPPED IT, which is a choice and not a failure of anybody's.
      *
@@ -20017,6 +20667,19 @@ declare const REFUSAL_REGISTRY: {
      * deciding they have seen enough; `incomplete` is a trial abloh could not finish on its own, and
      * reading one as the other would put a fact about the repository's own stages on a run nobody let
      * reach them. What the trial had printed before the stop stays on screen and is not a result.
+     *
+     * IT SAYS WHAT RAN, AND THAT IS THE WHOLE OF WHY IT MOVED (the round-2 maintainer review's A2).
+     * It read "you stopped the setup trial, so nothing here has executed the files abloh just wrote",
+     * which is the sentence `--skip-validation` earns and is false of a stop: on
+     * `react-hook-form/react-hook-form` the maintainer pressed ctrl+c after the setup stage passed,
+     * 115 test files had been mapped green and a mutant had been planted, and the run's own narration
+     * two lines above said abloh was publishing what it measured. The stages that passed before the
+     * stop are handed in by the caller off the ledger the child left, and a stop that left none says
+     * only that it was stopped rather than inventing a count.
+     *
+     * WHAT THE STOP STILL DOES NOT BUY IS A VERDICT. `init-validation.ts` reads a cancelled child's
+     * ledger for this account and for nothing else; the answer stays `skipped`, no stage of it is
+     * read as proof, and the contract is not committed.
      */
     readonly "local-trial-cancelled": {
         readonly factFamily: "init-local-trial";
@@ -20024,7 +20687,9 @@ declare const REFUSAL_REGISTRY: {
         readonly owner: "command";
         readonly privacy: "authored";
         readonly destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
-        readonly summary: () => string;
+        readonly summary: (facts: {
+            reached?: readonly string[];
+        }) => string;
         readonly remedy: () => RefusalRemedy;
         readonly evidence: readonly EvidenceSlot[];
     };
@@ -20072,17 +20737,6 @@ declare const REFUSAL_REGISTRY: {
         readonly remedy: (facts: never) => RefusalRemedy;
         readonly evidence: readonly EvidenceSlot[];
     };
-    /** An unattended init walled at validation and has no walk to hand the caller back to. */
-    readonly "init-unattended-walled": {
-        readonly factFamily: "init-unattended";
-        readonly stage: "init";
-        readonly owner: "repository";
-        readonly privacy: "authored";
-        readonly destinations: readonly ("artifact" | "terminal" | "markdown" | "job-log" | "check" | "slack" | "web" | "setup-comment" | "playground")[];
-        readonly summary: () => string;
-        readonly remedy: () => RefusalRemedy;
-        readonly evidence: readonly EvidenceSlot[];
-    };
     readonly "init-left-lockfile": {
         readonly factFamily: "init-abort-lockfile";
         readonly stage: "init";
@@ -20704,6 +21358,23 @@ declare function remedyLocation(remedy: RefusalRemedy): RemedyLocation | null;
  * standing rule that a sentence two places compose is a sentence two places can disagree about.
  */
 declare function summaryThenAction(summary: string, action: string): string;
+/**
+ * THE ONE LINE AN `Error` CARRIES FOR A REFUSAL: the sentence, then the next action.
+ *
+ * WHY IT IS A FUNCTION (the captain's ruling of 2026-09-15). {@link DeclaredRefusalError}'s
+ * constructor composed this shape, and nine sites in the CLI spelled it out again to build a message
+ * of their own - `summaryThenAction(refusal.summary, nextActionSentence(refusal.remedy))`, nine
+ * times, each one a join of two fields of one object. `preflight.ts` then compared a check's message
+ * against a TENTH spelling of it to decide whether the message adds anything to the refusal, so the
+ * duplicate rule and the thing it judges were two compositions that had to stay byte-identical by
+ * everybody remembering to.
+ *
+ * IT IS NOT {@link refusalLines}, and the difference is what a carrier can hold: this is ONE line
+ * for a channel that has one, and that is why it drops the evidence and the coordinates rather than
+ * folding them in. A surface with lines uses `refusalLines`; the CLI's own renderer is
+ * `apps/cli/src/refusal-display.ts`.
+ */
+declare function refusalMessage(refusal: Refusal): string;
 declare function nextActionSentence(remedy: RefusalRemedy, destination?: RefusalDestination): string;
 /**
  * RENDER A REFUSAL FOR ONE DESTINATION.
@@ -20720,7 +21391,17 @@ declare function renderRefusal(refusal: Refusal, destination: RefusalDestination
  * two different things - one a composed sentence, the other a bare slug. The Markdown wrapper adds
  * its own bullet syntax around these lines and changes nothing about them.
  */
-declare function refusalLines(rendered: RenderedRefusal): string[];
+declare function refusalLines(rendered: RenderedRefusal, options?: {
+    /**
+     * THE LABEL THIS SURFACE PUTS IN FRONT OF THE NEXT ACTION, and nothing else about the line.
+     *
+     * The terminal says `next:`, the local Markdown says `Fix:` and the setup pull request says
+     * `**Next:**` - three syntaxes for one sentence, which is the split `setup-report.ts` already
+     * states: a surface owns SYNTAX and never wording. Before this the two that wanted a different
+     * label could not call this function at all, so each rebuilt the whole line list beside it.
+     */
+    nextLabel?: string;
+}): string[];
 /**
  * THE VALUE THIS KEY TAKES, WRITTEN OUT, OR NULL WHERE THE PRODUCER HAS NONE.
  *
@@ -21233,6 +21914,15 @@ interface NormalizedMutant {
      * null is the absence of one. Absent therefore means unknown on every surface that shows it.
      */
     coveredBy?: number;
+    /**
+     * HOW FAR THIS LOCATION SITS FROM THE NEAREST PUBLIC ENTRY POINT, and ABSENT when nobody looked.
+     *
+     * Written by the run over the findings it files, from `classifyRoutePurity` - one static read of
+     * the file and the line, which executes nothing. `unknown` is a real rung meaning the scan ran and
+     * could not vouch for a route; only omission says nobody looked, and no surface may read the two
+     * as one.
+     */
+    routePurity?: RoutePurityRung;
     /**
      * Which producer pass emitted this mutant, when a carrier pass did.
      *
@@ -23482,6 +24172,41 @@ declare function plantedCounts(counts: Counts, mutantsPlanned: number, mutantsRu
     planted: number;
     judged: number;
 };
+/**
+ * IS THIS ROW ONE THE ENGINE PLANTED, OR ONE THE COVERAGE CLASSIFICATION FILED?
+ *
+ * THE SAME POPULATION {@link plantedCounts} SUBTRACTS, asked of one row rather than of a count map.
+ * `no-coverage` is the free bucket: nothing was written there, nothing was executed there, and the
+ * ingest door sums it into `mutantsPlanned` and `mutantsRun` because the findings array, the counts
+ * and those two figures are one population. A counter that wants the ENGINE's number therefore has
+ * to take the same rows out that the arithmetic does, and asking here and asking there in two
+ * different words is one drift away from two answers about one run.
+ *
+ * WHY NOT `findingKind`. That answers what KIND of hole a reader is looking at and reads the reason
+ * code first, so a row carrying the mechanical error-path code answers `error-handler` whatever its
+ * status - right for a work queue that filters on it, and wrong for a subtraction that has to
+ * agree entry for entry with a count map keyed on status alone.
+ */
+declare function isFreeCoverageRow(finding: {
+    status?: string | null;
+}): boolean;
+/**
+ * HOW MANY OF A RUN'S FINDINGS THE REVIEW ACTUALLY REACHED.
+ *
+ * WHAT IT REPLACES (surface parity audit, D05). Every finding carrying a triage record was counted,
+ * and since the captain's ruling of 2026-09-13 a changed line no test runs carries one too: it is
+ * auto-classified, and the one batched account call writes it the same title and grade it writes a
+ * survivor. So a run whose classifier reviewed eight survivors published "10 undetected changes
+ * reviewed" - the eight, plus two locations no model was asked a verdict about.
+ *
+ * THE SUBTRACTION IS {@link isFreeCoverageRow}'S, so this counter and the planted counter beside it
+ * take out one population rather than two readings of it. What is left is what a model was asked to
+ * judge, which is what the word on that row means.
+ */
+declare function reviewedFindingCount(findings: ReadonlyArray<{
+    status?: string | null;
+    triage?: unknown;
+}>): number;
 interface FloorConfig {
     minMutantsExecuted: number;
     maxErrorRate: number;
@@ -23852,60 +24577,6 @@ declare function registryEntryProblems(code: string, declaration: RefusalDeclara
  */
 declare const NEW_RAW_MESSAGE_GUIDANCE: string;
 
-/**
- * THE VERDICT ON A CHANGE NOTHING RUNS, and why it is a verdict rather than a skip notice.
- *
- * WHAT THIS REPLACES (Kenneth, 2026-08-30). A pull request whose changed lines no test executes used
- * to reach its author as bookkeeping: "no changed line here is run by a test, so there was nothing
- * for mutation to measure". Every word of that is true and it is written from the product's point of
- * view - it says which of our stages did not get to run. The reader's own fact is missing, and it is
- * the strongest one this product ever has: their change is untested, and we can prove it, because we
- * planted bugs in those lines and their suite noticed none of them.
- *
- * SO THE VERDICT LEADS AND THE BOOKKEEPING FOLLOWS. The refusal sentence stays exactly where it was
- * and says exactly what it said - there is still no catch rate, because a guaranteed miss cannot
- * enter a rate whose denominator we chose - but it is no longer the first thing on the page.
- *
- * NO PERCENTAGE, EVER. This population is sized by us, so it is reported in counts, under the same
- * ruling that governs the AI-planted row (2026-08-14 as amended 2026-08-15).
- *
- * ABSENT UNLESS ALL THREE FACTS ARE IN HAND: coverage really measured, the unexecuted lines are the
- * change (all of it, or most of it), and bugs were really planted there and really unnoticed. A
- * sentence composed from two of the three would be a claim this run did not establish.
- *
- * THE CHECK RENDERER GETS THIS FILE WRITTEN INTO IT, rather than a second copy of it. The GitHub
- * App declares no dependencies at all - that is what stops the vocabulary from following a payload
- * into a package that only renders it - so `scripts/generate-decision-copies.mts` renders this
- * module into `apps/github-app/src/untested-change.generated.ts`, which the check imports.
- *
- * IT WAS TWO AUTHORED COPIES until 2026-08-31, run over the same facts by
- * `scripts/untested-change-copies.test.ts` and refused when they differed. Both are deleted. That
- * test held only within one checkout, and the App and the control plane deploy independently - so
- * the pair it could never reach is the pair that matters. Change a sentence here and run
- * `pnpm gen:action`.
- */
-/** What a run knows about a change nobody's tests run. */
-interface UntestedChangeFacts {
-    /** true only when diff coverage actually measured this run */
-    coverageMeasured: boolean;
-    changedLines: number;
-    coveredLines: number;
-    /**
-     * Bugs this run planted on those unexecuted lines that the suite did not notice - each one proven
-     * by a witness test that passes on today's code and fails on the bugged code.
-     */
-    unnoticed: number;
-}
-/**
- * The lead paragraph, or null when this run has not earned one.
- *
- * MOST, NOT SOME. A change with two unexecuted lines out of forty is a change with a gap in it, and
- * the bug cards below already carry that, one card per bug. This sentence says the CHANGE is
- * untested, so it is written only when the unexecuted lines are the change: all of them, or a
- * majority of them.
- */
-declare function untestedChangeLead(facts: UntestedChangeFacts): string[] | null;
-
 /**
  * How many changed lines nothing runs, and how many mutable sites sit on them.
  *
@@ -27305,6 +27976,14 @@ interface GapFinding {
     status: "survived" | "no-coverage";
     /** tests covering the location; ABSENT means no covering population was measured - audit D14 */
     coveredBy?: number;
+    /**
+     * How far this location sits from the nearest public entry point.
+     *
+     * Absent means nobody looked, and `unknown` means the scan ran and could not tell - only the
+     * second is a measurement. See the field's own note on `runFinding` for why the rung travels here
+     * rather than being joined off the proposal loop's summaries.
+     */
+    routePurity?: RoutePurityRung;
     triage?: TriageRecord;
     /**
      * Exact 1-based columns of the mutated span, and the source slice it replaced.
@@ -29343,306 +30022,6 @@ declare function readReportedModel(surface: ModelSurface, event: unknown): strin
  */
 declare function readTerminalFact(surface: ModelSurface, event: unknown): StreamTerminalFact | null;
 
-/**
- * THE EXECUTABLE SCHEMA KERNEL: one declaration per wire boundary, everything else derived.
- *
- * WHY THIS EXISTS. The fact-divergence audit found the same shape declared twice on twenty-one
- * boundaries: a producer writes the object, a consumer re-types it, and neither reads the other.
- * They agree in one checkout and drift the moment one side changes - and because a customer runs a
- * PINNED Action, a PINNED CLI or a PINNED GitHub App against a service that moved, the drift is not
- * a same-build risk that a test comparing the two copies could catch. Two of these already cost
- * real runs: a runner emitting a valid new state made the service discard every Angular and Deno
- * upload, and an added field made a pinned GitHub App throw away a whole check.
- *
- * WHAT A CONTRACT DECLARES ONCE, and what is derived from it rather than written beside it:
- *
- *   the TypeScript type          `Infer<typeof C>` - the type IS the schema, not a copy of it
- *   the consumer parser          `C.parse(value)` - one refusal grammar, one path syntax
- *   the producer projection      `project(C, value)` - drops what the contract does not carry
- *   every discriminator value    `C.fields.x.values` - the enum tuple, readable at runtime
- *   every limit                  `C.fields.x.max` - the cap, readable by producer and consumer
- *
- * THE UNKNOWN-FIELD POSTURE IS DECLARED, NOT ASSUMED, and it is the single most important field on
- * an object node. Two different boundaries want opposite answers and both are right:
- *
- *   `unknownFields: "refuse"` is an INGEST DOOR. The service stores what it accepts and serves it
- *   to a customer surface, so a key it does not know is a producer attaching something the boundary
- *   never agreed to carry - a source slice on a row that is supposed to be a path. Refusing is the
- *   privacy posture and it must stay.
- *
- *   `unknownFields: "ignore"` is a PINNED CONSUMER reading a NEWER PRODUCER. The GitHub App parsing
- *   the service's evidence object cannot refuse a field that did not exist when it was released;
- *   that exact refusal discarded a whole check. Additive change is the normal direction of travel
- *   on these boundaries, and a consumer that cannot survive it is a released-version outage.
- *
- * FAILURE IS A PATH AND A CAUSE, never a boolean. `runResult.fixLoop.summaries[3].verdict` tells a
- * maintainer which field of which row, which is what the hand-written validators were already
- * doing one string concatenation at a time.
- *
- * NOT A VALIDATION LIBRARY. It has exactly the node kinds these boundaries use. A boundary that
- * needs something else adds the node here, once, rather than hand-writing its own validator again.
- */
-/** Where in the document a value sat, in the syntax a maintainer reads in a refusal. */
-type WirePath = string;
-type WireResult<T> = {
-    ok: true;
-    value: T;
-} | {
-    ok: false;
-    error: string;
-};
-/**
- * A node in a wire contract.
- *
- * `kind` and the per-kind reflection fields are what make a contract READABLE rather than only
- * runnable: the limits mechanism (F27, F55, F60) needs the cap as a number, and the vocabulary
- * mechanism (F11, F23, F54, F85) needs the enum as a tuple. A validator that only validated would
- * leave those facts owned somewhere else again.
- */
-interface WireNode<T> {
-    readonly kind: string;
-    /** Parse an unknown value from the wire. `path` is where it sat, for the refusal sentence. */
-    parse(value: unknown, path?: WirePath): WireResult<T>;
-}
-type Infer<N> = N extends WireNode<infer T> ? T : never;
-interface WireEnum<V extends string> extends WireNode<V> {
-    readonly kind: "enum";
-    /** The closed vocabulary, in declaration order. THE tuple - readers derive, never re-type. */
-    readonly values: readonly V[];
-    readonly has: (value: string) => value is V;
-}
-/**
- * A closed vocabulary.
- *
- * THE TUPLE IS THE VOCABULARY. `values` is exported so a producer can iterate it, a renderer can
- * exhaustively map it and a test can enumerate it - which is what stops the second copy from being
- * written. `ProposalsVerdict` is `Infer<typeof verdict>`, so a value added here reaches the type
- * system, the parser and every render map in the same edit.
- */
-declare function wireEnum<const V extends readonly string[]>(values: V): WireEnum<V[number]>;
-/**
- * WHAT A TEXT BOUND IS COUNTED IN, said out loud.
- *
- * A LENGTH WITH NO UNIT IS TWO RULES (boundary contract divergence audit, the length-and-character
- * class). `admitCandidate` counts a generated test in UTF-8 BYTES and the proofs acceptor counts the
- * same test in JavaScript CHARACTERS, so a body that passed one measurement failed the other and the
- * proof was lost after it had been paid for. The two numbers differ by up to a factor of four on
- * text the model is free to write.
- *
- * A node states which it is, and a producer that has to agree with a door asks rather than assumes.
- */
-type TextUnit = "characters" | "bytes";
-interface WireString extends WireNode<string> {
-    readonly kind: "string";
-    /** Maximum characters, or `undefined` when the boundary declares no bound. */
-    readonly max?: number;
-    readonly min: number;
-    /** A byte ceiling, for a boundary whose downstream ceiling is stated in bytes rather than characters. */
-    readonly maxBytes?: number;
-    /**
-     * WHICH UNIT THIS FIELD'S BOUND IS COUNTED IN, and the number in it.
-     *
-     * `undefined` on a node that declares no bound at all. A node declaring BOTH reports bytes, which
-     * is the tighter of the two for any text outside ASCII and is therefore the one a producer has to
-     * satisfy to be carried.
-     */
-    readonly bound?: {
-        readonly unit: TextUnit;
-        readonly max: number;
-    };
-    /** The grammar the boundary agreed the value is written in, when it declared one. */
-    readonly pattern?: RegExp;
-}
-/** How long a value is, in the unit the node declares. Never a second reading of the same rule. */
-declare function textLength(node: WireString, value: string): number;
-/** Whether a value fits, asked by a producer in the unit the door will count in. */
-declare function textFits(node: WireString, value: string): boolean;
-/**
- * A string with the boundary's own bound on it.
- *
- * THE CAP IS PART OF THE CONTRACT, not a constant beside it. F60 is exactly this: the wire reason
- * string's 200-character maximum was repeated three times in the service and twice in the CLI, so
- * raising one producer's cap made the service refuse the whole draft. A producer reads
- * `contract.fields.reason.max` and truncates to it; the door parses with the same node.
- */
-declare function wireString(options?: {
-    max?: number;
-    min?: number;
-    maxBytes?: number;
-    pattern?: RegExp;
-    patternIs?: string;
-}): WireString;
-/** Printable single-line ASCII: the egress grammar every stored, signed or rendered string is held to. */
-declare const PRINTABLE_ASCII: RegExp;
-/** A full sha256, lower or upper case. The one spelling of "this is a digest, not a body". */
-declare const HEX_DIGEST_64: RegExp;
-/** A bounded printable string: the shape almost every egress field on these boundaries has. */
-declare function wirePrintable(options?: {
-    max: number;
-    min?: number;
-}): WireString;
-/**
- * PRINTABLE SINGLE-LINE TEXT, which is what a field carrying somebody ELSE's words may be.
- *
- * {@link wirePrintable} is ASCII and is right for a vocabulary this product ships. It is wrong for a
- * test's name or a path, which a customer or a model wrote: holding those to ASCII refused a whole
- * live-progress update over a test named `café` (boundary contract divergence audit, D08 and D10).
- * The property a rendered surface needs is that no line break, control character or lone surrogate
- * reaches it, and that is what this refuses - nothing else.
- */
-declare const PRINTABLE_TEXT: RegExp;
-declare function wirePrintableText(options: {
-    max: number;
-    min?: number;
-}): WireString;
-/** A sha256 identity. Never a body - see every contract's egress rule. */
-declare function wireDigest(): WireString;
-interface WireInteger extends WireNode<number> {
-    readonly kind: "integer";
-    readonly min?: number;
-    readonly max?: number;
-}
-declare function wireInteger(options?: {
-    min?: number;
-    max?: number;
-}): WireInteger;
-interface WireNumber extends WireNode<number> {
-    readonly kind: "number";
-    readonly min?: number;
-    readonly max?: number;
-}
-declare function wireNumber(options?: {
-    min?: number;
-    max?: number;
-}): WireNumber;
-interface WireBoolean extends WireNode<boolean> {
-    readonly kind: "boolean";
-}
-declare function wireBoolean(): WireBoolean;
-interface WireLiteral<V extends string> extends WireNode<V> {
-    readonly kind: "literal";
-    readonly value: V;
-}
-/**
- * The schema discriminator itself: `"abloh-proposals/v1"` and its siblings.
- *
- * A CONTRACT NAMES ITSELF ON THE WIRE. That string is how a consumer tells a document it was
- * released against from one it was not, which is the only durable answer to a pinned client meeting
- * a newer service. It is declared here so the producer stamps and the consumer checks one value.
- */
-declare function wireLiteral<const V extends string>(value: V): WireLiteral<V>;
-/**
- * An object this contract carries but does not describe.
- *
- * DELIBERATE, AND NARROW. It says "there is an object here" and hands it to the one module that
- * owns its shape. Used only where restating the cargo's rules would create the second authority
- * this whole kernel exists to remove - the live-progress envelope's `evidence`, whose one authority
- * is the ingest body parser, is the case it was written for.
- */
-declare function wireRecord(): WireNode<Record<string, unknown>>;
-interface WireNullable<T> extends WireNode<T | null> {
-    readonly kind: "nullable";
-    readonly inner: WireNode<T>;
-}
-/**
- * A field that may be `null` ON THE WIRE, which is not the same fact as being absent.
- *
- * `summary.model` is the case that decided the distinction: `null` says a mechanism wrote this
- * candidate and no model did, and ABSENT would say this producer does not record who wrote it.
- * A single "optional" would collapse two different answers into one.
- */
-declare function wireNullable<T>(inner: WireNode<T>): WireNullable<T>;
-interface WireArray<T> extends WireNode<readonly T[]> {
-    readonly kind: "array";
-    readonly item: WireNode<T>;
-    /** The row bound the boundary agreed to, or `undefined` when it declared none. */
-    readonly max?: number;
-}
-declare function wireArray<T>(item: WireNode<T>, options?: {
-    max?: number;
-}): WireArray<T>;
-/**
- * A field of an object contract: its node, and whether the wire may leave it out.
- *
- * `Optional` IS A LITERAL TYPE PARAMETER rather than a `boolean` property, because the inferred
- * TypeScript type is derived from it. Widened to `boolean`, every field reads as required and the
- * generated type stops matching the parser beside it - which would put the two back out of step in
- * the one place this kernel exists to keep them together.
- */
-interface WireField<T, Optional extends boolean = boolean> {
-    readonly node: WireNode<T>;
-    readonly optional: Optional;
-}
-declare function required<T>(node: WireNode<T>): WireField<T, false>;
-declare function optional<T>(node: WireNode<T>): WireField<T, true>;
-/**
- * A field whose ABSENCE and whose MALFORMATION are the same answer: it is dropped, and the rest of
- * the document is still read.
- *
- * NOT LAZINESS - IT IS A JUDGEMENT ABOUT WHAT THE DOCUMENT IS FOR, and it belongs to exactly the
- * fields where acting on the rest is worth more than refusing over the part. The admission answer's
- * approaching-limit warning is the case it was written for: refusing the whole body over a nudge
- * nobody was owed would discard the loop guard and the wall notice with it, and discarding a
- * refusal is admitting.
- *
- * USE IT ONLY WHERE THE FIELD CHANGES NOTHING THE CALLER DOES. A tolerated field that gated
- * anything would be a silent default, which is the opposite of what this kernel is for.
- */
-declare function tolerated<T>(node: WireNode<T>): WireField<T, true>;
-type WireFields = Record<string, WireField<unknown, boolean>>;
-type RequiredKeys<F extends WireFields> = {
-    [K in keyof F]: F[K]["optional"] extends true ? never : K;
-}[keyof F];
-type OptionalKeys<F extends WireFields> = {
-    [K in keyof F]: F[K]["optional"] extends true ? K : never;
-}[keyof F];
-type InferFields<F extends WireFields> = {
-    [K in RequiredKeys<F>]: Infer<F[K]["node"]>;
-} & {
-    [K in OptionalKeys<F>]?: Infer<F[K]["node"]>;
-};
-/** What a consumer does with a key the contract does not declare. See the file header. */
-type UnknownFieldPosture = "refuse" | "ignore";
-interface WireObject<F extends WireFields> extends WireNode<InferFields<F>> {
-    readonly kind: "object";
-    readonly fields: F;
-    readonly unknownFields: UnknownFieldPosture;
-    /** The declared key names, in declaration order - the field allowlist, derived not re-typed. */
-    readonly keys: readonly (keyof F & string)[];
-}
-declare function wireObject<const F extends WireFields>(fields: F, options: {
-    unknownFields: UnknownFieldPosture;
-}): WireObject<F>;
-interface WireUnion<T> extends WireNode<T> {
-    readonly kind: "union";
-    readonly discriminator: string;
-    /** Every variant's discriminator value: the closed tag vocabulary, readable at runtime. */
-    readonly tags: readonly string[];
-    readonly variant: (tag: string) => WireNode<unknown> | undefined;
-}
-/**
- * A tagged union, keyed on a field both sides agree names the variant.
- *
- * THE TAG SET IS DERIVED FROM THE VARIANTS. F79 to F81 are three copies of the same discriminator:
- * `engine-scenarios` writes the tag, `triage` re-declares it, and a prompt asks a model for a third
- * spelling. One variant map makes the tag vocabulary, the parser and the prompt fragment the same
- * fact, so a producer cannot emit a task that the resolver was never told about.
- */
-declare function wireUnion<const M extends Record<string, WireNode<unknown>>>(discriminator: string, variants: M): WireUnion<Infer<M[keyof M]>>;
-/**
- * The producer projection, derived from the same contract the consumer parses with.
- *
- * WHY PROJECT RATHER THAN SEND THE OBJECT. A producer's in-memory record is wider than what the
- * boundary agreed to carry - it holds the model that wrote a candidate, the source slice, the local
- * report. `project` keeps exactly the declared keys and drops the rest, which is the same rule the
- * `unknownFields: "refuse"` door enforces from the other side. Written twice, the two rules drifted
- * (F57: direct and live delivery projected different evidence from the same run).
- *
- * IT RETURNS A RESULT, not a value: a projection that cannot be parsed by its own contract is a
- * producer bug and the caller finds out here rather than at the customer's door.
- */
-declare function project<F extends WireFields>(contract: WireObject<F>, value: InferFields<F>): WireResult<InferFields<F>>;
-
 /**
  * THE CONTRACT'S NAME ON THE WIRE.
  *
@@ -30169,7 +30548,7 @@ interface ModelTerminalEvent {
 declare const modelTerminalEventContract: WireObject<{
     readonly type: WireField<"abloh.terminal", false>;
     readonly contract: WireField<string, false>;
-    readonly outcome: WireField<"failed" | "completed" | "refused" | "interrupted" | "incomplete" | "reply-too-large", false>;
+    readonly outcome: WireField<"completed" | "failed" | "refused" | "interrupted" | "incomplete" | "reply-too-large", false>;
     readonly servedModel: WireField<string, false>;
     readonly upstreamReportedModel: WireField<string, false>;
     readonly error: WireField<Record<string, unknown>, true>;
@@ -38793,6 +39172,46 @@ type ActionFileReader = (path: string) => string;
  */
 declare function actionRuntimeFiles(read: ActionFileReader, references?: readonly string[]): string[];
 
+/** What a setup trial measures, once the rule has been applied. */
+interface SetupTrialChange {
+    /** The commit the trial measures from. */
+    from: string;
+    /** The changed source lines it measures, which the caller hands to its own stages. */
+    scope: ScopeResult;
+    /**
+     * The one line to say, or null when the trial measures the change it was handed.
+     *
+     * THE SENTENCE IS THIS MODULE'S AND THE SYNTAX IS EACH SURFACE'S. In CI it goes out on the run's
+     * own narration channel and locally it goes into the init transcript, which is the ordinary split
+     * for copy with one author and two readers.
+     */
+    said: string | null;
+}
+declare function setupTrialChange(input: {
+    repoDir: string;
+    /** The commit the trial was going to measure from. */
+    from: string;
+    /** The commit it measures to. */
+    head: string;
+    /**
+     * What `from` already gives the trial, where the caller has it in hand.
+     *
+     * Computed here when absent, so a caller that has not asked yet does not have to ask twice.
+     */
+    scope?: ScopeResult;
+    /**
+     * May this trial measure the change before the one it was handed?
+     *
+     * FALSE FOR AN ORDINARY MEASUREMENT, and false for a trial with nowhere to go back to. Each caller
+     * states its own reason at the call site, because the facts that decide it - which flag was passed,
+     * whether the checkout holds an earlier commit - are the caller's and not this module's.
+     */
+    eligible: boolean;
+    /** The one directory being measured, where the run is scoped to one. */
+    pathspec?: string;
+    scopeOptions?: ScopeOptions;
+}): Promise<SetupTrialChange>;
+
 /**
  * THE EXECUTABLE SETUP SCRIPT, WHICH IS NOW WHAT `abloh init` PRODUCES.
  *
@@ -39057,6 +39476,47 @@ declare function renderSetupFailure(input: {
  * builds does. Two copies would be two answers to one question.
  */
 declare function installCommandNeedsCorepackEnable(installCommand: readonly string[]): boolean;
+/**
+ * THE COMMANDS `corepack enable` PUTS ON PATH.
+ *
+ * MEASURED AND NOT REMEMBERED: `corepack enable --install-directory <dir>` on corepack 0.34.7 writes
+ * exactly these four shims. That is the whole reason the step exists - a slim Node image's archive
+ * publishes no package called `pnpm` and never has, and this is how a `corepack pnpm install` still
+ * leaves a bare `pnpm` on PATH for the repository's own lifecycle scripts (see
+ * {@link installCommandNeedsCorepackEnable}).
+ *
+ * `npm` AND `npx` ARE DELIBERATELY NOT HERE. Corepack no longer shims them, and while a Node image
+ * carries both anyway that is a fact about the IMAGE - this list is what abloh's own STEP provides,
+ * and claiming a command the step does not install would drop a symptom the archive really can
+ * answer. The direction this list may never move in is wider than what was measured.
+ */
+declare const COREPACK_PROVIDES: readonly string[];
+/**
+ * WHAT ABLOH'S OWN SETUP SCRIPT PUTS ON PATH BEFORE THE SUITE RUNS.
+ *
+ * WHAT THIS FIXES (the captain's second ruling of 2026-09-15, round-2 maintainer review C1). The
+ * proof-image check asked the archive "does a package ship this command" and answered a maintainer
+ * `your suite needs the command pnpm and no package in your proof image's archive ships it. next:
+ * Pin environment.runtimeImage to an image whose archive carries it.` No Debian archive has ever
+ * published pnpm, abloh had derived that image, and step 1 of the `.abloh/setup.sh` abloh derived
+ * in the same command is `corepack enable` - which is precisely how pnpm gets onto PATH. The
+ * question the check has to ask is whether the command will EXIST when the suite runs, and the
+ * script is the source of truth for what abloh's own plan provides.
+ *
+ * IT READS THE COMMAND AND NOT THE COMMENT. A step's `what` is a description a maintainer may
+ * reword and their coding agent may rewrite; the shell is what runs, on every road, whether the
+ * steps came from {@link renderSetupScript} or from {@link parseSetupScript} reading a file
+ * somebody has edited since.
+ *
+ * COREPACK IS THE WHOLE OF IT TODAY, and that is a fact about the script rather than a gap. The
+ * other steps abloh writes are an `apt-get install` of packages whose contents only the archive
+ * knows, an install into `node_modules`, and the maintainer's own build lines - none of which names
+ * a command on PATH in text this reader could believe. A future step that demonstrably does gets a
+ * clause here, beside this one.
+ */
+declare function commandsProvidedBySetup(steps: readonly {
+    readonly command: string;
+}[]): ReadonlySet<string>;
 /**
  * Whether `environment.setup` names a path this product will read, and what is wrong when it does
  * not.
@@ -40632,296 +41092,6 @@ declare function findXmlElements(roots: readonly XmlElement[], name: string): re
 /** The first direct child named `name`, or undefined. */
 declare function xmlChild(element: XmlElement, name: string): XmlElement | undefined;
 
-/** The block names itself on the wire. Producer stamps it, door checks it, neither owns a copy. */
-declare const PROPOSALS_BLOCK_SCHEMA = "abloh-proposals/v1";
-/**
- * THE NAMES THIS DOCUMENT USED TO ANSWER TO, and why a door must still take them.
- *
- * The engine that writes these is MARIGOLD since the captain's naming ruling of 2026-08-31, and
- * that name is internal - so the documents took the plain word instead of either name. A schema id
- * is the one thing in a document that cannot be renamed by fiat: a customer's workflow pins the
- * Action by SHA and the CLI it installs is resolved at run time, so `api.abloh.dev` meets producers
- * released before this for as long as those pins stand, and a door that refused one would lose the
- * WHOLE envelope - every package's completed evidence with it.
- *
- * THE PRODUCER STAMPS ONE VALUE AND THE DOOR TAKES THREE. That asymmetry is the point and it is the
- * same one {@link RETIRED_EVIDENCE_OUTPUTS} and `RETIRED_REFUSAL_CODES` are built on: the write side
- * moves in one release, the read side waits out the pins. It expires with them - see
- * `EVIDENCE_REGROUPING_EXPIRY`, whose arithmetic this shares.
- */
-declare const RETIRED_PROPOSALS_BLOCK_SCHEMAS: readonly string[];
-/** Whether a block's own `schema` is one this build reads, live name or retired one. */
-declare function readsProposalsBlockSchema(schema: unknown): boolean;
-/**
- * The local proof sidecar's shape.
- *
- * `/v2` since 2026-08-28 (junction audit EVID-01 and EVID-02): a candidate row now carries its
- * support files and its own model and prompt version, and a kill-matrix cell carries its execution
- * count and its hold. Every `/v1` field is present and unchanged, so a reader written against `/v1`
- * reads a `/v2` document; the version is what lets one tell whether the missing provenance on an old
- * document means "no model wrote it" or "this producer did not record it".
- */
-declare const PROPOSALS_SIDECAR_SCHEMA = "abloh-proposals-proofs/v2";
-/**
- * The longest free sentence any marigold field carries onto the wire.
- *
- * IT IS NOT A DISPLAY LIMIT. The ingest door validates the field and fails the WHOLE draft when it
- * is over length, so a producer that overran it would not lose the sentence - it would lose the
- * run. F60: this number was declared three times in the service and twice in the CLI, each copy
- * with a comment saying it mirrored one of the others.
- */
-declare const WIRE_REASON_MAX = 200;
-/**
- * THE LONGEST HOLD SENTENCE A PRODUCER MAY WRITE, and why it is not {@link WIRE_REASON_MAX}.
- *
- * WHAT WENT WRONG (boundary contract divergence audit, 2026-09-08, D02 / F5). `lightCheckHoldReason`
- * composes a 225-character sentence for the one verdict a maintainer can actually act on - a test
- * command that exits non-zero without running a test, which is a lint, format, typecheck or build
- * stage standing in front of the runner, and the sentence names the config key that moves it. The
- * loop counts that sentence into `funnel["light-check"].holdReasons` verbatim, and the ingest door
- * held every hold-reason KEY to the 200-character reason bound. A `markedjs/marked` record was
- * refused as carrying "an unprintable hold reason" after a complete measurement.
- *
- * THE SHORTENING IS NOT THE FIX AND WOULD HAVE RELOCATED THE DEFECT. Cutting the sentence at 200
- * loses the half that names the key; making the producer refuse it loses the run at a different
- * boundary. What was wrong is that a bound written for a generic diagnostic was applied to a
- * vocabulary this product ships and has already decided the wording of - so the bound moves to fit
- * the vocabulary, and both ends read the moved one.
- *
- * MEASURED, NOT CHOSEN: 225 is the longest sentence any closed hold reason in
- * `@abloh/marigold` produces today, and `packages/marigold/src/hold-reason-vocabulary.test.ts`
- * enumerates that vocabulary and asserts every member survives {@link boundHoldReason} BYTE FOR
- * BYTE. Shorten this number below any shipped sentence and that test names the sentence it broke.
- * The headroom above 225 is what stops an ordinary rewording of an existing sentence from being a
- * wire change; a NEW sentence longer than the ceiling is one, under `RELEASE.md`'s order - the
- * reading side ships first.
- */
-declare const MEASURED_LONGEST_HOLD_REASON = 225;
-declare const WIRE_HOLD_REASON_MAX = 320;
-/**
- * THE LONGEST ENDING SENTENCE A RUN MAY SEND, and why it is not {@link WIRE_REASON_MAX} either.
- *
- * WHAT WENT WRONG (the displayer divergence audit of 2026-09-12, A5). `proposals.reason` carries one
- * of six closed sentences from `PROPOSALS_UNAVAILABLE_COPY` and nothing else - the audit's own words
- * for the field are that nothing in it originates outside that table - and two of the six are
- * abloh-owned, so their whole remedy is the ownership closing and a report id. That half was dropped
- * at the copy table, so a maintainer read that a run proposed no tests and never that the reason was
- * a defect in abloh nor what to quote when they asked about it.
- *
- * THE BOUND MOVES TO FIT THE VOCABULARY, which is exactly the reasoning above this line: a number
- * written for a generic diagnostic was applied to a vocabulary this product ships and has already
- * decided the wording of. `engine-error` with its closing is 218 characters and
- * `spec-not-found` 236, against a 200-character bound written for a free sentence.
- *
- * MEASURED, NOT CHOSEN: 236 is the longest of the six today, and
- * `apps/cli/src/marigold-multi-package.test.ts` enumerates that vocabulary and asserts every member
- * fits. The headroom is what stops an ordinary rewording from being a wire change; a new sentence
- * over the ceiling is one, under `RELEASE.md`'s order - the reading side ships first.
- */
-declare const MEASURED_LONGEST_PROPOSALS_ENDING = 236;
-declare const WIRE_PROPOSALS_ENDING_MAX = 360;
-/**
- * A hold reason in the representation both ends agree on.
- *
- * The key of `funnel[stage].holdReasons` and the summary row's own `holdReason` are the same fact
- * written in two places, so they take the same node. It is the door's reading; {@link boundHoldReason}
- * is the producer's, and the two are the same numbers because they are the same declaration.
- */
-declare const holdReasonText: WireString;
-/**
- * MAKE ANY REASON CARRYABLE, at the one place a producer records one.
- *
- * Most hold reasons are closed sentences and pass through untouched, which is the property the
- * vocabulary test pins. A few are COMPOSED - an admission rule list joined with commas, a repair
- * refusal quoting the rules it failed - and those have no bound of their own, so a producer that
- * recorded one directly could overrun the wire exactly as the closed sentence did. Folding here
- * means the funnel a run publishes is conformant by construction rather than by every call site
- * remembering.
- *
- * FOLD THEN CUT, in that order: removing a character leaves the spaces around it, so collapsing
- * first turns "failed <emoji> here" into a double space. The cut ends on a full stop so a reader
- * can see the sentence was cut rather than that the producer stopped mid-word.
- */
-declare function boundHoldReason(reason: string): string;
-/** Whether the v2 arm ran at all. */
-declare const proposalsFeatureState: WireEnum<"not-run" | "completed" | "disabled" | "unavailable">;
-type ProposalsFeatureState = Infer<typeof proposalsFeatureState>;
-declare const PROPOSALS_FEATURE_STATES: readonly ("not-run" | "completed" | "disabled" | "unavailable")[];
-/** What became of a gap the loop attempted. */
-declare const proposalsVerdict: WireEnum<"proven" | "rejected" | "not-attempted-budget">;
-type ProposalsVerdict = Infer<typeof proposalsVerdict>;
-declare const PROPOSALS_VERDICTS: readonly ("proven" | "rejected" | "not-attempted-budget")[];
-/**
- * WHERE THE BUG THIS GAP STANDS FOR CAME FROM. A MECHANISM, NEVER A MODEL.
- *
- * `mechanical` is the deterministic path: a mutation operator rewrote one boundary in the source -
- * a comparison, a literal, an arithmetic sign - and the suite did not notice the rewrite. What the
- * gap asserts is therefore a boundary fact, checkable by reading the operator and the two texts
- * beside each other.
- *
- * `planted-bug` is the agent bug pool: a defect was written into the file as a whole change rather
- * than derived from an operator, the repository's own suite was run against it, and the suite
- * passed. What the gap asserts is a behaviour the suite does not pin down, which is a wider claim
- * than one boundary and cannot be read off an operator name.
- *
- * WHY THE TWO NAMES ARE MECHANISMS. Kenneth's rule of 2026-08-14: no surface a customer or their
- * coding agent reads names the model that wrote anything. `model` and `promptVersion` stay on the
- * summary as internal provenance and are not served; this field is what a reader is told instead,
- * and it says how the bug was produced rather than by whom.
- *
- * `nearby` is the neighborhood slice (the captain's D7 of 2026-09-05): the gap is a whole-body
- * gutting, so mechanically it is the first of these two, but it sits ONE CALL AWAY from the change
- * rather than inside it. What it asserts is that a function the change calls, or that calls the
- * change, has no test that notices it going away - and a reader offered a test for it needs to know
- * that before they read the diff, because the file it names is one their change did not touch.
- *
- * NOTHING WITH THIS ORIGIN EVER SCORED AND NOTHING WITH IT EVER WILL. That is the permanent ruling
- * of 2026-08-14 about code outside the change, and this field only says which population a proposal
- * closed.
- *
- * Closed on purpose: a producer cannot invent a fourth origin and have it served. Adding this one
- * is a wire change under `RELEASE.md`'s order - the control plane learns the value before a CLI
- * that can emit it is released, or the whole block is refused.
- */
-declare const proposalsGapOrigin: WireEnum<"mechanical" | "planted-bug" | "nearby">;
-type ProposalsGapOrigin = Infer<typeof proposalsGapOrigin>;
-declare const PROPOSALS_GAP_ORIGINS: readonly ("mechanical" | "planted-bug" | "nearby")[];
-/**
- * What the whole suite did with the candidate present.
- *
- * Three of the four are about the CANDIDATE. `pre-red-unchanged` is about the REPOSITORY: its suite
- * does not pass on its own inside the sealed environment, and the candidate changed nothing about
- * that. It joined on 2026-08-23 with the exit proof's baseline - before it, a suite already red for
- * its own reasons rejected every candidate in the package, and the block had no value that could
- * say so (`docs/lessons/a-gate-measures-the-difference.md`). `regressed` is the only one that
- * rejects, and it means the candidate made tests fail that PASSED WITHOUT IT.
- */
-declare const proposalsSuiteState: WireEnum<"not-checked" | "green" | "regressed" | "pre-red-unchanged">;
-type ProposalsSuiteState = Infer<typeof proposalsSuiteState>;
-declare const PROPOSALS_SUITE_STATES: readonly ("not-checked" | "green" | "regressed" | "pre-red-unchanged")[];
-/** Whether the runner demonstrably collects a test at the candidate's path. */
-declare const proposalsDiscoveryState: WireEnum<"confirmed" | "unconfirmed">;
-type ProposalsDiscoveryState = Infer<typeof proposalsDiscoveryState>;
-declare const PROPOSALS_DISCOVERY_STATES: readonly ("confirmed" | "unconfirmed")[];
-/**
- * The route-purity ladder, purest first. Ordinal by construction: a route's rung is the WORST
- * contact on it, and the engine's `worstOf` depends on this array's order.
- *
- * A producer cannot invent a sixth rung and have it served: the rung decides what sentence a
- * customer reads about their own code, and an unrecognised one would reach a surface with no copy
- * for it. `unknown` is a real rung and is accepted as one - "we looked and could not tell" is a
- * different fact from "nobody looked", and only the second is spelled by omitting the field.
- */
-declare const routePurityRung: WireEnum<"unknown" | "pure-exported" | "exported-with-io" | "scaffolding-reachable" | "structurally-out-of-reach">;
-type RoutePurityRung = Infer<typeof routePurityRung>;
-declare const ROUTE_PURITY_RUNGS: readonly ("unknown" | "pure-exported" | "exported-with-io" | "scaffolding-reachable" | "structurally-out-of-reach")[];
-/** What the predictor did to this run's execution set. */
-declare const proposalsPredictorMode: WireEnum<"shadow" | "cold" | "skipping">;
-type ProposalsPredictorMode = Infer<typeof proposalsPredictorMode>;
-declare const PROPOSALS_PREDICTOR_MODES: readonly ("shadow" | "cold" | "skipping")[];
-/** Field length caps, so an oversized string can never bloat a stored or signed egress record. */
-declare const PROPOSALS_MUTANT_ID_MAX = 600;
-declare const PROPOSALS_FILE_PATH_MAX = 512;
-/**
- * One offered (or refused) candidate, in the form that may leave the customer's machine.
- *
- * `unknownFields: "refuse"` IS THE PRIVACY POSTURE AND IT STAYS. What egresses is digests, counts,
- * verdicts and named reasons - never a generated test body, never a source slice, never a runner
- * report. A key this contract does not declare is a producer attaching something the boundary never
- * agreed to carry, and the door refuses it by name.
- */
-declare const proposalsSummary: WireObject<{
-    /** run-local mutant id, so a reader can join back to the mutant record */
-    readonly mutantId: WireField<string, false>;
-    /** cross-run gap identity, derived from what was mutated */
-    readonly gapId: WireField<string, false>;
-    /**
-     * How the bug this gap stands for was produced. A fact about the GAP, not about the candidate.
-     *
-     * ABSENT IS ACCEPTED AND MEANS `mechanical`. A block written before the field existed measured
-     * one population and it was the mechanical one, so reading absence as mechanical states what
-     * that run did rather than guessing.
-     */
-    readonly origin: WireField<"mechanical" | "planted-bug" | "nearby", true>;
-    /**
-     * WHERE THE GAP IS: the file and the first line of the span that was mutated.
-     *
-     * Absent on every block written before it existed, and empty-with-zero on a verdict whose gap
-     * the loop could not resolve - which is the "not recorded" the producer writes, so it is
-     * accepted rather than refused.
-     */
-    readonly file: WireField<string, true>;
-    readonly startLine: WireField<number, true>;
-    /** sha256 over the generated bundle; the bundle itself stays local */
-    readonly candidateDigest: WireField<string, false>;
-    readonly verdict: WireField<"proven" | "rejected" | "not-attempted-budget", false>;
-    /** the round that produced this candidate; round 1 means it worked first time */
-    readonly round: WireField<number, false>;
-    /**
-     * The per-test runner that executed it.
-     *
-     * NOT AN ENUM HERE. The runner vocabulary is the capability registry's, and closing over a copy
-     * of it is the exact defect that refused every Angular and deno upload. The door validates this
-     * against `RUNNER_CAPABILITIES`; see `runnerNameNode` below.
-     */
-    readonly runner: WireField<string, false>;
-    readonly model: WireField<string | null, false>;
-    readonly promptVersion: WireField<string, false>;
-    readonly suite: WireField<"not-checked" | "green" | "regressed" | "pre-red-unchanged", false>;
-    readonly discovery: WireField<"confirmed" | "unconfirmed", false>;
-    /** other gaps this same candidate closes, from the kill matrix */
-    readonly alsoClosesCount: WireField<number, false>;
-    /**
-     * Named reason when the verdict is not `proven`; never free-form model text.
-     *
-     * THE SAME NODE THE FUNNEL'S KEYS TAKE. The loop writes one `Hold.reason` into both places, so a
-     * sentence the funnel carries and this field refuses would be one fact with two bounds - which
-     * is D02 one field over.
-     */
-    readonly holdReason: WireField<string, true>;
-    /**
-     * How pure the shortest PUBLIC route to this gap's mutated line is.
-     *
-     * A closed rung or nothing: absent is a block written before the classifier existed, which is a
-     * fact about the producer rather than about the customer's code.
-     */
-    readonly routePurity: WireField<"unknown" | "pure-exported" | "exported-with-io" | "scaffolding-reachable" | "structurally-out-of-reach", true>;
-}>;
-/** The wire shape of a summary row: what the door accepts. See the header on producer narrowing. */
-type ProposalsSummaryWire = Infer<typeof proposalsSummary>;
-/** The declared key names - the door's field allowlist, derived and never re-typed. */
-declare const PROPOSALS_SUMMARY_FIELDS: readonly ("runner" | "file" | "startLine" | "verdict" | "promptVersion" | "model" | "origin" | "suite" | "candidateDigest" | "mutantId" | "gapId" | "round" | "discovery" | "alsoClosesCount" | "holdReason" | "routePurity")[];
-/**
- * The proof-shape rules a `proven` verdict must satisfy, stated once for both sides.
- *
- * THE WORD IS SHORT FOR THREE FACTS AND NOTHING MORE, which is what {@link PROVEN_BASIS} spells out
- * for every reader: a candidate asserting that the implementation file still CONTAINS a literal
- * satisfied "fails on the mutant, passes on the original" perfectly well and was recorded proven
- * having never called the function. The third fact is the one that rules that out, so a record that
- * carries the control's outcome is held to it here rather than at a call site.
- *
- * RECOMPUTED RATHER THAN TRUSTED at the door, and asserted by the producer before it writes: a
- * proven candidate must have been through the whole suite without breaking it AND have proven the
- * runner collects its path.
- *
- * TWO SUITE STATES SATISFY THE FIRST since 2026-08-23, and the second is not a loophole. `green` is
- * the suite passing with the candidate present. `pre-red-unchanged` is a suite that does not pass on
- * its own inside the sealed environment and that the candidate did not change - a fact about the
- * REPOSITORY, established by running the same suite in the same box with nothing generated in it.
- * The only alternative to it is the false conviction it replaced: a package whose tests drive `git`
- * is red inside an image that carries no `git`, so every candidate in it was rejected for 26
- * failures it did not cause (`docs/lessons/a-gate-measures-the-difference.md`). What stays refused
- * is `regressed`, the only state that says this candidate broke something.
- */
-declare const PROVEN_BASIS: string;
-declare function provenShapeProblem(summary: {
-    verdict: string;
-    suite: string;
-    discovery: string;
-    /** The control's own outcome, where the reader holds it. See {@link PROVEN_BASIS}. */
-    textControl?: string;
-}): string | undefined;
-
 /**
  * HOW A PROJECTION SPELLS "NOTHING TO SAY" - the rule, in the one form three processes can run.
  *
@@ -41101,6 +41271,23 @@ declare const runFinding: WireObject<{
      * omission on every side, and the door accepts omission.
      */
     readonly coveredBy: WireField<number, true>;
+    /**
+     * HOW FAR THIS LOCATION SITS FROM THE NEAREST PUBLIC ENTRY POINT.
+     *
+     * THE RUNG TRAVELS ON THE FINDING BECAUSE THE ONLY OTHER CARRIER COULD NOT REACH THIS LANE. A
+     * served finding used to get its rung by joining `mutantId` against the proposal loop's own
+     * summaries, and a summary exists only for a gap that loop TOOK - so an uncovered changed line,
+     * and any mechanical survivor the loop never reached, had no rung at all and the run page said
+     * `route could not be read` about a file the planted lane had read a minute earlier
+     * (`data/abloh-diagnose-uncovered-account-lost-on-the-pr-road/report.md`, B2).
+     *
+     * IT IS THE SAME SCAN either way - `classifyRoutePurity` over the file and the line - so the two
+     * carriers cannot disagree about one location; what changes is that every filed finding has one.
+     *
+     * ABSENT MEANS NOBODY LOOKED, which `RUN_FINDING_ABSENCE` spells as omission, and `unknown` is a
+     * real rung meaning the scan ran and could not tell. Only the second is a measurement.
+     */
+    readonly routePurity: WireField<"pure-exported" | "exported-with-io" | "scaffolding-reachable" | "structurally-out-of-reach" | "unknown", true>;
     /**
      * The classifier's record, or an explicit null for a finding nothing triaged.
      *
@@ -41171,7 +41358,7 @@ declare const runFinding: WireObject<{
 type RunFindingWire = Infer<typeof runFinding>;
 
 /** The declared key names: the projection's allowlist and the sanitizer's, derived and never re-typed. */
-declare const RUN_FINDING_FIELDS: readonly ("file" | "startLine" | "coveredBy" | "triage" | "status" | "endLine" | "mutantId" | "mutator")[];
+declare const RUN_FINDING_FIELDS: readonly ("file" | "startLine" | "coveredBy" | "routePurity" | "mutantId" | "triage" | "status" | "endLine" | "mutator")[];
 declare const RUN_FINDING_TRIAGE_FIELDS: readonly ("description" | "reasonCode" | "verdict" | "confidence" | "about" | "severity" | "severityBasis" | "emoji" | "overridden" | "effort" | "modelId" | "promptVersion" | "carried" | "carriedAtSha")[];
 /**
  * HOW THIS BOUNDARY SPELLS "NOTHING TO SAY", per key.
@@ -41266,7 +41453,7 @@ declare const proposalsCandidate: WireObject<{
     readonly textControl: WireField<InferFields<{
         readonly schema: WireField<"abloh-candidate-text-control/v1", false>;
         readonly file: WireField<string, false>;
-        readonly outcome: WireField<"passed" | "failed" | "unavailable" | "not-executed", false>;
+        readonly outcome: WireField<"unavailable" | "passed" | "failed" | "not-executed", false>;
         readonly identifiers: WireField<number, false>;
         readonly numbers: WireField<number, false>;
         readonly separators: WireField<number, false>;
@@ -41280,7 +41467,7 @@ declare const proposalsCandidate: WireObject<{
 }>;
 type ProposalsCandidateWire = Infer<typeof proposalsCandidate>;
 /** The uploaded field list, derived. `upload-projection.ts` copies exactly these and no others. */
-declare const PROPOSALS_CANDIDATE_FIELDS: readonly ("testName" | "testFile" | "testBody" | "gapId" | "round" | "candidateId" | "textControl")[];
+declare const PROPOSALS_CANDIDATE_FIELDS: readonly ("gapId" | "round" | "testName" | "testFile" | "testBody" | "candidateId" | "textControl")[];
 /** What an admission finding about uploadability is called. One rule per field, one name per rule. */
 declare const CANDIDATE_UPLOAD_RULES: readonly ["upload-body-cap", "upload-path-cap", "upload-name-cap"];
 type CandidateUploadRule = (typeof CANDIDATE_UPLOAD_RULES)[number];
@@ -41310,7 +41497,7 @@ declare const CANDIDATE_TEXT_CONTROL_DETAIL_MAX = 4000;
 declare const candidateTextControl: WireObject<{
     readonly schema: WireField<"abloh-candidate-text-control/v1", false>;
     readonly file: WireField<string, false>;
-    readonly outcome: WireField<"passed" | "failed" | "unavailable" | "not-executed", false>;
+    readonly outcome: WireField<"unavailable" | "passed" | "failed" | "not-executed", false>;
     readonly identifiers: WireField<number, false>;
     readonly numbers: WireField<number, false>;
     readonly separators: WireField<number, false>;
@@ -42570,6 +42757,159 @@ declare function alwaysEmittedEvidenceKeys(): readonly string[];
  */
 declare function runRecordReaderProblems(): readonly string[];
 
+/**
+ * EVERY FACT A RUN LEAVES BEHIND DECLARES THE SURFACES IT IS SHOWN ON.
+ *
+ * WHAT THIS FIXES (surface parity audit, 2026-09-13). A refusal has declared its destinations since
+ * `REFUSAL_DESTINATIONS` existed, and every other fact a run establishes had nothing of the kind.
+ * So a fact could be measured, projected, accepted at the door, stored, served - and drawn nowhere,
+ * with every suite in the product green, because each side tested its own half against a fixture of
+ * what it believed the others did. The audit measured four of those on one real run:
+ *
+ *   THE BASELINE'S OWN CENSUS reached the run page only where an AI pool happened to have run,
+ *   because it rode that block; a run with the identical stored count and no pool said nothing.
+ *
+ *   THE QUARANTINE GROWTH ALARM named the newly failing tests on the check and the comment, and
+ *   sent the dashboard four integers - so the surface with the most room to list them could say
+ *   three tests could not be measured and never which.
+ *
+ *   HOW MUCH OF THE CHANGE THE PLANTED SEARCH REACHED was said in the terminal and on the pull
+ *   request, and the dashboard drew the three counts with nothing saying what they covered.
+ *
+ *   TWO DIAGNOSTICS the Action projects were never retained at all, with no record saying so.
+ *
+ * SO EVERY STORED FACT HAS ONE ENTRY HERE, CARRYING FOUR THINGS:
+ *
+ *   - `fact`      what it IS, in one line, in the words a reader would use.
+ *   - `storedAt`  the dotted path on the stored run record. It is the JOIN: the totality check
+ *                 walks a real record and refuses a populated path no entry claims.
+ *   - `owner`     the module and symbol that put it there, so a surface arguing with the value has
+ *                 one place to go.
+ *   - `surfaces`  TOTAL over {@link REFUSAL_DESTINATIONS}. Every destination says either where it
+ *                 draws the fact, or - in writing - why it deliberately does not.
+ *
+ * THE DECLARATION IS A CENSUS AND NOT AN UPPER BOUND, which is the whole difference from
+ * `RUN_RECORD_CONTRACT`'s `readers` one file over. That one says which destinations a field is
+ * PERMITTED to reach, and a permitted-and-absent cell is exactly the state four facts were in. This
+ * one says which destinations DO reach it, and `run-facts-declare-their-surfaces.test.ts` drives
+ * the real composer for each and refuses a `shown` cell whose surface draws nothing.
+ *
+ * WHY THE SEVEN SURFACES OF THE RULING ARE FIVE DESTINATIONS HERE. The check run and the
+ * pull-request comment are one destination because the comment IS the check's own summary with a
+ * heading and a footer around it, so a fact on one is on the other by construction. The run page
+ * and the work queue are one because they are one app reading one served payload; where a fact is
+ * on one view and not the other, the cell says which. Minting names for the halves would be a
+ * second surface vocabulary beside the registry's, which `scripts/surface-vocabulary.test.ts`
+ * refuses outright and which is the divergence this table exists to end rather than to repeat.
+ *
+ * NOTHING HERE IS CUSTOMER-FACING. No sentence in this file is printed anywhere; `where` and
+ * `reason` are written for whoever next asks why a surface is quiet about a run's own measurement.
+ */
+
+/**
+ * A DESTINATION EITHER DRAWS THE FACT OR SAYS WHY IT DOES NOT. There is no third state and no
+ * absent cell: an omission is how the four the audit found stayed invisible for months, so the
+ * record is total and a new destination stops `pnpm typecheck` in every entry until somebody has
+ * decided what it does about every fact.
+ */
+type RunFactVisibility = 
+/** Drawn here. `where` names the view and the element, so the probe has something to look for. */
+{
+    readonly kind: "shown";
+    readonly where: string;
+}
+/** Deliberately absent, with the argument. Rendered as "not shown on purpose: <reason>". */
+ | {
+    readonly kind: "withheld";
+    readonly reason: string;
+};
+/** Drawn on this surface, in this view. */
+declare const shown: (where: string) => RunFactVisibility;
+/**
+ * NOT DRAWN, ON PURPOSE, AND THE PREFIX IS THE HELPER'S RATHER THAN THE AUTHOR'S.
+ *
+ * The ruling's words are "a surface deliberately left off carries a written reason, 'not shown on
+ * purpose: ...'", and a prefix typed at two hundred call sites is a prefix that is right at a
+ * hundred and ninety of them. {@link withheldSentence} composes it, so the declaration carries the
+ * argument and nothing else.
+ */
+declare const withheld: (reason: string) => RunFactVisibility;
+/** The one rendering of a withheld cell, wherever one is printed or compared. */
+declare function withheldSentence(cell: RunFactVisibility): string | null;
+interface RunFactContract {
+    /** What the fact is, in one line, in the words a reader would use. */
+    readonly fact: string;
+    /** Dotted path on the stored run record. `[]` stands for every element of an array. */
+    readonly storedAt: string;
+    /** Repo-relative path (from `product/`) of the module that establishes it. */
+    readonly owner: string;
+    /** The declaration in that module that establishes it. */
+    readonly ownerSymbol: string;
+    /** Total over every destination. */
+    readonly surfaces: Readonly<Record<RefusalDestination, RunFactVisibility>>;
+}
+/**
+ * EVERY FACT THE CONTROL PLANE STORES FROM A RUN.
+ *
+ * TOTAL OVER A REAL RECORD. `scripts/run-facts-declare-their-surfaces.test.ts` walks one stored run
+ * with every fact populated and refuses a populated path no entry claims, so a fact that gains a
+ * key gains an entry or fails the build. {@link RUN_FACTS_NOT_CUSTOMER_FACING} is where the
+ * scaffolding around a measurement - identities, digests, schema versions - is named instead.
+ */
+declare const RUN_FACT_SURFACES: Readonly<Record<string, RunFactContract>>;
+type RunFactName = keyof typeof RUN_FACT_SURFACES;
+/**
+ * WHAT THE RECORD HOLDS THAT IS NOT A FACT ABOUT THE CODE.
+ *
+ * Identity, addressing and bookkeeping: who the run belongs to, what it is about, the digests that
+ * bind its files, the schema it was written under. A surface may well print one - the run page's
+ * byline draws the commit - and none of them is a MEASUREMENT, which is what the table above
+ * declares the surfaces of. Naming them here is what keeps the totality check total without
+ * loosening it: a path in neither list fails the build.
+ *
+ * A path here matches itself and everything under it, on a dot boundary.
+ */
+declare const RUN_FACTS_NOT_CUSTOMER_FACING: Readonly<Record<string, string>>;
+/**
+ * A FACT DECLARED SHOWN ON A SURFACE THAT DOES NOT DRAW IT YET, named until it does.
+ *
+ * The same instrument `RUN_RECORD_WIRE_GAPS` is one file over, and for the same reason: a deliberate
+ * gap is declared with what closes it, in a table somebody empties, rather than by loosening the
+ * check until it stops finding anything.
+ */
+declare const RUN_FACT_SURFACE_GAPS: Readonly<Record<string, string>>;
+/**
+ * WHAT THE ENVELOPE CARRIES THAT THE CONTROL PLANE DELIBERATELY KEEPS NONE OF.
+ *
+ * SURFACE PARITY AUDIT, D16, which asked for one of two answers: preserve the fact for a whole run,
+ * or declare it intentionally local. These are the second answer, and the argument is the same for
+ * both - a value no surface could act on is a value the service has no business holding about a
+ * customer's run.
+ *
+ * IT IS NOT A THIRD VISIBILITY STATE. A fact in this list is never stored, so it has no `storedAt`
+ * and no row in the table above; the totality check walks the record and would never reach it.
+ */
+declare const RUN_FACTS_NOT_RETAINED: Readonly<Record<string, string>>;
+/** Does `path` name `prefix`, or something under it, on a dot boundary? */
+declare function factPathCovers(prefix: string, path: string): boolean;
+/**
+ * THE CHECK, stated here so the table and its test ask one function.
+ *
+ * A fact declared `shown` on a surface that draws nothing is a reader with no writer - the exact
+ * state the audit found four facts in. Returns the offending `<fact>.<destination>` pairs, each
+ * with what it claims; {@link RUN_FACT_SURFACE_GAPS} is what stands between here and empty.
+ */
+declare function runFactSurfaceProblems(drawn: (fact: string, destination: RefusalDestination) => boolean, destinations: readonly RefusalDestination[]): readonly string[];
+/**
+ * A POPULATED PATH ON A STORED RUN THAT NO ENTRY CLAIMS.
+ *
+ * This is the half that makes the table total rather than a list somebody remembered to add to: a
+ * fact that gains a key on the record gains an entry here, or fails the build.
+ */
+declare function undeclaredRunFactPaths(paths: readonly string[]): readonly string[];
+/** Every destination, so a caller can hold a record to being total over the vocabulary. */
+declare function runFactDestinations(): readonly RefusalDestination[];
+
 /**
  * WHO PRODUCED A RUN RECORD, DECLARED ONCE.
  *
@@ -42994,7 +43334,7 @@ declare const PLAYGROUND_STAGE_EVENT: WireUnion<InferFields<{
     readonly at: WireField<string, false>;
 }> | InferFields<{
     readonly type: WireField<"mutation-finished", false>;
-    readonly outcome: WireField<"timeout" | "unobserved" | "passed" | "failed", false>;
+    readonly outcome: WireField<"timeout" | "passed" | "unobserved" | "failed", false>;
     readonly mutantId: WireField<string, false>;
     readonly sequence: WireField<number, false>;
     readonly at: WireField<string, false>;
@@ -43005,7 +43345,7 @@ declare const PLAYGROUND_STAGE_EVENT: WireUnion<InferFields<{
     readonly at: WireField<string, false>;
 }> | InferFields<{
     readonly type: WireField<"confirmation-finished", false>;
-    readonly outcome: WireField<"timeout" | "unobserved" | "passed" | "failed", false>;
+    readonly outcome: WireField<"timeout" | "passed" | "unobserved" | "failed", false>;
     readonly mutantId: WireField<string, false>;
     readonly sequence: WireField<number, false>;
     readonly at: WireField<string, false>;
@@ -43029,7 +43369,7 @@ declare const PLAYGROUND_STAGE_EVENT: WireUnion<InferFields<{
     readonly at: WireField<string, false>;
 }> | InferFields<{
     readonly type: WireField<"run-finished", false>;
-    readonly outcome: WireField<"failed" | "completed" | "cancelled", false>;
+    readonly outcome: WireField<"completed" | "failed" | "cancelled", false>;
     readonly sequence: WireField<number, false>;
     readonly at: WireField<string, false>;
 }>>;
@@ -43068,7 +43408,7 @@ declare const PLAYGROUND_STAGE_EVENTS: WireNode<readonly (InferFields<{
     readonly at: WireField<string, false>;
 }> | InferFields<{
     readonly type: WireField<"mutation-finished", false>;
-    readonly outcome: WireField<"timeout" | "unobserved" | "passed" | "failed", false>;
+    readonly outcome: WireField<"timeout" | "passed" | "unobserved" | "failed", false>;
     readonly mutantId: WireField<string, false>;
     readonly sequence: WireField<number, false>;
     readonly at: WireField<string, false>;
@@ -43079,7 +43419,7 @@ declare const PLAYGROUND_STAGE_EVENTS: WireNode<readonly (InferFields<{
     readonly at: WireField<string, false>;
 }> | InferFields<{
     readonly type: WireField<"confirmation-finished", false>;
-    readonly outcome: WireField<"timeout" | "unobserved" | "passed" | "failed", false>;
+    readonly outcome: WireField<"timeout" | "passed" | "unobserved" | "failed", false>;
     readonly mutantId: WireField<string, false>;
     readonly sequence: WireField<number, false>;
     readonly at: WireField<string, false>;
@@ -43103,7 +43443,7 @@ declare const PLAYGROUND_STAGE_EVENTS: WireNode<readonly (InferFields<{
     readonly at: WireField<string, false>;
 }> | InferFields<{
     readonly type: WireField<"run-finished", false>;
-    readonly outcome: WireField<"failed" | "completed" | "cancelled", false>;
+    readonly outcome: WireField<"completed" | "failed" | "cancelled", false>;
     readonly sequence: WireField<number, false>;
     readonly at: WireField<string, false>;
 }>)[]>;
@@ -43129,8 +43469,27 @@ declare const PLAYGROUND_MODEL_RESPONSE: WireObject<{
     readonly severityBasis: WireField<string, false>;
     readonly review: WireField<"unclear" | "harmful" | "harmless", false>;
     readonly rationale: WireField<string, false>;
+    /**
+     * PERMITTED, NEVER REQUIRED, so a runtime released before the ask existed still validates: it
+     * sends nothing, this reads nothing, and the page draws the declared fallback exactly as it did.
+     * Absent means nothing chose one, on every reader.
+     */
+    readonly emoji: WireField<"🌿" | "📏" | "💥" | "🏷" | "📮" | "🔁" | "🔀" | "🧹" | "⚖" | "🛟" | "🎛" | "💰" | "🧾" | "💳" | "🧮" | "⏰" | "📅" | "🌍" | "🔑" | "🔒" | "🪪" | "📦" | "📤" | "📥" | "🔌" | "🪝" | "🧯" | "🚦" | "🧭" | "🔢" | "🔤" | "📐" | "🧊", true>;
 }>;
 type PlaygroundModelResponse = Infer<typeof PLAYGROUND_MODEL_RESPONSE>;
+/**
+ * THE MODEL'S OWN REPLY, READ ONCE.
+ *
+ * A DECORATIVE FIELD MAY NOT FAIL THE PARSE, which is why the emoji is dropped here rather than
+ * refused. This function is what reads a reply straight off the model, and the emoji is the one
+ * field in it a model can fumble without saying anything wrong: refusing the object over an
+ * off-list character would spend the paid call and hand the visitor no sentences at all, on a reply
+ * whose four sentences were fine. {@link acceptFindingEmoji} is the SAME acceptor the product's
+ * lanes drop a bad answer with, so absent, null and off-list are one outcome on all three.
+ *
+ * The node above still takes exact membership, because that door reads a result abloh's own worker
+ * produced rather than a model's reply - by then this function has already dropped anything else.
+ */
 declare function validatePlaygroundModelResponse(value: unknown, caption?: string): PlaygroundModelResponse | null;
 declare const PLAYGROUND_EXPLANATION: WireNode<InferFields<{
     readonly state: WireField<"observed", false>;
@@ -43145,6 +43504,12 @@ declare const PLAYGROUND_EXPLANATION: WireNode<InferFields<{
         readonly severityBasis: WireField<string, false>;
         readonly review: WireField<"unclear" | "harmful" | "harmless", false>;
         readonly rationale: WireField<string, false>;
+        /**
+         * PERMITTED, NEVER REQUIRED, so a runtime released before the ask existed still validates: it
+         * sends nothing, this reads nothing, and the page draws the declared fallback exactly as it did.
+         * Absent means nothing chose one, on every reader.
+         */
+        readonly emoji: WireField<"🌿" | "📏" | "💥" | "🏷" | "📮" | "🔁" | "🔀" | "🧹" | "⚖" | "🛟" | "🎛" | "💰" | "🧾" | "💳" | "🧮" | "⏰" | "📅" | "🌍" | "🔑" | "🔒" | "🪪" | "📦" | "📤" | "📥" | "🔌" | "🪝" | "🧯" | "🚦" | "🧭" | "🔢" | "🔤" | "📐" | "🧊", true>;
     }>, false>;
     readonly authority: WireField<"model-advisory", false>;
     readonly scoreEffect: WireField<"none", false>;
@@ -43172,7 +43537,7 @@ declare const PLAYGROUND_EXECUTED_TEST: WireObject<{
     readonly name: WireField<string, false>;
     readonly fullName: WireField<string, false>;
     readonly suite: WireField<readonly string[], false>;
-    readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+    readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
 }>;
 declare const PLAYGROUND_TEST_EXECUTION: WireUnion<InferFields<{
     readonly phase: WireField<"mutation" | "confirmation", false>;
@@ -43183,7 +43548,7 @@ declare const PLAYGROUND_TEST_EXECUTION: WireUnion<InferFields<{
         readonly name: WireField<string, false>;
         readonly fullName: WireField<string, false>;
         readonly suite: WireField<readonly string[], false>;
-        readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+        readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
     }>[], false>;
 }> | InferFields<{
     readonly phase: WireField<"mutation" | "confirmation", false>;
@@ -43194,7 +43559,7 @@ declare const PLAYGROUND_TEST_EXECUTION: WireUnion<InferFields<{
         readonly name: WireField<string, false>;
         readonly fullName: WireField<string, false>;
         readonly suite: WireField<readonly string[], false>;
-        readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+        readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
     }>[], false>;
 }>>;
 declare const PLAYGROUND_TEST_EXECUTIONS: WireNode<readonly (InferFields<{
@@ -43206,7 +43571,7 @@ declare const PLAYGROUND_TEST_EXECUTIONS: WireNode<readonly (InferFields<{
         readonly name: WireField<string, false>;
         readonly fullName: WireField<string, false>;
         readonly suite: WireField<readonly string[], false>;
-        readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+        readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
     }>[], false>;
 }> | InferFields<{
     readonly phase: WireField<"mutation" | "confirmation", false>;
@@ -43217,7 +43582,7 @@ declare const PLAYGROUND_TEST_EXECUTIONS: WireNode<readonly (InferFields<{
         readonly name: WireField<string, false>;
         readonly fullName: WireField<string, false>;
         readonly suite: WireField<readonly string[], false>;
-        readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+        readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
     }>[], false>;
 }>)[]>;
 type PlaygroundExecutedTest = Mutable<Infer<typeof PLAYGROUND_EXECUTED_TEST>>;
@@ -43277,7 +43642,7 @@ declare const PLAYGROUND_MUTANT_EVIDENCE: WireObject<{
             readonly name: WireField<string, false>;
             readonly fullName: WireField<string, false>;
             readonly suite: WireField<readonly string[], false>;
-            readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+            readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
         }>[], false>;
     }> | InferFields<{
         readonly phase: WireField<"mutation" | "confirmation", false>;
@@ -43288,7 +43653,7 @@ declare const PLAYGROUND_MUTANT_EVIDENCE: WireObject<{
             readonly name: WireField<string, false>;
             readonly fullName: WireField<string, false>;
             readonly suite: WireField<readonly string[], false>;
-            readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+            readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
         }>[], false>;
     }>)[], false>;
 }>;
@@ -43318,7 +43683,7 @@ declare const PLAYGROUND_ENGINE_MUTANT_FIELDS: {
             readonly name: WireField<string, false>;
             readonly fullName: WireField<string, false>;
             readonly suite: WireField<readonly string[], false>;
-            readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+            readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
         }>[], false>;
     }> | InferFields<{
         readonly phase: WireField<"mutation" | "confirmation", false>;
@@ -43329,7 +43694,7 @@ declare const PLAYGROUND_ENGINE_MUTANT_FIELDS: {
             readonly name: WireField<string, false>;
             readonly fullName: WireField<string, false>;
             readonly suite: WireField<readonly string[], false>;
-            readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+            readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
         }>[], false>;
     }>)[], false>;
 };
@@ -43351,7 +43716,7 @@ declare const PLAYGROUND_ENGINE_MUTANT: WireNode<InferFields<{
             readonly name: WireField<string, false>;
             readonly fullName: WireField<string, false>;
             readonly suite: WireField<readonly string[], false>;
-            readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+            readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
         }>[], false>;
     }> | InferFields<{
         readonly phase: WireField<"mutation" | "confirmation", false>;
@@ -43362,7 +43727,7 @@ declare const PLAYGROUND_ENGINE_MUTANT: WireNode<InferFields<{
             readonly name: WireField<string, false>;
             readonly fullName: WireField<string, false>;
             readonly suite: WireField<readonly string[], false>;
-            readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+            readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
         }>[], false>;
     }>)[], false>;
 }>>;
@@ -43381,6 +43746,12 @@ declare const PLAYGROUND_PUBLIC_MUTANT: WireObject<{
             readonly severityBasis: WireField<string, false>;
             readonly review: WireField<"unclear" | "harmful" | "harmless", false>;
             readonly rationale: WireField<string, false>;
+            /**
+             * PERMITTED, NEVER REQUIRED, so a runtime released before the ask existed still validates: it
+             * sends nothing, this reads nothing, and the page draws the declared fallback exactly as it did.
+             * Absent means nothing chose one, on every reader.
+             */
+            readonly emoji: WireField<"🌿" | "📏" | "💥" | "🏷" | "📮" | "🔁" | "🔀" | "🧹" | "⚖" | "🛟" | "🎛" | "💰" | "🧾" | "💳" | "🧮" | "⏰" | "📅" | "🌍" | "🔑" | "🔒" | "🪪" | "📦" | "📤" | "📥" | "🔌" | "🪝" | "🧯" | "🚦" | "🧭" | "🔢" | "🔤" | "📐" | "🧊", true>;
         }>, false>;
         readonly authority: WireField<"model-advisory", false>;
         readonly scoreEffect: WireField<"none", false>;
@@ -43432,7 +43803,7 @@ declare const PLAYGROUND_PUBLIC_MUTANT: WireObject<{
             readonly name: WireField<string, false>;
             readonly fullName: WireField<string, false>;
             readonly suite: WireField<readonly string[], false>;
-            readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+            readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
         }>[], false>;
     }> | InferFields<{
         readonly phase: WireField<"mutation" | "confirmation", false>;
@@ -43443,7 +43814,7 @@ declare const PLAYGROUND_PUBLIC_MUTANT: WireObject<{
             readonly name: WireField<string, false>;
             readonly fullName: WireField<string, false>;
             readonly suite: WireField<readonly string[], false>;
-            readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+            readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
         }>[], false>;
     }>)[], false>;
 }>;
@@ -43462,6 +43833,12 @@ declare const PLAYGROUND_PUBLIC_ROSTER: WireNode<readonly InferFields<{
             readonly severityBasis: WireField<string, false>;
             readonly review: WireField<"unclear" | "harmful" | "harmless", false>;
             readonly rationale: WireField<string, false>;
+            /**
+             * PERMITTED, NEVER REQUIRED, so a runtime released before the ask existed still validates: it
+             * sends nothing, this reads nothing, and the page draws the declared fallback exactly as it did.
+             * Absent means nothing chose one, on every reader.
+             */
+            readonly emoji: WireField<"🌿" | "📏" | "💥" | "🏷" | "📮" | "🔁" | "🔀" | "🧹" | "⚖" | "🛟" | "🎛" | "💰" | "🧾" | "💳" | "🧮" | "⏰" | "📅" | "🌍" | "🔑" | "🔒" | "🪪" | "📦" | "📤" | "📥" | "🔌" | "🪝" | "🧯" | "🚦" | "🧭" | "🔢" | "🔤" | "📐" | "🧊", true>;
         }>, false>;
         readonly authority: WireField<"model-advisory", false>;
         readonly scoreEffect: WireField<"none", false>;
@@ -43513,7 +43890,7 @@ declare const PLAYGROUND_PUBLIC_ROSTER: WireNode<readonly InferFields<{
             readonly name: WireField<string, false>;
             readonly fullName: WireField<string, false>;
             readonly suite: WireField<readonly string[], false>;
-            readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+            readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
         }>[], false>;
     }> | InferFields<{
         readonly phase: WireField<"mutation" | "confirmation", false>;
@@ -43524,7 +43901,7 @@ declare const PLAYGROUND_PUBLIC_ROSTER: WireNode<readonly InferFields<{
             readonly name: WireField<string, false>;
             readonly fullName: WireField<string, false>;
             readonly suite: WireField<readonly string[], false>;
-            readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+            readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
         }>[], false>;
     }>)[], false>;
 }>[]>;
@@ -43607,6 +43984,12 @@ declare const PLAYGROUND_PUBLIC_RESULT_MATERIAL: WireObject<{
                 readonly severityBasis: WireField<string, false>;
                 readonly review: WireField<"unclear" | "harmful" | "harmless", false>;
                 readonly rationale: WireField<string, false>;
+                /**
+                 * PERMITTED, NEVER REQUIRED, so a runtime released before the ask existed still validates: it
+                 * sends nothing, this reads nothing, and the page draws the declared fallback exactly as it did.
+                 * Absent means nothing chose one, on every reader.
+                 */
+                readonly emoji: WireField<"🌿" | "📏" | "💥" | "🏷" | "📮" | "🔁" | "🔀" | "🧹" | "⚖" | "🛟" | "🎛" | "💰" | "🧾" | "💳" | "🧮" | "⏰" | "📅" | "🌍" | "🔑" | "🔒" | "🪪" | "📦" | "📤" | "📥" | "🔌" | "🪝" | "🧯" | "🚦" | "🧭" | "🔢" | "🔤" | "📐" | "🧊", true>;
             }>, false>;
             readonly authority: WireField<"model-advisory", false>;
             readonly scoreEffect: WireField<"none", false>;
@@ -43658,7 +44041,7 @@ declare const PLAYGROUND_PUBLIC_RESULT_MATERIAL: WireObject<{
                 readonly name: WireField<string, false>;
                 readonly fullName: WireField<string, false>;
                 readonly suite: WireField<readonly string[], false>;
-                readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+                readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
             }>[], false>;
         }> | InferFields<{
             readonly phase: WireField<"mutation" | "confirmation", false>;
@@ -43669,7 +44052,7 @@ declare const PLAYGROUND_PUBLIC_RESULT_MATERIAL: WireObject<{
                 readonly name: WireField<string, false>;
                 readonly fullName: WireField<string, false>;
                 readonly suite: WireField<readonly string[], false>;
-                readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+                readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
             }>[], false>;
         }>)[], false>;
     }>[], false>;
@@ -43705,7 +44088,7 @@ declare const PLAYGROUND_PUBLIC_RESULT_MATERIAL: WireObject<{
         readonly at: WireField<string, false>;
     }> | InferFields<{
         readonly type: WireField<"mutation-finished", false>;
-        readonly outcome: WireField<"timeout" | "unobserved" | "passed" | "failed", false>;
+        readonly outcome: WireField<"timeout" | "passed" | "unobserved" | "failed", false>;
         readonly mutantId: WireField<string, false>;
         readonly sequence: WireField<number, false>;
         readonly at: WireField<string, false>;
@@ -43716,7 +44099,7 @@ declare const PLAYGROUND_PUBLIC_RESULT_MATERIAL: WireObject<{
         readonly at: WireField<string, false>;
     }> | InferFields<{
         readonly type: WireField<"confirmation-finished", false>;
-        readonly outcome: WireField<"timeout" | "unobserved" | "passed" | "failed", false>;
+        readonly outcome: WireField<"timeout" | "passed" | "unobserved" | "failed", false>;
         readonly mutantId: WireField<string, false>;
         readonly sequence: WireField<number, false>;
         readonly at: WireField<string, false>;
@@ -43740,7 +44123,7 @@ declare const PLAYGROUND_PUBLIC_RESULT_MATERIAL: WireObject<{
         readonly at: WireField<string, false>;
     }> | InferFields<{
         readonly type: WireField<"run-finished", false>;
-        readonly outcome: WireField<"failed" | "completed" | "cancelled", false>;
+        readonly outcome: WireField<"completed" | "failed" | "cancelled", false>;
         readonly sequence: WireField<number, false>;
         readonly at: WireField<string, false>;
     }>)[], false>;
@@ -43804,6 +44187,12 @@ declare const PLAYGROUND_PUBLIC_RESULT: WireObject<{
                 readonly severityBasis: WireField<string, false>;
                 readonly review: WireField<"unclear" | "harmful" | "harmless", false>;
                 readonly rationale: WireField<string, false>;
+                /**
+                 * PERMITTED, NEVER REQUIRED, so a runtime released before the ask existed still validates: it
+                 * sends nothing, this reads nothing, and the page draws the declared fallback exactly as it did.
+                 * Absent means nothing chose one, on every reader.
+                 */
+                readonly emoji: WireField<"🌿" | "📏" | "💥" | "🏷" | "📮" | "🔁" | "🔀" | "🧹" | "⚖" | "🛟" | "🎛" | "💰" | "🧾" | "💳" | "🧮" | "⏰" | "📅" | "🌍" | "🔑" | "🔒" | "🪪" | "📦" | "📤" | "📥" | "🔌" | "🪝" | "🧯" | "🚦" | "🧭" | "🔢" | "🔤" | "📐" | "🧊", true>;
             }>, false>;
             readonly authority: WireField<"model-advisory", false>;
             readonly scoreEffect: WireField<"none", false>;
@@ -43855,7 +44244,7 @@ declare const PLAYGROUND_PUBLIC_RESULT: WireObject<{
                 readonly name: WireField<string, false>;
                 readonly fullName: WireField<string, false>;
                 readonly suite: WireField<readonly string[], false>;
-                readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+                readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
             }>[], false>;
         }> | InferFields<{
             readonly phase: WireField<"mutation" | "confirmation", false>;
@@ -43866,7 +44255,7 @@ declare const PLAYGROUND_PUBLIC_RESULT: WireObject<{
                 readonly name: WireField<string, false>;
                 readonly fullName: WireField<string, false>;
                 readonly suite: WireField<readonly string[], false>;
-                readonly status: WireField<"passed" | "failed" | "skipped" | "unknown", false>;
+                readonly status: WireField<"unknown" | "passed" | "failed" | "skipped", false>;
             }>[], false>;
         }>)[], false>;
     }>[], false>;
@@ -43902,7 +44291,7 @@ declare const PLAYGROUND_PUBLIC_RESULT: WireObject<{
         readonly at: WireField<string, false>;
     }> | InferFields<{
         readonly type: WireField<"mutation-finished", false>;
-        readonly outcome: WireField<"timeout" | "unobserved" | "passed" | "failed", false>;
+        readonly outcome: WireField<"timeout" | "passed" | "unobserved" | "failed", false>;
         readonly mutantId: WireField<string, false>;
         readonly sequence: WireField<number, false>;
         readonly at: WireField<string, false>;
@@ -43913,7 +44302,7 @@ declare const PLAYGROUND_PUBLIC_RESULT: WireObject<{
         readonly at: WireField<string, false>;
     }> | InferFields<{
         readonly type: WireField<"confirmation-finished", false>;
-        readonly outcome: WireField<"timeout" | "unobserved" | "passed" | "failed", false>;
+        readonly outcome: WireField<"timeout" | "passed" | "unobserved" | "failed", false>;
         readonly mutantId: WireField<string, false>;
         readonly sequence: WireField<number, false>;
         readonly at: WireField<string, false>;
@@ -43937,7 +44326,7 @@ declare const PLAYGROUND_PUBLIC_RESULT: WireObject<{
         readonly at: WireField<string, false>;
     }> | InferFields<{
         readonly type: WireField<"run-finished", false>;
-        readonly outcome: WireField<"failed" | "completed" | "cancelled", false>;
+        readonly outcome: WireField<"completed" | "failed" | "cancelled", false>;
         readonly sequence: WireField<number, false>;
         readonly at: WireField<string, false>;
     }>)[], false>;
@@ -44122,4 +44511,4 @@ declare function nodeOptionInsertionPoint(argv: readonly string[], takesAValue?:
  */
 declare function destinationRepairs(argv: readonly string[]): string[];
 
-export { ABLOH_FAILURE_OWNERSHIP, ABLOH_FAILURE_OWNERSHIP_ANONYMOUS, ABLOH_SUPPORT_ADDRESS, ACCOUNT_MODEL_VARIABLES, ACCOUNT_ORGANIZATION_VAR, ACCOUNT_SESSION_TOKEN_VAR, ACCOUNT_TOKEN_URL_VAR, ACTION_NON_IMPORTED_ASSETS, ACTION_REFERENCES, ACTION_REPOSITORY, ADDITION_GROUPS, ADMISSION_DRIFT_PHRASES, ADMISSION_SENTENCE_MAX, ALL_STAGES_RAN_NOTE, ANGULAR_RUNNERS, ANNOTATION_SEVERITIES, API_KEY_SCOPES, ASTER_COVERAGE_FORMAT, ASTER_COVERAGE_PROVIDER, ASTER_COVERAGE_RAW_FORMAT, ASTER_COVERAGE_SCHEMA, ASTER_ENGINE_NAME, ASTER_ENGINE_VERSION, ATTESTATION_JOB_ID, ATTEST_ACTION, AUDITABLE_SOURCE_EXTENSIONS, type AblohConfig, type AblohFailureFacts, type ActionFileReader, type AddedVariable, type AdditionGroup, type AdmissionCoverage, type AdmissionDrift, type AdmissionDriftKind, type AdmissionKeyFacts, type AdmissionNeed, type AdmissionNeedFacts, type AdmissionRefusalReason, type AdmissionSubject, type AngularKarmaShape, type AngularRunnerName, type AngularTestRunner, type AngularTestTarget, type AnnotationSeverity, type ApiKeyScope, type AppliedCeilings, type ArchiveComponent, type ArchiveIdentity, type ArtifactDestinationFacts, type ArtifactDestinationProblem, type ArtifactOutputPathCombination, type ArtifactOutputPathFacts, type ArtifactOutputPathProblem, type ArtifactPublicationLockCombination, type ArtifactPublicationLockFacts, type ArtifactWriteCombination, type ArtifactWriteFacts, type AssayResult, type AssayVerdict, type AsterCoverageCensus, type AsterCoverageEvidence, type AsterCoverageFile, type AsterCoverageLine, type AttestResultsV2, type AttestStatus, type AttestationEnvironment, type AttestationInput, type AttributionQuality, type AuditScope, BASELINE_HISTORY_MAPPING, BASELINE_HISTORY_REASONS, BASELINE_JOB_CLOCK_REMEDY, BASELINE_JOB_CLOCK_RESERVE_SUITE_RUNS, BASELINE_LINE_MAPPING, BASELINE_PUBLICATION_ALLOWANCE_MS, BASELINE_RUN_FACTOR, BASELINE_RUN_FLOOR_MS, BOOST_MS_PER_DAY, BROWSER_LANE_MEASURED_ENVIRONMENT, BROWSER_LANE_SEAL, BROWSER_SHARED_MEMORY_ARGV, BROWSER_SHARED_MEMORY_PATH, BROWSER_SHARED_MEMORY_TMPFS, BUG_BEHAVIOUR_VERDICTS, BUG_EMOJI, BUG_SEVERITIES, BUN_DIFF_COVERAGE_NOTICE, BUN_DIFF_COVERAGE_NOTICE_SHORT, type BaseReachability, type BaseUnreachableCause, type BaselineCombination, type BaselineCommand, type BaselineGateAbsence, type BaselineHistoryCombination, type BaselineHistoryLine, type BaselineHistoryReason, type BaselineJobClock, type BaselineJobClockStop, type BaselineLine, type BaselineLineCombination, type BaselineOutcomeEvidence, type BaselineOutcomeFacts, type BaselineRunBound, type BaselineRunBoundSource, type BrowserSealClause, type BugBehaviourVerdict, type BugSeverity, type BuildCiPropertyBlockInput, type BuildScenarioSearchBlockInput, type BuiltOutputFacts, CANDIDATE_BODY_MAX, CANDIDATE_ENTRIES_MAX, CANDIDATE_NAME_MAX, CANDIDATE_PATH_MAX, CANDIDATE_TEXT_CONTROL_DETAIL_MAX, CANDIDATE_TEXT_CONTROL_SCHEMA, CANDIDATE_UPLOAD_RULES, CANONICAL_MODEL_VARIABLES, CARRIED_AFTER_SHA, CARRIED_BEFORE_SHA, CARRIED_BUG_OUTCOMES, CARRIED_SHA_LENGTH, CARRIED_UNNAMED, CHECKOUT_ACTION, CHECK_ADMISSION_SCHEMA, CHECK_ADMISSION_TIMEOUT_MS, CHROME_DENIED_CLONE_FLAGS, CHROME_SECCOMP_ADDITIONS, CI_OBLIGATION_SIGNAL_AUTHORITIES, CI_PROPERTY_AUTHORITIES, CI_PROPERTY_CAPS, CI_PROPERTY_FAMILIES, CI_PROPERTY_INTENT_POOL_SCHEMA, CI_PROPERTY_INTENT_TASK_SCHEMA, CI_PROPERTY_OUTCOMES, CI_PROPERTY_STATES, CI_RESIDUAL_STATES, CLI_COMMANDS, CLI_HELP_REMEDY, CLI_MAPPINGS, CLI_OPTIONS, CLI_OPTION_CONFIG_CONFLICT_REMEDY, CLI_OPTION_CONFLICT_REMEDY, CLI_OPTION_UNAVAILABLE_REMEDY, CLI_PATH_PROBLEMS, CLUSTER_STRATEGIES, COMMAND_READ_PROBLEMS, COMPUTE_RATE_ENV, CONFIG_DOCS_URL, CONFIG_FILE_PATH, CONFIG_KEY_REGISTRY, CONTROL_CHARACTERS, CONVENTIONAL_HEADER_MAX_LENGTH, CONVENTIONAL_TYPES, COST_UNKNOWN, COVERAGE_DISPLAY_STATES, COVERAGE_EVIDENCE_SCHEMA, COVERAGE_LINE_MAPPING, COVERAGE_PROVIDER_CACHE_DEFAULT_ROOT, COVERAGE_PROVIDER_CACHE_DIR_VAR, COVERAGE_PROVIDER_CHOICES, COVERAGE_STATE_WORDS, COVERAGE_VERDICT, CREDENTIAL_SHAPE_MASK, CUSTOMER_TYPED, type CallerJobOutcome, type CandidateTextControl, type CandidateUploadRule, type CarriedBugOutcome, type CarriedStanding, type CarriedVerdict, type CellObservation, type ChangedStructuralCounts, type CheckAdmissionCombination, type CheckAdmissionFacts, type CheckAdmissionRequestWire, type CheckAdmissionResponseWire, type CheckAdmissionSilence, type CheckoutIdentity, type ChromeSeccompAddition, type ChromeSeccompArg, type CiChangedRange, type CiObligationSignal, type CiObligationSignalAuthority, type CiPropertyAuthority, type CiPropertyCandidateCap, type CiPropertyCounts, type CiPropertyFamily, type CiPropertyMeasuredBlock, type CiPropertyOutcome, type CiPropertyRuleCandidate, type CiPropertyRuleDrop, type CiPropertySearchBlock, type CiPropertyState, type CiPropertySummary, type CiPropertyTargetCandidate, type CiPropertyTargetDecision, type CiPropertyTargetPlan, type CiResidualGapEntry, type CiResidualGapLedger, type CiResidualState, type CiStepsUnreadFacts, type ClassicMutationConfig, type ClassicMutationTier, type ClassicSamplingBlock, type CliCommand, type CliFacts, type CliOption, type CliPathProblem, type CliValueShape, type ClusterStrategy, type CodeownersRule, type CombinedGate, type CommandGlobExpansion, type CommandLine, type CommandLineCombination, type CommandLineObservation, type CommandPlan, type CommandProvenance, type CommandReadProblem, type CommandResolutionStop, type CommandRuntime, type CommandScriptHop, type CompiledOutputReading, type ComposedFindings, type ConditionalPowerResult, type ConfigInRangeCombination, type ConfigInRangeFacts, type ConfigInRangeSilence, type ConfigKeyEntry, type ConfigKeyReader, type ConfigKeyStanding, type ConfigLoad, type ConfigOrigin, type ConfigReadOptions, type ConfigTreeEntryCombination, type ConfigTreeEntryFacts, type ConfigTreeEntrySilence, type ConfigValueJudge, type ConfigValueRule, type ConfigValueVerdict, type ConfinementClause, type ConsumedGeneratedImport, type ContentsEntry, type ContentsIndexRef, type ConventionalHeader, type CoreSilence, type CorepackCacheFacts, type Counts, type CoverageAcquisitionObservation, type CoverageAdapterResolutionObservation, type CoverageAddressableFacts, type CoverageBundledPackageFacts, type CoverageCacheFacts, type CoverageComposition, type CoverageDisplayState, type CoverageEvidence, type CoverageEvidenceChild, type CoverageFacts, type CoverageLine, type CoverageLineCombination, type CoverageProvider, type CoverageProviderCacheFacts, type CoverageProviderChoice, type CoverageProviderFacts, type CoverageProviderObservation, type CoverageReportFormatFacts, type CoverageReportSizeFacts, type CoverageRunnerFacts, type CoverageScopeFacts, type CoverageStateWords, type CoverageVerdictState, DECLARED_SERVICE_CONFINEMENT, DEEPEN_FETCH_TIMEOUT_MS, DEEPEN_LADDER, DEEP_AUDIT_ARTIFACT_SCHEMA, DEEP_AUDIT_FINDING_ORIGINS, DEEP_AUDIT_LINE_VERDICTS, DEEP_AUDIT_SCOPE_SOURCES, DEFAULT_CLASSIC_MUTATION, DEFAULT_CONFIG, DEFAULT_DIFF_COVERAGE, DEFAULT_ENVIRONMENT, DEFAULT_ENVIRONMENT_IMAGE_DIGEST, DEFAULT_ENVIRONMENT_IMAGE_REF, DEFAULT_FLOOR, DEFAULT_MODEL_ENDPOINT, DEFAULT_MUTATION, DEFAULT_NATIVE_VOCABULARY, DEFAULT_SETUP_BOT_LOGIN, DEFAULT_SETUP_ROAD, DEPENDENCY_PATH_SEGMENTS, DESTINATION_LABELS, DIFF_COVERAGE_CANNOT_ATTEST_REASONS, DIFF_COVERAGE_THRESHOLD, DISPLAY_CUT_MARK, DISPLAY_TRUNCATABLE_FIELDS, DOCKER_DEFAULT_SECCOMP_SOURCE, type DecisiveLayer, type DeclaredEnvironment, type DeclaredKey, type DeclaredKeyCombination, type DeclaredKeyObservation, type DeclaredPackageManager, DeclaredRefusalError, type DeclaredValue, type DeepAuditArtifactParse, type DeepAuditCountsReport, type DeepAuditCoverageFileReport, type DeepAuditCoverageRange, type DeepAuditFinding, type DeepAuditFindingOrigin, type DeepAuditLineVerdict, type DeepAuditReachReport, type DeepAuditRunArtifact, type DeepAuditScopeReport, type DeepAuditScopeSource, type DeepAuditSpendReport, type DetectionCell, type DeterministicMutantsBlock, type DiffCoverageCannotAttestReason, type DiffCoverageConfig, type DiffCoverageCounts, type DiffCoverageLine, type DiffCoverageLineState, type DiffCoverageNotApplicableReason, type DiffCoverageNotRunReason, type DiffCoverageResult, DiffScopeError, type DisplayTruncatableField, type DisplayTruncation, type DockerCommandRunner, type DockerInvocation, ENGINE_FAILURE_LOG, ENGINE_FAILURE_REPORT_ID_PATTERN, ENGINE_FAILURE_SHAPE_NAMES, ENGINE_FAILURE_TIMED_OUT, ENGINE_MODEL_FAILURES, ENVELOPE_ONLY_EVIDENCE_KEYS, ENVIRONMENT_AMENDMENT_COMMIT_MESSAGE, EVIDENCE_API_KEY_SCOPES, EVIDENCE_CUT_CLAUSE, EVIDENCE_EGRESS_SAFE, EVIDENCE_INDEX_MISSING_REMEDY, EVIDENCE_INDEX_UNREADABLE_REPORT_ID, EVIDENCE_MANIFEST_SCHEMA, EVIDENCE_OUTPUTS, EVIDENCE_REGROUPING_EXPIRY, EVIDENCE_RETENTION_DEFAULT_DAYS, EVIDENCE_RETENTION_MAX_DAYS, EVIDENCE_RETENTION_MIN_DAYS, EVIDENCE_SOURCES, EVIDENCE_WORD, EXCLUDE_RE, EXECUTION_ROADS, EXECUTION_STAGES, EXPECTED_ORACLE_CELL, type EgressEngineFailure, type EgressRefusal, type EngineFailureBlock, type EngineFailureShape, type EngineModelFailure, type EnsureBaseReachableInput, type EnvironmentConfig, type EnvironmentServiceConfig, type ErrorHandlersBlock, type ErrorPathsConfig, type EvidenceCustody, type EvidenceFloor, type EvidenceIndexFacts, type EvidenceIndexProblem, type EvidenceKind, type EvidenceManifest, type EvidenceManifestEntry, type EvidenceOutput, type EvidenceOutputId, type EvidenceProfile, type EvidenceProvenance, type EvidenceRole, type EvidenceSlot, type EvidenceSource, type EvidenceUploadPlan, type EvidenceVerdictState, type EvidenceWithholdReason, type ExecutionAxis, type ExecutionCapabilities, type ExecutionCopies, type ExecutionCopy, type ExecutionCopyMethod, type ExecutionPlan, type ExecutionRecord, type ExecutionRecordSink, type ExecutionRoad, type ExecutionStage, type ExpandedCommandGlobs, type ExperimentManifest, FAIL_FAST_JOB_NOTE, FEATURE_NOT_RUN_REASONS, FINDINGS_TABLE_MAPPING, FINDING_CARRIED_SHA, FINDING_EMOJI, FINDING_EMOJI_FALLBACK, FINDING_FILE_PATH_MAX, FINDING_MUTANT_ID_MAX, FINDING_MUTATOR_MAX, FINDING_PROVENANCE_MAX, FINDING_SEVERITIES, type FactMapping, type FactTestRow, type FactsOf, type FailFastJob, type FailFastReading, type FailedTestFile, type FeatureNotRunReason, type FeatureState, type FileFacts, type FileScope, type FileStructural, type FindingSeverity, type FindingStatus, type FindingTitleParts, type FindingsTable, type FindingsTableCombination, type FirstPassProjection, type FirstPassRates, type FittedRefusal, type FixLoopBlock, type FixProofSummary, type FixProofVerdict, type FlakyConfig, type FloorConfig, GATE_VERDICT, GATE_WORD, GENERATION_STATES, type GapFinding, type GapKeyInput, type GateResult, type GateStatus, type GateVerdictState, type GeneratedPath, type GenerationState, type GitCommandCombination, type GitCommandFacts, type GitCommandSilence, type GitHubStructuralFinding, type GithubValue, type GroupableFinding, HANDOFF_EVIDENCE_KEYS_V1, HANDOFF_EVIDENCE_KEYS_V2, HANDOFF_TARGET_KEYS, HEALABLE_SETUP_STAGES, HEX_DIGEST_64, HOSTED_CHECKS_NEED_NO_KEYS, HOSTED_RUN_HEADER, type HandlerAntiPatternKind, type HandlerFinding, type HeadroomResult, type HeadroomVerdict, type HistoricalPair, type HostedRunIdentity, IDENTITY_CONDITION_CODES, IMPORT_SELECTOR_PREFIX, INACTIVE_INPUT_REASONS, INIT_DOORS, INIT_FAILURE_CLASSES, INIT_OUTCOMES, INIT_PACKAGE_MANAGERS, INIT_QUESTION_KEYS, INIT_RUNNERS, INIT_TELEMETRY_SCHEMA, INIT_TELEMETRY_VERSION, INTENT_TASK_COMMON_FIELDS, INTERRUPTION_MECHANISMS, INVENTORY_NAME_RENDER_LIMIT, type IdentityConditionFacts, type IdentityConditionKind, type ImportHop, type InactiveInputReason, type InactiveInputs, type IndexCandidate, type IndexQuery, type Infer, type InferFields, type InitDoor, type InitFailureClass, type InitOutcome, type InitPackageManager, type InitQuestionKey, type InitRunner, type InitTelemetryEvent, type InstalledInput, type InstrumentationComparison, type InstrumentationDivergence, type InterruptionMechanism, InvariantError, JEST_WATCH_DISABLE_FLAGS, JEST_WATCH_DISABLE_SUFFIX, JOB_CLOCK_COST_BASES, JOB_CLOCK_SEALED_STAGES, JOB_CLOCK_STAGES, JOB_CLOCK_STAGE_OVERHEADS, JOB_CLOCK_STAGE_UNITS, type JobClockCostBasis, type JobClockStage, type JobClockStageOverhead, type JobClockStageProjection, type JobClockStageStop, type JobClockStageUnit, type JobTimeBudgetRefusalFacts, KNOWN_ENVIRONMENT_KEYS, KNOWN_SETUP_KEYS, LAYER0_EXECUTION, LAYER0_SCOPE_DISCLOSURE, LAYER1_EXECUTION, LAYER2_INTENT_PROPOSAL_FIELDS, LAYER2_INTENT_PROPOSAL_SCHEMA, LAYER2_INTENT_TASK_SCHEMA, LIVE_PROGRESS_MAX_UPDATES_PER_RUN, LIVE_PROGRESS_SCHEMA, LIVE_PROGRESS_SUMMARY_MAX_BYTES, LIVE_PROGRESS_TIMEOUT_MS, LIVE_PROGRESS_TITLE_MAX, LOCAL_DESTINATIONS, LOCAL_LADDER_LEAD_IN, LOCAL_MODEL_DOCS_URL, LOCAL_TRIAL_ANSWERS, LOCK_POLL_MS, LOCK_STALE_MS, LOCK_WAIT_MS, type Layer1GateInput, type Layer2IntentProposalField, type LedgerEntry, type LineGroup, type LiveProgressUpdateWire, type LocalTrialAnswer, MAINLINE_BRANCHES, MAX_ANNOTATION_MUTATORS, MAX_ANNOTATION_REASONS, MAX_ANSWERED_SYSTEM_PACKAGES, MAX_ARTIFACT_COVERAGE_FILES, MAX_ARTIFACT_FINDINGS, MAX_ARTIFACT_RANGES_PER_FILE, MAX_BUG_DESCRIPTION_LEN, MAX_BUG_RATIONALE_LEN, MAX_BUG_SENTENCE_LEN, MAX_BUG_TYPE_LEN, MAX_CARRIED_BUG_ENTRIES, MAX_DEEPEN_DEPTH, MAX_DIAGNOSTIC_REASON_CHARS, MAX_ENVIRONMENT_SERVICES, MAX_EXECUTION_RECORDS, MAX_EXPANDED_LINES, MAX_FINDING_ABOUT_LEN, MAX_FINDING_DESCRIPTION_LEN, MAX_GENERATED_FILES, MAX_IMPORT_LENGTH, MAX_LITERAL_ARGUMENTS, MAX_LITERAL_COMMAND_BYTES, MAX_MUTANT_ROSTER, MAX_MUTANT_ROSTER_ROWS, MAX_OBSERVED_EVENT_BYTES, MAX_PACKAGE_ROWS, MAX_PATTERN_LENGTH, MAX_POOL2_EVIDENCE_ENTRIES, MAX_PREFLIGHT_CHECKS_RUN, MAX_PREFLIGHT_LIST, MAX_PROPOSAL_CANDIDATES, MAX_RESOLVED_FINDINGS, MAX_REWRITTEN_FILES, MAX_SCOPE_IMPORTS, MAX_SCOPE_PATTERNS, MAX_SCOPE_RANGES, MAX_SCOPE_TEAMS, MAX_SCRIPT_HOPS, MAX_SETUP_SCRIPT_BYTES, MAX_SETUP_STEPS, MAX_SYSTEM_PACKAGES, MAX_UNCOVERED_LOCATION_FINDINGS, MAX_UPLOADED_FINDINGS, MEASURED_COST_MODEL_UNCERTAINTY, MEASURED_DOLLARS_PER_ESCAPE, MEASURED_DOLLARS_PER_HUNTED_FILE, MEASURED_FUNCTIONS_PER_AUDITABLE_KILOBYTE, MEASURED_LONGEST_HOLD_REASON, MEASURED_LONGEST_PROPOSALS_ENDING, MEASURED_SECONDS_PER_SWEPT_FUNCTION, MEASURED_TREES, MEASURED_TYPICAL_ESCAPES_PER_HUNTED_FILE, MEASURED_WORST_ESCAPES_PER_HUNTED_FILE, MEASUREMENT_PLAN_SCHEMA, MECHANICAL_ERROR_PATH_REASON, MEMORY_CEILING_MAX_MB, MEMORY_FLOOR_MB, MEMORY_HOST_SHARE, MEMORY_PER_CORE_MB, MERGE_REF_REMEDY, MESSAGE_MAPPINGS, MINT_TIMEOUT_MS, MIN_CELL_REPEATS, MODEL_AUTH_VAR, MODEL_DISPATCH_ATTEMPT_ID_RE, MODEL_DISPATCH_DOORS, MODEL_DISPATCH_REFUSALS, MODEL_ENDPOINT_VAR, MODEL_ERROR_CATEGORIES, MODEL_ERROR_RETRYABLE, MODEL_KEY_PREFIX, MODEL_KEY_VAR, MODEL_OIDC_AUDIENCE_VAR, MODEL_OIDC_REQUEST_TOKEN_VAR, MODEL_OIDC_REQUEST_URL_VAR, MODEL_PATH_DISPOSITION, MODEL_PATH_NAMED_ELSEWHERE, MODEL_PROBE_REFUSAL_CODES, MODEL_RECEIPT_KEY, MODEL_REQUEST_LOCAL_REFUSALS, MODEL_RESPONSE_MODES, MODEL_SERVICE_BASE_PATH, MODEL_SERVICE_CONTRACT_VERSION, MODEL_SERVICE_EFFORTS, MODEL_SERVICE_LIMITS, MODEL_SERVICE_MODEL_NAME, MODEL_SERVICE_OUTPUT_FORMATS, MODEL_SERVICE_ROUTES, MODEL_SERVICE_SURFACES, MODEL_SERVICE_VERSIONS_UNDERSTOOD, MODEL_SETUP_HINT, MODEL_STREAM_OUTCOMES, MODEL_TERMINAL_EVENT_TYPE, MODEL_TOKEN_INPUT_NAME, MODEL_TOKEN_SECRET_NAME, MODEL_VARIABLE_ALIASES, MODEL_VARIABLE_GUIDE, MUTANT_STATUSES, MUTATION_ATTEMPTED_NOT_RUN_REASONS, MUTATION_EXECUTION_STATES, MUTATION_LINE_MAPPING, MUTATION_NOT_RUN_REASONS, MUTATION_REFUSAL_CODES, MUTATION_SCOPE_KINDS, MUTATION_SCOPE_SURFACE, MUTATION_SKIP_REASONS, MUTATION_STAGE_WALL_MINUTES, MUTATION_STAGE_WALL_MS, MUTATOR_TOKEN_RE, type ManifestModel, type ManifestValidation, type MapCostPolicy, type MapCostProjection, type MapCostReading, type MapCostRoadFacts, type MapCostStop, type MatrixLeg, type MatrixLegs, type MatrixValue, type MeasuredEnvironmentPlan, type MeasuredTree, type MeasurementPlan, type MechanicalCounts, type MessageFacts, type MessageOutcome, type MessagePreview, type MessageSilence, type ModelAccess, type ModelBufferedReceipt, type ModelChoiceConfig, type ModelCostState, type ModelDispatchClaim, type ModelDispatchClaimAnswer, type ModelDispatchClaims, type ModelDispatchDoor, type ModelDispatchRefusal, type ModelDispatchRunKey, type ModelDispatchSettlement, type ModelErrorCategory, type ModelFailureDisposition, type ModelPathFailure, type ModelProbe, type ModelProbeCombination, type ModelRate, type ModelReceipt, type ModelReplyReading, type ModelRequestFit, type ModelRequestFitFailure, type ModelRequestLocalRefusal, type ModelResponseMode, type ModelServiceAnswer, type ModelServiceEffort, type ModelServiceErrorBody, type ModelServiceErrorEnvelope, type ModelServiceOutage, type ModelServiceOutputFormat, type ModelServiceRoute, type ModelServiceSurface, type ModelStep, type ModelStreamOutcome, ModelStreamReading, type ModelSurface, type ModelTerminalEvent, type ModelUsage, type ModelUsageState, type ModelVariableRead, type ModelsConfig, type ModuleLayout, type MutantRosterEntry, type MutantStatus, type MutationConfig, type MutationExecution, type MutationExecutionState, type MutationLine, type MutationLineCombination, type MutationMode, type MutationNotRunReason, type MutationScopeKind, type MutationSkipReason, NATIVE_FLOOR_PACKAGES, NATIVE_FLOOR_PACKAGE_NAMES, NATIVE_FONT_PACKAGES, NATIVE_FONT_REASON, NATIVE_SYMPTOM_KINDS, NATIVE_VOCABULARIES, NEARBY_EXPLAINS, NEARBY_MAX_NAMED, NEARBY_NOT_COVERED_WORD, NEARBY_NOT_IN_RATE, NEARBY_NOT_NOTICED_WORD, NEARBY_TITLE, NEW_RAW_MESSAGE_GUIDANCE, NODE_FLAGS_TAKING_A_VALUE, NODE_REPORTER_STDOUT, NOFILE_CEILING_MAX, NOFILE_FLOOR, NOFILE_PER_CORE, NON_EVIDENCE_OUTPUTS, NON_SOURCE_DIRECTORIES, NOTHING_IS_WAITING, NOTHING_IS_WAITING_LABEL, NOTHING_IS_WAITING_LINE, NO_JOB_TO_RIDE_NOTE, NO_PROPOSAL_LINES, NO_VERDICT_LABEL, type NarrationSink, type NativeFloorPackage, type NativeResolution, type NativeResolutionResult, type NativeSymptom, type NativeSymptomKind, type NativeUnresolved, type NativeUnresolvedCause, type NativeVocabulary, type NearbyCodeUnmeasuredCause, type NearbyCodeUnmeasuredFacts, type NearbyFinding, type NearbyReport, type NearbyRole, type NearbyVerdict, type NestedProjection, type NextActionParts, type NodeRuntime, type NodeRuntimeCombination, type NodeRuntimeObservation, type NonEvidenceKind, type NonEvidenceOutput, type NonEvidenceOutputId, type NormalizedCoverage, type NormalizedMutant, ORIGIN_TRACKED_KEYS, OWNER_KIND, type Observation, type OracleObservation, type OriginFacts, type OutcomeFor, PACKAGE_EXCLUSION_TEXT_MAX, PACKAGE_MANAGERS, PACKAGE_ROW_EXCLUDED_FIELDS, PACKAGE_ROW_FIELDS, PACKAGE_UNMEASURABLE, PATTERN_REFUSALS, PIDS_CEILING_MAX, PIDS_FLOOR, PIDS_PER_CORE, PINNED_ACTION, PLANTED_COUNTS_MAPPING, PLAN_NAMES, PLAN_REFUSAL_CODES, PLAYGROUND_ABLOH_FAILURE_LINE, PLAYGROUND_ADVISORY_TRIAGE, PLAYGROUND_DISMISS_LABEL, PLAYGROUND_ENGINE_MUTANT, PLAYGROUND_ENGINE_MUTANT_FIELDS, PLAYGROUND_ENGINE_NAME, PLAYGROUND_ENGINE_REVISION, PLAYGROUND_ENGINE_VERSION, PLAYGROUND_EXCERPTS_PER_MUTANT, PLAYGROUND_EXCERPT_MAX_BYTES, PLAYGROUND_EXCERPT_RESULT_SHARE, PLAYGROUND_EXECUTED_TEST, PLAYGROUND_EXPLANATION, PLAYGROUND_JOB_API_VERSION_V2, PLAYGROUND_MAX_MUTANTS, PLAYGROUND_MODEL_RESPONSE, PLAYGROUND_MUTANT_EVIDENCE, PLAYGROUND_MUTANT_STATUSES, PLAYGROUND_OPERATOR_SET_VERSION, PLAYGROUND_POLICY_SHA256, PLAYGROUND_PUBLIC_MUTANT, PLAYGROUND_PUBLIC_RESULT, PLAYGROUND_PUBLIC_RESULT_MATERIAL, PLAYGROUND_PUBLIC_ROSTER, PLAYGROUND_PUBLIC_RUN_RESULT_SCHEMA, PLAYGROUND_RESULT_MAX_BYTES, PLAYGROUND_RESULT_WITHHELD, PLAYGROUND_REVIEWS, PLAYGROUND_ROSTER_EXCERPT_MAX_BYTES, PLAYGROUND_SANDBOX_VERSIONS, PLAYGROUND_SENTENCES, PLAYGROUND_SEVERITIES, PLAYGROUND_SOURCE_MAX_BYTES, PLAYGROUND_STAGE_EVENT, PLAYGROUND_STAGE_EVENTS, PLAYGROUND_SUMMARY, PLAYGROUND_TEST_EVIDENCE_ABSENCES, PLAYGROUND_TEST_EXECUTION, PLAYGROUND_TEST_EXECUTIONS, PLAYGROUND_TEST_STATUSES, PLAYGROUND_TRIAGE_FIELD_POLICY, PLAYGROUND_TRIAGE_REASON_CODES_V2, PLAYGROUND_TRIAGE_VERDICTS_V2, PLAYGROUND_VITEST_RUNNER_VERSION, PNPM_VERIFY_DEPS_OFF, PNPM_VERIFY_DEPS_VARIABLE, PNP_RUNTIME_BASENAME, PNP_RUNTIME_FILE_PATTERN, POOL2_EVIDENCE_SCHEMA, PREFLIGHT_CHECKS, PRINTABLE_ASCII, PRINTABLE_TEXT, PRINT_WIDTH, PRIVATE_DIRECTORY_MODE, PRIVATE_FILE_MODE, PROPOSALS_BLOCK_SCHEMA, PROPOSALS_CANDIDATE_FIELDS, PROPOSALS_DISCOVERY_STATES, PROPOSALS_FEATURE_STATES, PROPOSALS_FILE_PATH_MAX, PROPOSALS_GAP_ORIGINS, PROPOSALS_MUTANT_ID_MAX, PROPOSALS_PACKAGE_SIDECAR_INDEX, PROPOSALS_PREDICTOR_MODES, PROPOSALS_SIDECAR_SCHEMA, PROPOSALS_SUITE_STATES, PROPOSALS_SUMMARY_FIELDS, PROPOSALS_UNAVAILABLE_COPY, PROPOSALS_VERDICTS, PROVEN_BASIS, PROVIDER_RAW_FORMAT, type PackageEvidence, type PackageExclusion, type PackageManagerDeclaration, type PackageManagerName, type PackageManagerPin, type PackageManifest, type PackageManifestProblem, type PackageManifestReading, type PackageRowField, type PairIsolation, type PatternRefusal, type PerTestAttribution, type PerTestBlock, type PerTestConfig, type PerTestFinding, type PerTestFindingKind, type PerTestReportFailure, type PlanBinding, type PlanCommand, type PlanCommandSource, type PlanEnvironment, type PlanEnvironmentBackend, type PlanEvidence, type PlanExecution, type PlanLimitFacts, type PlanName, type PlanQuarantine, type PlanRefusalCode, type PlanRefusalCombination, type PlanRefusalFacts, type PlanRefusalObservation, type PlanSetup, type PlanTarget, type PlantedCounts, type PlantedCountsCombination, type PlaygroundAdvisoryTriage, type PlaygroundEngineMutant, type PlaygroundExecutedTest, type PlaygroundExplanation, type PlaygroundModelResponse, type PlaygroundMutantStatusName, type PlaygroundPublicMutant, type PlaygroundPublicResult, type PlaygroundPublicResultMaterial, type PlaygroundPublicSummary, type PlaygroundStageEvent, type PlaygroundStageFact, type PlaygroundTestExecution, type PluginInvocation, type PreflightCheck, type PreflightCombination, type PreflightEventWire, type PreflightReportFacts, type PreflightSilence, type PreparationRole, type PreparedTestCommand, type PreparedTestCommandSource, type ProducerChoice, type ProposalsCandidateWire, type ProposalsConfig, type ProposalsDiscoveryState, type ProposalsFeatureState, type ProposalsGapOrigin, type ProposalsPredictorMode, type ProposalsSuiteState, type ProposalsSummaryWire, type ProposalsUnavailableCode, type ProposalsVerdict, type ProposedFile, type ProposedMutant, type ProvenanceStrength, type PullRequestCheckout, QUARANTINE_CAP_MINIMUM, QUARANTINE_CAP_PROPORTION, QUARANTINE_NAME_RENDER_LIMIT, QUARANTINE_REASONS, QUARANTINE_REASON_COPY, type QualificationResult, type QualificationVerdict, type QualifiedOmission, type QuarantineAdmission, type QuarantineCounts, type QuarantineDisclosure, type QuarantineExclusionMode, type QuarantineReason, RATE_CARD_ENV, RATE_CARD_SCHEMA, RAW_COVERAGE_FORMATS, REALISTIC_CATEGORIES, RECEIPT_DETAIL_MAX, RECEIPT_DIRECTORY, RECEIPT_FILE_MAX_BYTES, RECEIPT_STAGES, RECEIPT_UNREADABLE_PHRASES, RED_BASELINE_OUTPUT_TAIL_LINES, REFUSAL_CODES, REFUSAL_CODE_MERGE_EXPIRY, REFUSAL_CODE_RE, REFUSAL_DESTINATIONS, REFUSAL_FIT_NOTE, REFUSAL_FIT_ORDER, REFUSAL_MESSAGE_MAX, REFUSAL_MESSAGE_PATHS, REFUSAL_OWNERS, REFUSAL_PRIVACY, REFUSAL_REGISTRY, REFUSAL_STAGES, REMINT_MARGIN_MS, REPORT_DIALECTS, REPORT_MAPPINGS, REPORT_SECTION_MAPPING, REPORT_UNAVAILABLE_CAUSES, RESERVED_CUSTOMER_PREFIXES, RESERVED_CUSTOMER_VARIABLES, RESOLVED_EVIDENCE_FIELDS, RESOLVED_EVIDENCE_SCHEMA, RESOLVED_EVIDENCE_UNKNOWN_FIELDS, RETIRED_EVIDENCE_OUTPUTS, RETIRED_KEYS, RETIRED_PROPOSALS_BLOCK_SCHEMAS, RETIRED_REFUSAL_CODES, RETIRED_REFUSAL_DESTINATIONS, ROAD_INPUTS, ROUTE_PURITY_RUNGS, RULED_AUDITABLE_FILES_PER_HUNTABLE_FILE, RULED_FIRST_PASS_RATES, RULED_HUNT_ENVELOPE_DOLLARS, RULED_MAP_ROAD_SLICE_EXECUTIONS, RULED_PROPOSAL_CHANGED_WITHIN_DAYS, RULED_RUN_DOLLAR_CAP, RULED_RUN_HUNT_WALL_MS, RULED_RUN_WALL_MS, RULED_SIZE_GATE, RULED_SWEEP_WALL_FRACTION, RUNNER_BINARY_SUFFIX_SOURCE, RUNNER_CAPABILITIES, RUNNER_DEFAULT_SOURCE, RUNNER_TYPED_CONSEQUENCE, RUN_ATTEMPT_DIGITS, RUN_ATTEMPT_MAX, RUN_CEILING_REMEDY, RUN_COST_STOP_MAPPING, RUN_FINDING_ABSENCE, RUN_FINDING_FIELDS, RUN_FINDING_NESTED, RUN_FINDING_TRIAGE_ABSENCE, RUN_FINDING_TRIAGE_FIELDS, RUN_INTERRUPTION_FACT_KEY_RE, RUN_INTERRUPTION_LIMITS, RUN_LOCAL_EVIDENCE_SCHEMA, RUN_LOG_STAGE, RUN_MODEL_COST_LIMITS, RUN_PROGRESS, RUN_PROGRESS_COUNTERS, RUN_PROGRESS_COUNTER_MAX, RUN_PROGRESS_COUNTS, RUN_PROGRESS_MAX_PROPOSALS, RUN_PROGRESS_NAME_MAX, RUN_PROGRESS_PATH_MAX, RUN_PROGRESS_PROPOSAL, RUN_PROGRESS_REASON_MAX, RUN_PROGRESS_STAGES, RUN_PROGRESS_STAGE_ROW, RUN_PROGRESS_STAGE_STATES, RUN_RECORD_ASSEMBLY_SITES, RUN_RECORD_CONTRACT, RUN_RECORD_WIRE_GAPS, RUN_REFUSAL_CODE_RE, RUN_REFUSAL_LIMITS, RUN_SCOPE_MAPPING, RUN_STAGES, RUN_STAGE_UNITS, type RankedCiPropertyRule, type RateCard, type RateCardFailure, type RateCardResolution, type RawCoverageFormat, type RawCoverageFormatName, type RealisticCategory, type RebuildFacts, type ReceiptCombination, type ReceiptFileInvalidity, type ReceiptFileParse, type ReceiptInvalidity, type ReceiptProvenance, type ReceiptStage, type ReceiptStageName, type ReceiptState, type ReconciliationBlock, type RecordingReplayCombination, type RecordingReplayFacts, type RecordingReplaySilence, type RecordingsFileCombination, type RecordingsFileFacts, type RecordingsFileSilence, type RedBaselineFacts, type RedBaselineShape, type Refusal, type RefusalCard, type RefusalCode, type RefusalContent, type RefusalDeclaration, type RefusalDestination, type RefusalEnvelope, type RefusalEvidence, type RefusalFitField, type RefusalFitParts, type RefusalInput, type RefusalOf, type RefusalOwner, type RefusalPrivacy, type RefusalRemedy, type RefusalStage, type RegistryAuthFailure, type RemedyLocation, type RenderedRefusal, type RepoReader, type ReportDialect, type ReportFacts, type ReportOutcome, type ReportSection, type ReportSectionCombination, type ReportSectionName, type ReportSilence, type ReportUnavailable, type ReportUnavailableCause, type ReportedTestFiles, type RepositoryFileReader, type RepositoryModelCredential, type RepositorySizeScan, type RepositorySizeVerdict, type ReservedComposition, type ResolvedCommandPlan, type ResolvedEvidenceObject, type ResolvedProjectPackage, type RetiredEvidenceOutput, type RetiredEvidenceOutputId, type RetiredRefusalCode, type RetiredRefusalDestination, type RoadFacts, type RoadSettings, type RoutePurityRung, type RunAdmission, type RunAttempt, type RunCeilingFacts, type RunCostStop, type RunCostStopCombination, type RunEventCombination, type RunEventFacts, type RunFindingTriageWire, type RunFindingWire, type RunInterruption, type RunLocalEvidence, type RunLogStage, type RunModelCost, type RunModelCostLane, type RunProgress, type RunProgressCounter, type RunProgressStage, type RunProgressStageState, type RunRecordAssemblySite, type RunRecordFieldContract, type RunRecordFieldName, type RunRecordWire, type RunScope, type RunScopeCombination, type RunStage, type RunStageProgress, type RunStageUnit, type RunnerAlias, type RunnerCapability, type RunnerEcosystem, type RunnerFailureSummary, type RunnerName, type RunnerSpecSelection, SCENARIO_AUTHORITIES, SCENARIO_LANES, SCENARIO_OUTCOMES, SCENARIO_SEARCH_STATES, SCENARIO_SOURCE_INDEPENDENCE, SCENARIO_SOURCE_KINDS, SCORE_EVIDENCE_MAPPING, SCRIPT_NAMED_RUNNERS, SEALED_BROWSER_UID, SEALED_BUN_LINK, SEALED_BUN_PREFIX, SEALED_BUN_VERSION, SEALED_CHROME_BIN, SEALED_CHROMIUM_PACKAGES, SEALED_COREPACK_HOME, SEALED_DENO_BINARY_RELATIVE, SEALED_DENO_DIR, SEALED_DENO_LINK, SEALED_DENO_PREFIX, SEALED_DENO_VERSION, SEALED_EXECUTION_AMBIENT_FACTOR, SEALED_EXECUTION_CEILING_UNMEASURED_MS, SEALED_PLAYWRIGHT_BROWSERS_PATH, SEALED_PNPM_VERSION, SEALED_PREPARATION_ALLOWANCE_MS, SEALED_RUNTIME_ROOT, SEALED_TEST_COMMAND_SOURCES, SEALED_TEST_PROCESS_CONFINEMENT, SEALED_TOOLCHAIN_APT_PACKAGES, SEALED_TOOLCHAIN_BINARIES, SEALED_YARN_VERSION, SECRET_MASKING_FLOOR, SERVICE_REFUSED_FLAGS, SETUP_BRANCH, SETUP_BRANCH_COMMIT_MESSAGE, SETUP_CANDIDATE_CAP, SETUP_CHECK_NAME, SETUP_COMMIT_EMAIL, SETUP_DOCS_URL, SETUP_FAIL_FAST_ANSWERS, SETUP_FAIL_FAST_CONSEQUENCES, SETUP_NODE_ACTION, SETUP_PR_TITLE_TEXT, SETUP_REHEARSAL_ENV, SETUP_REPORT_MARKER, SETUP_REPORT_OVERSIZE_CODE, SETUP_REPORT_OVERSIZE_NEXT_ACTION, SETUP_REPORT_REFUSAL_CODES, SETUP_ROADS, SETUP_ROAD_CONSEQUENCES, SETUP_ROAD_LABELS, SETUP_ROAD_QUESTION, SETUP_SCRIPT_FOOTER, SETUP_SCRIPT_MODE, SETUP_SCRIPT_PATH, SETUP_STAGE_LABELS, SETUP_STAGE_ORDER, SETUP_STEP_ACTION, SETUP_STEP_IF, SETUP_STEP_JOB_STATUS, SETUP_STEP_NAME, SETUP_STEP_STATES, SETUP_TRIAL_ARTIFACT_NAME, SETUP_TRIAL_MAX_BYTES, SETUP_TRIAL_RERUN, SETUP_TRIAL_SCHEMA, SETUP_VOCABULARY, SET_AT_THE_PROMPT, SIGNED_SCORE_RULE, SIZE_BANDS, SOURCE_CHECK_STEPS, SOURCE_RE, SPEND_UNMETERED_REASONS, STANDING_LIMITATION_IDS, SUBDIR_CONFIG_KEY, SUBDIR_OPTION, SYSTEM_PACKAGE_ARCHIVE_HINT, SYSTEM_PACKAGE_NAME, SYSTEM_PACKAGE_VERSION, type ScenarioAuthority, type ScenarioExpectedObservation, type ScenarioInputDomain, type ScenarioIntent, type ScenarioIntentDraft, type ScenarioLane, type ScenarioOperationStep, type ScenarioOutcome, type ScenarioSearchBlock, type ScenarioSearchCounts, type ScenarioSearchMeasuredBlock, type ScenarioSearchProvenance, type ScenarioSearchRestrictions, type ScenarioSearchState, type ScenarioSourceIndependence, type ScenarioSourceKind, type ScenarioSourceRef, type ScenarioSummary, type ScopeFilters, type ScopeOptions, type ScopeParse, type ScopeProposal, type ScopeResolution, type ScopeResolutionInput, type ScopeResult, type ScoreComponent, type ScoreEvidence, type ScoreEvidenceCombination, type ScoreInput, type Scores, type ScriptNamedRunner, type ScriptRun, type ScriptRunEnvironment, type ScriptRunKind, type ScriptRunLauncher, type ScriptRunsInput, type ScriptSeparator, type SealedCeiling, type SealedExtra, type SealedRunnerCapabilities, type SealedRuntime, type SealedSetupFlags, type SealedTestCommand, type SealedTestCommandSource, type ServicePortAssignment, type ServicePortRequest, type SetupAnswer, type SetupAnswerCombination, type SetupAnswerObservation, type SetupCandidateExclusion, type SetupCandidateFilter, type SetupCandidateGate, type SetupCandidateJob, type SetupCandidateTrigger, type SetupFailFast, type SetupHealing, type SetupHealingNote, type SetupJobAttempt, type SetupJobDeclarationUnusableFacts, type SetupNoUsableJobFacts, type SetupPin, type SetupPinReading, type SetupPublishHost, type SetupRefusalDisplay, type SetupRegistryUnreachableFacts, type SetupReportInput, type SetupReportOversizeFacts, type SetupRideTier, type SetupRoad, type SetupScriptDraftProblem, SetupScriptError, type SetupScriptStep, type SetupStepState, type SetupStepStatus, type SetupTrialArtifact, type SetupTrialInvalidity, type SetupTrialParse, type SetupTrialRoad, type SetupTrialRun, type SetupTrialRunOrder, type SetupWorkflowCaller, type ShardDeclaration, type SizeBand, type SizeBandReason, type SizeGateMessage, type SizeGateThresholds, type SourceCheckStep, type SpendUnmeteredReason, type StageBInputs, type StageBReadiness, type StandingLimitation, type StandingLimitationFacts, type StandingLimitationId, type StandsForFacts, type StepConditionVerdict, type StreamTerminalFact, StreamUsageObserver, type StructuralCoverage, type StructuralSite, type Subject, type SuiteObservation, type SuiteOutcome, type SystemPackage, type SystemPackageOperand, TARGET_ARTIFACT_KEYS, TARGET_INVENTORY_SCHEMA, TARGET_INVENTORY_SOURCES, TARGET_RECEIPT_FILE_SCHEMA, TARGET_RECEIPT_SCHEMA, TARGET_SELECTION_KINDS, TARGET_STATE_LABELS, TARGET_STATE_MARKS, TASK_REPLY_PROBLEMS, TEST_COMMAND_SOURCE, TEST_FILE_PATH, TEST_MODULE_MOCKS_FLAG, TEST_PATH_RE, TRIAGE_CALL_FAILURES, TRIAGE_REASON_CODES, TRIAGE_REQUEST_CATEGORIES, TRIAGE_STATES, TRIAGE_VERDICTS, type TargetAdmission, type TargetAdmissionState, type TargetInventoryRow, type TargetInventorySource, type TargetReceipt, type TargetReceiptFile, type TargetSelectionKind, type TaskReplyProblem, type TaskReplyReading, type TestFileCounts, type TestFileTextReader, type TestLocation, type TestRunFacts, type TestRunStage, type TestStrengthBlock, type TextUnit, type TriageCallFailure, type TriageReasonCode, type TriageRecord, type TriageRequestCategory, type TriageState, type TriageVerdict, UNCOVERED_LOCATION_MUTATOR, UNDRIVABLE_RUNNERS, UNOBSERVED_REASONS, UNRECOGNISED_ENGINE_FAILURE, UNREPORTED_ENGINE_FAILURE, UNRESOLVED, USAGE_UNKNOWN, type UnguardedSites, type UnknownFieldPosture, type Unobserved, type UnobservedBaselineCause, type UnobservedBaselineFacts, type UnobservedOutcome, type UnobservedReason, type Unresolved, type UnsatisfiableCheck, type UntestedChangeFacts, type UploadAnswerCombination, type UploadAnswerFacts, type UploadArtifactFacts, type UploadTransportFacts, type UploadedRefusal, type UploadedRefusalEvidence, type UploadedRefusalRemedy, VALUE_ORIGINS, type ValueOrigin, type ValueOriginMap, type VcsSuiteFinding, type VcsSuiteUse, type VerdictExecutionEnvironment, WIRE_CUT_NOTE, WIRE_HOLD_REASON_MAX, WIRE_PROPOSALS_ENDING_MAX, WIRE_REASON_MAX, WORKFLOW_FILE_PATH, WORKFLOW_JOB_ID, WORKFLOW_RUNTIME_PREFIX, WORKSPACE_ORIGINS, type WireAbsence, type WireArray, type WireBoolean, type WireEnum, type WireField, type WireFields, type WireInteger, type WireLiteral, type WireNode, type WireNullable, type WireNumber, type WireObject, type WirePath, type WireResult, type WireString, type WireUnion, type WithheldEvidence, type WorkflowNodePin, type WorkflowRuntime, type WorkspaceOrigin, type WorstOfOutcome, type WorstOfRow, type XmlElement, YARN_DEPENDENCY_ENTRIES, type YamlQuote, ablohAuthored, ablohComposedAlone, ablohFailureClosingLine, acceptBugBehaviour, acceptBugDescription, acceptBugEmoji, acceptBugSentence, acceptBugSeverity, acceptBugType, acceptCarriedBugOutcome, acceptFindingEmoji, accountModelMinter, actionFilesReferenced, actionPinOf, actionRuntimeFiles, actionSubPathOf, addSealedReporter, additionsBetween, admissionCoverage, admissionDecisionProblem, admissionDigest, admissionDrift, admissionKeyIsAblohs, admissionSubject, admitFirstPassRun, admitTarget, admitsMainlineBranch, alwaysEmittedEvidenceKeys, ambientEnvironmentWithoutEngineCredentials, angularKarmaShape, angularProjectFromScript, angularRunnerName, angularScriptIsFanout, angularSealedTestCommand, apiKeyScopeProblem, appReceiptCommitMessage, appSetupFileCommitMessage, appSetupHealCommitMessage, appSetupPullRequestTitle, appendRunnerArguments, applyLayer1Gate, arrangesACheck, asciiDiagnostic, assertNever, assignServicePorts, attributionComplete, attributionMissing, avaInvocation, baselineGateObservation, baselineJobClockBoundMs, baselineJobClockRemedy, baselineJobClockRemedyLocation, baselineJobClockStopSentence, baselineJobClockTimeoutKey, baselineObservedNoTests, baselineOutcome, baselineRunBound, baselineRunBoundDisclosure, baselineRunTimeoutProse, binaryName, boundHoldReason, boundMinutes, boundProgressCount, boundProgressText, boundReceiptDetail, browserLaneSealSummary, bugIdentity, buildCiPropertySearchBlock, buildCiPropertyTargetUniverse, buildCustomerProcessEnvironment, buildOutputDirectory, buildScenarioSearchBlock, buildScopeProposal, buildSecretsFor, bunInvocation, callCeilingDollars, canBeOwnedByAbloh, canStartStageB, candidateBody, candidateName, candidatePath, candidateTextControl, candidateUploadProblem, canonicalJson, capability, carriedVerdict, carriedVerdictNote, catchRate, catchRateIsRaw, catchRateScopeNote, categoryOfStatus, caughtWithinMeasured, ceilingDollarsPerHuntedFile, ceilingNotice, changedStructuralCoverage, chatRequestContract, checkAdmissionRefusal, checkAdmissionRequest, checkAdmissionResponse, checkAdmissionWarning, checkModelRequestFits, checkoutNotComparableReason, chosenTestFiles, chromeSeccompDigest, chromeSeccompProfile, ciPropertyBehaviourKey, ciPropertyLedgerDigest, ciPropertyMutatorFamilies, classicHeadroom, classicMutationExecution, classicMutationTier, classifyDiffCoverage, classifyPullRequestCheckout, classifyReportUnavailable, classifyRepositorySize, clearExecutionPlan, cliOptionConfigConflictSentence, cliOptionConflictSentence, cliOptionPathUnusableRemedy, cliOptionPathUnusableSentence, cliOptionRequiredRemedy, cliOptionRequiredSentence, cliOptionRequiresRemedy, cliOptionRequiresSentence, cliOptionUnavailableSentence, cliOptionValueInvalidRemedy, cliOptionValueInvalidSentence, cliUnknownCommandRemedy, cliUnknownCommandSentence, cliUnknownOptionRemedy, cliUnknownOptionSentence, cliUnknownSubcommandRemedy, cliUnknownSubcommandSentence, codeownersFor, codesInFamily, combineLayerGates, commandGlobMatches, commandOutputTail, commandRuntime, commandStageName, commandStages, commandTokens, compareInstrumentation, compiledOutputEvidence, composableReservedEntries, composeExecutionRecord, composeReservedValue, composedValueJudges, computeScope, computeScores, conditionalPower, configFlakyLines, configHeaderLines, configKeyChildren, configKeyDefault, configKeyEntry, configKeyEntryFields, configKeyValueRule, configSettingLines, configSetupJobLines, confinementArgv, consumedGeneratedImport, containsEngineCredential, contentsIndexRefs, conventionalHeaderProblem, countCoverageLines, countsAreWholeVerdicts, countsFrom, countsFromLines, coverageComposition, coverageCounted, coverageDisplayState, coverageGroupState, coverageLocationFinding, coverageLocationFindingFor, coveragePathNotAddressableSentence, coverageProviderCacheUnusableSentence, coverageProviderProblem, coverageProviderUnavailableSentence, coverageProviderUnsupportedRunnerSentence, coverageReportBytes, coverageReportInvalidSentence, coverageReportTooLargeSentence, coverageScopeIncompleteSentence, coveredLinesToScope, credentialShapeRefusal, currentExecutionPlan, customerChildEnvironment, customerEnvironmentFromConfig, customerEnvironmentNames, cutAtCodePoints, cutTailAtCodePoints, debugPreparationOverflowStack, debugPreparationStack, decideObservation, decideQuarantineAdmission, decideSetupHealing, declarableTopLevelKeys, declaredConfigKeys, declaredDependencies, declaredOrigin, declaredRunnerProblem, declaredShard, declaredValueOrigins, declaredValues, declaresJestWatchMode, declaresWatchMode, decodeTaskObject, decodeTaskReply, decodeXmlEntities, defaultDockerCommandRunner, denominatorOf, dependencyPath, dependencyRoot, deprecatedModelVariableWarning, deprecatedModelVariablesInUse, deriveScenarioSearchCounts, deriveWorstOfGate, describeCommandGlobExpansions, describeDays, describeDollars, describeFiles, describeFinding, describeJobClockStage, describeJobDuration, describeMutationEvidence, describeReasonCode, describeRunStage, describeRuns, destinationLabel, destinationRepairs, detectModuleLayout, detectNativeSymptoms, detectReactNativeProject, detectVcsSuiteUse, detectedHostCores, detectedHostMemoryMb, diffCoverageExecution, directRunnerCommand, displayTruncationNote, distinctChecks, dotEnvDefinesModelVariables, dotEnvModelHint, egressRefusalFor, emojiAlreadyUsedClause, emptyCounts, emptyScope, endProcessGroup, endsSentence, engineFailureEgress, engineFailureLog, engineFailureReportId, engineFailureShape, engineFailureShapeSentence, engineFailureSignature, engineFailureTimeoutMinutes, engineOrDependencyStoragePath, ensureBaseReachable, entryAnswers, envelopeEvidenceKeys, environmentDifference, environmentValueProblem, errorCountOf, evaluateAssay, evaluateDiffCoverageGate, evaluateFloor, evaluateGate, evaluateStepCondition, evaluateStepConditions, evidenceBasename, evidenceDeleteAfter, evidenceIndexMissingLines, evidenceIndexMissingSentence, evidenceIndexRefusalCode, evidenceLabelLine, evidenceLine, evidenceOutput, evidenceOutputByBasename, evidenceRetentionDaysOr, evidenceRetentionExpired, evidenceUploadPlan, evidenceWithheldLine, excludedAndDisclosed, executionPlan, executionRecorder, expandCommandGlobs, expandDeclaredTestCommand, expandScopeLines, expectedDollarsPerHuntedFile, extractImportSpecifiers, factStandIn, failFastCancelsLegs, failFastEditable, failFastNotice, failFastReceipt, failedSetupStage, failingTestSentence, fileImportTargets, fileSelectionArgs, fileSelectionTemplate, fileUrlCarriesPath, filterSetupCandidates, findRunnerFailureSummary, findXmlElements, findingDisplayTitle, findingEffort, findingEmoji, findingEmojiAsk, findingKind, findingReasonCode, findingSeverity, findingStatus, findingTitleParts, findingTriageVerdict, fitRefusal, foldToPrintableAscii, foldToPrintableText, foldedNeighborsClause, formattedJson, fullyConstructible, gapKeys, generatedFilePathProblem, generatedFilesValue, generatedPaths, generationState, gitHeaderPath, githubEquals, githubTruthy, globToRegExp, gradedFindingSeverity, groupFindingsByLine, hasAbandonedImportClause, hasRegisteredSecrets, healthCommandProblem, healthPortProblem, holdReasonText, hostedRunHeaderValue, hostedRunHeaders, identityConditionLine, identityConditionOfEnvironment, identityConditionSentence, identityFilesValue, imageVocabulary, importSelectorTarget, importTargetMatches, inactiveInputKeys, inactiveInputReason, inactiveInputs, inactiveInputsNamed, indexQueryFor, initExecutionPlan, insertSealedSetupFlags, installCommandNeedsCorepackEnable, installExecutionPlan, installedInputs, instrumentationComparisonLines, invokesDefaultTestScript, isAblohFailureClosing, isAblohSetupAuthor, isAngularRunner, isAnnotatableSurvivor, isAuditableSourcePath, isBoundedCodeFreeSentence, isCanonicalBase64, isCiPropertyCandidateCap, isClusterStrategy, isCodeFreeProse, isConfirmedEquivalent, isDiffCoverageCannotAttestReason, isEngineFailureReportId, isEngineFailureShapeName, isEnvironmentName, isEvidenceRetentionDays, isExactPackageManagerVersion, isExpandableGlobArgument, isModelServiceOutageAnswer, isModelTerminalEvent, isNonExecutableLine, isNothingWaiting, isObserved, isPlaygroundSentence, isReservedCustomerVariable, isScenarioAuthority, isScenarioLane, isScenarioOutcome, isScenarioSearchState, isSetupBranchName, isSetupReportComment, isTestPath, isValueOrigin, isWellFormedText, itemsPerModelRequest, jobClockRaiseInstruction, jobClockStageLogPrefix, jobClockStageRemedy, jobClockStageStopSentence, jobClockStageTimeoutKey, jobOnMatrixLeg, jobTimeBudgetSentence, jsRunners, judgeCandidateTextControl, judgeConfigKeyValue, keylessLocalRunBlock, kibibytes, knownRunner, layer0EnabledRunners, layer2IntentProposalFieldsSentence, liveProgressUpdate, loadConfig, loadConfigWithNotes, localBinaryPrefix, localContractCommitMessage, localDetailClause, localEvidenceText, localLadderLines, locationOfPattern, lockPathFor, looksLikeRunnerFailureSummary, makeFilePrivate, manifestBasename, manifestScripts, mapCostGate, mapCostReason, mapCostRoadFacts, mapCostSentence, mapCostsMoreThanTheVerdicts, markNonExecutable, matchesCredentialShape, matrixLegAsOffered, matrixLegProblem, matrixLegRunner, matrixValueAsOffered, matrixValueCondition, matrixValueText, matrixValueYaml, measurableCount, measurableTestRuns, measuredCiOverride, measurementPlanDigest, measuringRoad, mebibytes, mechanicalCounts, mechanicalErrorPathDisposition, memoryRepoReader, mergeBaseNotEstablished, message, messageFromFacts, messageShape, microsToUsd, missingActionFiles, missingModelVariableReason, missingScopedFiles, modelBufferedReceipt, modelDispatchClaimProblem, modelOidcMinter, modelRequestContract, modelRequestKeys, modelServiceAnswers, modelServiceBaseUrl, modelServiceErrorContract, modelServiceOutageEvidence, modelStepBoundaryMessage, modelTerminalEvent, modelTerminalEventContract, mutantIdentity, mutationRefusalSentence, mutationRefusalWall, mutationWasAttempted, nameDrivenRunners, narrationTo, nativeFloorCommand, nearbyCarryClause, nearbyCodeSentence, nearbyConsequenceClause, nearbyDirectionArrow, nearbyDirectionChip, nearbyFindingName, nearbyFindingSentence, nearbyLine, nearbyMeasurementClause, nearbyRelationClause, nearbyRemainderSentence, nearbyReportFrom, nearbyRow, nearbyVerdictWord, newlyFailingTests, nextActionLine, nextActionParts, nextActionSentence, nodeMajorFromImageRef, nodeOptionInsertionPoint, nodeReporterCounts, nodeTestInvocation, nodeVersionFromImageRef, nonEvidenceBasename, nonEvidenceOutput, normalizeDeclaredPath, normalizeImportTarget, normalizeOwner, normalizeRepoPath, normalizeRunFinding, notUploadedRunRecordFields, noteModelServiceAnswer, nothingToMeasurePathFilter, observedNegative, observedPositive, openExecutionCopies, optional, originOf, outputShowsDeniedFork, overlayRepoReader, ownedByOrigin, packageScriptSeparator, parseAptSources, parseAsterCoverageEvidence, parseClosedReason, parseCodeowners, parseContentsEntry, parseConventionalHeader, parseDeepAuditArtifact, parseDpkgArchitecture, parseEvidenceManifest, parseHostedRunHeader, parseInitTelemetryEvent, parseJsonc, parseLiteralArguments, parsePreparedTestCommand, parseRunLocalEvidence, parseRunModelCost, parseScope, parseSetupScript, parseSetupTrialArtifact, parseTargetInventory, parseTargetReceiptFile, parseUnifiedDiff, parseUploadedInterruption, parseUploadedRefusal, parseValueOriginMap, parseXml, partialAdmissionSentence, pathWithin, patternMatches, patternRefusal, percentOfMeasured, pidCeilingExhaustion, pidCeilingNotice, plainSafe, planCommand, planCompletionBatches, planLimitRemedy, planLimitSentence, planRefusalFactsOf, planRefusalRemedy, planRefusalSentence, plantedCounts, playgroundExcerptBytes, playgroundOutcome, playgroundRosterExcerptsFit, pnpRuntimeFile, pool2Population, preflightCheck, preflightEvent, preparedCommandProblem, previewRefusal, privateDirectory, producerChoice, project, projectFirstPass, projectMapCost, projectRunFinding, projectRunFindingTriage, projectedRunRecordFields, projectionHours, proposalCandidatePaths, proposalIsOffered, proposalMessage, proposalsCandidate, proposalsDiscoveryState, proposalsFeatureState, proposalsGapOrigin, proposalsPredictorMode, proposalsSuiteState, proposalsSummary, proposalsUnavailableSentence, proposalsVerdict, provenShapeProblem, publishableEvidenceDirectories, publishableEvidenceFiles, qualifyCorpus, qualifyHistoricalPair, quarantineCap, quarantineCapExceeded, quarantineDisclosureSentence, quarantineExcludableRunners, quarantineExcludedTotal, quarantineExclusionMode, quarantineFloorBreached, quarantineFloorRefusal, quarantineGrowthSentence, quarantineNameList, quarantineNamesSentence, quoteLiteralArgument, rankCiPropertyRules, rankIndexCandidates, rankSetupCandidates, rateCardFromEnvironment, readBufferedModelReply, readEventUsage, readFailFastDeclaration, readModelBufferedReceipt, readModelServiceError, readModelServiceOutage, readModelTerminalEvent, readModelVariable, readOutputItemsText, readPackageManagerDeclaration, readPackageManagerPin, readPackageManifest, readPackageManifestFile, readRefusalText, readRegistryAuthFailure, readReportedModel, readReportedTestFiles, readRunAttempt, readSetupPin, readSetupPinFromDocument, readTerminalFact, readTextDelta, readUsageFrame, readsCompiledOutput, readsProposalsBlockSchema, readsReportedTestFiles, rebuildBeforeMeasuringFailedSentence, receiptPathFor, recognizedProvidersFor, recordsForStage, redBaselineCallerGreenDetail, redBaselineCallerJobWasGreen, redBaselineCommandNeverStarted, redBaselineDetail, redBaselineRefusal, redBaselineReportFailureNote, redBaselineRunnerExitedNonZero, redBaselineShape, redactCredentialShapes, redactCredentialShapesDeep, redactTriageForEgress, refusalCodeIsReadable, refusalCodeOf, refusalDetail, refusalEnvelope, refusalFromFacts, refusalFromStoredCode, refusalIsWall, refusalLineWhoeverOwnsIt, refusalLines, refusalMessageOf, refusalOfUploaded, refusalOwnersOf, refusalRemedyText, refusalSentence, refusalSentenceWithRemedy, refusalSummary, refuse, refusedAsAblohOwned, registerSecretValue, registeredBasenames, registeredSecretNames, registryAuthRefusal, registryEntryProblems, releaseDigestFor, remedyEditLines, remedyLocation, remedyValueShape, renderAsterCoverageEvidence, renderCoverageEvidence, renderEvidenceManifest, renderModelVariableRow, renderRefusal, renderRunLocalEvidence, renderSetupFailure, renderSetupReportComment, renderSetupScript, renderSetupStepLine, renderTargetReceiptFile, reportMessageFromFacts, reportUnavailableFacts, repositoryModelCredentialOfEnvironment, requireEvidenceCustody, requirePackageManifest, required, reservedComposeProblem, reservedComposition, resetModelServiceAnswers, resetRegisteredSecrets, resolveCommandPlan, resolveFacts, resolveImportTarget, resolveModelAccess, resolvePreparedTestCommand, resolveProjectPackage, resolveRefusalCode, resolveRefusalDestination, resolveRefusalOwner, resolveScope, resolveSealedTestCommand, resourceCeilingExhaustion, respelledClasses, responsesRequestContract, retiredConfigKeyNote, retiredConfigKeyWarning, retiredConfigKeys, retiredEvidenceBasename, retiredEvidenceBasenames, retiredEvidenceOutputs, rewrittenFilePathProblem, rewrittenFilesValue, ridableMatrixCombinations, roadOpensPullRequest, roadRunsLocalTrial, rosterTruncation, routePurityRung, rowAdmitted, runAttempt, runCeilingSentence, runExecutionPlan, runFinding, runFindingProblem, runFindingTriage, runIsDroppable, runRecordReaderProblems, runnerAliases, runnerChoiceConsequence, runnerConfigFromInvocation, runnerImageVocabulary, runnerNamePattern, runnerNamesInScript, runnerSpecSelection, runsLifecycleScripts, runsPackageScript, runsRequiredBefore, sameMatrixValue, sameModelDispatchRun, sanitizeCiPropertySummary, sanitizeFindingAbout, sanitizeFindingDescription, sanitizeScenarioSummary, scanRepositoryTree, scopeCallsModel, scopeHeadline, scopeImportSelectors, scopeIsEmpty, scopeReadsEvidence, scopeSummary, scriptRuns, scrubSecrets, scrubSecretsDeep, sealedBunInstallProgram, sealedBunPackage, sealedCommandForInvocation, sealedDenoInstallProgram, sealedExecutionCeilingMs, sealedExtrasNeeded, sealedFileDescriptorLimit, sealedMemoryLimitMb, sealedPidsLimit, sealedReportingArgs, sealedRunnerCommand, sealedRuntimeInstallProgram, sealedRuntimeNeeded, sealedRuntimeVersion, sealedSetupFlags, sealedTestProcessArgv, sealedToolchainCommand, selectAngularTestTarget, selectCiPropertyTargets, selectScriptNames, separatorForCommand, serviceNameProblem, setupCandidateExclusion, setupCandidateNarrowing, setupCandidatesExhausted, setupFailFastProblem, setupFailureRefusal, setupFailureSentence, setupHealingAsksForAnEdit, setupJobProblem, setupJobReference, setupMatrixLegProblem, setupPinProblem, setupProvisionalRideUnproven, setupPublishHost, setupRefusalDisplay, setupReportOversizeLine, setupReportOversizeSentence, setupRideIsProvisional, setupRunnerExclusion, setupScriptDraftProblem, setupScriptPathProblem, setupStageLabel, setupStepIf, setupStepLabel, setupStepLines, setupStepMarker, setupStepNumber, setupStepStatuses, setupTrialPassed, setupTrialRunOrder, setupWordingProblem, sha256, sha256Bytes, shardDeclarationBlock, shardDisclosure, shippedGeneratedPaths, shortenForDisplay, shortenTailForDisplay, silence, sizeGateMessage, slotPrivacy, sortedSystemPackages, specPositionalsOf, stableOutcome, stageProjectionMs, stageProjectionsMs, stagedEvidenceIsLedger, standingLimitationClause, standingLimitations, statedByTheClock, statesTestingGap, storedEvidenceBasename, storedEvidenceLabel, streamOutcomeIsSuccess, stripComments, stripJsonComments, stripTestIdentityDiscriminator, structuralDigest, structuralFindingsFor, subjectDigest, summaryThenAction, supportsTestModuleMocks, survivingMutantFinding, survivingMutantObligationSignals, systemPackageInstallCommand, systemPackageOperandProblem, systemPackagePinHint, systemPackageProblem, tallyCounts, targetReceiptDigest, targetReceiptFile, testLocations, testRunObservation, testRunStages, testRuns, testsImportBuiltOutputSentence, textDeclaredLocations, textFits, textLength, toApiKeyScope, toEgressRefusal, toGapFindings, toPosixSeparators, toUploadedInterruption, toUploadedRefusal, toWorkdirRelPosix, tokenIsSearchable, tolerated, triageState, truncateForDisplay, truncatedRosterNote, uncoveredCount, uncoveredLinesToScope, uncoveredLocationFindings, understandsModelServiceVersion, undrivableRunner, unguardedSentence, unguardedSitesFrom, unmaskableSecretRefusal, unobserved, unobservedBaselineCause, unobservedBaselineCode, unobservedBaselineRefusal, unobservedBaselineRunnerNote, untestedChangeLead, upstreamErrorInBody, usageDollars, usageKnown, usageOrNull, usdToMicros, validateCiResidualGapLedger, validateConfig, validateConfigWithNotes, validateDiffCoverageLines, validateManifest, validatePlaygroundExplanation, validatePlaygroundModelResponse, validatePlaygroundPublicMaterial, validatePlaygroundPublicResult, validatePlaygroundSummary, validatePreparedTestCommand, validateTargetReceipt, verdictExecutionEnvironment, verdictGatesSomebodyElse, watchModeDisableFlags, watchModeRefusal, wilsonInterval, wireArray, wireBoolean, wireDigest, wireEnum, wireInteger, wireLiteral, wireNullable, wireNumber, wireObject, wirePrintable, wirePrintableText, wireRecord, wireString, wireUnion, withFileLock, withJestWatchModeDisabled, withWatchModeDisabled, withheldEvidenceLine, withinPackage, withoutJestWatchDisableFlags, withoutKeys, withoutRetiredKeys, withoutSpecPositionals, withoutUbuntuTimeSuffix, withoutWatchDisableFlags, workflowRuntimeBin, workflowRuntimeCheckStep, workflowRuntimePrefix, workflowRuntimeSteps, workflowYaml, writePrivateFile, xmlChild, yamlLegValue, yamlScalar };
+export { ABLOH_FAILURE_OWNERSHIP, ABLOH_FAILURE_OWNERSHIP_ANONYMOUS, ABLOH_SUPPORT_ADDRESS, ACCOUNT_MODEL_VARIABLES, ACCOUNT_ORGANIZATION_VAR, ACCOUNT_SESSION_TOKEN_VAR, ACCOUNT_TOKEN_URL_VAR, ACTION_NON_IMPORTED_ASSETS, ACTION_REFERENCES, ACTION_REPOSITORY, ADDITION_GROUPS, ADMISSION_DRIFT_PHRASES, ADMISSION_SENTENCE_MAX, ALL_STAGES_RAN_NOTE, ANGULAR_RUNNERS, ANNOTATION_SEVERITIES, API_KEY_SCOPES, ASTER_COVERAGE_FORMAT, ASTER_COVERAGE_PROVIDER, ASTER_COVERAGE_RAW_FORMAT, ASTER_COVERAGE_SCHEMA, ASTER_ENGINE_NAME, ASTER_ENGINE_VERSION, ATTESTATION_JOB_ID, ATTEST_ACTION, AUDITABLE_SOURCE_EXTENSIONS, type AblohConfig, type AblohFailureFacts, type ActionFileReader, type AddedVariable, type AdditionGroup, type AdmissionCoverage, type AdmissionDrift, type AdmissionDriftKind, type AdmissionKeyFacts, type AdmissionNeed, type AdmissionNeedFacts, type AdmissionOwnFacts, type AdmissionRefusalReason, type AdmissionSubject, type AngularKarmaShape, type AngularRunnerName, type AngularTestRunner, type AngularTestTarget, type AnnotationSeverity, type ApiKeyScope, type AppliedCeilings, type ArchiveComponent, type ArchiveIdentity, type ArtifactDestinationFacts, type ArtifactDestinationProblem, type ArtifactOutputPathCombination, type ArtifactOutputPathFacts, type ArtifactOutputPathProblem, type ArtifactPublicationLockCombination, type ArtifactPublicationLockFacts, type ArtifactWriteCombination, type ArtifactWriteFacts, type AssayResult, type AssayVerdict, type AsterCoverageCensus, type AsterCoverageEvidence, type AsterCoverageFile, type AsterCoverageLine, type AttestResultsV2, type AttestStatus, type AttestationEnvironment, type AttestationInput, type AttributionQuality, type AuditScope, BASELINE_HISTORY_MAPPING, BASELINE_HISTORY_REASONS, BASELINE_JOB_CLOCK_REMEDY, BASELINE_JOB_CLOCK_RESERVE_SUITE_RUNS, BASELINE_LINE_MAPPING, BASELINE_PUBLICATION_ALLOWANCE_MS, BASELINE_RUN_FACTOR, BASELINE_RUN_FLOOR_MS, BOOST_MS_PER_DAY, BROWSER_LANE_MEASURED_ENVIRONMENT, BROWSER_LANE_SEAL, BROWSER_SHARED_MEMORY_ARGV, BROWSER_SHARED_MEMORY_PATH, BROWSER_SHARED_MEMORY_TMPFS, BUG_BEHAVIOUR_VERDICTS, BUG_EMOJI, BUG_SEVERITIES, BUN_DIFF_COVERAGE_NOTICE, BUN_DIFF_COVERAGE_NOTICE_SHORT, type BaseReachability, type BaseUnreachableCause, type BaselineCombination, type BaselineCommand, type BaselineGateAbsence, type BaselineHistoryCombination, type BaselineHistoryLine, type BaselineHistoryReason, type BaselineJobClock, type BaselineJobClockStop, type BaselineLine, type BaselineLineCombination, type BaselineOutcomeEvidence, type BaselineOutcomeFacts, type BaselineRunBound, type BaselineRunBoundSource, type BrowserSealClause, type BugBehaviourVerdict, type BugSeverity, type BuildCiPropertyBlockInput, type BuildScenarioSearchBlockInput, type BuiltOutputFacts, CANDIDATE_BODY_MAX, CANDIDATE_ENTRIES_MAX, CANDIDATE_NAME_MAX, CANDIDATE_PATH_MAX, CANDIDATE_TEXT_CONTROL_DETAIL_MAX, CANDIDATE_TEXT_CONTROL_SCHEMA, CANDIDATE_UPLOAD_RULES, CANONICAL_MODEL_VARIABLES, CARRIED_AFTER_SHA, CARRIED_BEFORE_SHA, CARRIED_BUG_OUTCOMES, CARRIED_SHA_LENGTH, CARRIED_UNNAMED, CHECKOUT_ACTION, CHECK_ADMISSION_SCHEMA, CHECK_ADMISSION_TIMEOUT_MS, CHROME_DENIED_CLONE_FLAGS, CHROME_SECCOMP_ADDITIONS, CI_OBLIGATION_SIGNAL_AUTHORITIES, CI_PROPERTY_AUTHORITIES, CI_PROPERTY_CAPS, CI_PROPERTY_FAMILIES, CI_PROPERTY_INTENT_POOL_SCHEMA, CI_PROPERTY_INTENT_TASK_SCHEMA, CI_PROPERTY_OUTCOMES, CI_PROPERTY_STATES, CI_RESIDUAL_STATES, CLI_COMMANDS, CLI_HELP_REMEDY, CLI_MAPPINGS, CLI_OPTIONS, CLI_OPTION_CONFIG_CONFLICT_REMEDY, CLI_OPTION_CONFLICT_REMEDY, CLI_OPTION_UNAVAILABLE_REMEDY, CLI_PATH_PROBLEMS, CLUSTER_STRATEGIES, COMMAND_READ_PROBLEMS, COMPUTE_RATE_ENV, CONFIG_DOCS_URL, CONFIG_FILE_PATH, CONFIG_KEY_REGISTRY, CONTROL_CHARACTERS, CONVENTIONAL_HEADER_MAX_LENGTH, CONVENTIONAL_TYPES, COREPACK_PROVIDES, COST_UNKNOWN, COVERAGE_DISPLAY_STATES, COVERAGE_EVIDENCE_SCHEMA, COVERAGE_LINE_MAPPING, COVERAGE_PROVIDER_CACHE_DEFAULT_ROOT, COVERAGE_PROVIDER_CACHE_DIR_VAR, COVERAGE_PROVIDER_CHOICES, COVERAGE_STATE_WORDS, COVERAGE_VERDICT, CREDENTIAL_SHAPE_MASK, CUSTOMER_TYPED, type CallerJobOutcome, type CandidateTextControl, type CandidateUploadRule, type CarriedBugOutcome, type CarriedStanding, type CarriedVerdict, type CellObservation, type ChangedStructuralCounts, type CheckAdmissionCombination, type CheckAdmissionFacts, type CheckAdmissionRequestWire, type CheckAdmissionResponseWire, type CheckAdmissionSilence, type CheckoutIdentity, type ChromeSeccompAddition, type ChromeSeccompArg, type CiChangedRange, type CiObligationSignal, type CiObligationSignalAuthority, type CiPropertyAuthority, type CiPropertyCandidateCap, type CiPropertyCounts, type CiPropertyFamily, type CiPropertyMeasuredBlock, type CiPropertyOutcome, type CiPropertyRuleCandidate, type CiPropertyRuleDrop, type CiPropertySearchBlock, type CiPropertyState, type CiPropertySummary, type CiPropertyTargetCandidate, type CiPropertyTargetDecision, type CiPropertyTargetPlan, type CiResidualGapEntry, type CiResidualGapLedger, type CiResidualState, type CiStepsUnreadFacts, type ClassicMutationConfig, type ClassicMutationTier, type ClassicSamplingBlock, type CliCommand, type CliFacts, type CliOption, type CliPathProblem, type CliValueShape, type ClusterStrategy, type CodeownersRule, type CombinedGate, type CommandGlobExpansion, type CommandLine, type CommandLineCombination, type CommandLineObservation, type CommandPlan, type CommandProvenance, type CommandReadProblem, type CommandResolutionStop, type CommandRuntime, type CommandScriptHop, type CompiledOutputReading, type ComposedFindings, type ConditionalPowerResult, type ConfigInRangeCombination, type ConfigInRangeFacts, type ConfigInRangeSilence, type ConfigKeyEntry, type ConfigKeyReader, type ConfigKeyStanding, type ConfigLoad, type ConfigOrigin, type ConfigReadOptions, type ConfigTreeEntryCombination, type ConfigTreeEntryFacts, type ConfigTreeEntrySilence, type ConfigValueJudge, type ConfigValueRule, type ConfigValueVerdict, type ConfinementClause, type ConsumedGeneratedImport, type ContentsEntry, type ContentsIndexRef, type ConventionalHeader, type CoreSilence, type CorepackCacheFacts, type Counts, type CoverageAcquisitionObservation, type CoverageAdapterResolutionObservation, type CoverageAddressableFacts, type CoverageBundledPackageFacts, type CoverageCacheFacts, type CoverageComposition, type CoverageDisplayState, type CoverageEvidence, type CoverageEvidenceChild, type CoverageFacts, type CoverageLine, type CoverageLineCombination, type CoverageProvider, type CoverageProviderCacheFacts, type CoverageProviderChoice, type CoverageProviderFacts, type CoverageProviderObservation, type CoverageReportFormatFacts, type CoverageReportSizeFacts, type CoverageRunnerFacts, type CoverageScopeFacts, type CoverageStateWords, type CoverageVerdictState, DECLARED_SERVICE_CONFINEMENT, DEEPEN_FETCH_TIMEOUT_MS, DEEPEN_LADDER, DEEP_AUDIT_ARTIFACT_SCHEMA, DEEP_AUDIT_FINDING_ORIGINS, DEEP_AUDIT_LINE_VERDICTS, DEEP_AUDIT_SCOPE_SOURCES, DEFAULT_CLASSIC_MUTATION, DEFAULT_CONFIG, DEFAULT_DIFF_COVERAGE, DEFAULT_ENVIRONMENT, DEFAULT_ENVIRONMENT_IMAGE_DIGEST, DEFAULT_ENVIRONMENT_IMAGE_REF, DEFAULT_FLOOR, DEFAULT_MODEL_ENDPOINT, DEFAULT_MUTATION, DEFAULT_NATIVE_VOCABULARY, DEFAULT_SETUP_BOT_LOGIN, DEFAULT_SETUP_ROAD, DEPENDENCY_PATH_SEGMENTS, DESTINATION_LABELS, DIFF_COVERAGE_CANNOT_ATTEST_REASONS, DIFF_COVERAGE_THRESHOLD, DISPLAY_CUT_MARK, DISPLAY_TRUNCATABLE_FIELDS, DOCKER_DEFAULT_SECCOMP_SOURCE, type DecisiveLayer, type DeclaredEnvironment, type DeclaredKey, type DeclaredKeyCombination, type DeclaredKeyObservation, type DeclaredPackageManager, DeclaredRefusalError, type DeclaredValue, type DeepAuditArtifactParse, type DeepAuditCountsReport, type DeepAuditCoverageFileReport, type DeepAuditCoverageRange, type DeepAuditFinding, type DeepAuditFindingOrigin, type DeepAuditLineVerdict, type DeepAuditReachReport, type DeepAuditRunArtifact, type DeepAuditScopeReport, type DeepAuditScopeSource, type DeepAuditSpendReport, type DetectionCell, type DeterministicMutantsBlock, type DiffCoverageCannotAttestReason, type DiffCoverageConfig, type DiffCoverageCounts, type DiffCoverageLine, type DiffCoverageLineState, type DiffCoverageNotApplicableReason, type DiffCoverageNotRunReason, type DiffCoverageResult, DiffScopeError, type DisplayTruncatableField, type DisplayTruncation, type DockerCommandRunner, type DockerInvocation, ENGINE_FAILURE_LOG, ENGINE_FAILURE_REPORT_ID_PATTERN, ENGINE_FAILURE_SHAPE_NAMES, ENGINE_FAILURE_TIMED_OUT, ENGINE_MODEL_FAILURES, ENVELOPE_ONLY_EVIDENCE_KEYS, ENVIRONMENT_AMENDMENT_COMMIT_MESSAGE, EVIDENCE_API_KEY_SCOPES, EVIDENCE_CUT_CLAUSE, EVIDENCE_EGRESS_SAFE, EVIDENCE_INDEX_MISSING_REMEDY, EVIDENCE_INDEX_UNREADABLE_REPORT_ID, EVIDENCE_MANIFEST_SCHEMA, EVIDENCE_OUTPUTS, EVIDENCE_REGROUPING_EXPIRY, EVIDENCE_RETENTION_DEFAULT_DAYS, EVIDENCE_RETENTION_MAX_DAYS, EVIDENCE_RETENTION_MIN_DAYS, EVIDENCE_SOURCES, EVIDENCE_WORD, EXCLUDE_RE, EXECUTION_ROADS, EXECUTION_STAGES, EXPECTED_ORACLE_CELL, type EgressEngineFailure, type EgressRefusal, type EngineFailureBlock, type EngineFailureShape, type EngineModelFailure, type EnsureBaseReachableInput, type EnvironmentConfig, type EnvironmentServiceConfig, type ErrorHandlersBlock, type ErrorPathsConfig, type EvidenceCustody, type EvidenceFloor, type EvidenceIndexFacts, type EvidenceIndexProblem, type EvidenceKind, type EvidenceManifest, type EvidenceManifestEntry, type EvidenceOutput, type EvidenceOutputId, type EvidenceProfile, type EvidenceProvenance, type EvidenceRole, type EvidenceSlot, type EvidenceSource, type EvidenceUploadPlan, type EvidenceVerdictState, type EvidenceWithholdReason, type ExecutionAxis, type ExecutionCapabilities, type ExecutionCopies, type ExecutionCopy, type ExecutionCopyMethod, type ExecutionPlan, type ExecutionRecord, type ExecutionRecordSink, type ExecutionRoad, type ExecutionStage, type ExpandedCommandGlobs, type ExperimentManifest, FAIL_FAST_JOB_NOTE, FEATURE_NOT_RUN_REASONS, FINDINGS_TABLE_MAPPING, FINDING_CARRIED_SHA, FINDING_EMOJI, FINDING_EMOJI_FALLBACK, FINDING_FILE_PATH_MAX, FINDING_MUTANT_ID_MAX, FINDING_MUTATOR_MAX, FINDING_PROVENANCE_MAX, FINDING_SEVERITIES, type FactMapping, type FactTestRow, type FactsOf, type FailFastJob, type FailFastReading, type FailedTestFile, type FeatureNotRunReason, type FeatureState, type FileFacts, type FileScope, type FileStructural, type FindingSeverity, type FindingStatus, type FindingTitleParts, type FindingsTable, type FindingsTableCombination, type FirstPassProjection, type FirstPassRates, type FittedRefusal, type FixLoopBlock, type FixProofSummary, type FixProofVerdict, type FlakyConfig, type FloorConfig, GATE_VERDICT, GATE_WORD, GENERATION_STATES, type GapFinding, type GapKeyInput, type GateResult, type GateStatus, type GateVerdictState, type GeneratedPath, type GenerationState, type GitCommandCombination, type GitCommandFacts, type GitCommandSilence, type GitHubStructuralFinding, type GithubValue, type GroupableFinding, HANDOFF_EVIDENCE_KEYS_V1, HANDOFF_EVIDENCE_KEYS_V2, HANDOFF_TARGET_KEYS, HEALABLE_SETUP_STAGES, HEX_DIGEST_64, HOSTED_CHECKS_NEED_NO_KEYS, HOSTED_RUN_HEADER, type HandlerAntiPatternKind, type HandlerFinding, type HeadroomResult, type HeadroomVerdict, type HistoricalPair, type HostedRunIdentity, IDENTITY_CONDITION_CODES, IMPORT_SELECTOR_PREFIX, INACTIVE_INPUT_REASONS, INIT_DOORS, INIT_FAILURE_CLASSES, INIT_OUTCOMES, INIT_PACKAGE_MANAGERS, INIT_QUESTION_KEYS, INIT_RUNNERS, INIT_TELEMETRY_SCHEMA, INIT_TELEMETRY_VERSION, INTENT_TASK_COMMON_FIELDS, INTERRUPTION_MECHANISMS, INVENTORY_NAME_RENDER_LIMIT, type IdentityConditionFacts, type IdentityConditionKind, type ImportHop, type InactiveInputReason, type InactiveInputs, type IndexCandidate, type IndexQuery, type Infer, type InferFields, type InitDoor, type InitFailureClass, type InitOutcome, type InitPackageManager, type InitQuestionKey, type InitRunner, type InitTelemetryEvent, type InstalledInput, type InstrumentationComparison, type InstrumentationDivergence, type InterruptionMechanism, InvariantError, JEST_WATCH_DISABLE_FLAGS, JEST_WATCH_DISABLE_SUFFIX, JOB_CLOCK_COST_BASES, JOB_CLOCK_SEALED_STAGES, JOB_CLOCK_STAGES, JOB_CLOCK_STAGE_OVERHEADS, JOB_CLOCK_STAGE_UNITS, type JobClockCostBasis, type JobClockStage, type JobClockStageOverhead, type JobClockStageProjection, type JobClockStageStop, type JobClockStageUnit, type JobTimeBudgetRefusalFacts, KNOWN_ENVIRONMENT_KEYS, KNOWN_SETUP_KEYS, LAYER0_EXECUTION, LAYER0_SCOPE_DISCLOSURE, LAYER1_EXECUTION, LAYER2_INTENT_PROPOSAL_FIELDS, LAYER2_INTENT_PROPOSAL_SCHEMA, LAYER2_INTENT_TASK_SCHEMA, LIVE_PROGRESS_MAX_UPDATES_PER_RUN, LIVE_PROGRESS_SCHEMA, LIVE_PROGRESS_SUMMARY_MAX_BYTES, LIVE_PROGRESS_TIMEOUT_MS, LIVE_PROGRESS_TITLE_MAX, LOCAL_DESTINATIONS, LOCAL_LADDER_LEAD_IN, LOCAL_MODEL_DOCS_URL, LOCAL_TRIAL_ANSWERS, LOCK_POLL_MS, LOCK_STALE_MS, LOCK_WAIT_MS, type Layer1GateInput, type Layer2IntentProposalField, type LedgerEntry, type LineGroup, type LiveProgressUpdateWire, type LocalTrialAnswer, MAINLINE_BRANCHES, MAX_ANNOTATION_MUTATORS, MAX_ANNOTATION_REASONS, MAX_ANSWERED_SYSTEM_PACKAGES, MAX_ARTIFACT_COVERAGE_FILES, MAX_ARTIFACT_FINDINGS, MAX_ARTIFACT_RANGES_PER_FILE, MAX_BUG_DESCRIPTION_LEN, MAX_BUG_RATIONALE_LEN, MAX_BUG_SENTENCE_LEN, MAX_BUG_TYPE_LEN, MAX_CARRIED_BUG_ENTRIES, MAX_DEEPEN_DEPTH, MAX_DIAGNOSTIC_REASON_CHARS, MAX_ENVIRONMENT_SERVICES, MAX_EXECUTION_RECORDS, MAX_EXPANDED_LINES, MAX_FINDING_ABOUT_LEN, MAX_FINDING_DESCRIPTION_LEN, MAX_GENERATED_FILES, MAX_IMPORT_LENGTH, MAX_LITERAL_ARGUMENTS, MAX_LITERAL_COMMAND_BYTES, MAX_MUTANT_ROSTER, MAX_MUTANT_ROSTER_ROWS, MAX_OBSERVED_EVENT_BYTES, MAX_PACKAGE_ROWS, MAX_PATTERN_LENGTH, MAX_POOL2_EVIDENCE_ENTRIES, MAX_PREFLIGHT_CHECKS_RUN, MAX_PREFLIGHT_LIST, MAX_PROPOSAL_CANDIDATES, MAX_RESOLVED_FINDINGS, MAX_REWRITTEN_FILES, MAX_SCOPE_IMPORTS, MAX_SCOPE_PATTERNS, MAX_SCOPE_RANGES, MAX_SCOPE_TEAMS, MAX_SCRIPT_HOPS, MAX_SETUP_SCRIPT_BYTES, MAX_SETUP_STEPS, MAX_SYSTEM_PACKAGES, MAX_UNCOVERED_LOCATION_FINDINGS, MAX_UPLOADED_FINDINGS, MEASURED_COST_MODEL_UNCERTAINTY, MEASURED_DOLLARS_PER_ESCAPE, MEASURED_DOLLARS_PER_HUNTED_FILE, MEASURED_FUNCTIONS_PER_AUDITABLE_KILOBYTE, MEASURED_LONGEST_HOLD_REASON, MEASURED_LONGEST_PROPOSALS_ENDING, MEASURED_SECONDS_PER_SWEPT_FUNCTION, MEASURED_TREES, MEASURED_TYPICAL_ESCAPES_PER_HUNTED_FILE, MEASURED_WORST_ESCAPES_PER_HUNTED_FILE, MEASUREMENT_PLAN_SCHEMA, MECHANICAL_ERROR_PATH_REASON, MEMORY_CEILING_MAX_MB, MEMORY_FLOOR_MB, MEMORY_HOST_SHARE, MEMORY_PER_CORE_MB, MERGE_REF_REMEDY, MESSAGE_MAPPINGS, MINT_TIMEOUT_MS, MIN_CELL_REPEATS, MODEL_AUTH_VAR, MODEL_DISPATCH_ATTEMPT_ID_RE, MODEL_DISPATCH_DOORS, MODEL_DISPATCH_REFUSALS, MODEL_ENDPOINT_VAR, MODEL_ERROR_CATEGORIES, MODEL_ERROR_RETRYABLE, MODEL_KEY_PREFIX, MODEL_KEY_VAR, MODEL_OIDC_AUDIENCE_VAR, MODEL_OIDC_REQUEST_TOKEN_VAR, MODEL_OIDC_REQUEST_URL_VAR, MODEL_PATH_DISPOSITION, MODEL_PATH_NAMED_ELSEWHERE, MODEL_PROBE_REFUSAL_CODES, MODEL_RECEIPT_KEY, MODEL_REQUEST_LOCAL_REFUSALS, MODEL_RESPONSE_MODES, MODEL_SERVICE_BASE_PATH, MODEL_SERVICE_CONTRACT_VERSION, MODEL_SERVICE_EFFORTS, MODEL_SERVICE_LIMITS, MODEL_SERVICE_MODEL_NAME, MODEL_SERVICE_OUTPUT_FORMATS, MODEL_SERVICE_ROUTES, MODEL_SERVICE_SURFACES, MODEL_SERVICE_VERSIONS_UNDERSTOOD, MODEL_SETUP_HINT, MODEL_STREAM_OUTCOMES, MODEL_TERMINAL_EVENT_TYPE, MODEL_TOKEN_INPUT_NAME, MODEL_TOKEN_SECRET_NAME, MODEL_VARIABLE_ALIASES, MODEL_VARIABLE_GUIDE, MUTANT_STATUSES, MUTATION_ATTEMPTED_NOT_RUN_REASONS, MUTATION_EXECUTION_STATES, MUTATION_LINE_MAPPING, MUTATION_NOT_RUN_REASONS, MUTATION_REFUSAL_CODES, MUTATION_SCOPE_KINDS, MUTATION_SCOPE_SURFACE, MUTATION_SKIP_REASONS, MUTATION_STAGE_WALL_MINUTES, MUTATION_STAGE_WALL_MS, MUTATOR_TOKEN_RE, type ManifestModel, type ManifestValidation, type MapCostPolicy, type MapCostProjection, type MapCostReading, type MapCostRoadFacts, type MapCostStop, type MatrixLeg, type MatrixLegs, type MatrixValue, type MeasuredEnvironmentPlan, type MeasuredTree, type MeasurementPlan, type MechanicalCounts, type MessageFacts, type MessageOutcome, type MessagePreview, type MessageSilence, type ModelAccess, type ModelBufferedReceipt, type ModelChoiceConfig, type ModelCostState, type ModelDispatchClaim, type ModelDispatchClaimAnswer, type ModelDispatchClaims, type ModelDispatchDoor, type ModelDispatchRefusal, type ModelDispatchRunKey, type ModelDispatchSettlement, type ModelErrorCategory, type ModelFailureDisposition, type ModelPathFailure, type ModelProbe, type ModelProbeCombination, type ModelRate, type ModelReceipt, type ModelReplyReading, type ModelRequestFit, type ModelRequestFitFailure, type ModelRequestLocalRefusal, type ModelResponseMode, type ModelServiceAnswer, type ModelServiceEffort, type ModelServiceErrorBody, type ModelServiceErrorEnvelope, type ModelServiceOutage, type ModelServiceOutputFormat, type ModelServiceRoute, type ModelServiceSurface, type ModelStep, type ModelStreamOutcome, ModelStreamReading, type ModelSurface, type ModelTerminalEvent, type ModelUsage, type ModelUsageState, type ModelVariableRead, type ModelsConfig, type ModuleLayout, type MutantRosterEntry, type MutantStatus, type MutationConfig, type MutationExecution, type MutationExecutionState, type MutationLine, type MutationLineCombination, type MutationMode, type MutationNotRunReason, type MutationScopeKind, type MutationSkipReason, NATIVE_FLOOR_PACKAGES, NATIVE_FLOOR_PACKAGE_NAMES, NATIVE_FONT_PACKAGES, NATIVE_FONT_REASON, NATIVE_SYMPTOM_KINDS, NATIVE_VOCABULARIES, NEARBY_EXPLAINS, NEARBY_MAX_NAMED, NEARBY_NOT_COVERED_WORD, NEARBY_NOT_IN_RATE, NEARBY_NOT_NOTICED_WORD, NEARBY_TITLE, NEW_RAW_MESSAGE_GUIDANCE, NODE_FLAGS_TAKING_A_VALUE, NODE_REPORTER_STDOUT, NOFILE_CEILING_MAX, NOFILE_FLOOR, NOFILE_PER_CORE, NON_EVIDENCE_OUTPUTS, NON_SOURCE_DIRECTORIES, NOTHING_IS_WAITING, NOTHING_IS_WAITING_LABEL, NOTHING_IS_WAITING_LINE, NO_JOB_TO_RIDE_NOTE, NO_PROPOSAL_LINES, NO_VERDICT_LABEL, type NarrationSink, type NativeFloorPackage, type NativeResolution, type NativeResolutionResult, type NativeSymptom, type NativeSymptomKind, type NativeUnresolved, type NativeUnresolvedCause, type NativeVocabulary, type NearbyCodeUnmeasuredCause, type NearbyCodeUnmeasuredFacts, type NearbyFinding, type NearbyReport, type NearbyRole, type NearbyVerdict, type NestedProjection, type NextActionParts, type NodeRuntime, type NodeRuntimeCombination, type NodeRuntimeObservation, type NonEvidenceKind, type NonEvidenceOutput, type NonEvidenceOutputId, type NormalizedCoverage, type NormalizedMutant, ORIGIN_TRACKED_KEYS, OWNER_KIND, type Observation, type OracleObservation, type OriginFacts, type OutcomeFor, PACKAGE_EXCLUSION_TEXT_MAX, PACKAGE_MANAGERS, PACKAGE_ROW_EXCLUDED_FIELDS, PACKAGE_ROW_FIELDS, PACKAGE_UNMEASURABLE, PATTERN_REFUSALS, PIDS_CEILING_MAX, PIDS_FLOOR, PIDS_PER_CORE, PINNED_ACTION, PLANTED_COUNTS_MAPPING, PLAN_NAMES, PLAN_REFUSAL_CODES, PLAYGROUND_ABLOH_FAILURE_LINE, PLAYGROUND_ADVISORY_TRIAGE, PLAYGROUND_DISMISS_LABEL, PLAYGROUND_ENGINE_MUTANT, PLAYGROUND_ENGINE_MUTANT_FIELDS, PLAYGROUND_ENGINE_NAME, PLAYGROUND_ENGINE_REVISION, PLAYGROUND_ENGINE_VERSION, PLAYGROUND_EXCERPTS_PER_MUTANT, PLAYGROUND_EXCERPT_MAX_BYTES, PLAYGROUND_EXCERPT_RESULT_SHARE, PLAYGROUND_EXECUTED_TEST, PLAYGROUND_EXPLANATION, PLAYGROUND_JOB_API_VERSION_V2, PLAYGROUND_MAX_MUTANTS, PLAYGROUND_MODEL_RESPONSE, PLAYGROUND_MUTANT_EVIDENCE, PLAYGROUND_MUTANT_STATUSES, PLAYGROUND_OPERATOR_SET_VERSION, PLAYGROUND_POLICY_SHA256, PLAYGROUND_PUBLIC_MUTANT, PLAYGROUND_PUBLIC_RESULT, PLAYGROUND_PUBLIC_RESULT_MATERIAL, PLAYGROUND_PUBLIC_ROSTER, PLAYGROUND_PUBLIC_RUN_RESULT_SCHEMA, PLAYGROUND_RESULT_MAX_BYTES, PLAYGROUND_RESULT_WITHHELD, PLAYGROUND_REVIEWS, PLAYGROUND_ROSTER_EXCERPT_MAX_BYTES, PLAYGROUND_SANDBOX_VERSIONS, PLAYGROUND_SENTENCES, PLAYGROUND_SEVERITIES, PLAYGROUND_SOURCE_MAX_BYTES, PLAYGROUND_STAGE_EVENT, PLAYGROUND_STAGE_EVENTS, PLAYGROUND_SUMMARY, PLAYGROUND_TEST_EVIDENCE_ABSENCES, PLAYGROUND_TEST_EXECUTION, PLAYGROUND_TEST_EXECUTIONS, PLAYGROUND_TEST_STATUSES, PLAYGROUND_TRIAGE_FIELD_POLICY, PLAYGROUND_TRIAGE_REASON_CODES_V2, PLAYGROUND_TRIAGE_VERDICTS_V2, PLAYGROUND_VITEST_RUNNER_VERSION, PNPM_VERIFY_DEPS_OFF, PNPM_VERIFY_DEPS_VARIABLE, PNP_RUNTIME_BASENAME, PNP_RUNTIME_FILE_PATTERN, POOL2_EVIDENCE_SCHEMA, PREFLIGHT_CHECKS, PRINTABLE_ASCII, PRINTABLE_TEXT, PRINT_WIDTH, PRIVATE_DIRECTORY_MODE, PRIVATE_FILE_MODE, PROPOSALS_BLOCK_SCHEMA, PROPOSALS_CANDIDATE_FIELDS, PROPOSALS_DISCOVERY_STATES, PROPOSALS_FEATURE_STATES, PROPOSALS_FILE_PATH_MAX, PROPOSALS_GAP_ORIGINS, PROPOSALS_MUTANT_ID_MAX, PROPOSALS_PACKAGE_SIDECAR_INDEX, PROPOSALS_PREDICTOR_MODES, PROPOSALS_SIDECAR_SCHEMA, PROPOSALS_SUITE_STATES, PROPOSALS_SUMMARY_FIELDS, PROPOSALS_UNAVAILABLE_COPY, PROPOSALS_VERDICTS, PROVEN_BASIS, PROVIDER_RAW_FORMAT, type PackageEvidence, type PackageExclusion, type PackageManagerDeclaration, type PackageManagerName, type PackageManagerPin, type PackageManifest, type PackageManifestProblem, type PackageManifestReading, type PackageRowField, type PairIsolation, type PatternRefusal, type PerTestAttribution, type PerTestBlock, type PerTestConfig, type PerTestFinding, type PerTestFindingKind, type PerTestReportFailure, type PlanBinding, type PlanCommand, type PlanCommandSource, type PlanEnvironment, type PlanEnvironmentBackend, type PlanEvidence, type PlanExecution, type PlanLimitFacts, type PlanName, type PlanQuarantine, type PlanRefusalCode, type PlanRefusalCombination, type PlanRefusalFacts, type PlanRefusalObservation, type PlanSetup, type PlanTarget, type PlantedCounts, type PlantedCountsCombination, type PlaygroundAdvisoryTriage, type PlaygroundEngineMutant, type PlaygroundExecutedTest, type PlaygroundExplanation, type PlaygroundModelResponse, type PlaygroundMutantStatusName, type PlaygroundPublicMutant, type PlaygroundPublicResult, type PlaygroundPublicResultMaterial, type PlaygroundPublicSummary, type PlaygroundStageEvent, type PlaygroundStageFact, type PlaygroundTestExecution, type PluginInvocation, type PreflightCheck, type PreflightCombination, type PreflightEventWire, type PreflightReportFacts, type PreflightSilence, type PreparationRole, type PreparedTestCommand, type PreparedTestCommandSource, type ProducerChoice, type ProposalsCandidateWire, type ProposalsConfig, type ProposalsDiscoveryState, type ProposalsFeatureState, type ProposalsGapOrigin, type ProposalsPredictorMode, type ProposalsSuiteState, type ProposalsSummaryWire, type ProposalsUnavailableCode, type ProposalsVerdict, type ProposedFile, type ProposedMutant, type ProvenanceStrength, type PullRequestCheckout, QUARANTINE_CAP_MINIMUM, QUARANTINE_CAP_PROPORTION, QUARANTINE_NAME_RENDER_LIMIT, QUARANTINE_REASONS, QUARANTINE_REASON_COPY, type QualificationResult, type QualificationVerdict, type QualifiedOmission, type QuarantineAdmission, type QuarantineCounts, type QuarantineDisclosure, type QuarantineExclusionMode, type QuarantineReason, RATE_CARD_ENV, RATE_CARD_SCHEMA, RAW_COVERAGE_FORMATS, REALISTIC_CATEGORIES, RECEIPT_DETAIL_MAX, RECEIPT_DIRECTORY, RECEIPT_FILE_MAX_BYTES, RECEIPT_STAGES, RECEIPT_UNREADABLE_PHRASES, RED_BASELINE_OUTPUT_TAIL_LINES, REFUSAL_CODES, REFUSAL_CODE_MERGE_EXPIRY, REFUSAL_CODE_RE, REFUSAL_DESTINATIONS, REFUSAL_FIT_NOTE, REFUSAL_FIT_ORDER, REFUSAL_MESSAGE_MAX, REFUSAL_MESSAGE_PATHS, REFUSAL_OWNERS, REFUSAL_PRIVACY, REFUSAL_REGISTRY, REFUSAL_STAGES, REMINT_MARGIN_MS, REPORT_DIALECTS, REPORT_MAPPINGS, REPORT_SECTION_MAPPING, REPORT_UNAVAILABLE_CAUSES, RESERVED_CUSTOMER_PREFIXES, RESERVED_CUSTOMER_VARIABLES, RESOLVED_EVIDENCE_FIELDS, RESOLVED_EVIDENCE_SCHEMA, RESOLVED_EVIDENCE_UNKNOWN_FIELDS, RETIRED_EVIDENCE_OUTPUTS, RETIRED_KEYS, RETIRED_PROPOSALS_BLOCK_SCHEMAS, RETIRED_REFUSAL_CODES, RETIRED_REFUSAL_DESTINATIONS, ROAD_INPUTS, ROUTE_PURITY_RUNGS, RULED_AUDITABLE_FILES_PER_HUNTABLE_FILE, RULED_FIRST_PASS_RATES, RULED_HUNT_ENVELOPE_DOLLARS, RULED_MAP_ROAD_SLICE_EXECUTIONS, RULED_PROPOSAL_CHANGED_WITHIN_DAYS, RULED_RUN_DOLLAR_CAP, RULED_RUN_HUNT_WALL_MS, RULED_RUN_WALL_MS, RULED_SIZE_GATE, RULED_SWEEP_WALL_FRACTION, RUNNER_BINARY_SUFFIX_SOURCE, RUNNER_CAPABILITIES, RUNNER_DEFAULT_SOURCE, RUNNER_TYPED_CONSEQUENCE, RUN_ATTEMPT_DIGITS, RUN_ATTEMPT_MAX, RUN_CEILING_REMEDY, RUN_COST_STOP_MAPPING, RUN_FACTS_NOT_CUSTOMER_FACING, RUN_FACTS_NOT_RETAINED, RUN_FACT_SURFACES, RUN_FACT_SURFACE_GAPS, RUN_FINDING_ABSENCE, RUN_FINDING_FIELDS, RUN_FINDING_NESTED, RUN_FINDING_TRIAGE_ABSENCE, RUN_FINDING_TRIAGE_FIELDS, RUN_INTERRUPTION_FACT_KEY_RE, RUN_INTERRUPTION_LIMITS, RUN_LOCAL_EVIDENCE_SCHEMA, RUN_LOG_STAGE, RUN_MODEL_COST_LIMITS, RUN_PROGRESS, RUN_PROGRESS_COUNTERS, RUN_PROGRESS_COUNTER_MAX, RUN_PROGRESS_COUNTS, RUN_PROGRESS_MAX_PROPOSALS, RUN_PROGRESS_NAME_MAX, RUN_PROGRESS_PATH_MAX, RUN_PROGRESS_PROPOSAL, RUN_PROGRESS_REASON_MAX, RUN_PROGRESS_STAGES, RUN_PROGRESS_STAGE_ROW, RUN_PROGRESS_STAGE_STATES, RUN_RECORD_ASSEMBLY_SITES, RUN_RECORD_CONTRACT, RUN_RECORD_WIRE_GAPS, RUN_REFUSAL_CODE_RE, RUN_REFUSAL_LIMITS, RUN_SCOPE_MAPPING, RUN_STAGES, RUN_STAGE_UNITS, type RankedCiPropertyRule, type RateCard, type RateCardFailure, type RateCardResolution, type RawCoverageFormat, type RawCoverageFormatName, type RealisticCategory, type RebuildFacts, type ReceiptCombination, type ReceiptFileInvalidity, type ReceiptFileParse, type ReceiptInvalidity, type ReceiptProvenance, type ReceiptStage, type ReceiptStageName, type ReceiptState, type ReconciliationBlock, type RecordingReplayCombination, type RecordingReplayFacts, type RecordingReplaySilence, type RecordingsFileCombination, type RecordingsFileFacts, type RecordingsFileSilence, type RedBaselineFacts, type RedBaselineShape, type Refusal, type RefusalCard, type RefusalCode, type RefusalContent, type RefusalDeclaration, type RefusalDestination, type RefusalEnvelope, type RefusalEvidence, type RefusalFitField, type RefusalFitParts, type RefusalInput, type RefusalOf, type RefusalOwner, type RefusalPrivacy, type RefusalRemedy, type RefusalStage, type RegistryAuthFailure, type RemedyLocation, type RenderedRefusal, type RepoReader, type ReportDialect, type ReportFacts, type ReportOutcome, type ReportSection, type ReportSectionCombination, type ReportSectionName, type ReportSilence, type ReportUnavailable, type ReportUnavailableCause, type ReportedTestFiles, type RepositoryFileReader, type RepositoryModelCredential, type RepositorySizeScan, type RepositorySizeVerdict, type ReservedComposition, type ResolvedCommandPlan, type ResolvedEvidenceObject, type ResolvedProjectPackage, type RetiredEvidenceOutput, type RetiredEvidenceOutputId, type RetiredRefusalCode, type RetiredRefusalDestination, type RoadFacts, type RoadSettings, type RoutePurityRung, type RunAdmission, type RunAttempt, type RunCeilingFacts, type RunCostStop, type RunCostStopCombination, type RunEventCombination, type RunEventFacts, type RunFactContract, type RunFactName, type RunFactVisibility, type RunFindingTriageWire, type RunFindingWire, type RunInterruption, type RunLocalEvidence, type RunLogStage, type RunModelCost, type RunModelCostLane, type RunProgress, type RunProgressCounter, type RunProgressStage, type RunProgressStageState, type RunRecordAssemblySite, type RunRecordFieldContract, type RunRecordFieldName, type RunRecordWire, type RunScope, type RunScopeCombination, type RunStage, type RunStageProgress, type RunStageUnit, type RunnerAlias, type RunnerCapability, type RunnerEcosystem, type RunnerFailureSummary, type RunnerName, type RunnerSpecSelection, SCENARIO_AUTHORITIES, SCENARIO_LANES, SCENARIO_OUTCOMES, SCENARIO_SEARCH_STATES, SCENARIO_SOURCE_INDEPENDENCE, SCENARIO_SOURCE_KINDS, SCORE_EVIDENCE_MAPPING, SCRIPT_NAMED_RUNNERS, SEALED_BROWSER_UID, SEALED_BUN_LINK, SEALED_BUN_PREFIX, SEALED_BUN_VERSION, SEALED_CHROME_BIN, SEALED_CHROMIUM_PACKAGES, SEALED_COREPACK_HOME, SEALED_DENO_BINARY_RELATIVE, SEALED_DENO_DIR, SEALED_DENO_LINK, SEALED_DENO_PREFIX, SEALED_DENO_VERSION, SEALED_EXECUTION_AMBIENT_FACTOR, SEALED_EXECUTION_CEILING_UNMEASURED_MS, SEALED_PLAYWRIGHT_BROWSERS_PATH, SEALED_PNPM_VERSION, SEALED_PREPARATION_ALLOWANCE_MS, SEALED_RUNTIME_ROOT, SEALED_TEST_COMMAND_SOURCES, SEALED_TEST_PROCESS_CONFINEMENT, SEALED_TOOLCHAIN_APT_PACKAGES, SEALED_TOOLCHAIN_BINARIES, SEALED_YARN_VERSION, SECRET_MASKING_FLOOR, SERVICE_REFUSED_FLAGS, SETUP_BRANCH, SETUP_BRANCH_COMMIT_MESSAGE, SETUP_CANDIDATE_CAP, SETUP_CHECK_NAME, SETUP_COMMIT_EMAIL, SETUP_DOCS_URL, SETUP_FAIL_FAST_ANSWERS, SETUP_FAIL_FAST_CONSEQUENCES, SETUP_NODE_ACTION, SETUP_PR_TITLE_TEXT, SETUP_REHEARSAL_ENV, SETUP_REPORT_MARKER, SETUP_REPORT_OVERSIZE_CODE, SETUP_REPORT_OVERSIZE_NEXT_ACTION, SETUP_REPORT_REFUSAL_CODES, SETUP_ROADS, SETUP_ROAD_CONSEQUENCES, SETUP_ROAD_LABELS, SETUP_ROAD_QUESTION, SETUP_SCRIPT_FOOTER, SETUP_SCRIPT_MODE, SETUP_SCRIPT_PATH, SETUP_STAGE_LABELS, SETUP_STAGE_ORDER, SETUP_STEP_ACTION, SETUP_STEP_IF, SETUP_STEP_JOB_STATUS, SETUP_STEP_NAME, SETUP_STEP_STATES, SETUP_TRIAL_ARTIFACT_NAME, SETUP_TRIAL_MAX_BYTES, SETUP_TRIAL_RERUN, SETUP_TRIAL_SCHEMA, SETUP_VOCABULARY, SET_AT_THE_PROMPT, SET_BY_YOU, SIGNED_SCORE_RULE, SIZE_BANDS, SOURCE_CHECK_STEPS, SOURCE_RE, SPEND_UNMETERED_REASONS, STANDING_LIMITATION_IDS, SUBDIR_CONFIG_KEY, SUBDIR_OPTION, SYSTEM_PACKAGE_ARCHIVE_HINT, SYSTEM_PACKAGE_NAME, SYSTEM_PACKAGE_VERSION, type ScenarioAuthority, type ScenarioExpectedObservation, type ScenarioInputDomain, type ScenarioIntent, type ScenarioIntentDraft, type ScenarioLane, type ScenarioOperationStep, type ScenarioOutcome, type ScenarioSearchBlock, type ScenarioSearchCounts, type ScenarioSearchMeasuredBlock, type ScenarioSearchProvenance, type ScenarioSearchRestrictions, type ScenarioSearchState, type ScenarioSourceIndependence, type ScenarioSourceKind, type ScenarioSourceRef, type ScenarioSummary, type ScopeFilters, type ScopeOptions, type ScopeParse, type ScopeProposal, type ScopeResolution, type ScopeResolutionInput, type ScopeResult, type ScoreComponent, type ScoreEvidence, type ScoreEvidenceCombination, type ScoreInput, type Scores, type ScriptNamedRunner, type ScriptRun, type ScriptRunEnvironment, type ScriptRunKind, type ScriptRunLauncher, type ScriptRunsInput, type ScriptSeparator, type SealedCeiling, type SealedExtra, type SealedRunnerCapabilities, type SealedRuntime, type SealedSetupFlags, type SealedTestCommand, type SealedTestCommandSource, type ServicePortAssignment, type ServicePortRequest, type SetupAnswer, type SetupAnswerCombination, type SetupAnswerObservation, type SetupCandidateExclusion, type SetupCandidateFilter, type SetupCandidateGate, type SetupCandidateJob, type SetupCandidateTrigger, type SetupFailFast, type SetupHealing, type SetupHealingNote, type SetupJobAttempt, type SetupJobDeclarationUnusableFacts, type SetupNoUsableJobFacts, type SetupPin, type SetupPinReading, type SetupPublishHost, type SetupRefusalDisplay, type SetupRegistryUnreachableFacts, type SetupReportInput, type SetupReportOversizeFacts, type SetupRideTier, type SetupRoad, type SetupScriptDraftProblem, SetupScriptError, type SetupScriptStep, type SetupStepState, type SetupStepStatus, type SetupTrialArtifact, type SetupTrialChange, type SetupTrialInvalidity, type SetupTrialParse, type SetupTrialRoad, type SetupTrialRun, type SetupTrialRunOrder, type SetupWorkflowCaller, type ShardDeclaration, type SizeBand, type SizeBandReason, type SizeGateMessage, type SizeGateThresholds, type SourceCheckStep, type SpendUnmeteredReason, type StageBInputs, type StageBReadiness, type StandingLimitation, type StandingLimitationFacts, type StandingLimitationId, type StandsForFacts, type StepConditionVerdict, type StreamTerminalFact, StreamUsageObserver, type StructuralCoverage, type StructuralSite, type Subject, type SuiteObservation, type SuiteOutcome, type SystemPackage, type SystemPackageOperand, TARGET_ARTIFACT_KEYS, TARGET_INVENTORY_SCHEMA, TARGET_INVENTORY_SOURCES, TARGET_RECEIPT_FILE_SCHEMA, TARGET_RECEIPT_SCHEMA, TARGET_SELECTION_KINDS, TARGET_STATE_LABELS, TARGET_STATE_MARKS, TASK_REPLY_PROBLEMS, TEST_COMMAND_SOURCE, TEST_FILE_PATH, TEST_MODULE_MOCKS_FLAG, TEST_PATH_RE, TRIAGE_CALL_FAILURES, TRIAGE_REASON_CODES, TRIAGE_REQUEST_CATEGORIES, TRIAGE_STATES, TRIAGE_VERDICTS, type TargetAdmission, type TargetAdmissionState, type TargetInventoryRow, type TargetInventorySource, type TargetReceipt, type TargetReceiptFile, type TargetSelectionKind, type TaskReplyProblem, type TaskReplyReading, type TestFileCounts, type TestFileTextReader, type TestLocation, type TestRunFacts, type TestRunStage, type TestStrengthBlock, type TextUnit, type TriageCallFailure, type TriageReasonCode, type TriageRecord, type TriageRequestCategory, type TriageState, type TriageVerdict, UNCOVERED_LOCATION_MUTATOR, UNDRIVABLE_RUNNERS, UNOBSERVED_REASONS, UNRECOGNISED_ENGINE_FAILURE, UNREPORTED_ENGINE_FAILURE, UNRESOLVED, USAGE_UNKNOWN, type UnguardedSites, type UnknownFieldPosture, type Unobserved, type UnobservedBaselineCause, type UnobservedBaselineFacts, type UnobservedOutcome, type UnobservedReason, type Unresolved, type UnsatisfiableCheck, type UploadAnswerCombination, type UploadAnswerFacts, type UploadArtifactFacts, type UploadTransportFacts, type UploadedRefusal, type UploadedRefusalEvidence, type UploadedRefusalRemedy, VALUE_ORIGINS, type ValueOrigin, type ValueOriginMap, type VcsSuiteFinding, type VcsSuiteUse, type VerdictExecutionEnvironment, WIRE_CUT_NOTE, WIRE_HOLD_REASON_MAX, WIRE_PROPOSALS_ENDING_MAX, WIRE_REASON_MAX, WORKFLOW_FILE_PATH, WORKFLOW_JOB_ID, WORKFLOW_RUNTIME_PREFIX, WORKSPACE_ORIGINS, type WireAbsence, type WireArray, type WireBoolean, type WireEnum, type WireField, type WireFields, type WireInteger, type WireLiteral, type WireNode, type WireNullable, type WireNumber, type WireObject, type WirePath, type WireResult, type WireString, type WireUnion, type WithheldEvidence, type WorkflowNodePin, type WorkflowRuntime, type WorkspaceOrigin, type WorstOfOutcome, type WorstOfRow, type XmlElement, YARN_DEPENDENCY_ENTRIES, type YamlQuote, ablohAuthored, ablohComposedAlone, ablohFailureClosingLine, acceptBugBehaviour, acceptBugDescription, acceptBugEmoji, acceptBugSentence, acceptBugSeverity, acceptBugType, acceptCarriedBugOutcome, acceptFindingEmoji, accountModelMinter, actionFilesReferenced, actionPinOf, actionRuntimeFiles, actionSubPathOf, addSealedReporter, additionsBetween, admissionCoverage, admissionDecisionProblem, admissionDigest, admissionDrift, admissionKeyIsAblohs, admissionKeyIsHostedRoadOnly, admissionSubject, admitFirstPassRun, admitTarget, admitsMainlineBranch, alwaysEmittedEvidenceKeys, ambientEnvironmentWithoutEngineCredentials, angularKarmaShape, angularProjectFromScript, angularRunnerName, angularScriptIsFanout, angularSealedTestCommand, apiKeyScopeProblem, appReceiptCommitMessage, appSetupFileCommitMessage, appSetupHealCommitMessage, appSetupPullRequestTitle, appendRunnerArguments, applyLayer1Gate, arrangesACheck, asciiDiagnostic, assertNever, assignServicePorts, attributionComplete, attributionMissing, avaInvocation, baselineGateObservation, baselineJobClockBoundMs, baselineJobClockRemedy, baselineJobClockRemedyLocation, baselineJobClockStopSentence, baselineJobClockTimeoutKey, baselineObservedNoTests, baselineOutcome, baselineRunBound, baselineRunBoundDisclosure, baselineRunTimeoutProse, binaryName, boundHoldReason, boundMinutes, boundProgressCount, boundProgressText, boundReceiptDetail, browserLaneSealSummary, bugIdentity, buildCiPropertySearchBlock, buildCiPropertyTargetUniverse, buildCustomerProcessEnvironment, buildOutputDirectory, buildScenarioSearchBlock, buildScopeProposal, buildSecretsFor, bunInvocation, callCeilingDollars, canBeOwnedByAbloh, canStartStageB, candidateBody, candidateName, candidatePath, candidateTextControl, candidateUploadProblem, canonicalJson, capability, carriedVerdict, carriedVerdictNote, catchRate, catchRateIsRaw, catchRateScopeNote, categoryOfStatus, caughtWithinMeasured, ceilingDollarsPerHuntedFile, ceilingNotice, changedStructuralCoverage, chatRequestContract, checkAdmissionRefusal, checkAdmissionRequest, checkAdmissionResponse, checkAdmissionWarning, checkModelRequestFits, checkoutNotComparableReason, chosenTestFiles, chromeSeccompDigest, chromeSeccompProfile, ciPropertyBehaviourKey, ciPropertyLedgerDigest, ciPropertyMutatorFamilies, classicHeadroom, classicMutationExecution, classicMutationTier, classifyDiffCoverage, classifyPullRequestCheckout, classifyReportUnavailable, classifyRepositorySize, clearExecutionPlan, cliOptionConfigConflictSentence, cliOptionConflictSentence, cliOptionPathUnusableRemedy, cliOptionPathUnusableSentence, cliOptionRequiredRemedy, cliOptionRequiredSentence, cliOptionRequiresRemedy, cliOptionRequiresSentence, cliOptionUnavailableSentence, cliOptionValueInvalidRemedy, cliOptionValueInvalidSentence, cliUnknownCommandRemedy, cliUnknownCommandSentence, cliUnknownOptionRemedy, cliUnknownOptionSentence, cliUnknownSubcommandRemedy, cliUnknownSubcommandSentence, codeownersFor, codesInFamily, combineLayerGates, commandGlobMatches, commandOutputTail, commandRuntime, commandStageName, commandStages, commandTokens, commandsProvidedBySetup, compareInstrumentation, compiledOutputEvidence, composableReservedEntries, composeExecutionRecord, composeReservedValue, composedValueJudges, computeScope, computeScores, conditionalPower, configFlakyLines, configHeaderLines, configKeyChildren, configKeyDefault, configKeyEntry, configKeyEntryFields, configKeyValueRule, configSettingLines, configSetupJobLines, confinementArgv, consumedGeneratedImport, containsEngineCredential, contentsIndexRefs, conventionalHeaderProblem, countCoverageLines, countsAreWholeVerdicts, countsFrom, countsFromLines, coverageComposition, coverageCounted, coverageDisplayState, coverageGroupState, coverageLocationFinding, coverageLocationFindingFor, coveragePathNotAddressableSentence, coverageProviderCacheUnusableSentence, coverageProviderProblem, coverageProviderUnavailableSentence, coverageProviderUnsupportedRunnerSentence, coverageReportBytes, coverageReportInvalidSentence, coverageReportTooLargeSentence, coverageScopeIncompleteSentence, coveredLinesToScope, credentialShapeRefusal, currentExecutionPlan, customerChildEnvironment, customerEnvironmentFromConfig, customerEnvironmentNames, cutAtCodePoints, cutTailAtCodePoints, debugPreparationOverflowStack, debugPreparationStack, decideObservation, decideQuarantineAdmission, decideSetupHealing, declarableTopLevelKeys, declaredConfigKeys, declaredDependencies, declaredOrigin, declaredRunnerProblem, declaredShard, declaredValueOrigins, declaredValues, declaresJestWatchMode, declaresWatchMode, decodeTaskObject, decodeTaskReply, decodeXmlEntities, defaultDockerCommandRunner, denominatorOf, dependencyPath, dependencyRoot, deprecatedModelVariableWarning, deprecatedModelVariablesInUse, deriveScenarioSearchCounts, deriveWorstOfGate, describeCommandGlobExpansions, describeDays, describeDollars, describeFiles, describeFinding, describeJobClockStage, describeJobDuration, describeMutationEvidence, describeReasonCode, describeRunStage, describeRuns, destinationLabel, destinationRepairs, detectModuleLayout, detectNativeSymptoms, detectReactNativeProject, detectVcsSuiteUse, detectedHostCores, detectedHostMemoryMb, diffCoverageExecution, directRunnerCommand, displayTruncationNote, distinctChecks, dotEnvDefinesModelVariables, dotEnvModelHint, egressRefusalFor, emojiAlreadyUsedClause, emptyCounts, emptyScope, endProcessGroup, endsSentence, engineFailureEgress, engineFailureLog, engineFailureReportId, engineFailureShape, engineFailureShapeSentence, engineFailureSignature, engineFailureTimeoutMinutes, engineOrDependencyStoragePath, ensureBaseReachable, entryAnswers, envelopeEvidenceKeys, environmentDifference, environmentValueProblem, errorCountOf, evaluateAssay, evaluateDiffCoverageGate, evaluateFloor, evaluateGate, evaluateStepCondition, evaluateStepConditions, evidenceBasename, evidenceDeleteAfter, evidenceIndexMissingLines, evidenceIndexMissingSentence, evidenceIndexRefusalCode, evidenceLabelLine, evidenceLine, evidenceOutput, evidenceOutputByBasename, evidenceRetentionDaysOr, evidenceRetentionExpired, evidenceUploadPlan, evidenceWithheldLine, excludedAndDisclosed, executionPlan, executionRecorder, expandCommandGlobs, expandDeclaredTestCommand, expandScopeLines, expectedDollarsPerHuntedFile, extractImportSpecifiers, factPathCovers, factStandIn, failFastCancelsLegs, failFastEditable, failFastNotice, failFastReceipt, failedSetupStage, failingTestSentence, fileImportTargets, fileSelectionArgs, fileSelectionTemplate, fileUrlCarriesPath, filterSetupCandidates, findRunnerFailureSummary, findXmlElements, findingDisplayTitle, findingEffort, findingEmoji, findingEmojiAsk, findingKind, findingReasonCode, findingSeverity, findingStatus, findingTitleParts, findingTriageVerdict, fitRefusal, foldToPrintableAscii, foldToPrintableText, foldedNeighborsClause, formattedJson, fullyConstructible, gapKeys, generatedFilePathProblem, generatedFilesValue, generatedPaths, generationState, gitHeaderPath, githubEquals, githubTruthy, globToRegExp, gradedFindingSeverity, groupFindingsByLine, hasAbandonedImportClause, hasRegisteredSecrets, healthCommandProblem, healthPortProblem, holdReasonText, hostedRunHeaderValue, hostedRunHeaders, identityConditionLine, identityConditionOfEnvironment, identityConditionSentence, identityFilesValue, imageVocabulary, importSelectorTarget, importTargetMatches, inactiveInputKeys, inactiveInputReason, inactiveInputs, inactiveInputsNamed, indexQueryFor, initExecutionPlan, insertSealedSetupFlags, installCommandNeedsCorepackEnable, installExecutionPlan, installedInputs, instrumentationComparisonLines, invokesDefaultTestScript, isAblohFailureClosing, isAblohSetupAuthor, isAngularRunner, isAnnotatableSurvivor, isAuditableSourcePath, isBoundedCodeFreeSentence, isCanonicalBase64, isCiPropertyCandidateCap, isClusterStrategy, isCodeFreeProse, isConfirmedEquivalent, isDiffCoverageCannotAttestReason, isEngineFailureReportId, isEngineFailureShapeName, isEnvironmentName, isEvidenceRetentionDays, isExactPackageManagerVersion, isExpandableGlobArgument, isFreeCoverageRow, isModelServiceOutageAnswer, isModelTerminalEvent, isNonExecutableLine, isNothingWaiting, isObserved, isPlaygroundSentence, isReservedCustomerVariable, isScenarioAuthority, isScenarioLane, isScenarioOutcome, isScenarioSearchState, isSetupBranchName, isSetupReportComment, isTestPath, isValueOrigin, isWellFormedText, itemsPerModelRequest, jobClockRaiseInstruction, jobClockStageLogPrefix, jobClockStageRemedy, jobClockStageStopSentence, jobClockStageTimeoutKey, jobOnMatrixLeg, jobTimeBudgetSentence, jsRunners, judgeCandidateTextControl, judgeConfigKeyValue, keylessLocalRunBlock, kibibytes, knownRunner, layer0EnabledRunners, layer2IntentProposalFieldsSentence, liveProgressUpdate, loadConfig, loadConfigWithNotes, localBinaryPrefix, localContractCommitMessage, localDetailClause, localEvidenceText, localLadderLines, locationOfPattern, lockPathFor, looksLikeRunnerFailureSummary, makeFilePrivate, manifestBasename, manifestScripts, mapCostGate, mapCostReason, mapCostRoadFacts, mapCostSentence, mapCostsMoreThanTheVerdicts, markNonExecutable, matchesCredentialShape, matrixLegAsOffered, matrixLegProblem, matrixLegRunner, matrixValueAsOffered, matrixValueCondition, matrixValueText, matrixValueYaml, measurableCount, measurableTestRuns, measuredCiOverride, measurementPlanDigest, measuringRoad, mebibytes, mechanicalCounts, mechanicalErrorPathDisposition, memoryRepoReader, mergeBaseNotEstablished, message, messageFromFacts, messageShape, microsToUsd, missingActionFiles, missingModelVariableReason, missingScopedFiles, modelBufferedReceipt, modelDispatchClaimProblem, modelOidcMinter, modelRequestContract, modelRequestKeys, modelServiceAnswers, modelServiceBaseUrl, modelServiceErrorContract, modelServiceOutageEvidence, modelStepBoundaryMessage, modelTerminalEvent, modelTerminalEventContract, mutantIdentity, mutationRefusalSentence, mutationRefusalWall, mutationWasAttempted, nameDrivenRunners, narrationTo, nativeFloorCommand, nearbyCarryClause, nearbyCodeSentence, nearbyConsequenceClause, nearbyDirectionArrow, nearbyDirectionChip, nearbyFindingName, nearbyFindingSentence, nearbyLine, nearbyMeasurementClause, nearbyRelationClause, nearbyRemainderSentence, nearbyReportFrom, nearbyRow, nearbyVerdictWord, newlyFailingTests, nextActionLine, nextActionParts, nextActionSentence, nodeMajorFromImageRef, nodeOptionInsertionPoint, nodeReporterCounts, nodeTestInvocation, nodeVersionFromImageRef, nonEvidenceBasename, nonEvidenceOutput, normalizeDeclaredPath, normalizeImportTarget, normalizeOwner, normalizeRepoPath, normalizeRunFinding, notUploadedRunRecordFields, noteModelServiceAnswer, nothingToMeasurePathFilter, observedNegative, observedPositive, openExecutionCopies, optional, originOf, outputShowsDeniedFork, overlayRepoReader, ownedByOrigin, packageScriptSeparator, parseAptSources, parseAsterCoverageEvidence, parseClosedReason, parseCodeowners, parseContentsEntry, parseConventionalHeader, parseDeepAuditArtifact, parseDpkgArchitecture, parseEvidenceManifest, parseHostedRunHeader, parseInitTelemetryEvent, parseJsonc, parseLiteralArguments, parsePreparedTestCommand, parseRunLocalEvidence, parseRunModelCost, parseScope, parseSetupScript, parseSetupTrialArtifact, parseTargetInventory, parseTargetReceiptFile, parseUnifiedDiff, parseUploadedInterruption, parseUploadedRefusal, parseValueOriginMap, parseXml, partialAdmissionSentence, pathWithin, patternMatches, patternRefusal, percentOfMeasured, pidCeilingExhaustion, pidCeilingNotice, plainSafe, planCommand, planCompletionBatches, planLimitRemedy, planLimitSentence, planRefusalFactsOf, planRefusalRemedy, planRefusalSentence, plantedCounts, playgroundExcerptBytes, playgroundOutcome, playgroundRosterExcerptsFit, pnpRuntimeFile, pool2Population, preflightCheck, preflightEvent, preparedCommandProblem, previewRefusal, privateDirectory, producerChoice, project, projectFirstPass, projectMapCost, projectRunFinding, projectRunFindingTriage, projectedRunRecordFields, projectionHours, proposalCandidatePaths, proposalIsOffered, proposalMessage, proposalsCandidate, proposalsDiscoveryState, proposalsFeatureState, proposalsGapOrigin, proposalsPredictorMode, proposalsSuiteState, proposalsSummary, proposalsUnavailableSentence, proposalsVerdict, provenShapeProblem, publishableEvidenceDirectories, publishableEvidenceFiles, qualifyCorpus, qualifyHistoricalPair, quarantineCap, quarantineCapExceeded, quarantineDisclosureSentence, quarantineExcludableRunners, quarantineExcludedTotal, quarantineExclusionMode, quarantineFloorBreached, quarantineFloorRefusal, quarantineGrowthSentence, quarantineNameList, quarantineNamesSentence, quoteLiteralArgument, rankCiPropertyRules, rankIndexCandidates, rankSetupCandidates, rateCardFromEnvironment, readBufferedModelReply, readEventUsage, readFailFastDeclaration, readModelBufferedReceipt, readModelServiceError, readModelServiceOutage, readModelTerminalEvent, readModelVariable, readOutputItemsText, readPackageManagerDeclaration, readPackageManagerPin, readPackageManifest, readPackageManifestFile, readRefusalText, readRegistryAuthFailure, readReportedModel, readReportedTestFiles, readRunAttempt, readSetupPin, readSetupPinFromDocument, readTerminalFact, readTextDelta, readUsageFrame, readsCompiledOutput, readsProposalsBlockSchema, readsReportedTestFiles, rebuildBeforeMeasuringFailedSentence, receiptPathFor, recognizedProvidersFor, recordsForStage, redBaselineCallerGreenDetail, redBaselineCallerJobWasGreen, redBaselineCommandNeverStarted, redBaselineDetail, redBaselineRefusal, redBaselineReportFailureNote, redBaselineRunnerExitedNonZero, redBaselineShape, redactCredentialShapes, redactCredentialShapesDeep, redactTriageForEgress, refusalCodeIsReadable, refusalCodeOf, refusalDetail, refusalEnvelope, refusalFromFacts, refusalFromStoredCode, refusalIsWall, refusalLineWhoeverOwnsIt, refusalLines, refusalMessage, refusalMessageOf, refusalOfUploaded, refusalOwnersOf, refusalRemedyText, refusalSentence, refusalSentenceWithRemedy, refusalSummary, refuse, refusedAsAblohOwned, registerSecretValue, registeredBasenames, registeredSecretNames, registryAuthRefusal, registryEntryProblems, releaseDigestFor, remedyEditLines, remedyLocation, remedyValueShape, renderAsterCoverageEvidence, renderCoverageEvidence, renderEvidenceManifest, renderModelVariableRow, renderRefusal, renderRunLocalEvidence, renderSetupFailure, renderSetupReportComment, renderSetupScript, renderSetupStepLine, renderTargetReceiptFile, reportMessageFromFacts, reportUnavailableFacts, repositoryModelCredentialOfEnvironment, requireEvidenceCustody, requirePackageManifest, required, reservedComposeProblem, reservedComposition, resetModelServiceAnswers, resetRegisteredSecrets, resolveCommandPlan, resolveFacts, resolveImportTarget, resolveModelAccess, resolvePreparedTestCommand, resolveProjectPackage, resolveRefusalCode, resolveRefusalDestination, resolveRefusalOwner, resolveScope, resolveSealedTestCommand, resourceCeilingExhaustion, respelledClasses, responsesRequestContract, retiredConfigKeyNote, retiredConfigKeyWarning, retiredConfigKeys, retiredEvidenceBasename, retiredEvidenceBasenames, retiredEvidenceOutputs, reviewedFindingCount, rewrittenFilePathProblem, rewrittenFilesValue, ridableMatrixCombinations, roadOpensPullRequest, roadRunsLocalTrial, rosterTruncation, routePurityRung, rowAdmitted, runAttempt, runCeilingSentence, runExecutionPlan, runFactDestinations, runFactSurfaceProblems, runFinding, runFindingProblem, runFindingTriage, runIsDroppable, runRecordReaderProblems, runnerAliases, runnerChoiceConsequence, runnerConfigFromInvocation, runnerImageVocabulary, runnerNamePattern, runnerNamesInScript, runnerSpecSelection, runsLifecycleScripts, runsPackageScript, runsRequiredBefore, sameMatrixValue, sameModelDispatchRun, sanitizeCiPropertySummary, sanitizeFindingAbout, sanitizeFindingDescription, sanitizeScenarioSummary, scanRepositoryTree, scopeCallsModel, scopeHeadline, scopeImportSelectors, scopeIsEmpty, scopeReadsEvidence, scopeSummary, scriptRuns, scrubSecrets, scrubSecretsDeep, sealedBunInstallProgram, sealedBunPackage, sealedCommandForInvocation, sealedDenoInstallProgram, sealedExecutionCeilingMs, sealedExtrasNeeded, sealedFileDescriptorLimit, sealedMemoryLimitMb, sealedPidsLimit, sealedReportingArgs, sealedRunnerCommand, sealedRuntimeInstallProgram, sealedRuntimeNeeded, sealedRuntimeVersion, sealedSetupFlags, sealedTestProcessArgv, sealedToolchainCommand, selectAngularTestTarget, selectCiPropertyTargets, selectScriptNames, separatorForCommand, serviceNameProblem, setupCandidateExclusion, setupCandidateNarrowing, setupCandidatesExhausted, setupFailFastProblem, setupFailureRefusal, setupFailureSentence, setupHealingAsksForAnEdit, setupJobProblem, setupJobReference, setupMatrixLegProblem, setupPinProblem, setupProvisionalRideUnproven, setupPublishHost, setupRefusalDisplay, setupReportOversizeLine, setupReportOversizeSentence, setupRideIsProvisional, setupRunnerExclusion, setupScriptDraftProblem, setupScriptPathProblem, setupStageLabel, setupStepIf, setupStepLabel, setupStepLines, setupStepMarker, setupStepNumber, setupStepStatuses, setupTrialChange, setupTrialPassed, setupTrialRunOrder, setupWordingProblem, sha256, sha256Bytes, shardDeclarationBlock, shardDisclosure, shippedGeneratedPaths, shortenForDisplay, shortenTailForDisplay, shown, silence, sizeGateMessage, slotPrivacy, sortedSystemPackages, specPositionalsOf, stableOutcome, stageProjectionMs, stageProjectionsMs, stagedEvidenceIsLedger, standingLimitationClause, standingLimitations, statedByTheClock, statesTestingGap, storedEvidenceBasename, storedEvidenceLabel, streamOutcomeIsSuccess, stripComments, stripJsonComments, stripTestIdentityDiscriminator, structuralDigest, structuralFindingsFor, subjectDigest, summaryThenAction, supportsTestModuleMocks, survivingMutantFinding, survivingMutantObligationSignals, systemPackageInstallCommand, systemPackageOperandProblem, systemPackagePinHint, systemPackageProblem, tallyCounts, targetReceiptDigest, targetReceiptFile, testLocations, testRunObservation, testRunStages, testRuns, testsImportBuiltOutputSentence, textDeclaredLocations, textFits, textLength, toApiKeyScope, toEgressRefusal, toGapFindings, toPosixSeparators, toUploadedInterruption, toUploadedRefusal, toWorkdirRelPosix, tokenIsSearchable, tolerated, triageState, truncateForDisplay, truncatedRosterNote, uncoveredCount, uncoveredLinesToScope, uncoveredLocationFindings, undeclaredRunFactPaths, understandsModelServiceVersion, undrivableRunner, unguardedSentence, unguardedSitesFrom, unmaskableSecretRefusal, unobserved, unobservedBaselineCause, unobservedBaselineCode, unobservedBaselineRefusal, unobservedBaselineRunnerNote, upstreamErrorInBody, usageDollars, usageKnown, usageOrNull, usdToMicros, validateCiResidualGapLedger, validateConfig, validateConfigWithNotes, validateDiffCoverageLines, validateManifest, validatePlaygroundExplanation, validatePlaygroundModelResponse, validatePlaygroundPublicMaterial, validatePlaygroundPublicResult, validatePlaygroundSummary, validatePreparedTestCommand, validateTargetReceipt, verdictExecutionEnvironment, verdictGatesSomebodyElse, watchModeDisableFlags, watchModeRefusal, wilsonInterval, wireArray, wireBoolean, wireDigest, wireEnum, wireInteger, wireLiteral, wireNullable, wireNumber, wireObject, wirePrintable, wirePrintableText, wireRecord, wireString, wireUnion, withFileLock, withJestWatchModeDisabled, withWatchModeDisabled, withheld, withheldEvidenceLine, withheldSentence, withinPackage, withoutJestWatchDisableFlags, withoutKeys, withoutRetiredKeys, withoutSpecPositionals, withoutUbuntuTimeSuffix, withoutWatchDisableFlags, workflowRuntimeBin, workflowRuntimeCheckStep, workflowRuntimePrefix, workflowRuntimeSteps, workflowYaml, writePrivateFile, xmlChild, yamlLegValue, yamlScalar };