@enricai/barnacle 1.0.0

package/dist/lib/llm/judges/modal-priority.js

@@ -0,0 +1,74 @@
+"use strict";
+/**
+ * Modal-priority judge. Replaces the keyword regex
+ * `MODAL_PRIORITY_RX = /(modal|dialog|popup|overlay|drawer)/i` that
+ * matched Stagehand's English description strings.
+ *
+ * Why: the regex missed sheet, flyout, panel, sidebar, lightbox,
+ * cdk-overlay, radix-portal, app-prefixed variants, and any non-English
+ * description. When the regex missed, the rephrase prompt's UNFOCUSED
+ * OBSERVE section didn't bubble the blocking modal to the top — the
+ * LLM saw the form fields first and didn't realize a modal was in the
+ * way.
+ *
+ * The judge looks at the full unfocused-observe list and decides which
+ * entries are STRUCTURALLY blocking the form (modal with backdrop,
+ * dialog, overlay, popup) vs which are always-visible UI (sidebars,
+ * sticky headers, panels). Returns indices to bubble to the top.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODAL_PRIORITY_SYSTEM_PROMPT = void 0;
+exports.judgeModalPriorityWithLLM = judgeModalPriorityWithLLM;
+const judge_1 = require("../../../lib/llm/judge");
+const schemas_1 = require("../../../lib/llm/schemas");
+const call_types_1 = require("../../../lib/telemetry/call-types");
+const MODAL_PRIORITY_SYSTEM_PROMPT = `You are a strict modal-priority judge for browser-automation. Given a list of UI elements observed on the page (with English descriptions), identify which ones are STRUCTURALLY blocking modal/dialog/overlay components that need to be dismissed before the underlying form can be interacted with.
+
+Strict criteria for marking an index as priority:
+- Cookie consent banners (block the page until accepted/dismissed) — PRIORITY.
+- Welcome / sign-in modals with a dismiss action — PRIORITY.
+- Floating sheet/flyout/dialog/popup/overlay UIs covering form content — PRIORITY.
+- Lightbox image viewers — PRIORITY when they cover the form.
+- Drawer components when they're modal (block underlying interaction) — PRIORITY.
+
+Do NOT mark as priority:
+- Sidebars and navigation panels that are always visible by design.
+- Sticky headers / footers that don't block form interaction.
+- Tooltips / popovers that auto-dismiss on click outside.
+- Slide-out panels in responsive layouts when they're statically open.
+
+The descriptions are English prose generated by Stagehand. Class names mentioned in the description (e.g. cdk-overlay, app-modal) are stronger evidence than keywords. Site-specific app-prefixed dialog/modal classes count as priority.
+
+Return the indices (0-based) of priority items in the order they appear in the input. Max 50 items. Include a one-sentence rationale citing the strongest signal.`;
+exports.MODAL_PRIORITY_SYSTEM_PROMPT = MODAL_PRIORITY_SYSTEM_PROMPT;
+function buildModalPriorityPrompt(input) {
+    const list = input.observations
+        .map((o, i) => `  ${i}. ${o.description} — ${o.selector}`)
+        .join("\n");
+    return `Which observed elements are structurally blocking modal/dialog/overlay components?
+
+OBSERVATIONS (index. description — selector):
+${list}`;
+}
+/**
+ * Run the modal-priority judge. Returns priority indices + a rationale.
+ * Returns null when the client is null (Bedrock-only) or the API call
+ * fails — callers fall back to leaving the original order untouched.
+ */
+async function judgeModalPriorityWithLLM(params) {
+    const { client, input, captureFn } = params;
+    if (client === null)
+        return null;
+    if (input.observations.length === 0)
+        return null;
+    const result = await (0, judge_1.callHaikuJudge)({
+        client,
+        systemPrompt: MODAL_PRIORITY_SYSTEM_PROMPT,
+        userPrompt: buildModalPriorityPrompt(input),
+        schema: schemas_1.MODAL_PRIORITY_SCHEMA,
+        callType: call_types_1.CALL_TYPE_JUDGE_MODAL_PRIORITY,
+        captureFn,
+    });
+    return result?.parsed ?? null;
+}
+//# sourceMappingURL=modal-priority.js.map

package/dist/lib/llm/judges/modal-priority.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"modal-priority.js","sourceRoot":"","sources":["../../../../src/lib/llm/judges/modal-priority.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;GAgBG;;;AAgDH,8DAiBC;AA5DD,2CAAsE;AACtE,+CAA0D;AAC1D,2DAA4E;AAE5E,MAAM,4BAA4B,GAAG;;;;;;;;;;;;;;;;;kKAiB6H,CAAC;AAyC1J,oEAA4B;AAlCrC,SAAS,wBAAwB,CAAC,KAA8B;IAC9D,MAAM,IAAI,GAAG,KAAK,CAAC,YAAY;SAC5B,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,WAAW,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC;SACzD,IAAI,CAAC,IAAI,CAAC,CAAC;IACd,OAAO;;;EAGP,IAAI,EAAE,CAAC;AACT,CAAC;AAED;;;;GAIG;AACI,KAAK,UAAU,yBAAyB,CAAC,MAI/C;IACC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;IAC5C,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACjC,IAAI,KAAK,CAAC,YAAY,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IACjD,MAAM,MAAM,GAAG,MAAM,IAAA,sBAAc,EAAC;QAClC,MAAM;QACN,YAAY,EAAE,4BAA4B;QAC1C,UAAU,EAAE,wBAAwB,CAAC,KAAK,CAAC;QAC3C,MAAM,EAAE,+BAAqB;QAC7B,QAAQ,EAAE,2CAA8B;QACxC,SAAS;KACV,CAAC,CAAC;IACH,OAAO,MAAM,EAAE,MAAM,IAAI,IAAI,CAAC;AAChC,CAAC"}

