atsfill 0.0.7.dev212__tar.gz → 0.0.8.dev221__tar.gz

{atsfill-0.0.7.dev212 → atsfill-0.0.8.dev221}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atsfill
-Version: 0.0.7.dev212
+Version: 0.0.8.dev221
 Summary: Read, dry-run and submit job application forms on hiring systems: Ashby, Greenhouse, Teamtailor, Welcome to the Jungle.
 Keywords: job-applications,ats,ashby,greenhouse,teamtailor,ai-agents,cli
 Author: shbernal

{atsfill-0.0.7.dev212 → atsfill-0.0.8.dev221}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.7.dev212"
+version = "0.0.8.dev221"
 description = "Read, dry-run and submit job application forms on hiring systems: Ashby, Greenhouse, Teamtailor, Welcome to the Jungle."
 readme = "README.md"
 license = "MIT"

{atsfill-0.0.7.dev212 → atsfill-0.0.8.dev221}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.7.dev212"
+version = "0.0.8.dev221"
 description = "Read, dry-run and submit job application forms on hiring systems: Ashby, Greenhouse, Teamtailor, Welcome to the Jungle."
 readme = "README.md"
 license = "MIT"

{atsfill-0.0.7.dev212 → atsfill-0.0.8.dev221}/src/atsfill/adapters/adp.py

@@ -49,6 +49,9 @@ NEXT = "#ja_sv_cw_next_footer_btn"
 PREVIOUS = "#ja_sv_cw_prev_footer_btn"
 SUBMIT = "#submitApplication"
 ATTEST = "input[name=self_att_agree_chk]"
+SIGNATURE = "attestation.signature"
+OPT_OUT = "resume.ai_opt_out"
+LATE = {SIGNATURE: OPTION_TIMEOUT_MS, OPT_OUT: UPLOAD_TIMEOUT_MS}  # boxes shown a moment after
 PERSON = "/jobApplication/applicant/person"
 PAY = "/jobApplication/requestedPayRate"
 
@@ -74,6 +77,7 @@ SHOWN_BY_COUNTRY = {"county"}  # once a country with counties is picked
 ADDRESS_MAX = 30  # "Address Line 1 must not exceed 30 characters"
 FIXED = {"personal.email"}  # the verified email, read only
 QUESTIONS = "#question_0, #questionYes_0, #desiredSalaryId, #refferalOptions, #commentTextArea"
+NOT_FIELDS = re.compile(r"select-filter-input|react-select-.*")  # a list's own inputs
 
 # Voluntary Self-ID: its lists and radio groups, each with the meta's indicator that shows it
 # and its code list; a radio's value is its code
@@ -113,6 +117,7 @@ class ADP:
         self._values: dict[str, Answer] = {}
         self._codes: dict[str, dict[str, str]] = {}  # a radio's label by its value, by field id
         self._amounts: set[str] = set()  # the page shows them formatted: `50,000.00`
+        self._shown: dict[str, None] = {}  # the fields each step showed, in order
 
     def detect(self, url: str, page: Page | None) -> bool:
         return _posting(url) is not None
@@ -166,7 +171,7 @@ class ADP:
         asked = self._questions(control, transforms)
         self._steps = [
             Step("Personal Information", PERSONAL[0][1], self._personal(page, transforms)),
-            Step("Resume", "input[type=file]", [self._resume()]),
+            Step("Resume", "input[type=file]", [self._resume(), self._opt_out()]),
         ]  # fmt: skip
         # A wizard with nothing to ask has no Questions step; one that asks nothing the meta
         # lists has no box of its own: Next moves past it
@@ -176,25 +181,44 @@ class ADP:
             fields = self._self_id(transforms, indicators)
             self._steps.append(Step("Voluntary Self-ID", "#vsidWhy, #vsidEthRace", fields))
         self._steps.append(Step("Review Your Application", ""))
-        self._steps.append(Step("Self-Attest & Submit", SUBMIT, [self._attestation(control)]))
+        attest = [self._attestation(control), self._signature()]
+        self._steps.append(Step("Self-Attest & Submit", SUBMIT, attest))
         return [f for s in self._steps for f in s.fields]
 
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
         """Answers each step and moves on with Next, up to the attestation, which it agrees to
         without Submit."""
