atsfill 0.0.4.dev22__tar.gz → 0.0.4.dev25__tar.gz

{atsfill-0.0.4.dev22 → atsfill-0.0.4.dev25}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: atsfill
-Version: 0.0.4.dev22
+Version: 0.0.4.dev25
 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
@@ -53,7 +53,7 @@ It is built for agents with a shell: every command prints one JSON document and
 ## Supported hiring systems
 
 <!-- badges -->
-![oracle: dry run verified 2026-10-20](https://img.shields.io/badge/oracle-dry%20run%20verified%202026--10--20-7aa2f7) ![smartrecruiters: dry run verified 2026-10-20](https://img.shields.io/badge/smartrecruiters-dry%20run%20verified%202026--10--20-7aa2f7) ![greenhouse: dry run verified 2026-10-19](https://img.shields.io/badge/greenhouse-dry%20run%20verified%202026--10--19-7aa2f7) ![ashby: send verified 2026-10-19](https://img.shields.io/badge/ashby-send%20verified%202026--10--19-9ece6a) ![teamtailor: send verified 2026-10-20](https://img.shields.io/badge/teamtailor-send%20verified%202026--10--20-9ece6a) ![wttj: send verified 2026-10-20](https://img.shields.io/badge/wttj-send%20verified%202026--10--20-9ece6a)
+![oracle: dry run verified 2026-10-20](https://img.shields.io/badge/oracle-dry%20run%20verified%202026--10--20-7aa2f7) ![smartrecruiters: dry run verified 2026-10-20](https://img.shields.io/badge/smartrecruiters-dry%20run%20verified%202026--10--20-7aa2f7) ![greenhouse: dry run verified 2026-10-19](https://img.shields.io/badge/greenhouse-dry%20run%20verified%202026--10--19-7aa2f7) ![manatal: dry run verified 2026-10-20](https://img.shields.io/badge/manatal-dry%20run%20verified%202026--10--20-7aa2f7) ![paylocity: dry run verified 2026-10-20](https://img.shields.io/badge/paylocity-dry%20run%20verified%202026--10--20-7aa2f7) ![ashby: send verified 2026-10-19](https://img.shields.io/badge/ashby-send%20verified%202026--10--19-9ece6a) ![teamtailor: send verified 2026-10-20](https://img.shields.io/badge/teamtailor-send%20verified%202026--10--20-9ece6a) ![wttj: send verified 2026-10-20](https://img.shields.io/badge/wttj-send%20verified%202026--10--20-9ece6a)
 <!-- /badges -->
 
 | System | Account needed | `read` without a browser |

{atsfill-0.0.4.dev22 → atsfill-0.0.4.dev25}/README.md

@@ -29,7 +29,7 @@ It is built for agents with a shell: every command prints one JSON document and
 ## Supported hiring systems
 
 <!-- badges -->
-![oracle: dry run verified 2026-10-20](https://img.shields.io/badge/oracle-dry%20run%20verified%202026--10--20-7aa2f7) ![smartrecruiters: dry run verified 2026-10-20](https://img.shields.io/badge/smartrecruiters-dry%20run%20verified%202026--10--20-7aa2f7) ![greenhouse: dry run verified 2026-10-19](https://img.shields.io/badge/greenhouse-dry%20run%20verified%202026--10--19-7aa2f7) ![ashby: send verified 2026-10-19](https://img.shields.io/badge/ashby-send%20verified%202026--10--19-9ece6a) ![teamtailor: send verified 2026-10-20](https://img.shields.io/badge/teamtailor-send%20verified%202026--10--20-9ece6a) ![wttj: send verified 2026-10-20](https://img.shields.io/badge/wttj-send%20verified%202026--10--20-9ece6a)
+![oracle: dry run verified 2026-10-20](https://img.shields.io/badge/oracle-dry%20run%20verified%202026--10--20-7aa2f7) ![smartrecruiters: dry run verified 2026-10-20](https://img.shields.io/badge/smartrecruiters-dry%20run%20verified%202026--10--20-7aa2f7) ![greenhouse: dry run verified 2026-10-19](https://img.shields.io/badge/greenhouse-dry%20run%20verified%202026--10--19-7aa2f7) ![manatal: dry run verified 2026-10-20](https://img.shields.io/badge/manatal-dry%20run%20verified%202026--10--20-7aa2f7) ![paylocity: dry run verified 2026-10-20](https://img.shields.io/badge/paylocity-dry%20run%20verified%202026--10--20-7aa2f7) ![ashby: send verified 2026-10-19](https://img.shields.io/badge/ashby-send%20verified%202026--10--19-9ece6a) ![teamtailor: send verified 2026-10-20](https://img.shields.io/badge/teamtailor-send%20verified%202026--10--20-9ece6a) ![wttj: send verified 2026-10-20](https://img.shields.io/badge/wttj-send%20verified%202026--10--20-9ece6a)
 <!-- /badges -->
 
 | System | Account needed | `read` without a browser |

{atsfill-0.0.4.dev22 → atsfill-0.0.4.dev25}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.4.dev22"
+version = "0.0.4.dev25"
 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.4.dev22 → atsfill-0.0.4.dev25}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "atsfill"
-version = "0.0.4.dev22"
+version = "0.0.4.dev25"
 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.4.dev22 → atsfill-0.0.4.dev25}/src/atsfill/adapters/__init__.py

@@ -1,6 +1,8 @@
 from atsfill.adapters.ashby import Ashby
 from atsfill.adapters.greenhouse import Greenhouse
+from atsfill.adapters.manatal import Manatal
 from atsfill.adapters.oracle import Oracle
+from atsfill.adapters.paylocity import Paylocity
 from atsfill.adapters.smartrecruiters import SmartRecruiters
 from atsfill.adapters.teamtailor import Teamtailor
 from atsfill.adapters.wttj import WelcomeToTheJungle
@@ -13,4 +15,6 @@ ADAPTERS: list[Adapter] = [
     WelcomeToTheJungle(),
     SmartRecruiters(),
     Oracle(),
+    Manatal(),
+    Paylocity(),
 ]

atsfill-0.0.4.dev25/src/atsfill/adapters/manatal.py

@@ -0,0 +1,294 @@
+"""Manatal (`www.careers-page.com`), as docs/adapters/manatal.md observes.
+
+The apply page renders the fields its `application-form` endpoint lists and reads the inputs
+back only when Apply is clicked, so the inputs are the read-back.
+"""
+
+import json
+import re
+import urllib.request
+from collections.abc import Callable
+from typing import Any
+from urllib.parse import urlsplit
+
+from atsfill.core.adapter import Blocked, Unsupported
+from atsfill.core.browser import Page
+from atsfill.core.results import Answer, Field, FieldType, SideEffect
+
+HOST = "www.careers-page.com"
+API = f"https://{HOST}/api/v1.0/"
+HEADERS = {"User-Agent": "Mozilla/5.0", "Accept": "application/json"}
+JOB_ID = re.compile(r'const selectedJobId = "(\d+)"')
+TERMS_REQUIRED = re.compile(r'const isTCPPRequired = "True"')
+NUMBER = re.compile(r"\d+(\.\d+)?")  # what a number input with `min="0"` takes
+TERMS = "terms_and_condition"
+TERMS_LABEL = "I agree to the terms and conditions & privacy policy"
+YES_NO = ["Yes", "No"]
+GENDERS = ["Male", "Female", "Other"]
+NOTICE_PERIODS = ["Immediately", *(f"{d} days" for d in range(10, 130, 10)), "120+ days"]
+YEARS = ["No experience", *(f"{n}+ year" for n in range(1, 21))]
+# Slugs shown as a multiple select of a list fetched apart: its path and an item's label.
+LISTS: dict[str, tuple[str, Callable[[dict[str, Any]], str]]] = {
+    "nationalities": ("nationalities/", lambda n: f"{n['demonym']} ({n['common_name']})"),
+    "languages": ("languages/", lambda n: n["name"]),
+    "industries": ("clients/{client}/industries/", lambda n: n["name"]),
+}
+ENTRIES = ("educations", "experiences")  # a sub-form of entries: left out when optional
+SHORT = {"full_name", "email", "phone_number", "city", "address", "latest_degree",
+         "latest_university", "current_company", "current_department", "current_position",
+         "current_benefits", "expected_benefits", "skype", "contact"}  # fmt: skip
+RESUME_TYPES = [".pdf", ".doc", ".docx", ".rtf"]
+LOAD_TIMEOUT_MS = 30_000
+SUBMIT_TIMEOUT_MS = 120_000
+
+# The answer each input holds, by field id, read as the page reads them on Apply.
+_READ = """fields => Object.fromEntries(fields.map(([id, kind]) => {
+  const el = document.getElementById('field' + id);
+  const named = [...document.querySelectorAll(`input[name="${id}"]`)];
+  const texts = s => [...s.selectedOptions].filter(o => o.value).map(o => o.text.trim());
+  switch (kind) {
+    case 'file': return [id, el && el.files.length ? el.files[0].name : null];
+    case 'boolean': return [id, el.checked ? 'Yes' : 'No'];
+    case 'radio': return [id, (named.find(i => i.checked) || {}).value || null];
+    case 'checkbox': return [id, named.filter(i => i.checked).map(i => i.value)];
+    case 'select': return [id, texts(el)[0] || null];
+    case 'multiple': return [id, texts(el)];
+    case 'terms': return [id, document.querySelector(`input[name="${id}"]`).checked ? 'Yes' : 'No'];
+    default: return [id, el ? el.value || null : null];
+  }
+}))"""
+# Selects the options with these labels on a select2 multiple select, which select2 follows.
+_SELECT = """(el, labels) => {
+  for (const o of el.options) o.selected = labels.includes(o.text.trim());
+  el.dispatchEvent(new Event('change', {bubbles: true}));
+}"""
+# Clicks a radio or a box when its state differs: the styled mark over it can sit outside the
+# viewport, out of reach of a pointer click.
+_CHECK = """(el, checked) => { if (el.checked !== checked) el.click(); }"""
+# Types a date into flatpickr's read-only input, in the `Y-m-d` format it is set up with.
+_DATE = """(el, value) => {
+  el.value = value;
+  el.dispatchEvent(new Event('change', {bubbles: true}));
+}"""
+
+
+def _posting(url: str) -> str:
+    """`https://www.careers-page.com/<client>/job/<code>`, without `/apply` or a query."""
+    client, _, code = urlsplit(url).path.strip("/").split("/")[:3]
+    return f"https://{HOST}/{client}/job/{code}"
+
+
+def _kind(entry: dict[str, Any]) -> str:
+    """How the page renders the field: the input `_READ` and `fill` work on."""
+    slug, ftype = entry["client_field_slug"], entry["client_field_field_type"]
+    if entry["field_type"] in ("resume", "attachment"):
+        return "file"
+    if entry["field_type"] in ENTRIES:
+        return "entries"
+    if entry["field_type"] == "candidate_field":
+        if slug in ("gender", "current_notice_period", "years_of_experience"):
+            return "select"
+        if slug in LISTS or ftype == "multiple_select_dropdown":
+            return "multiple"
+        if ftype == "dropdown":
+            return "select"
+        if ftype == "multiple_choice":
+            return "radio"
+        if ftype == "checkbox":
+            return "checkbox"
+    match entry["response_type"]:
+        case "boolean":
+            return "boolean"
+        case "datetime":
+            return "date"
+        case "integer":
+            return "number"
+    return "text"
+
+
+def _field(entry: dict[str, Any], options: list[str] | None) -> Field | None:
+    """The field an entry of the endpoint lists, None for optional entries."""
+    kind, slug = _kind(entry), entry["client_field_slug"]
+    fid, label, required = str(entry["id"]), entry["label"], bool(entry["is_required"])
+    match kind:
+        case "entries" if required:
+            raise Unsupported(f"form_shape: {entry['field_type']} entries are required")
+        case "entries":
+            return None
+        case "file":
+            accept = RESUME_TYPES if entry["field_type"] == "resume" else None
+            return Field(fid, label, FieldType.FILE, required, accept=accept)
+        case "boolean":
+            return Field(fid, label, FieldType.CHOICE, required, YES_NO)
+        case "date":
+            return Field(fid, label, FieldType.DATE, required)
+        case "select" | "radio":
+            return Field(fid, label, FieldType.CHOICE, required, options)
+        case "multiple" | "checkbox":
+            return Field(fid, label, FieldType.MULTI_CHOICE, required, options)
+        case "number":
+            return Field(fid, f"{label} (a number)", FieldType.TEXT, required)
+    if slug == "phone_number":
+        return Field(fid, label, FieldType.PHONE, required)
+    short = 255 if slug in SHORT or entry["field_type"] == "other" else 1000
+    return Field(fid, label, FieldType.TEXT, required, max_length=short)
+
+
+def _get(path: str) -> Any:
+    request = urllib.request.Request(API + path, headers=HEADERS)
+    with urllib.request.urlopen(request, timeout=20) as response:
+        return json.load(response)
+
+
+def _options(entry: dict[str, Any], client: str) -> list[str] | None:
+    """The options the endpoint's entry names, the page's fixed lists or a list fetched apart."""
+    match entry["client_field_slug"]:
+        case "gender":
+            return GENDERS
+        case "current_notice_period":
+            return NOTICE_PERIODS
+        case "years_of_experience":
+            return YEARS
+        case slug if slug in LISTS:
+            path, label = LISTS[slug]
+            return [label(n) for n in _get(path.format(client=client))]
+    return entry["client_field_answer_choices"] or None
+
+
+class Manatal:
+    name = "manatal"
+    side_effects = [
+        SideEffect("submit", "hiring_system", "the resume and attachments are uploaded"),
+        SideEffect("submit", "employer", "the application reaches the employer"),
+    ]
+
+    def __init__(self) -> None:
+        self._entries: list[dict[str, Any]] = []
+
+    def detect(self, url: str, page: Page | None) -> bool:
+        parts = urlsplit(url).path.strip("/").split("/")
+        return urlsplit(url).hostname == HOST and len(parts) >= 3 and parts[1] == "job"
+
+    def posting(self, url: str) -> str:
+        return _posting(url)
+
+    def read_api(self, url: str) -> list[Field] | None:
+        """The fields from the endpoint the apply page fetches, its job id from that page."""
+        client = urlsplit(url).path.strip("/").split("/")[0]
+        try:
+            apply = urllib.request.Request(_posting(url) + "/apply", headers=HEADERS)
+            with urllib.request.urlopen(apply, timeout=20) as response:
+                html = response.read().decode()
+            job = JOB_ID.search(html)
+            if job is None:
+                return None
+            entries = _get(f"jobs/{job.group(1)}/application-form/")
+            terms = bool(TERMS_REQUIRED.search(html))
+            return self._fields(entries, terms, lambda e: _options(e, client))
+        except OSError, ValueError, KeyError, TypeError, Unsupported:
+            return None
+
+    def read_form(self, page: Page) -> list[Field]:
+        with page.expect_response(
+            lambda r: r.request.method == "GET" and "/application-form/" in r.url,
+            timeout=LOAD_TIMEOUT_MS,
+        ) as loaded:
+            page.goto(_posting(page.url) + "/apply")
+        response = loaded.value
+        if response.headers.get("x-amzn-waf-action") == "challenge":
+            raise Blocked("captcha: AWS WAF challenge")
+        if not response.ok:
+            raise Unsupported(f"posting_gone: the form answered {response.status}")
+        self._entries = response.json()
+        page.wait_for_selector("#submit-id-submit", timeout=LOAD_TIMEOUT_MS)
+        # The lists of a multiple select come in their own requests, once the form is drawn.
+        page.wait_for_function(
+            "() => [...document.querySelectorAll('select.multiselect')]"
+            ".every(s => s.options.length && s.classList.contains('select2-hidden-accessible'))",
+            timeout=LOAD_TIMEOUT_MS,
+        )
+        terms = page.locator(f'input[name="{TERMS}"]').count() > 0
+        return self._fields(self._entries, terms, lambda e: self._shown(page, e))
+
+    def fill(self, page: Page, answers: dict[str, Answer]) -> None:
+        kinds = {str(e["id"]): _kind(e) for e in self._entries} | {TERMS: "terms"}
+        for field_id, answer in answers.items():
+            box = page.locator(f"#field{field_id}")
+            named = page.locator(f'input[name="{field_id}"]')
+            match kinds.get(field_id), answer:
+                case "text", str():
+                    box.fill(answer)
+                case "number", str() if NUMBER.fullmatch(answer.strip()):
+                    box.fill(answer.strip())
+                case "number", str():
+                    pass  # a number input holds no text: it reads back empty
+                case "date", str():
+                    box.evaluate(_DATE, answer)
+                case "file", str():
+                    box.set_input_files(answer)
+                case "select", str():
+                    box.select_option(label=answer)
+                case "multiple", list():
+                    box.evaluate(_SELECT, answer)
+                case "radio", str():
+                    named.and_(
+                        page.locator(f"[value={json.dumps(answer, ensure_ascii=False)}]")
+                    ).evaluate(_CHECK, True)
+                case "checkbox", list():
+                    for value in answer:
+                        named.and_(
+                            page.locator(f"[value={json.dumps(value, ensure_ascii=False)}]")
+                        ).evaluate(_CHECK, True)
+                case "boolean", str():
+                    box.evaluate(_CHECK, answer == "Yes")
+                case "terms", str():
+                    named.evaluate(_CHECK, answer == "Yes")
+                case kind, _:
+                    raise Unsupported(
+                        f"form_shape: cannot fill {field_id}, a {kind}, with {answer!r}"
+                    )
+
+    def read_back(self, page: Page) -> dict[str, Answer]:
+        kinds = [[str(e["id"]), _kind(e)] for e in self._entries if _kind(e) != "entries"]
+        if page.locator(f'input[name="{TERMS}"]').count():
+            kinds.append([TERMS, "terms"])
+        held = page.evaluate(_READ, kinds)
+        return {k: v for k, v in held.items() if v not in (None, [])}
+
+    def submit(self, page: Page) -> str | None:
+        with page.expect_response(
+            lambda r: r.request.method == "POST" and "/application-form/" in r.url,
+            timeout=SUBMIT_TIMEOUT_MS,
+        ) as submitted:
+            page.locator("#submit-id-submit").click()
+        response = submitted.value
+        if response.headers.get("x-amzn-waf-action") in ("challenge", "captcha"):
+            raise Blocked("captcha: AWS WAF challenge")
+        if not response.ok:
+            raise Blocked(f"form_errors: {response.status} {response.text()[:300]}")
+        return f"POST application-form → {response.status} ({page.url})"
+
+    def _fields(
+        self,
+        entries: list[dict[str, Any]],
+        terms: bool,
+        options: Callable[[dict[str, Any]], list[str] | None],
+    ) -> list[Field]:
+        fields = [f for e in entries if (f := _field(e, options(e))) is not None]
+        if terms:
+            fields.append(Field(TERMS, TERMS_LABEL, FieldType.CHOICE, True, YES_NO))
+        return fields
+
+    @staticmethod
+    def _shown(page: Page, entry: dict[str, Any]) -> list[str] | None:
+        """The options the page shows for a choice, without the empty placeholder."""
+        match _kind(entry):
+            case "select" | "multiple":
+                return page.locator(f"#field{entry['id']} option").evaluate_all(
+                    "os => os.filter(o => o.value).map(o => o.text.trim())"
+                )
+            case "radio" | "checkbox":
+                return page.locator(f'input[name="{entry["id"]}"]').evaluate_all(
+                    "is => is.map(i => i.value)"
+                )
+        return None

atsfill-0.0.4.dev25/src/atsfill/adapters/paylocity.py

@@ -0,0 +1,632 @@
+"""Paylocity Recruiting (`recruiting.paylocity.com/Recruiting/Jobs/...`), as
+docs/adapters/paylocity.md observes.
+
+The apply page carries the whole form's configuration in `window.pageData`: the sections and
+their fields, the screener questions and the option lists. `read_api` fetches it over HTTP,
+`read_form` takes it from the page, and both list the fields from it. The form is one page or
+a wizard of steps that render one at a time, so `fill` keeps each step's read-back before
+moving on; nothing reaches the employer before Submit.
+"""
+
+import json
+import re
+import urllib.request
+from contextlib import suppress
+from dataclasses import dataclass
+from datetime import date
+from pathlib import Path
+from typing import Any
+from urllib.parse import urlsplit
+
+from atsfill.core.adapter import Unsupported
+from atsfill.core.browser import Locator, Page, Timeout
+from atsfill.core.results import Answer, Field, FieldType, SideEffect
+
+HOST = "recruiting.paylocity.com"
+JOB = re.compile(r"^/Recruiting/Jobs/(?:Details|Apply)/(\d+)", re.IGNORECASE)
+APPLY = f"https://{HOST}/Recruiting/Jobs/Apply/"
+PAGE_DATA = "window.pageData ="
+NEXT = "[data-automation-id=btnNext]"
+SUBMIT = "[data-automation-id=btnSubmit]"
+STEP = "#appDetailDiv .type-bold.float-right"  # "Step 2 of 5"
+FORCED_RESUME = ".modal.in #btn-forceResume"
+FORM_TIMEOUT_MS = 30_000
+STEP_TIMEOUT_MS = 20_000
+UPLOAD_TIMEOUT_MS = 30_000
+SUBMIT_TIMEOUT_MS = 90_000
+YES_NO = ["Yes", "No"]
+ADDRESS = "public-site-address"  # an address block: its inputs' ids start with this
+COMPANY = "public-candidate-work-history-address-0"
+
+
+@dataclass(frozen=True)
+class Spec:
+    """One control a pageData field renders as. `required` None takes the field's own."""
+
+    dom: str  # the element id; a radio group's name; `{n}` for an entry's index
+    label: str
+    kind: str  # a key of TYPES
+    required: bool | None = None
+    options: str | list[str] | None = None  # a list, or the pageData key of one
+    when: tuple[str, str] | None = None  # asked only when (control, answer)
+    max_length: int | None = None
+
+
+def _yes_no(dom: str, label: str) -> Spec:
+    return Spec(dom, label, "dropdown", options=YES_NO)
+
+
+WORKED_BEFORE = ("info.haveYouWorkedWithUsBefore", "Yes")
+INFO: dict[str, list[Spec]] = {
+    "name": [
+        Spec("info.firstName", "First Name", "text", True),
+        Spec("info.lastName", "Last Name", "text", True),
+        Spec("info.middleName", "Middle Name", "text", False),
+        Spec("info.preferredName", "Preferred First Name", "text", False),
+    ],
+    "emailAddress": [Spec("info.email", "Email Address", "text")],
+    "cellPhone": [Spec("info.cellPhone", "Mobile Number", "phone")],
+    "homePhone": [Spec("info.phone", "Home Phone Number", "phone")],
+    "smsOptedIn": [_yes_no("info.smsOptedIn", "")],
+    "appliedBefore": [_yes_no("info.haveYouAppliedWithUsBefore", "")],
+    "workedHereBefore": [
+        _yes_no(WORKED_BEFORE[0], ""),
+        Spec("info.priorEmploymentPositionHeld", "Position", "text", False, when=WORKED_BEFORE),
+        Spec("info.priorEmploymentStartDate", "Start Date", "date", False, when=WORKED_BEFORE),
+        Spec("info.priorEmploymentEndDate", "End Date", "date", False, when=WORKED_BEFORE),
+    ],
+    "address": [
+        Spec(f"{ADDRESS}-address-1", "Address Line 1", "address", max_length=50),
+        Spec(f"{ADDRESS}-county", "County", "text", max_length=50),
+    ],
+    "address2": [Spec(f"{ADDRESS}-address-2", "Address Line 2", "text", max_length=50)],
+    "city": [Spec(f"{ADDRESS}-city", "City", "text", max_length=50)],
+    "state": [Spec(f"{ADDRESS}-us-state", "State", "state", options="statesOptions")],
+    "postalCode": [Spec(f"{ADDRESS}-zip", "Zip Code", "text", max_length=20)],
+    "dateAvailable": [Spec("info.dateAvailableToStart", "Available to Start", "date")],
+    "linkedInUrl": [Spec("info.linkedIn", "LinkedIn Profile URL", "text")],
+    "howDidYouHear": [Spec("info.howDidYouHearAboutUs", "", "radio", options="values")],
+    "referredBy": [Spec("info.referredBy", "Referred by", "text")],
+    "skills": [Spec("info.skills", "Skills", "tags")],
+    "uploadCoverLetter": [Spec("btn-coverLetter", "Cover Letter", "file")],
+    "uploadAdditionalFiles": [Spec("btn-additionalFiles", "Additional Files", "file")],
+}
+SALARY = {  # by desiredSalaryInputType
+    1: [
+        Spec("info.minimumDesiredSalary", "Desired Salary (minimum)", "text"),
+        Spec("info.maximumDesiredSalary", "Desired Salary (maximum)", "text"),
+    ],
+    2: [Spec("info.desiredSalaryDescription", "Desired Salary", "text")],
+}
+# Shown on their own: the country (United States until changed), the EEO identity questions.
+OPTIONAL_ONLY = {"country", "dni", "ethnicity", "genderIdentity", "personalPronoun",
+                 "sexualOrientation", "eVerify", "priorConviction"}  # fmt: skip
+CONTACT = ("workHistory.mayWeContactSupervisor.0", "Yes")
+GRADUATED = ("educationHistory.didYouGraduate.0", "Yes")
+WORK: dict[str, list[Spec]] = {
+    "companyName": [Spec("workHistory.companyName.0", "Company Name", "text")],
+    "position": [Spec("workHistory.position.0", "Position", "text")],
+    "companyPhone": [Spec("workHistory.companyPhone.0", "Company Phone Number", "phone")],
+    "responsibilities": [Spec("workHistory.responsibilities.0", "Responsibilities", "text")],
+    "startEndDate": [
+        Spec("txt-workHistory-startDate-0", "Start Date (MM/YYYY)", "month"),
+        Spec("txt-workHistory-endDate-0", "End Date (MM/YYYY)", "month"),
+    ],
+    "reasonForLeaving": [Spec("workHistory.reasonForLeaving.0", "Reason for Leaving", "text")],
+    "companyLocation": [
+        Spec(f"{COMPANY}-address-1", "Company Address Line 1", "address", max_length=50),
+        Spec(f"{COMPANY}-address-2", "Company Address Line 2", "text", False, max_length=50),
+        Spec(f"{COMPANY}-city", "Company City", "text", max_length=50),
+        Spec(f"{COMPANY}-county", "Company County", "text", max_length=50),
+        Spec(f"{COMPANY}-us-state", "Company State", "state", options="statesOptions"),
+        Spec(f"{COMPANY}-zip", "Company Zip Code", "text", max_length=20),
+    ],
+    "currentlyWorkingHere": [
+        Spec(
+            "workHistory.currentlyWorkingHere.0",
+            "Currently Working Here",
+            "check",
+            False,
+            ["No", "Yes"],
+        )  # fmt: skip
+    ],
+    "mayWeContact": [_yes_no(CONTACT[0], "May We Contact for Reference?")],
+    "contactSupervisorName": [
+        Spec("workHistory.supervisorName.0", "Supervisor Name", "text", False, when=CONTACT)
+    ],
+    "contactSupervisorPosition": [
+        Spec("workHistory.supervisorPosition.0", "Supervisor Position", "text", False, when=CONTACT)
+    ],
+    "contactSupervisorPhone": [
+        Spec(
+            "workHistory.supervisorPhone.0", "Supervisor Phone Number", "phone", False, when=CONTACT
+        )
+    ],  # fmt: skip
+    "contactSupervisorEmail": [
+        Spec(
+            "workHistory.supervisorEmail.0", "Supervisor Email Address", "text", False, when=CONTACT
+        )
+    ],  # fmt: skip
+}
+EDUCATION: dict[str, list[Spec]] = {
+    "certsOrAwards": [
+        Spec("educationHistory.certificationsAndAwards", "Certifications & Awards", "tags")
+    ],
+    "schoolName": [Spec("educationHistory.name.0", "School Name", "text")],
+    "areaOfStudy": [Spec("educationHistory.areaOfStudy.0", "Area of Study", "text")],
+    "didYouGraduate": [
+        Spec(GRADUATED[0], "Did you Graduate?", "dropdown", options="graduationOptions")
+    ],
+    "degreeObtained": [
+        Spec(
+            "educationHistory.degreeId.0",
+            "Degree Obtained",
+            "dropdown",
+            False,
+            "degreeOptions",
+            GRADUATED,
+        )
+    ],  # fmt: skip
+    "schoolType": [
+        Spec("educationHistory.type.0", "School Type", "dropdown", options="schoolTypeOptions")
+    ],
+    "schoolLocation": [
+        Spec("educationHistory.city.0", "School City", "text"),
+        Spec("educationHistory.state.0", "School State", "dropdown", options="statesOptions"),
+    ],
+}
+REFERENCE: dict[str, list[Spec]] = {
+    "referenceName": [Spec("references.name.{n}", "Name", "text")],
+    "referenceEmail": [Spec("references.email.{n}", "Email Address", "text")],
+    "referencePhoneNumber": [Spec("references.phone.{n}", "Phone Number", "phone")],
+    "referencePersonalOrWork": [
+        Spec(
+            "references.referenceType.{n}",
+            "Personal or Work Reference?",
+            "dropdown",
+            options="referenceTypeOptions",
+        )
+    ],  # fmt: skip
+    "referenceYearsKnown": [
+        Spec(
+            "references.yearsKnown.{n}",
+            "Years Known",
+            "dropdown",
+            options=["1 year", *(f"{n} years" for n in range(2, 6))],
+        )
+    ],  # fmt: skip
+}
+ACKNOWLEDGEMENTS: dict[str, list[Spec]] = {
+    "eeoGenderEthnicity": [
+        Spec("acknowledgements.eeoGender", "Gender", "dropdown", options="genderOptions"),
+        Spec(
+            "acknowledgements.racialOrEthnicGroup",
+            "Race and/or Ethnicity",
+            "dropdown",
+            options="raceOptions",
+        ),
+    ],  # fmt: skip
+    "ofccp": [
+        Spec(
+            "acknowledgements.militaryService",
+            "Veteran Status",
+            "dropdown",
+            options="militaryServiceOptions",
+        )
+    ],  # fmt: skip
+    "eeoDisability": [
+        Spec(
+            "acknowledgements.disability",
+            "Disability Status",
+            "dropdown",
+            options="disabilityOptions",
+        )
+    ],  # fmt: skip
+    "priorFelony": [_yes_no("acknowledgements.priorFelony", "")],
+    "priorMisdemeanor": [_yes_no("acknowledgements.priorMisdemeanor", "")],
+    "authorizedToWork": [_yes_no("acknowledgements.authorizedToWorkInUs", "")],
+}
+# Fields shown only when the form also has another, which switches them on.
+SHOWN_WITH = {
+    "priorFelony": "priorConviction",
+    "priorMisdemeanor": "priorConviction",
+    **{f"contactSupervisor{k}": "mayWeContact" for k in ("Name", "Position", "Phone", "Email")},
+}
+SECTIONS = {
+    "info": INFO,
+    "workHistory": WORK,
+    "educationHistory": EDUCATION,
+    "references": REFERENCE,
+    "acknowledgements": ACKNOWLEDGEMENTS,
+    "expandedIdentityQuestions": {},
+}
+ENTRIES = ("workHistory", "educationHistory")  # one entry shown when required, none else
+ENTRY = re.compile(r"[.-]0(-|$)")  # an entry's control, by its index
+RESUME = Spec("btn-resume", "Resume", "file")
+ACKNOWLEDGE = Spec("applyAcknowledgement", "I have read and accept the above acknowledgement",
+                   "check", True, YES_NO)  # fmt: skip
+FILE_IDS = {"btn-resume": "resume", "btn-coverLetter": "coverLetter",
+            "btn-additionalFiles": "additionalFiles"}  # fmt: skip
+TYPES = {
+    "text": FieldType.TEXT,
+    "address": FieldType.TEXT,
+    "month": FieldType.TEXT,
+    "tags": FieldType.TEXT,
+    "phone": FieldType.PHONE,
+    "date": FieldType.DATE,
+    "dropdown": FieldType.CHOICE,
+    "state": FieldType.CHOICE,
+    "radio": FieldType.CHOICE,
+    "check": FieldType.CHOICE,
+    "screener": FieldType.CHOICE,
+    "screener_multi": FieldType.MULTI_CHOICE,
+    "screener_text": FieldType.TEXT,
+    "file": FieldType.FILE,
+}
+
+
+@dataclass(frozen=True)
+class Control:
+    kind: str
+    dom: str
+    options: list[str] | None = None
+
+
+class Paylocity:
+    name = "paylocity"
+    side_effects = [
+        SideEffect("upload", "hiring_system", "an attached file is stored by Paylocity at once"),
+        SideEffect("fill", "hiring_system", "each step's answers go to Paylocity for validation"),
+        SideEffect("submit", "employer", "the application reaches the employer"),
+    ]  # fmt: skip
+
+    def __init__(self) -> None:
+        self._form: list[tuple[Field, Control]] = []
+        self._values: dict[str, Answer] = {}  # the read-back of the steps left behind
+
+    def detect(self, url: str, page: Page | None) -> bool:
+        return _job(url) is not None
+
+    def posting(self, url: str) -> str:
+        job = _job(url)
+        return f"https://{HOST}/Recruiting/Jobs/Details/{job}" if job else url
+
+    def read_api(self, url: str) -> list[Field] | None:
+        if (job := _job(url)) is None:
+            return None
+        request = urllib.request.Request(APPLY + job, headers={"User-Agent": "atsfill"})
+        try:
+            with urllib.request.urlopen(request, timeout=20) as response:
+                html = response.read().decode()
+            return [f for f, _ in _form(_page_data(html))]
+        except OSError, ValueError, KeyError, TypeError, Unsupported:
+            return None
+
+    def read_form(self, page: Page) -> list[Field]:
+        job = _job(page.url)
+        if job and "/apply/" not in page.url.lower():
+            page.goto(APPLY + job)
+        try:
+            page.locator(f"{NEXT}, {SUBMIT}").first.wait_for(
+                state="attached", timeout=FORM_TIMEOUT_MS
+            )
+            self._form = _form(_page_data(page.content()))
+        except Timeout, ValueError, KeyError:
+            raise Unsupported("posting_gone: no application form on the page") from None
+        return [f for f, _ in self._form]
+
+    def fill(self, page: Page, answers: dict[str, Answer]) -> None:
+        self._values = {}
+        page.locator("form, #app").first.wait_for(timeout=FORM_TIMEOUT_MS)
+        _dismiss_cookies(page)
+        if "resume" in answers:  # first: a parsed resume fills fields the answers then override
+            _upload_resume(page, _one(answers["resume"]))
+        while True:
+            for field, control in self._form:
+                if field.id in answers and field.id != "resume" and _present(page, control):
+                    _fill(page, control, answers[field.id])
+            self._values.update(self._read(page))
+            if not page.locator(NEXT).count() or not _next(page):
+                return
+
+    def read_back(self, page: Page) -> dict[str, Answer]:
+        values = {**self._values, **self._read(page)}
+        return {k: v for k, v in values.items() if v not in (None, "", [])}
+
+    def submit(self, page: Page) -> str | None:
+        before = page.url
+        page.locator(SUBMIT).click()
+        page.wait_for_url(lambda url: url != before, timeout=SUBMIT_TIMEOUT_MS)
+        return page.url
+
+    def _read(self, page: Page) -> dict[str, Answer]:
+        values: dict[str, Answer] = {}
+        for field, control in self._form:
+            if _present(page, control) and (value := _read(page, control)) is not None:
+                values[field.id] = value
+        return values
+
+
+def _job(url: str) -> str | None:
+    parts = urlsplit(url)
+    if parts.hostname != HOST or not (match := JOB.match(parts.path)):
+        return None
+    return match[1]
+
+
+def _page_data(html: str) -> dict[str, Any]:
+    """The apply page's `window.pageData`, from its inline script."""
+    start = html.index(PAGE_DATA) + len(PAGE_DATA)
+    return json.JSONDecoder().raw_decode(html[start:].lstrip())[0]
+
+
+def _form(data: dict[str, Any]) -> list[tuple[Field, Control]]:
+    """The fields and their controls, in the page's order, from the apply page's pageData."""
+    custom = data["customJobApplication"]
+    out: list[tuple[Field, Control]] = []
+    labels: dict[str, str] = {}
+
+    def add(spec: Spec, field: dict[str, Any], prefix: str = "", n: int = 0) -> None:
+        dom = spec.dom.format(n=n)
+        options = spec.options
+        if options == "values":
+            options = [v["value"] for v in field["values"]]
+        elif isinstance(options, str):
+            listed = [o for o in data.get(options) or [] if o.get("text")]
+            options = [o["value" if spec.kind == "state" else "text"] for o in listed]
+        label = prefix + (spec.label or _plain(field["displayName"]))
+        required = field["isRequired"] if spec.required is None else spec.required
+        if spec.when:
+            trigger, value = spec.when
+            label += f" (asked when {labels.get(trigger, trigger)!r} is {value})"
+        labels[dom] = label
+        field_id = FILE_IDS.get(dom, dom)
+        out.append((Field(field_id, label, TYPES[spec.kind], bool(required), options,
+                          spec.max_length),
+                    Control(spec.kind, dom, options)))  # fmt: skip
+
+    add(RESUME, {"isRequired": bool(custom.get("requireResume") or data.get("requireResume"))})
+    for section in custom["sections"]:
+        if not section["isIncluded"]:
+            continue
+        name = section["name"]
+        entries = name not in ENTRIES or section["isOneRequired"]
+        count = 1
+        if name == "references":
+            if not custom.get("referencesRequired"):
+                continue
+            count = custom.get("referencesRequiredCount") or 1
+        vocabulary = SECTIONS.get(name)
+        if vocabulary is None:
+            raise Unsupported(f"form_shape: unknown section {name!r}")
+        included = {f["name"] for f in section["fields"] if f["isIncluded"]}
+        for n in range(count):
+            prefix = f"Reference {n + 1}: " if name == "references" else ""
+            for field in section["fields"]:
+                if not field["isIncluded"]:
+                    continue
+                specs = vocabulary.get(field["name"])
+                if field["name"] == "desiredSalary":
+                    specs = SALARY.get(custom.get("desiredSalaryInputType"))
+                if specs is None:
+                    if entries and field["isRequired"] and field["name"] not in OPTIONAL_ONLY:
+                        raise Unsupported(
+                            f"form_shape: {_plain(field['displayName'])!r} ({field['name']}) "
+                            "is not handled"
+                        )
+                    continue
+                if SHOWN_WITH.get(field["name"], field["name"]) not in included:
+                    continue
+                for spec in specs:
+                    if entries or not ENTRY.search(spec.dom):  # the section's own fields show
+                        add(spec, field, prefix, n)
+    screener = data.get("screener") or {}
+    for i, question in enumerate(screener.get("questions") or []):
+        kind = question.get("questionType")
+        answers = [a["title"] for a in question.get("answers") or []]
+        if kind == "multi":
+            kind = "screener_multi" if question.get("allowsMultipleResponses") else "screener"
+            dom = f"multiQuestionAnswer{question['screenerQuestionId']}"
+        elif kind == "text":
+            kind, answers, dom = "screener_text", None, f"screener-question-{i}-textarea"
+        else:
+            raise Unsupported(f"form_shape: a {kind} screener question")
+        field_id = f"screener.{question['screenerQuestionId']}"
+        out.append((Field(field_id, _plain(question["title"]), TYPES[kind],
+                          bool(question.get("isRequired")), answers),
+                    Control(kind, dom, answers)))  # fmt: skip
+    add(ACKNOWLEDGE, {"isRequired": True})
+    return out
+
+
+def _plain(text: str) -> str:
+    return re.sub(r"\s+", " ", re.sub(r"<[^>]+>", " ", text or "")).strip()
+
+
+def _one(answer: Answer) -> str:
+    return answer if isinstance(answer, str) else answer[0]
+
+
+def _by_id(page: Page, dom: str) -> Locator:
+    """The control: the last step reviews the others' answers in elements with their ids."""
+    return page.locator(f"input[id='{dom}'], textarea[id='{dom}'], .rw-dropdownlist[id='{dom}']")
+
+
+def _present(page: Page, control: Control) -> bool:
+    match control.kind:
+        case "radio":
+            return page.locator(f"input[name='{control.dom}']").count() > 0
+        case "screener" | "screener_multi":
+            label = page.locator(f"label[for='{control.dom}_0']")
+            return label.count() > 0 and label.first.is_visible()
+        case "file":
+            return _by_id(page, control.dom).count() > 0 or (
+                control.dom == "btn-resume" and page.locator("#remove-resume").count() > 0
+            )
+        case "state":
+            return page.locator(f"#{control.dom}-select-wrapper").count() > 0
+        case _:
+            target = _by_id(page, control.dom)
+            return target.count() == 1 and target.is_visible()
+
+
+def _dismiss_cookies(page: Page) -> None:
+    close = page.locator("#onetrust-banner-sdk .onetrust-close-btn-handler")
+    with suppress(Timeout):
+        close.first.wait_for(state="visible", timeout=5_000)
+        close.first.click()
+
+
+def _upload_resume(page: Page, path: str) -> None:
+    forced = page.locator(FORCED_RESUME)
+    if forced.count():
+        target = forced
+    else:
+        parse = page.locator("#useAttachedResumeToFillOutApplication")
+        if parse.count() and parse.is_checked():
+            parse.uncheck()
+        target = page.locator("#btn-resume")
+        if not target.count():
+            return
+    target.set_input_files(path)
+    with suppress(Timeout):
+        page.locator("#remove-resume").wait_for(timeout=UPLOAD_TIMEOUT_MS)
+    page.locator(".modal.in").wait_for(state="detached", timeout=UPLOAD_TIMEOUT_MS)
+
+
+def _next(page: Page) -> bool:
+    """Goes on to the next step; False when the page stays (an answer it does not accept)."""
+    step = page.locator(STEP)
+    before = step.inner_text() if step.count() else None
+    page.locator(NEXT).click()
+    try:
+        page.wait_for_function(
+            """before => {
+                const s = document.querySelector("#appDetailDiv .type-bold.float-right");
+                return (s ? s.textContent : null) !== before;
+            }""",
+            arg=before,
+            timeout=STEP_TIMEOUT_MS,
+        )
+    except Timeout:
+        return False
+    page.wait_for_timeout(500)
+    return True
+
+
+def _pick(page: Page, dom: str, value: str) -> None:
+    """A react-widgets dropdown: its list opens on a click."""
+    _by_id(page, dom).click()
+    options = page.locator(f"[id='{dom}__listbox'] [role=option]")
+    for n in range(options.count()):
+        if options.nth(n).inner_text().strip().rstrip("*") == value:
+            options.nth(n).click()
+            return
+    page.keyboard.press("Escape")
+
+
+def _fill(page: Page, control: Control, answer: Answer) -> None:
+    value = _one(answer)
+    target = _by_id(page, control.dom)
+    match control.kind:
+        case "text" | "phone" | "screener_text":
+            target.fill(value)
+            target.blur()
+        case "address":  # a suggestion list that drops keys typed while it loads
+            target.click()
+            target.fill("")
+            target.press_sequentially(value, delay=80)
+            page.keyboard.press("Escape")
+            if target.input_value() != value:
+                target.fill(value)
+            target.blur()
+        case "date":
+            if re.fullmatch(r"\d{4}-\d{2}-\d{2}", value):
+                y, m, d = value.split("-")
+                target.click()
+                target.press_sequentially(f"{m}/{d}/{y}", delay=30)
+                target.blur()
+        case "month":
+            target.click()
+            target.press_sequentially(value, delay=30)
+            target.blur()
+        case "dropdown":
+            _pick(page, control.dom, value)
+        case "state":
+            page.locator(f"#{control.dom}-select-wrapper").click()
+            page.keyboard.type(value, delay=40)
+            item = page.locator(
+                f"#{control.dom}-dropdown-list-container [role=listitem][title='{value}']"
+            )
+            try:
+                item.first.click(timeout=5_000)
+            except Timeout:
+                page.keyboard.press("Escape")
+        case "radio":
+            page.locator(f"input[name='{control.dom}'][value='{value}']").check(force=True)
+        case "check":
+            if target.is_checked() != (value == "Yes"):
+                target.check(force=True) if value == "Yes" else target.uncheck(force=True)
+        case "tags":  # takes typed keys only
+            target.click()
+            target.press_sequentially(value, delay=20)
+            target.press("Enter")
+        case "file":
+            target.set_input_files(answer if isinstance(answer, list) else value)
+            listed = target.locator("xpath=..").locator("tbody td span")
+            with suppress(Timeout):
+                listed.filter(has_text=Path(value).name).first.wait_for(timeout=UPLOAD_TIMEOUT_MS)
+        case "screener" | "screener_multi":
+            values = [answer] if isinstance(answer, str) else answer
+            for n, option in enumerate(control.options or []):
+                box = page.locator(f"[id='{control.dom}_{n}']")
+                if (option in values) != box.is_checked():
+                    page.locator(f"label[for='{control.dom}_{n}']").click()
+
+
+def _read(page: Page, control: Control) -> Answer | None:
+    target = _by_id(page, control.dom)
+    match control.kind:
+        case "date":  # a native date input, else a masked MM/DD/YYYY one
+            value = target.input_value()
+            if re.fullmatch(r"\d{4}-\d{2}-\d{2}", value):
+                return value
+            digits = re.findall(r"\d+", value)
+            if len(digits) != 3:
+                return None
+            m, d, y = (int(x) for x in digits)
+            with suppress(ValueError):
+                return date(y, m, d).isoformat()
+            return None
+        case "dropdown":
+            text = target.locator(".rw-input").first.inner_text().strip().rstrip("*")
+            return "" if text == "--" else text
+        case "state":
+            text = page.locator(f"#{control.dom}-select-wrapper .input-select-input-single-value")
+            value = text.first.inner_text().strip() if text.count() else ""
+            return value if value in (control.options or []) else ""
+        case "radio":
+            checked = page.locator(f"input[name='{control.dom}']:checked")
+            return checked.first.get_attribute("value") if checked.count() else ""
+        case "check":
+            return "Yes" if target.is_checked() else "No"
+        case "tags":
+            tags = target.locator("xpath=..").locator(".react-tagsinput-tag")
+            return tags.first.inner_text().strip() if tags.count() else ""
+        case "file":
+            if control.dom == "btn-resume":
+                name = page.locator(".rounded-box:has(#remove-resume) .no-wrap")
+                return name.first.inner_text().strip() if name.count() else ""
+            names = target.locator("xpath=..").locator("tbody td span")  # the files listed
+            return names.first.inner_text().strip() if names.count() else ""
+        case "screener" | "screener_multi":
+            picked = [
+                option
+                for n, option in enumerate(control.options or [])
+                if page.locator(f"[id='{control.dom}_{n}']").is_checked()
+            ]
+            if control.kind == "screener_multi":
+                return picked
+            return picked[0] if picked else ""
+        case _:
+            return target.input_value()

{atsfill-0.0.4.dev22 → atsfill-0.0.4.dev25}/src/atsfill/core/registry.py

@@ -9,7 +9,7 @@ from importlib.resources import files
 KINDS = ("ats", "board", "aggregator", "custom")
 ACCOUNTS = ("none", "to_send", "to_read")  # also the backlog order (ADR 0013)
 HOSTING = ("hosted", "embedded")
-VENDORS = ("DataDome", "Cloudflare", "Akamai", "PerimeterX", "unknown")
+VENDORS = ("DataDome", "Cloudflare", "Akamai", "PerimeterX", "hCaptcha", "unknown")
 STEPS = ("posting", "form", "upload")
 STATES = ("mapped", "dry_run_verified", "send_verified")
 CAUSES = ("system", "code", "unknown")

{atsfill-0.0.4.dev22 → atsfill-0.0.4.dev25}/src/atsfill/registry.toml

@@ -102,6 +102,7 @@ kind = "ats"
 share = 0.0244
 account = "none"
 hosting = ["hosted"]
+block = { vendor = "hCaptcha", signal = "image challenge on Continue To Application, the step before the form, 3 of 3 companies headless, and again on a virtual display and headed", step = "form", date = 2026-10-20, version = "0.0.3", camoufox = "0.5.8", browser = "156.0.1-beta.36" }
 mapped = { date = 2026-10-20, version = "0.0.2", by = "agent", commit = "7934b25" }
 
 [icims]
@@ -116,14 +117,18 @@ kind = "ats"
 share = 0.0187
 account = "none"
 hosting = ["hosted"]
+adapter = "manatal"
 mapped = { date = 2026-10-20, version = "0.0.2", by = "agent", commit = "7934b25" }
+dry_run_verified = { date = 2026-10-20, version = "0.0.3", by = "gate", commit = "e682656" }
 
 [paylocity]
 kind = "ats"
 share = 0.0167
 account = "none"
 hosting = ["hosted"]
+adapter = "paylocity"
 mapped = { date = 2026-10-20, version = "0.0.2", by = "agent", commit = "7934b25" }
+dry_run_verified = { date = 2026-10-20, version = "0.0.3", by = "gate", commit = "d3edb25" }
 
 [dayforce]
 kind = "ats"