package/dist/lib/llm/judges/select-option.d.ts

@@ -0,0 +1,49 @@
+/**
+ * Select-option picker judge. When a recon flow step hardcodes a dropdown
+ * answer (e.g. "select 'Emergency Department'") but that exact option does
+ * not exist in a given requisition's option list — different jobs render
+ * different screening-question options — this judge chooses the most
+ * plausible AVAILABLE option so the required question is answered and the
+ * multi-page wizard can advance.
+ *
+ * Why an LLM (not fuzzy string match): the gap is semantic, not lexical. An
+ * "Emergency Department" hint on a Cardiac requisition has near-zero string
+ * overlap with the real options (CVICU, Progressive Care, …) yet a human
+ * would pick the closest clinically-plausible one. Deterministic overlap
+ * would pick nothing or the wrong option. This is the "LLM-chosen, correct
+ * real submission" policy the answers land in the ATS under.
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+import type { z } from "zod/v4";
+import { type JudgeCaptureFn } from "../../../lib/llm/judge";
+import { SELECT_OPTION_SCHEMA } from "../../../lib/llm/schemas";
+declare const SELECT_OPTION_SYSTEM_PROMPT = "You are a job applicant answering a required screening dropdown on an application form. You are given a QUESTION, a HINT at the intended answer (from a generic template that may not match this specific job), and SEVERAL candidate dropdowns on the page \u2014 each with its own list of options. Exactly one dropdown (or none) is the one that answers the question.\n\nDo two things:\n1. Pick the dropdown (selectIndex) whose options actually answer the QUESTION. E.g. a nursing-education question is answered by a dropdown whose options are education levels, NOT one whose options are disability choices or countries. If NO dropdown's options fit the question, return selectIndex=null.\n2. Within that dropdown, pick the option (optionIndex) that is the most plausible, truthful answer letting a qualified candidate proceed:\n   - Prefer the option semantically closest to the hint (e.g. hint \"Emergency Department\" on a cardiac role \u2192 the closest clinical specialty available).\n   - For EEO / self-identification / voluntary demographic questions (race, gender, disability, veteran status), prefer a decline option (\"I do not wish to answer\", \"Prefer not to answer\", \"Decline to self-identify\").\n   - For yes/no eligibility questions, choose the answer that keeps a qualified candidate eligible (usually the hint).\n   - NEVER choose a disabled placeholder (\"Please select\u2026\", \"-- Select --\", empty first entry).\n\nReturn selectIndex = the 0-based index into the candidate dropdowns (or null if none fit), optionIndex = the 0-based index into THAT dropdown's options (null if selectIndex is null). Always give a one-line reason.";
+export interface JudgeSelectOptionCandidate {
+    /** The dropdown's nearby/associated label text, when discoverable. */
+    label: string | null;
+    /** The dropdown's real option texts, in DOM order (index-aligned). */
+    options: readonly string[];
+}
+export interface JudgeSelectOptionInput {
+    /** The question being answered (from the flow step). */
+    questionLabel: string | null;
+    /** The flow's intended answer text (may not exist in any dropdown). */
+    desiredHint: string;
+    /** Candidate dropdowns on the page (unfilled ones), index-aligned. */
+    candidates: readonly JudgeSelectOptionCandidate[];
+}
+/**
+ * Run the select-option picker. Returns the parsed verdict — which candidate
+ * dropdown (selectIndex) answers the question and which option in it
+ * (optionIndex), or both null when no dropdown fits. Returns null when the
+ * client is null (Bedrock-only) or the API call fails — the caller then falls
+ * through to the cascade instead of applying a guess. Both indices are bounds-
+ * checked against the supplied candidates before returning.
+ */
+export declare function judgeSelectOptionWithLLM(params: {
+    client: Anthropic | null;
+    input: JudgeSelectOptionInput;
+    captureFn?: JudgeCaptureFn;
+}): Promise<z.infer<typeof SELECT_OPTION_SCHEMA> | null>;
+export { SELECT_OPTION_SYSTEM_PROMPT };
+//# sourceMappingURL=select-option.d.ts.map

package/dist/lib/llm/judges/select-option.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-option.d.ts","sourceRoot":"","sources":["../../../../src/lib/llm/judges/select-option.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAEH,OAAO,KAAK,SAAS,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,mBAAmB,CAAC;AAGzD,QAAA,MAAM,2BAA2B,wnDAUqL,CAAC;AAEvN,MAAM,WAAW,0BAA0B;IACzC,sEAAsE;IACtE,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;IACrB,sEAAsE;IACtE,OAAO,EAAE,SAAS,MAAM,EAAE,CAAC;CAC5B;AAED,MAAM,WAAW,sBAAsB;IACrC,wDAAwD;IACxD,aAAa,EAAE,MAAM,GAAG,IAAI,CAAC;IAC7B,uEAAuE;IACvE,WAAW,EAAE,MAAM,CAAC;IACpB,sEAAsE;IACtE,UAAU,EAAE,SAAS,0BAA0B,EAAE,CAAC;CACnD;AAiBD;;;;;;;GAOG;AACH,wBAAsB,wBAAwB,CAAC,MAAM,EAAE;IACrD,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,sBAAsB,CAAC;IAC9B,SAAS,CAAC,EAAE,cAAc,CAAC;CAC5B,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,GAAG,IAAI,CAAC,CA+BvD;AAED,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/lib/llm/judges/select-option.js