-        self._values = {}
+        self._values, self._shown = {}, {}
         answers = {f.id: f.prefilled for s in self._steps for f in s.fields
                    if f.prefilled is not None} | answers  # fmt: skip
         for step in self._steps:
             _wait_for_step(page, step)
+            before = {key for key, _ in page.evaluate(_CONTROLS)}
             for f in step.fields:
                 if f.id in answers and f.id not in FIXED:
                     self._set(page, f, answers[f.id])
+            self._shown |= dict.fromkeys(self._shown_on(page, step, before))
             self._values |= self._read(page, step)
             if step.marker == SUBMIT:
                 return
             _next(page, step)
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """The fields each step showed once answered: the wizard holds one step at a time."""
+        return list(self._shown)
+
+    def _shown_on(self, page: Page, step: Step, before: set[str]) -> list[str]:
+        """The open step's fields: those with an enabled box, then the controls its answers
+        added that no field has. What it showed before them is not all fields, such as a
+        preferred name's box, so a control counts only as an answer's."""
+        boxes = {name for box in self._boxes.values() for name in re.findall(r"[\w-]+", box)}
+        shown = [f.id for f in step.fields if _enabled(page.locator(self._boxes[f.id]).first)]
+        for key, dom in page.evaluate(_CONTROLS):
+            listed = key in boxes or dom in boxes or NOT_FIELDS.fullmatch(key)
+            if key and key not in before and not listed:
+                shown.append(key)
+        return shown
+
     def read_back(self, page: Page) -> dict[str, Answer]:
         """Each step's values as it was left."""
         return dict(self._values)
@@ -246,6 +270,17 @@ class ADP:
         self._boxes["resume"] = "input[type=file]"
         return Field("resume", "Resume", FieldType.FILE, True, accept=[".pdf", ".doc", ".docx"])
 
+    def _opt_out(self) -> Field:
+        """The opt-out an employer's uploaded résumé shows, in no meta: listed on every form,
+        its box left alone unless answered."""
+        self._boxes[OPT_OUT] = "input[name=candidateProfileRelevanceOptionDivId]"
+        label = (
+            "I want to opt out from having my resume reviewed by artificial intelligence as "
+            "part of the application process."
+        )
+        return Field(OPT_OUT, label, FieldType.CHOICE, False, YES_NO, default="No",
+                     shown_when=Is("resume"))  # fmt: skip
+
     def _questions(self, control: dict[str, Any], transforms: dict[str, Any]) -> list[Field]:
         """The questionnaire, each question its `#question_<n>` by position; then the desired
         pay and the comment where the meta does not hide them."""
@@ -356,8 +391,17 @@ class ADP:
         self._boxes["attestation"] = ATTEST
         return Field("attestation", label, FieldType.CHOICE, True, YES_NO)
 
+    def _signature(self) -> Field:
+        """The name agreeing shows beneath the box, in no meta; the page's own words."""
+        self._boxes[SIGNATURE] = "#electronicSignature"
+        return Field(SIGNATURE, "Please type your full name.", FieldType.TEXT, True,
+                     shown_when=Is("attestation", ["Yes"]))  # fmt: skip
+
     def _set(self, page: Page, f: Field, answer: Answer) -> None:
         box = page.locator(self._boxes[f.id]).first
+        if f.id in LATE:
+            with suppress(Timeout):
+                box.wait_for(state="attached", timeout=LATE[f.id])
         if not box.count():
             return  # not shown: its condition is unmet
         if f.type is FieldType.FILE:
@@ -416,6 +460,10 @@ class ADP:
         return values
 
 