@@ -0,0 +1,90 @@
+"use strict";
+/**
+ * Select-option picker judge. When a recon flow step hardcodes a dropdown
+ * answer (e.g. "select 'Emergency Department'") but that exact option does
+ * not exist in a given requisition's option list — different jobs render
+ * different screening-question options — this judge chooses the most
+ * plausible AVAILABLE option so the required question is answered and the
+ * multi-page wizard can advance.
+ *
+ * Why an LLM (not fuzzy string match): the gap is semantic, not lexical. An
+ * "Emergency Department" hint on a Cardiac requisition has near-zero string
+ * overlap with the real options (CVICU, Progressive Care, …) yet a human
+ * would pick the closest clinically-plausible one. Deterministic overlap
+ * would pick nothing or the wrong option. This is the "LLM-chosen, correct
+ * real submission" policy the answers land in the ATS under.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SELECT_OPTION_SYSTEM_PROMPT = void 0;
+exports.judgeSelectOptionWithLLM = judgeSelectOptionWithLLM;
+const judge_1 = require("../../../lib/llm/judge");
+const schemas_1 = require("../../../lib/llm/schemas");
+const call_types_1 = require("../../../lib/telemetry/call-types");
+const SELECT_OPTION_SYSTEM_PROMPT = `You are a job applicant answering a required screening dropdown on an application form. You are given a QUESTION, a HINT at the intended answer (from a generic template that may not match this specific job), and SEVERAL candidate dropdowns on the page — each with its own list of options. Exactly one dropdown (or none) is the one that answers the question.
+
+Do two things:
+1. Pick the dropdown (selectIndex) whose options actually answer the QUESTION. E.g. a nursing-education question is answered by a dropdown whose options are education levels, NOT one whose options are disability choices or countries. If NO dropdown's options fit the question, return selectIndex=null.
+2. Within that dropdown, pick the option (optionIndex) that is the most plausible, truthful answer letting a qualified candidate proceed:
+   - Prefer the option semantically closest to the hint (e.g. hint "Emergency Department" on a cardiac role → the closest clinical specialty available).
+   - For EEO / self-identification / voluntary demographic questions (race, gender, disability, veteran status), prefer a decline option ("I do not wish to answer", "Prefer not to answer", "Decline to self-identify").
+   - For yes/no eligibility questions, choose the answer that keeps a qualified candidate eligible (usually the hint).
+   - NEVER choose a disabled placeholder ("Please select…", "-- Select --", empty first entry).
+
+Return selectIndex = the 0-based index into the candidate dropdowns (or null if none fit), optionIndex = the 0-based index into THAT dropdown's options (null if selectIndex is null). Always give a one-line reason.`;
+exports.SELECT_OPTION_SYSTEM_PROMPT = SELECT_OPTION_SYSTEM_PROMPT;
+function buildSelectOptionPrompt(input) {
+    const blocks = input.candidates
+        .map((c, si) => {
+        const opts = c.options.map((o, oi) => `    ${oi}. ${o}`).join("\n");
+        return `DROPDOWN ${si}${c.label ? ` (label: ${c.label})` : ""}:\n${opts}`;
+    })
+        .join("\n\n");
+    return `QUESTION: ${input.questionLabel ?? "(no label discoverable)"}
+
+INTENDED ANSWER (hint, may not match): ${input.desiredHint}
+
+CANDIDATE DROPDOWNS (pick the one that answers the question, then an option in it):
+${blocks}`;
+}
+/**
+ * Run the select-option picker. Returns the parsed verdict — which candidate
+ * dropdown (selectIndex) answers the question and which option in it
+ * (optionIndex), or both null when no dropdown fits. Returns null when the
+ * client is null (Bedrock-only) or the API call fails — the caller then falls
+ * through to the cascade instead of applying a guess. Both indices are bounds-
+ * checked against the supplied candidates before returning.
+ */
+async function judgeSelectOptionWithLLM(params) {
+    const { client, input, captureFn } = params;
+    if (client === null)
+        return null;
+    if (input.candidates.length === 0)
+        return null;
+    const result = await (0, judge_1.callHaikuJudge)({
+        client,
+        systemPrompt: SELECT_OPTION_SYSTEM_PROMPT,
+        userPrompt: buildSelectOptionPrompt(input),
+        schema: schemas_1.SELECT_OPTION_SCHEMA,
+        callType: call_types_1.CALL_TYPE_JUDGE_SELECT_OPTION,
+        captureFn,
+    });
+    const parsed = result?.parsed ?? null;
+    if (!parsed || parsed.selectIndex === null)
+        return parsed;
+    // Guard both indices against the supplied candidates — a hallucinated
+    // out-of-range index must not index past the arrays in the caller.
+    const nullVerdict = (reason) => ({
+        selectIndex: null,
+        optionIndex: null,
+        reason,
+    });
+    const chosenCandidate = input.candidates[parsed.selectIndex];
+    if (!chosenCandidate) {
+        return nullVerdict(`LLM selectIndex ${parsed.selectIndex} out of range`);
+    }
+    if (parsed.optionIndex === null || parsed.optionIndex >= chosenCandidate.options.length) {
+        return nullVerdict(`LLM optionIndex ${parsed.optionIndex} out of range for dropdown ${parsed.selectIndex}`);
+    }
+    return parsed;
+}
+//# sourceMappingURL=select-option.js.map

package/dist/lib/llm/judges/select-option.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"select-option.js","sourceRoot":"","sources":["../../../../src/lib/llm/judges/select-option.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;GAcG;;;AA4DH,4DAmCC;AA1FD,2CAAsE;AACtE,+CAAyD;AACzD,2DAA2E;AAE3E,MAAM,2BAA2B,GAAG;;;;;;;;;;sNAUkL,CAAC;AA8E9M,kEAA2B;AA5DpC,SAAS,uBAAuB,CAAC,KAA6B;IAC5D,MAAM,MAAM,GAAG,KAAK,CAAC,UAAU;SAC5B,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE;QACb,MAAM,IAAI,GAAG,CAAC,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,EAAE,EAAE,CAAC,OAAO,EAAE,KAAK,CAAC,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;QACpE,OAAO,YAAY,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,YAAY,CAAC,CAAC,KAAK,GAAG,CAAC,CAAC,CAAC,EAAE,MAAM,IAAI,EAAE,CAAC;IAC5E,CAAC,CAAC;SACD,IAAI,CAAC,MAAM,CAAC,CAAC;IAChB,OAAO,aAAa,KAAK,CAAC,aAAa,IAAI,yBAAyB;;yCAE7B,KAAK,CAAC,WAAW;;;EAGxD,MAAM,EAAE,CAAC;AACX,CAAC;AAED;;;;;;;GAOG;AACI,KAAK,UAAU,wBAAwB,CAAC,MAI9C;IACC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;IAC5C,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACjC,IAAI,KAAK,CAAC,UAAU,CAAC,MAAM,KAAK,CAAC;QAAE,OAAO,IAAI,CAAC;IAC/C,MAAM,MAAM,GAAG,MAAM,IAAA,sBAAc,EAAC;QAClC,MAAM;QACN,YAAY,EAAE,2BAA2B;QACzC,UAAU,EAAE,uBAAuB,CAAC,KAAK,CAAC;QAC1C,MAAM,EAAE,8BAAoB;QAC5B,QAAQ,EAAE,0CAA6B;QACvC,SAAS;KACV,CAAC,CAAC;IACH,MAAM,MAAM,GAAG,MAAM,EAAE,MAAM,IAAI,IAAI,CAAC;IACtC,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,WAAW,KAAK,IAAI;QAAE,OAAO,MAAM,CAAC;IAC1D,sEAAsE;IACtE,mEAAmE;IACnE,MAAM,WAAW,GAAG,CAAC,MAAc,EAAwC,EAAE,CAAC,CAAC;QAC7E,WAAW,EAAE,IAAI;QACjB,WAAW,EAAE,IAAI;QACjB,MAAM;KACP,CAAC,CAAC;IACH,MAAM,eAAe,GAAG,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC;IAC7D,IAAI,CAAC,eAAe,EAAE,CAAC;QACrB,OAAO,WAAW,CAAC,mBAAmB,MAAM,CAAC,WAAW,eAAe,CAAC,CAAC;IAC3E,CAAC;IACD,IAAI,MAAM,CAAC,WAAW,KAAK,IAAI,IAAI,MAAM,CAAC,WAAW,IAAI,eAAe,CAAC,OAAO,CAAC,MAAM,EAAE,CAAC;QACxF,OAAO,WAAW,CAChB,mBAAmB,MAAM,CAAC,WAAW,8BAA8B,MAAM,CAAC,WAAW,EAAE,CACxF,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC;AAChB,CAAC"}

package/dist/lib/llm/judges/verify-submit.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Submit-verification judge. Replaces the per-site `submitEndpointPattern`
+ * regex with a Haiku 4.5 structured-output call that judges success across
+ * multiple corroborating signals (network 2xx + DOM success component + URL
+ * transition + page title).
+ *
+ * Empirically validated 2026-06-11 on two production failure cases:
+ *  - Case A (was wrongly flagged as failure by the regex): verdict=true,
+ *    correctly identified dom_signal="uapp-universal-submitted-page" and
+ *    url_signal="/applyboard/applied".
+ *  - Case B (genuinely stuck, 10 ng-invalid markers, no success DOM):
+ *    verdict=false with a coherent reason about why submission failed.
+ *
+ * Strictness rule baked into the system prompt: verified=true requires at
+ * least one DOM/URL/title signal of post-submit state. A 2xx alone is NOT
+ * sufficient (could be telemetry). The judge defaults to verified=false
+ * when signals are ambiguous — strong evidence, not lax permission.
+ */
+import type Anthropic from "@anthropic-ai/sdk";
+import type { z } from "zod/v4";
+import { type JudgeCaptureFn } from "../../../lib/llm/judge";
+import { SUBMIT_VERDICT_SCHEMA } from "../../../lib/llm/schemas";
+/**
+ * System prompt for the submit-verifier. The strictness rules are
+ * intentionally explicit and multi-signal — the empirical replay confirmed
+ * Haiku follows them honestly on both true-success and genuine-failure cases.
+ */
+declare const SUBMIT_VERIFY_SYSTEM_PROMPT = "You are a strict submit-verifier for browser-automated job applications. Given evidence about what happened after a Submit click, decide whether the submission actually succeeded.\n\nStrictness rule for verified=true:\n- You need at least ONE strong DOM/URL/title signal: a post-submit success component is visible in the page DOM (matching one of submitted-state selectors or a generic post-submit marker like *-submitted-page, *-thank-you, *-confirmation), OR the page title contains a confirmation phrase (\"Thank you\", \"Application submitted\", \"Submitted\", \"Confirmation\"), OR the URL transitioned to a success path (any of the success URL fragments supplied, or generic patterns like \"/applied\", \"/submitted\", \"/confirmation\", \"/thank-you\").\n- A 2xx POST/PUT/DELETE to the site's own backend (matching one of the supplied ownBackendHostnames) STRENGTHENS the case but is not required on its own \u2014 sometimes the network capture window misses the submit POST because the SPA navigates faster than the recorder.\n- A 2xx network request alone, with NO DOM/URL/title indication of success, is INSUFFICIENT. Could be telemetry. Set verified=false in that case.\n- If only error indicators are present (4xx, 5xx, error containers, the form is still visible with invalid markers), set verified=false with a reason.\n- When ambiguous, set verified=false with a reason. Be strict, not lax \u2014 false positives here mean the engine thinks a submit succeeded when it didn't, and the candidate's application is lost.\n\nWhen verified=true, populate the three signal fields with what you found (any can be null if absent), and write a one-sentence rationale citing the strongest signal.\nWhen verified=false, write a one-sentence reason citing what you'd need to see to be convinced.";
+/**
+ * Site-supplied evidence and criteria for the submit-verifier. The engine
+ * is fully site-agnostic; this object is built from the parsed flow file
+ * and the in-flight cascade state.
+ */
+export interface VerifySubmitInput {
+    pageUrl: string;
+    pageTitle: string;
+    unfocusedObserve: {
+        description: string;
+        selector: string;
+    }[];
+    networkCaptures: {
+        method: string;
+        status: number;
+        url: string;
+    }[];
+    invalidMarkerCount: number;
+    /** Per-site: hostnames that count as "the site's own backend." */
+    ownBackendHostnames: string[];
+    /** Per-site: URL fragments that indicate a successful submit. */
+    successUrlFragments: string[];
+    /** Per-site: page-title substrings that indicate a successful submit. */
+    successPageTitleHints: string[];
+    /** Per-site: DOM selectors that indicate the success page is rendered. */
+    submittedStateSelectors: string[];
+}
+/**
+ * Run the Haiku submit-verifier. Returns the parsed verdict (discriminated
+ * union — `verified: true | false`). Returns null when the client is null
+ * (Bedrock-only deployment, no Anthropic SDK) or when the API call fails —
+ * callers fall back to the conservative "verified=false" default.
+ */
+export declare function verifySubmitWithLLM(params: {
+    client: Anthropic | null;
+    input: VerifySubmitInput;
+    captureFn?: JudgeCaptureFn;
+}): Promise<z.infer<typeof SUBMIT_VERDICT_SCHEMA> | null>;
+export { SUBMIT_VERIFY_SYSTEM_PROMPT };
+//# sourceMappingURL=verify-submit.d.ts.map