+# The open step's controls: what names each, and its id
+_CONTROLS = """() => [...document.querySelectorAll(
+  "input, textarea, select, sdf-select-simple, wfn-dropdown-list"
+)].map(e => [e.name || e.id, e.id])"""
 # The meta lists the questionnaire of the posting its header names
 _FETCH = """async ([url, requisition]) => {
   const headers = {requisitionoid: requisition, 'x-requested-with': 'XMLHttpRequest'};
@@ -520,6 +568,11 @@ def _label(page: Page, selector: str) -> str:
     return ""
 
 
+def _enabled(box: Locator) -> bool:
+    """A box the step shows and takes an answer in: race stays disabled until ethnicity allows."""
+    return box.count() > 0 and not box.evaluate("e => e.disabled === true")
+
+
 def _wait_for_step(page: Page, step: Step) -> None:
     if not step.marker:
         page.wait_for_timeout(SETTLE_MS)

{atsfill-0.0.7.dev212 → atsfill-0.0.8.dev221}/src/atsfill/adapters/adpmyjobs.py

@@ -95,6 +95,7 @@ class ADPMyJobs:
         self._codes: dict[str, dict[str, str]] = {}  # by field id: an option's label by code
         self._values: dict[str, Answer] = {}
         self._fixed: set[str] = set()  # disabled questions, their value shown as text
+        self._shown: dict[str, None] = {}  # the fields each page showed, in order
 
     def detect(self, url: str, page: Page | None) -> bool:
         return _posting(url) is not None
@@ -202,7 +203,7 @@ class ADPMyJobs:
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
         """Answers each section page by page, saving each with Next, up to the last section's
         last page, or its review."""
-        self._values = {}
+        self._values, self._shown = {}, {}
         answers = {f.id: f.prefilled for s in self._sections for f in s.fields
                    if f.prefilled is not None} | answers  # fmt: skip
         for section in self._sections:
@@ -210,9 +211,10 @@ class ADPMyJobs:
                 _on_section(page, section)
                 _to_page(page, section, ids)
                 _add_entries(page, section, number)
-                if unlisted := _unlisted(page, section):
-                    raise NotTaken(f"{section.title} shows {unlisted}, which the read did not list")
+                _all_listed(page, section)
                 self._answer(page, section, answers)
+                _all_listed(page, section)  # before a Next saves what the answers showed
+                self._shown |= dict.fromkeys(_shown_ids(page, section))
                 self._values |= self._read(page, section)
                 last = number == max(len(section.pages), 1) - 1
                 if section is self._sections[-1] and last and not section.review:
@@ -221,6 +223,10 @@ class ADPMyJobs:
             if section.review and section is not self._sections[-1]:
                 self._next(page, section)  # the review's Next saves the section
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """The fields each page showed once answered: the workflow keeps one page at a time."""
+        return list(self._shown)
+
     def read_back(self, page: Page) -> dict[str, Answer]:
         """Each section's values as it was left."""
         return dict(self._values)
@@ -654,13 +660,24 @@ _SHOWN = """es => es
   .map(e => [e.dataset.name, e.querySelector('label')?.innerText.trim()])"""
 
 
-def _unlisted(page: Page, section: Section) -> str:
-    """The questions the open page shows that the read did not list, by label."""
+def _all_listed(page: Page, section: Section) -> None:
+    """Stops on a question the open page shows that the read did not list, before its Next
+    saves the section for good."""
     if section.component.startswith("prescreen"):
-        return ""
+        return
     listed = {f.id.removeprefix(f"{section.component}.") for f in section.fields}
     shown = page.locator("adp-form-group").evaluate_all(_SHOWN)
-    return ", ".join(repr(label or name) for name, label in shown if name not in listed)
+    unlisted = ", ".join(repr(label or name) for name, label in shown if name not in listed)
+    if unlisted:
+        raise NotTaken(f"{section.title} shows {unlisted}, which the read did not list")
+
+
+def _shown_ids(page: Page, section: Section) -> list[str]:
+    """The ids of the fields the open page shows; a prescreen's questions have no group."""
+    if section.component.startswith("prescreen"):
+        return [f.id for f in section.fields if _box(page, section, f).count()]
+    shown = page.locator("adp-form-group").evaluate_all(_SHOWN)
+    return [f"{section.component}.{name}" for name, _ in shown]
 
 
 def _on_section(page: Page, section: Section) -> None:

{atsfill-0.0.7.dev212 → atsfill-0.0.8.dev221}/src/atsfill/adapters/bamboohr.py

@@ -95,6 +95,9 @@ TYPES = {
     "file": FieldType.FILE,
 }
 