package/dist/lib/llm/judges/verify-submit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-submit.d.ts","sourceRoot":"","sources":["../../../../src/lib/llm/judges/verify-submit.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AAEH,OAAO,KAAK,SAAS,MAAM,mBAAmB,CAAC;AAC/C,OAAO,KAAK,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAEhC,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,iBAAiB,CAAC;AACtE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAG1D;;;;GAIG;AACH,QAAA,MAAM,2BAA2B,2wDAU+D,CAAC;AAEjG;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC,OAAO,EAAE,MAAM,CAAC;IAChB,SAAS,EAAE,MAAM,CAAC;IAClB,gBAAgB,EAAE;QAAE,WAAW,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IAC9D,eAAe,EAAE;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,CAAA;KAAE,EAAE,CAAC;IACnE,kBAAkB,EAAE,MAAM,CAAC;IAC3B,kEAAkE;IAClE,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,iEAAiE;IACjE,mBAAmB,EAAE,MAAM,EAAE,CAAC;IAC9B,yEAAyE;IACzE,qBAAqB,EAAE,MAAM,EAAE,CAAC;IAChC,0EAA0E;IAC1E,uBAAuB,EAAE,MAAM,EAAE,CAAC;CACnC;AA+BD;;;;;GAKG;AACH,wBAAsB,mBAAmB,CAAC,MAAM,EAAE;IAChD,MAAM,EAAE,SAAS,GAAG,IAAI,CAAC;IACzB,KAAK,EAAE,iBAAiB,CAAC;IACzB,SAAS,CAAC,EAAE,cAAc,CAAC;CAC5B,GAAG,OAAO,CAAC,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,GAAG,IAAI,CAAC,CAYxD;AAED,OAAO,EAAE,2BAA2B,EAAE,CAAC"}

package/dist/lib/llm/judges/verify-submit.js