+CUSTOM_CONTROL = re.compile(r"customQuestionAnswers\.[a-z_]+?_(\d+)(_other)?")
+VETERAN_RADIOS = ("declineToAnswer", "notVeteran", "veteran")
+
 # The form's JSON answer and the state lists, fetched as the page fetches them.
 _FETCH = """async urls => {
   const out = [];
@@ -105,6 +108,12 @@ _FETCH = """async urls => {
   return out;
 }"""
 
+# Each control of the form: what names it, and whether a person sees it.
+_CONTROLS = """form => [...form.querySelectorAll("input, select, textarea")].map(e => ({
+  name: e.name, id: e.id, date: (e.placeholder ?? "").includes("yyyy"),
+  visible: e.offsetParent !== null,
+}))"""
+
 # What each present control shows, by the field's kind.
 _READ_BACK = """(form, specs) => {
   const named = name => form.querySelector(`[name="${name}"]`);
@@ -151,6 +160,7 @@ class BambooHR:
         # each field's (kind, control name, extra): a radio's option ids by text, the
         # veteran kinds' texts by id, a date's nothing
         self._specs: dict[str, tuple[str, str | None, Any]] = {}
+        self._on_read: set[str] = set()  # the controls' names as the form opened: its honeypot
 
     def detect(self, url: str, page: Page | None) -> bool:
         return _job(url) is not None
@@ -208,6 +218,7 @@ class BambooHR:
         self._specs = {
             f.id: spec for f, (_, spec) in zip(out, fields, strict=True) if not f.unfillable
         }
+        self._on_read = {control["name"] for control in form.evaluate(_CONTROLS)}
         return out
 
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
@@ -266,6 +277,17 @@ class BambooHR:
                             continue  # its question was not answered Other
                     control.fill(value)
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """The fields the form holds a control for, once filled; a visible control that came
+        after the read and no field names, by its name."""
+        shown: dict[str, None] = {}
+        for control in page.locator(FORM).evaluate(_CONTROLS):
+            if field_id := _field_of(control):
+                shown[field_id] = None
+            elif control["visible"] and control["name"] not in self._on_read:
+                shown[control["name"]] = None
+        return [i for i in shown if i != "dateAvailable" or i in self._specs]
+
     def read_back(self, page: Page) -> dict[str, Answer]:
         specs = {
             i: (kind, name, extra if kind == "veteran" else None)
@@ -307,6 +329,18 @@ class BambooHR:
         return f"{response.url} {response.status}"
 
 
+def _field_of(control: dict[str, Any]) -> str | None:
+    """The field a control belongs to: by its name, the date by its placeholder and the veteran
+    radios, whose name React makes up, by their ids."""
+    if control["date"]:
+        return "dateAvailable"
+    if control["id"] in VETERAN_RADIOS:
+        return "veteranStatusId"
+    if custom := CUSTOM_CONTROL.fullmatch(control["name"]):
+        return f"question_{custom[1]}{custom[2] or ''}"
+    return next((k for k, (_, name) in STANDARD.items() if name == control["name"]), None)
+
+
 def _job(url: str) -> tuple[str, str] | None:
     parts = urlsplit(url)
     if not (parts.hostname and HOST.match(parts.hostname)) or not (m := JOB.match(parts.path)):

{atsfill-0.0.7.dev212 → atsfill-0.0.8.dev221}/src/atsfill/adapters/breezy.py

@@ -328,6 +328,11 @@ class Breezy:
             case _:
                 controls.first.fill(values[0])
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """The controls `browser_read` names; a work history or education entry's have no name.
+        Every step stays in the page, the others hidden."""
+        return [raw["id"] for raw in page.locator(FORM).evaluate(_READ)]
+
     def read_back(self, page: Page) -> dict[str, Answer]:
         form = page.locator(FORM)
         out: dict[str, Answer] = {}

{atsfill-0.0.7.dev212 → atsfill-0.0.8.dev221}/src/atsfill/adapters/eightfold.py

@@ -92,6 +92,9 @@ _DOM_IDS = """keys => {
   return out;
 }"""
 
+# The element ids of the controls on the page.
+_SHOWN = """() => [...document.querySelectorAll('[id$="_error"]')].map(e => e.id.slice(0, -6))"""
+
 _READ_BACK = """controls => {
   const out = {};
   for (const [qid, dom, kind] of controls) {
@@ -150,6 +153,7 @@ class Eightfold:
     def __init__(self) -> None:
         self._controls: list[_Control] = []  # in the form's order
         self._fields: list[Field] = []
+        self._ends: dict[str, str] = {}  # each question's id, by what its element id ends with
 
     def detect(self, url: str, page: Page | None) -> bool:
         if _pid(url) is None:
@@ -216,6 +220,7 @@ class Eightfold:
             if control.field.id in held and control.field.prefilled is None:
                 control.field = replace(control.field, default=held[control.field.id])
         self._fields = [c.field for c in self._controls]
+        self._ends = {end: c.field.id for c in self._controls for end in c.ends}
         self._controls = [c for c in self._controls if not c.field.unfillable]
         return self._fields
 
@@ -237,6 +242,15 @@ class Eightfold:
             _fill(page, control, answer)
             given[control.field.id] = answer
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """The questions rendered once filled, each control's by the longest question id its
+        element id ends with; one no question's id ends as the page names it."""
+        shown: dict[str, None] = {}
+        for dom in page.evaluate(_SHOWN):
+            ends = [end for end in self._ends if dom == end or dom.endswith(f"_{end}")]
+            shown[self._ends[max(ends, key=len)] if ends else dom] = None
+        return list(shown)
+
     def read_back(self, page: Page) -> dict[str, Answer]:
         unplaced = [[c.field.id, c.ends] for c in self._controls if c.dom is None]
         doms = page.evaluate(_DOM_IDS, unplaced) if unplaced else {}

{atsfill-0.0.7.dev212 → atsfill-0.0.8.dev221}/src/atsfill/adapters/greenhouse.py

@@ -11,13 +11,14 @@ import re
 import time
 import urllib.request
 from contextlib import suppress
+from dataclasses import replace
 from typing import Any
 from urllib.parse import parse_qs, urlencode, urlsplit
 
 from atsfill.core import browser, otp
 from atsfill.core.adapter import Blocked, Gap, Unsupported
 from atsfill.core.browser import HTTP_TIMEOUT_S, BrowserError, Page, Timeout
-from atsfill.core.results import Answer, Field, FieldType, SideEffect
+from atsfill.core.results import Answer, Field, FieldType, Is, SideEffect
 
 HOSTS = re.compile(r"^(job-boards|boards)(\.eu)?\.greenhouse\.io$")
 FORM = "#application-form"
@@ -29,6 +30,7 @@ EDUCATION_API = "https://boards-api.greenhouse.io/v1/boards/{board}/education/{k
 EMBED = "https://job-boards.greenhouse.io/embed/job_app"
 EMBED_TIMEOUT_MS = 15_000
 OPTIONS_TIMEOUT_MS = 3_000
+RACE_TIMEOUT_MS = 3_000
 HYDRATE_TIMEOUT_MS = 15_000
 FORM_TIMEOUT_MS = 20_000
 ANSWER_TIMEOUT_MS = 15_000  # an upload's file name, a suggestion: past it, a mismatch
@@ -52,6 +54,7 @@ OTP_ERROR = "#email-verification-error"
 # Sections the page adds or names its own way, or shows a question of only on another answer
 # (EEOC race after Hispanic/Latino): `request_read` declines a posting with any (ADR 0011).
 UNMAPPED = ("education", "compliance", "demographic_questions")
+ETHNICITY, NOT_HISPANIC, RACE = "hispanic_ethnicity", "No", "race"
 
 # The fields in page order. A select's options are read by opening it, from Python.
 _READ = """form => {
@@ -196,10 +199,11 @@ class Greenhouse:
         fields = [self._field(page, raw) for raw in raws]
         self._fields = {f.id: f for f in fields}
         self._kinds = {raw["id"]: raw["kind"] for raw in raws}
-        return fields
+        return self._with_race(page, fields)
 
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
-        for field_id, answer in answers.items():
+        # the page draws race only once the answer to Hispanic/Latino is in
+        for field_id, answer in sorted(answers.items(), key=lambda a: a[0] == RACE):
             values = [answer] if isinstance(answer, str) else answer
             match self._kinds[field_id]:
                 case "file":
@@ -235,6 +239,9 @@ class Greenhouse:
                 case _:
                     page.locator(_by_id(field_id)).fill(values[0])
 
+    def shown_fields(self, page: Page) -> list[str]:
+        return [raw["id"] for raw in page.locator(FORM).evaluate(_READ)]
+
     def read_back(self, page: Page) -> dict[str, Answer]:
         values = page.locator(FORM).evaluate(_READ_BACK, list(self._fields))
         return {k: v for k, v in values.items() if v not in (None, "", [])}
@@ -295,6 +302,30 @@ class Greenhouse:
             one_of=raw.get("oneOf"),
         )
 
+    def _with_race(self, page: Page, fields: list[Field]) -> list[Field]:
+        """`fields` with the EEOC race question, a follow-up of Hispanic/Latino: its page's own
+        label and options show only with the question, so the read answers No, reads it and
+        clears the answer. The API's options are not the page's."""
+        ethnicity = self._fields.get(ETHNICITY)
+        if (
+            RACE in self._fields
+            or ethnicity is None
+            or NOT_HISPANIC not in (ethnicity.options or [])
+        ):
+            return fields
+        _select(page, ETHNICITY, NOT_HISPANIC, False)
+        with suppress(Timeout):
+            page.locator(_by_id(RACE)).wait_for(timeout=RACE_TIMEOUT_MS)
+        raws = page.locator(FORM).evaluate(_READ)
+        raw = next((r for r in raws if r["id"] == RACE), None)
+        if raw is not None:
+            race = replace(self._field(page, raw), shown_when=Is(ETHNICITY, [NOT_HISPANIC]))
+            self._fields[RACE], self._kinds[RACE] = race, raw["kind"]
+            fields = [*fields]
+            fields.insert(fields.index(ethnicity) + 1, race)
+        _clear(page, ETHNICITY)
+        return fields
+
     def _education(self, page: Page, field_id: str) -> list[str] | None:
         """An education select's options, every page of them, read once per kind; None for
         another field or when the endpoint does not answer."""
@@ -429,6 +460,14 @@ def _exact(value: str) -> re.Pattern[str]:
     return re.compile(rf"^\s*{re.escape(value)}\s*$")
 
 
+def _clear(page: Page, field_id: str) -> None:
+    """Empties a single react-select."""
+    box = page.locator(_by_id(field_id))
+    box.click()
+    box.press("Backspace")
+    box.press("Escape")
+
+
 def _select(page: Page, field_id: str, value: str, suggested: bool) -> None:
     """Types into a react-select and picks the option: focused with the arrow keys then Enter,
     which every select takes (a hover does not move the focus once typed). A suggestion list

{atsfill-0.0.7.dev212 → atsfill-0.0.8.dev221}/src/atsfill/adapters/gupy.py

@@ -9,12 +9,13 @@ information; the questions are saved by submit, for good.
 
 import re
 import time
+from collections.abc import Callable
 from typing import Any
 from urllib.parse import urlsplit
 
 from atsfill.core import browser
 from atsfill.core.adapter import Blocked, Gap, NotTaken, Unsupported, known_gap
-from atsfill.core.browser import Locator, Page, Request, Response, Timeout
+from atsfill.core.browser import BrowserError, Locator, Page, Request, Response, Timeout
 from atsfill.core.results import Answer, Field, FieldType, Is, SideEffect
 
 HOST = re.compile(r"^([a-z0-9-]+)\.gupy\.io$")
@@ -32,9 +33,26 @@ RESUME_WAIT_S = 15
 SAVE_TIMEOUT_MS = 30_000
 SIGN_IN_TIMEOUT_MS = 30_000
 FORMS_TIMEOUT_S = 10
+CLICK_ATTEMPTS = 3
 YES_NO = ["Yes", "No"]
+# What a Yes on an Additional information radio shows, the same on every posting, in no source a
+# read can see; the page will not save it empty.
+FOLLOW_UPS = {
+    "radioGroupIsIndicatedTitle": {
+        "guiddedApplicationAdditionalDataIndicatedByNameInput": (
+            "Name of the person who recommended you"
+        ),
+        "guiddedApplicationAdditionalDataIndicatedByEmailInput": (
+            "E-mail of the person who has referred you"
+        ),
+    },
+    "radioGroupIsCompanyEmployeeTitle": {
+        "guiddedApplicationAdditionalDataCorporateEmailInput": "Provide your corporate email",
+    },
+}
 TYPES = {
     "SELECT": FieldType.CHOICE,
+    "CONDITIONAL": FieldType.CHOICE,  # a SELECT with questions shown by its answer
     "MULTI_SELECT": FieldType.MULTI_CHOICE,
     "TEXT": FieldType.TEXT,
     "TEXT_AREA": FieldType.TEXT,
@@ -71,6 +89,11 @@ _READ_QUESTIONS = """(ids) => Object.fromEntries(ids.map(([id, title]) => {
   return [`question-${id}`, text?.value ?? null];
 }))"""
 
+# The questions page's controls: `question-<id>` radios, `checkbox-<id>-<n>` boxes, a text named by
+# its question's title.
+_SHOWN_QUESTIONS = f"""() => [...document.querySelectorAll({QUESTIONS!r})]
+  .map(e => e.name || e.id)"""
+
 
 class Gupy:
     name = "gupy"
@@ -86,6 +109,8 @@ class Gupy:
         self._questions: dict[str, dict[str, Any]] = {}
         self._fields: dict[str, Field] = {}
         self._additional: dict[str, Answer] = {}
+        self._additional_shown: list[str] = []  # saved before the questions open
+        self._given: set[str] = set()
 
     def detect(self, url: str, page: Page | None) -> bool:
         parts = urlsplit(url)
@@ -145,7 +170,7 @@ class Gupy:
                 page.wait_for_timeout(STEP_POLL_MS)
         finally:
             page.remove_listener("response", on_response)
-        fields = [_additional(raw) for raw in page.evaluate(_READ_ADDITIONAL)]
+        fields = _additional_fields(page.evaluate(_READ_ADDITIONAL))
         questions = (forms[-1].json().get("questionForm") or {}).get("questions") if forms else []
         self._questions = {f"question-{q['questionId']}": q for q in questions or []}
         fields += [_question(q) for q in self._questions.values()]
@@ -167,7 +192,7 @@ class Gupy:
                     continue
                 if button.is_enabled():
                     disabled_since = None
-                    browser.click(button)
+                    _click(lambda found=button: found)
                 # Continue Application is disabled while the resume loads, for good when the
                 # resume is incomplete
                 elif (disabled_since := disabled_since or time.monotonic()) < (
@@ -182,22 +207,44 @@ class Gupy:
     def fill(self, page: Page, answers: dict[str, Answer]) -> None:
         """Fills Additional information and, where the posting has questions, saves it and
         opens them; the questions are filled and left unsaved for submit."""
+        self._given = set(answers)
         for field_id, answer in answers.items():
             if field_id not in self._questions:
                 _set(page, self._fields[field_id], field_id, answer)
         self._additional = self._read_additional(page)
+        self._additional_shown = [raw["id"] for raw in page.evaluate(_READ_ADDITIONAL)]
         if not self._questions:
             return
         if page.locator(ADDITIONAL).count():
             browser.click(page.locator("button:has-text('Save and continue')").first)
         answer_now = page.locator(ANSWER_NOW).first
-        answer_now.wait_for(timeout=SAVE_TIMEOUT_MS)
+        try:
+            answer_now.wait_for(timeout=SAVE_TIMEOUT_MS)
+        except Timeout:
+            if page.locator(ADDITIONAL).count():
+                raise NotTaken("the page would not save Additional information") from None
+            raise
         browser.click(answer_now)
         page.locator(QUESTIONS).first.wait_for(timeout=SAVE_TIMEOUT_MS)
         for field_id, answer in answers.items():
             if (question := self._questions.get(field_id)) is not None:
                 _answer(page, self._fields[field_id], question, answer)
 
+    def shown_fields(self, page: Page) -> list[str]:
+        """Additional information as it was saved, and the questions the page renders: a text
+        is known only by its title, which questions can share."""
+        by_title: dict[str, list[str]] = {}
+        for field_id, question in self._questions.items():
+            by_title.setdefault(question["title"], []).append(field_id)
+        for ids in by_title.values():
+            ids.sort(key=lambda i: i not in self._given)
+        shown = list(self._additional_shown)
+        for control in page.evaluate(_SHOWN_QUESTIONS) if page.locator(QUESTIONS).count() else []:
+            ids = by_title.get(control.removeprefix("input-"))
+            field_id = ids.pop(0) if ids else _question_id(control)
+            shown += [field_id] if field_id not in shown else []
+        return shown
+
     def _read_additional(self, page: Page) -> dict[str, Answer]:
         values = {raw["id"]: raw["value"] for raw in page.evaluate(_READ_ADDITIONAL)}
         return {k: v for k, v in values.items() if k in self._fields and v}
@@ -222,6 +269,23 @@ class Gupy:
         raise RuntimeError(f"{response.request.method} {response.url} answered {response.status}")
 
 
+def _additional_fields(raws: list[dict[str, Any]]) -> list[Field]:
+    """Additional information as the page has it, each radio before what its Yes shows."""
+    values = {raw["id"]: raw["value"] for raw in raws}
+    shown_by = {name for names in FOLLOW_UPS.values() for name in names}
+    fields = []
+    for raw in raws:
+        if raw["id"] in shown_by:
+            continue
+        fields.append(_additional(raw))
+        for name, label in FOLLOW_UPS.get(raw["id"], {}).items():
+            yes = Is(raw["id"], ["Yes"])
+            fields.append(
+                Field(name, label, FieldType.TEXT, True, prefilled=values.get(name), shown_when=yes)
+            )
+    return fields
+
+
 def _additional(raw: dict[str, Any]) -> Field:
     """A radio group is a choice; the source list, a combobox, is not filled."""
     name, label = raw["id"], raw["label"]
@@ -243,7 +307,8 @@ def _question(q: dict[str, Any]) -> Field:
         shown = Is(f"question-{q['parentQuestionId']}", q.get("conditionalTriggerOptions") or None)
     if kind is None:
         reason = f"unhandled_rendering: {q['title']!r} is a {q['type']} question"
-        return Field(field_id, q["title"], FieldType.TEXT, q["required"], unfillable=reason)
+        return Field(field_id, q["title"], FieldType.TEXT, q["required"], unfillable=reason,
+                     shown_when=shown)  # fmt: skip
     return Field(
         field_id, q["title"], kind, bool(q["required"]),
         options if kind is not FieldType.TEXT else None, prefilled=q.get("answer") or None,
@@ -251,6 +316,17 @@ def _question(q: dict[str, Any]) -> Field:
     )  # fmt: skip
 
 
+def _click(find: Callable[[], Locator]) -> None:
+    """Clicks what `find` finds: the page renders again as it loads, detaching what it found."""
+    for _ in range(CLICK_ATTEMPTS - 1):
+        try:
+            return browser.click(find())
+        except BrowserError as e:
+            if "not attached" not in str(e):
+                raise
+    browser.click(find())
+
+
 def _label(page: Page, selector: str, text: str) -> Locator:
     """The label, wrapping it, of the input `selector` matches whose text is `text`."""
     inputs = page.locator(selector)
@@ -263,7 +339,7 @@ def _label(page: Page, selector: str, text: str) -> Locator:
 def _set(page: Page, field: Field, field_id: str, answer: Answer) -> None:
     match field.type, answer:
         case FieldType.CHOICE, str():
-            browser.click(_label(page, f'main input[name="{field_id}"]', answer))
+            _click(lambda: _label(page, f'main input[name="{field_id}"]', answer))
         case FieldType.TEXT, str():
             page.locator(f'main input[name="{field_id}"], main input[id="{field_id}"]').fill(answer)
         case kind, _:
@@ -290,5 +366,11 @@ def _answer(page: Page, field: Field, question: dict[str, Any], answer: Answer)
             raise Unsupported(f"unhandled_rendering: cannot fill question-{qid}, a {kind}")
 
 
+def _question_id(control: str) -> str:
+    """The question of a radio or a checkbox's name; anything else as the page names it."""
+    box = re.fullmatch(r"checkbox-(\d+)-\d+", control)
+    return f"question-{box[1]}" if box else control
+
+
 def _css(text: str) -> str:
     return text.replace("\\", "\\\\").replace('"', '\\"')