@@ -0,0 +1,89 @@
+"use strict";
+/**
+ * Submit-verification judge. Replaces the per-site `submitEndpointPattern`
+ * regex with a Haiku 4.5 structured-output call that judges success across
+ * multiple corroborating signals (network 2xx + DOM success component + URL
+ * transition + page title).
+ *
+ * Empirically validated 2026-06-11 on two production failure cases:
+ *  - Case A (was wrongly flagged as failure by the regex): verdict=true,
+ *    correctly identified dom_signal="uapp-universal-submitted-page" and
+ *    url_signal="/applyboard/applied".
+ *  - Case B (genuinely stuck, 10 ng-invalid markers, no success DOM):
+ *    verdict=false with a coherent reason about why submission failed.
+ *
+ * Strictness rule baked into the system prompt: verified=true requires at
+ * least one DOM/URL/title signal of post-submit state. A 2xx alone is NOT
+ * sufficient (could be telemetry). The judge defaults to verified=false
+ * when signals are ambiguous — strong evidence, not lax permission.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SUBMIT_VERIFY_SYSTEM_PROMPT = void 0;
+exports.verifySubmitWithLLM = verifySubmitWithLLM;
+const judge_1 = require("../../../lib/llm/judge");
+const schemas_1 = require("../../../lib/llm/schemas");
+const call_types_1 = require("../../../lib/telemetry/call-types");
+/**
+ * System prompt for the submit-verifier. The strictness rules are
+ * intentionally explicit and multi-signal — the empirical replay confirmed
+ * Haiku follows them honestly on both true-success and genuine-failure cases.
+ */
+const SUBMIT_VERIFY_SYSTEM_PROMPT = `You are a strict submit-verifier for browser-automated job applications. Given evidence about what happened after a Submit click, decide whether the submission actually succeeded.
+
+Strictness rule for verified=true:
+- You need at least ONE strong DOM/URL/title signal: a post-submit success component is visible in the page DOM (matching one of submitted-state selectors or a generic post-submit marker like *-submitted-page, *-thank-you, *-confirmation), OR the page title contains a confirmation phrase ("Thank you", "Application submitted", "Submitted", "Confirmation"), OR the URL transitioned to a success path (any of the success URL fragments supplied, or generic patterns like "/applied", "/submitted", "/confirmation", "/thank-you").
+- A 2xx POST/PUT/DELETE to the site's own backend (matching one of the supplied ownBackendHostnames) STRENGTHENS the case but is not required on its own — sometimes the network capture window misses the submit POST because the SPA navigates faster than the recorder.
+- A 2xx network request alone, with NO DOM/URL/title indication of success, is INSUFFICIENT. Could be telemetry. Set verified=false in that case.
+- If only error indicators are present (4xx, 5xx, error containers, the form is still visible with invalid markers), set verified=false with a reason.
+- When ambiguous, set verified=false with a reason. Be strict, not lax — false positives here mean the engine thinks a submit succeeded when it didn't, and the candidate's application is lost.
+
+When verified=true, populate the three signal fields with what you found (any can be null if absent), and write a one-sentence rationale citing the strongest signal.
+When verified=false, write a one-sentence reason citing what you'd need to see to be convinced.`;
+exports.SUBMIT_VERIFY_SYSTEM_PROMPT = SUBMIT_VERIFY_SYSTEM_PROMPT;
+/**
+ * Render the evidence into a user prompt for Haiku. The structure mirrors
+ * the empirical-replay prototype that proved this works on production cases.
+ */
+function buildVerifySubmitPrompt(input) {
+    return `Did the submit succeed?
+
+PAGE URL: ${input.pageUrl}
+PAGE TITLE: ${input.pageTitle}
+
+NETWORK REQUESTS IN ATTEMPT WINDOW (method, status, url):
+${input.networkCaptures.length > 0
+        ? input.networkCaptures.map((c) => `  ${c.method} ${c.status} ${c.url}`).join("\n")
+        : "  (none)"}
+
+UNFOCUSED OBSERVE (xpaths the agent can see on the page right now):
+${input.unfocusedObserve.map((o, i) => `  ${i + 1}. ${o.description} — ${o.selector}`).join("\n")}
+
+DOM INVALID-MARKER COUNT: ${input.invalidMarkerCount} (form fields still showing structural error/invalid state)
+
+SITE CRITERIA:
+- Own-backend hostnames: ${JSON.stringify(input.ownBackendHostnames)}
+- Success URL fragments: ${JSON.stringify(input.successUrlFragments)}
+- Success page title hints: ${JSON.stringify(input.successPageTitleHints)}
+- Submitted-state selectors (DOM components that indicate post-submit state): ${JSON.stringify(input.submittedStateSelectors)}`;
+}
+/**
+ * Run the Haiku submit-verifier. Returns the parsed verdict (discriminated
+ * union — `verified: true | false`). Returns null when the client is null
+ * (Bedrock-only deployment, no Anthropic SDK) or when the API call fails —
+ * callers fall back to the conservative "verified=false" default.
+ */
+async function verifySubmitWithLLM(params) {
+    const { client, input, captureFn } = params;
+    if (client === null)
+        return null;
+    const result = await (0, judge_1.callHaikuJudge)({
+        client,
+        systemPrompt: SUBMIT_VERIFY_SYSTEM_PROMPT,
+        userPrompt: buildVerifySubmitPrompt(input),
+        schema: schemas_1.SUBMIT_VERDICT_SCHEMA,
+        callType: call_types_1.CALL_TYPE_JUDGE_SUBMIT_VERIFY,
+        captureFn,
+    });
+    return result?.parsed ?? null;
+}
+//# sourceMappingURL=verify-submit.js.map

package/dist/lib/llm/judges/verify-submit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"verify-submit.js","sourceRoot":"","sources":["../../../../src/lib/llm/judges/verify-submit.ts"],"names":[],"mappings":";AAAA;;;;;;;;;;;;;;;;;GAiBG;;;AAkFH,kDAgBC;AA7FD,2CAAsE;AACtE,+CAA0D;AAC1D,2DAA2E;AAE3E;;;;GAIG;AACH,MAAM,2BAA2B,GAAG;;;;;;;;;;gGAU4D,CAAC;AA4ExF,kEAA2B;AArDpC;;;GAGG;AACH,SAAS,uBAAuB,CAAC,KAAwB;IACvD,OAAO;;YAEG,KAAK,CAAC,OAAO;cACX,KAAK,CAAC,SAAS;;;EAI3B,KAAK,CAAC,eAAe,CAAC,MAAM,GAAG,CAAC;QAC9B,CAAC,CAAC,KAAK,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,MAAM,IAAI,CAAC,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;QACnF,CAAC,CAAC,UACN;;;EAGE,KAAK,CAAC,gBAAgB,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC,WAAW,MAAM,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC;;4BAErE,KAAK,CAAC,kBAAkB;;;2BAGzB,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,mBAAmB,CAAC;2BACzC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,mBAAmB,CAAC;8BACtC,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,qBAAqB,CAAC;gFACO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,uBAAuB,CAAC,EAAE,CAAC;AAChI,CAAC;AAED;;;;;GAKG;AACI,KAAK,UAAU,mBAAmB,CAAC,MAIzC;IACC,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,GAAG,MAAM,CAAC;IAC5C,IAAI,MAAM,KAAK,IAAI;QAAE,OAAO,IAAI,CAAC;IACjC,MAAM,MAAM,GAAG,MAAM,IAAA,sBAAc,EAAC;QAClC,MAAM;QACN,YAAY,EAAE,2BAA2B;QACzC,UAAU,EAAE,uBAAuB,CAAC,KAAK,CAAC;QAC1C,MAAM,EAAE,+BAAqB;QAC7B,QAAQ,EAAE,0CAA6B;QACvC,SAAS;KACV,CAAC,CAAC;IACH,OAAO,MAAM,EAAE,MAAM,IAAI,IAAI,CAAC;AAChC,CAAC"}

package/dist/lib/llm/schemas.d.ts

@@ -0,0 +1,220 @@
+/**
+ * Zod schemas for every Anthropic LLM call site's structured output. Every
+ * call in the engine goes through `client.messages.parse` + `zodOutputFormat`
+ * (or equivalent) so the SDK throws on schema violation rather than handing
+ * back malformed text the caller has to defensively parse. Co-locating the
+ * schemas here keeps the contracts visible in one file instead of buried
+ * inside ~4500-line scripts.
+ *
+ * Naming: each schema corresponds 1:1 to a `CALL_TYPE_*` constant in
+ * `src/lib/telemetry/call-types.ts`.
+ */
+import { z } from "zod/v4";
+/**
+ * Cap on per-replan step list size. Anything beyond this is almost certainly
+ * the LLM hallucinating an entire flow from scratch instead of writing the
+ * minimum bridge needed to unstick the cascade. Matches the existing pre-move
+ * constant value so call-site behavior is identical.
+ */
+export declare const REPLAN_MAX_STEPS = 30;
+/**
+ * Flow step shape consumed by every recon-flow consumer (file parsing,
+ * replanner output, normalizer). A bare string is a required step; the
+ * object form supports `optional` and `upload` flags.
+ *
+ * Moved here from recon-browser.ts so REPLAN_RESPONSE_SCHEMA can be defined
+ * alongside it without recon-browser.ts having to re-export both.
+ */
+export declare const RECON_FLOW_STEP_SCHEMA: z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+    step: z.ZodString;
+    optional: z.ZodDefault<z.ZodBoolean>;
+    upload: z.ZodDefault<z.ZodBoolean>;
+    submitStep: z.ZodDefault<z.ZodBoolean>;
+    payloadField: z.ZodOptional<z.ZodString>;
+    payloadFieldNone: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>]>;
+/**
+ * Replanner response. Discriminated union on `outcome`. When the cascade has
+ * exhausted all per-step healing attempts, the replanner either proposes a
+ * bridge sequence (`replan` outcome) or admits the page state is
+ * unrecoverable (`impossible`). The single-action constraint on each step is
+ * enforced by the caller's normalizer, not the schema (the LLM emits
+ * arbitrary text inside `step`; we trust the caller's downstream parse).
+ */
+export declare const REPLAN_RESPONSE_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    outcome: z.ZodLiteral<"replan">;
+    steps: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
+        step: z.ZodString;
+        optional: z.ZodDefault<z.ZodBoolean>;
+        upload: z.ZodDefault<z.ZodBoolean>;
+        submitStep: z.ZodDefault<z.ZodBoolean>;
+        payloadField: z.ZodOptional<z.ZodString>;
+        payloadFieldNone: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    outcome: z.ZodLiteral<"impossible">;
+    reason: z.ZodString;
+}, z.core.$strip>]>;
+/**
+ * Rephrase response. Discriminated union on `outcome`. The pre-schema
+ * contract was free text plus the magic string "IMPOSSIBLE" — fragile and
+ * easy for the LLM to emit prose around. The schema makes the contract
+ * explicit and parses on the API side.
+ */
+export declare const REPHRASE_RESPONSE_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    outcome: z.ZodLiteral<"rewrite">;
+    instruction: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    outcome: z.ZodLiteral<"impossible">;
+    reason: z.ZodString;
+}, z.core.$strip>]>;
+/**
+ * Patch generator response shape. Shared between `recon-flow-patch` and
+ * `llm-prompt-patch` — both follow the same anchor/replacement/strategy
+ * minimal-change discipline. The contract was identical at the prose level
+ * before this schema; making it shared explicit Zod cleans up two parallel
+ * `JSON.parse` ladders.
+ *
+ * Cross-field validation (anchor must exist in the artifact being patched)
+ * stays at the caller because the artifact isn't known to the schema.
+ */
+export declare const PATCH_RESPONSE_SCHEMA: z.ZodObject<{
+    anchor: z.ZodString;
+    replacement: z.ZodString;
+    strategy: z.ZodString;
+    pivot_reason: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * Judge verdict shape. The existing judge prompt already specifies this
+ * structure in prose; moving it to a Zod schema makes the contract enforced
+ * by the SDK and removes the manual try/catch JSON-parse ladder.
+ */
+export declare const JUDGE_VERDICT_SCHEMA: z.ZodObject<{
+    schemaOk: z.ZodBoolean;
+    schemaRationale: z.ZodString;
+    factuallyGrounded: z.ZodBoolean;
+    factualRationale: z.ZodString;
+    hallucinationFree: z.ZodBoolean;
+    hallucinationRationale: z.ZodString;
+    worstOffender: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        schema: "schema";
+        factual: "factual";
+        hallucination: "hallucination";
+    }>>>;
+}, z.core.$strip>;
+/**
+ * Submit-verification verdict. Replaces the per-site `submitEndpointPattern`
+ * regex. Discriminated union forces the LLM to commit to verified=true|false
+ * — no in-between "maybe" state.
+ *
+ * The verified=true branch requires populating three signal fields (any can
+ * be null but at least one of dom_signal / url_signal SHOULD be non-null per
+ * the strict system prompt). The verifier's `rationale` must cite the
+ * strongest signal — keeps Haiku honest about why it ruled success.
+ *
+ * The verified=false branch requires a reason — keeps Haiku from waving
+ * failures away without explanation, and gives the rephrase prompt
+ * downstream a structured signal about what to look for.
+ *
+ * Empirically validated 2026-06-11 on two real production failure dumps
+ * (one wrongly-flagged-as-fail, one genuinely-stuck) — both verdicts
+ * correct, both rationale fields coherent.
+ */
+export declare const SUBMIT_VERDICT_SCHEMA: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    verified: z.ZodLiteral<true>;
+    network_signal: z.ZodNullable<z.ZodObject<{
+        url: z.ZodString;
+        status: z.ZodNumber;
+        method: z.ZodString;
+    }, z.core.$strip>>;
+    dom_signal: z.ZodNullable<z.ZodString>;
+    url_signal: z.ZodNullable<z.ZodString>;
+    rationale: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    verified: z.ZodLiteral<false>;
+    reason: z.ZodString;
+}, z.core.$strip>]>;
+/**
+ * Invalid-field detection verdict. Replaces INVALID_CLASS_RX regex.
+ * `present` is the top-level boolean so a downstream consumer can
+ * short-circuit on "no invalid fields here" without iterating `fields`.
+ * `fields` carries the discovered structural markers per-container so
+ * the rephrase prompt can build its INTERACTIVE TARGETS section.
+ *
+ * Strict prompting requires: structural marker (class containing
+ * "invalid", aria-invalid="true", data-invalid, or visible error
+ * container near input). Visual-only styling does NOT count.
+ */
+export declare const INVALID_FIELDS_SCHEMA: z.ZodObject<{
+    present: z.ZodBoolean;
+    fields: z.ZodArray<z.ZodObject<{
+        containerXpath: z.ZodString;
+        label: z.ZodNullable<z.ZodString>;
+        markerKind: z.ZodEnum<{
+            class: "class";
+            aria: "aria";
+            data: "data";
+            "error-container": "error-container";
+            other: "other";
+        }>;
+        framework: z.ZodEnum<{
+            other: "other";
+            angular: "angular";
+            react: "react";
+            vue: "vue";
+            mantine: "mantine";
+            chakra: "chakra";
+            bootstrap: "bootstrap";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Modal-priority verdict. Replaces MODAL_PRIORITY_RX keyword regex over
+ * Stagehand's English description strings. Returns indices into the
+ * caller-supplied unfocused-observe array — the engine just re-sorts
+ * its own list, the LLM doesn't see selectors or have to echo them
+ * back.
+ *
+ * Strict prompting requires: structurally blocking the form. Cookie
+ * banners and welcome modals ARE priority. Always-visible panels and
+ * sidebars are NOT.
+ */
+export declare const MODAL_PRIORITY_SCHEMA: z.ZodObject<{
+    priorityIndices: z.ZodArray<z.ZodNumber>;
+    rationale: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Visible-error-message extraction verdict. Replaces `errorPattern`
+ * regex. Each entry carries the text, an optional field-name hint,
+ * and a severity ranking — the rephrase prompt today renders these as
+ * the VISIBLE ERROR / REQUIRED-FIELD MESSAGES section.
+ *
+ * Strict prompting: structurally-marked error containers + visible text
+ * only. Skip placeholder text, help text, and inactive tooltips.
+ */
+export declare const ERROR_MESSAGES_SCHEMA: z.ZodObject<{
+    messages: z.ZodArray<z.ZodObject<{
+        text: z.ZodString;
+        fieldHint: z.ZodNullable<z.ZodString>;
+        severity: z.ZodEnum<{
+            info: "info";
+            error: "error";
+            warning: "warning";
+        }>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+/**
+ * Select-option picker verdict. When a flow step's hardcoded dropdown answer
+ * doesn't exist in a given requisition's option list (per-req variance —
+ * e.g. an ER-flavored answer on a Cardiac job), this judge picks the most
+ * plausible AVAILABLE option so the required question can be answered and the
+ * wizard advances. `selectIndex` picks which candidate dropdown answers the
+ * question (or null when none does); `optionIndex` picks the option within that
+ * dropdown (null when `selectIndex` is null).
+ */
+export declare const SELECT_OPTION_SCHEMA: z.ZodObject<{
+    selectIndex: z.ZodNullable<z.ZodNumber>;
+    optionIndex: z.ZodNullable<z.ZodNumber>;
+    reason: z.ZodString;
+}, z.core.$strip>;
+//# sourceMappingURL=schemas.d.ts.map

package/dist/lib/llm/schemas.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schemas.d.ts","sourceRoot":"","sources":["../../../src/lib/llm/schemas.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;GAUG;AAEH,OAAO,EAAE,CAAC,EAAE,MAAM,QAAQ,CAAC;AAE3B;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,KAAK,CAAC;AAEnC;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;;;;;;;mBAiCjC,CAAC;AAEH;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;mBASjC,CAAC;AAEH;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB;;;;;;mBASnC,CAAC;AAEH;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB;;;;;iBAKhC,CAAC;AAEH;;;;GAIG;AACH,eAAO,MAAM,oBAAoB;;;;;;;;;;;;iBAQ/B,CAAC;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;mBAkBhC,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;iBAYhC,CAAC;AAEH;;;;;;;;;;GAUG;AACH,eAAO,MAAM,qBAAqB;;;iBAGhC,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;iBAUhC,CAAC;AAEH;;;;;;;;GAQG;AACH,eAAO,MAAM,oBAAoB;;;;iBAQ/B,CAAC"}