jd-intel 0.8.3 → 0.9.0

package/README.md

@@ -131,6 +131,19 @@ const jobs = await fetchJobs({
 });
 ```
 
+Results come back newest first by `postedAt`, undated last (`order: 'board'` keeps the ATS's own order). `fetchJobs` returns the page as an array. `fetchJobsDetailed` returns the same page plus `total_matched`, the number of matches before `offset` and `limit`, so you can tell a small board from a cut and page through the rest:
+
+```js
+import { fetchJobsDetailed } from 'jd-intel';
+
+const { jobs, total_matched } = await fetchJobsDetailed({
+  company: '<your-target-company>',
+  titleFilter: 'engineer',
+  limit: 20,
+  offset: 20, // second page
+});
+```
+
 CLI usage: `npx jd-intel fetch <company-slug> --title-filter "engineer" --posted-within-days 14`. Full filter reference [below](#filters-quick-reference).
 
 Node.js 18+. No API keys. No configuration.
@@ -189,8 +202,10 @@ Every job normalizes to one schema, across every platform:
   "title": "Senior Software Engineer, Platform",
   "department": "Engineering",
   "location": "Remote - US",
+  "locations": ["Remote - US", "Toronto, Canada"],
   "locationType": "remote",
-  "salary": { "min": 180000, "max": 240000, "currency": "USD" },
+  "workplace": { "type": "remote", "source": "ats" },
+  "salary": { "min": 180000, "max": 240000, "currency": "USD", "period": "year", "source": "text" },
   "description": "Design and build the API surface our customers integrate against...",
   "url": "https://boards.example.com/jobs/12345",
   "postedAt": "2026-04-10T14:30:00Z"
@@ -206,9 +221,11 @@ No custom parsing per company.
 | `title` | Full job title |
 | `company` | Normalized company name |
 | `department` | Team or department (when provided) |
-| `location` | City, state, country, or remote |
-| `locationType` | `remote`, `hybrid`, or `onsite` |
-| `salary` | Min-max range with currency (when available) |
+| `location` | Primary location: city, state, country, or remote |
+| `locations` | Every location the posting is open in, primary first. The location filters check each entry |
+| `locationType` | `remote`, `hybrid`, `onsite`, or `unknown` when neither the platform nor the location text says |
+| `workplace` | `{ type, source }`. `type` repeats `locationType`; `source` is `ats` when the platform stated it, `text` when read from the location string, null when unknown |
+| `salary` | Min-max range with `currency`, plus `period` (`year`, `month`, `hour`, or null) and `source` (`ats` when the platform supplied it, `text` when parsed from the posting). Null when nothing is stated |
 | `description` | Full JD in clean markdown |
 | `url` | Direct link to the posting |
 | `postedAt` | Publication date (when provided) |

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jd-intel",
-  "version": "0.8.3",
+  "version": "0.9.0",
   "description": "Fetch and normalize job descriptions across seven major ATS (Greenhouse, Lever, Ashby, Workday, and more), for your AI assistant. No copy-paste.",
   "type": "module",
   "main": "src/index.js",

package/src/adapters/ashby.js

@@ -1,4 +1,4 @@
-import { normalize } from '../normalizer.js';
+import { normalize, extractSalaryFromText } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 const API_URL = 'https://jobs.ashbyhq.com/api/non-user-graphql';
@@ -36,23 +36,33 @@ async function fetchAshbyRest(slug) {
   const jobs = data.jobs || [];
 
   return jobs.map(job => {
-    const salary = parseAshbyCompensation(job.compensation);
+    const comp = job.compensation || {};
 
     return normalize({
       companySlug: slug,
       company: data.organizationName || slug,
       title: job.title || '',
-      department: job.departmentName || '',
+      department: job.department || '',
       location: job.location || '',
+      locations: (job.secondaryLocations || []).map(l => l?.location || ''),
+      workplace: parseAshbyWorkplace(job),
       description: job.descriptionHtml || job.descriptionPlain || '',
       url: `https://jobs.ashbyhq.com/${slug}/${job.id}`,
       postedAt: job.publishedAt || null,
-      salary,
+      salary: parseAshbyCompensation(comp),
       metadata: {
         ashbyId: job.id,
         employmentType: job.employmentType || '',
         isRemote: job.isRemote || false,
-        team: job.teamName || '',
+        team: job.team || '',
+        // The rendered summaries keep what min/max drop: "Offers Equity",
+        // "Multiple Ranges", and per-location tiers labelled OTE.
+        compensationSummary: comp.compensationTierSummary || '',
+        compensationTiers: (comp.compensationTiers || []).map(tier => ({
+          title: tier.title || '',
+          summary: tier.tierSummary || '',
+          additionalInformation: tier.additionalInformation || '',
+        })),
       },
     }, 'ashby');
   });
@@ -110,22 +120,47 @@ async function fetchAshbyGraphQL(slug) {
   }, 'ashby'));
 }
 
+const WORKPLACE_TYPES = { remote: 'remote', hybrid: 'hybrid', onsite: 'onsite' };
+
+/**
+ * `workplaceType` is 'Remote', 'Hybrid' or 'OnSite'. `isRemote` is the
+ * older flag and can only say remote, so it is the fallback when the type
+ * is absent. false means nothing: the role may be hybrid or onsite.
+ */
+function parseAshbyWorkplace(job) {
+  const type = WORKPLACE_TYPES[String(job.workplaceType || '').toLowerCase()];
+  if (type) return type;
+  return job.isRemote === true ? 'remote' : null;
+}
+
+const INTERVAL_PERIOD = { '1 YEAR': 'year', '1 MONTH': 'month', '1 HOUR': 'hour' };
+
+/**
+ * Read pay from Ashby's `compensation` object (issue #67).
+ *
+ * `summaryComponents` carries one structured entry per component type
+ * (Salary, Bonus, Commission, Equity); the Salary entry spans every tier.
+ * `scrapeableCompensationSalarySummary` and `compensationTierSummary` are
+ * the rendered strings. A board that publishes no pay still sends the
+ * object, with null summaries and empty arrays, so a miss here has to
+ * return null for the normalizer's text fallback to run.
+ */
 function parseAshbyCompensation(comp) {
-  if (!comp) return null;
-  // Ashby compensation can be a string or structured object
-  if (typeof comp === 'string') {
-    const match = comp.match(/\$?([\d,]+)\s*[-–]\s*\$?([\d,]+)/);
-    if (!match) return null;
+  const salary = (comp.summaryComponents || []).find(c => c.compensationType === 'Salary');
+  if (salary && (salary.minValue != null || salary.maxValue != null)) {
     return {
-      min: parseInt(match[1].replace(/,/g, '')),
-      max: parseInt(match[2].replace(/,/g, '')),
-      currency: 'USD',
+      min: salary.minValue ?? null,
+      max: salary.maxValue ?? null,
+      currency: salary.currencyCode || 'USD',
+      period: INTERVAL_PERIOD[salary.interval] || null,
+      source: 'ats',
     };
   }
-  if (comp.min && comp.max) {
-    return { min: comp.min, max: comp.max, currency: comp.currency || 'USD' };
-  }
-  return null;
+  // The summaries are still the ATS's own compensation field, so a range
+  // read out of one counts as source 'ats'.
+  const parsed = extractSalaryFromText(comp.scrapeableCompensationSalarySummary)
+    || extractSalaryFromText(comp.compensationTierSummary);
+  return parsed ? { ...parsed, source: 'ats' } : null;
 }
 
 export async function hasAshby(slug) {

package/src/adapters/greenhouse.js

@@ -1,4 +1,4 @@
-import { normalize, stripHtml } from '../normalizer.js';
+import { normalize, decodeEntities } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 const BASE_URL = 'https://boards-api.greenhouse.io/v1/boards';
@@ -29,19 +29,42 @@ export async function fetchGreenhouse(slug) {
     title: job.title || '',
     department: job.departments?.[0]?.name || '',
     location: job.location?.name || '',
-    description: stripHtml(job.content || ''),
+    workplace: parseGreenhouseWorkplace(job.metadata),
+    // `content` arrives HTML-escaped (`<p>`). Decode that outer layer
+    // once so normalize() sees real tags; it strips and decodes the rest.
+    description: decodeEntities(job.content || ''),
     url: job.absolute_url || '',
-    postedAt: job.updated_at || null,
-    salary: null, // Greenhouse doesn't expose salary in public API
+    // updated_at is an edit time that many boards bulk-refresh, so it is not
+    // a posting date. first_published is. Fallback covers boards without it (#69).
+    postedAt: job.first_published || job.updated_at || null,
+    salary: null, // list endpoint has no structured pay; normalizer parses the pay transparency text
     metadata: {
       greenhouseId: job.id,
       internal_job_id: job.internal_job_id,
       departments: job.departments?.map(d => d.name) || [],
       offices: job.offices?.map(o => o.name) || [],
+      updatedAt: job.updated_at,
     },
   }, 'greenhouse'));
 }
 
+/**
+ * Greenhouse has no native workplace field. Boards that track it define a
+ * custom field ("Location Type", "Workplace Type") that arrives in the
+ * job's `metadata[]`, with `value` a string for single-select fields and
+ * an array for multi-select. Values seen: On-Site, Hybrid (Travel-Required),
+ * Remote. Anything else is no signal and the location string decides.
+ */
+function parseGreenhouseWorkplace(metadata) {
+  const field = (metadata || []).find(m => /location type|workplace type/i.test(m?.name || ''));
+  if (!field) return null;
+  const value = [].concat(field.value ?? []).join(' ').toLowerCase();
+  if (/remote/.test(value)) return 'remote';
+  if (/hybrid/.test(value)) return 'hybrid';
+  if (/on-?site/.test(value)) return 'onsite';
+  return null;
+}
+
 /**
  * Check if a company has a Greenhouse board.
  */

package/src/adapters/lever.js

@@ -1,11 +1,16 @@
-import { normalize, stripHtml } from '../normalizer.js';
+import { normalize, extractSalaryFromText } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 const BASE_URL = 'https://api.lever.co/v0/postings';
 
+const PERIODS = { 'per-year-salary': 'year', 'per-month-salary': 'month', 'per-hour-wage': 'hour' };
+// Lever's workplaceType is one of these or 'unspecified'.
+const WORKPLACE_TYPES = new Set(['remote', 'hybrid', 'onsite']);
+
 /**
  * Fetch all jobs from a Lever job board.
  * Public API, no auth required.
+ * Docs: https://github.com/lever/postings-api
  *
  * @param {string} slug - Company slug (e.g., 'stripe', 'figma')
  * @returns {Promise<Array>} Normalized job objects
@@ -22,30 +27,72 @@ export async function fetchLever(slug) {
   const jobs = await resp.json();
   if (!Array.isArray(jobs)) return [];
 
-  return jobs.map(job => {
-    const salary = parseLeverSalary(job.categories?.commitment, job.text);
+  return jobs.map(job => normalize({
+    companySlug: slug,
+    // Lever's API doesn't return the company name at the board or job level,
+    // so the slug is the honest fallback. `categories.team` is the team within
+    // the company ("Payments Platform"), not the company itself.
+    company: titleCaseSlug(slug),
+    title: job.text || '',
+    department: job.categories?.department || job.categories?.team || '',
+    location: job.categories?.location || '',
+    locations: job.categories?.allLocations || [],
+    workplace: WORKPLACE_TYPES.has(job.workplaceType) ? job.workplaceType : null,
+    description: buildDescription(job),
+    url: job.hostedUrl || '',
+    postedAt: job.createdAt ? new Date(job.createdAt).toISOString() : null,
+    salary: parseLeverSalary(job.salaryRange, job.text),
+    metadata: {
+      leverId: job.id,
+      team: job.categories?.team || '',
+      commitment: job.categories?.commitment || '', // Full-time, Part-time, etc.
+      workplaceType: job.workplaceType || '',
+      salaryDescription: job.salaryDescriptionPlain || '',
+    },
+  }, 'lever'));
+}
+
+/**
+ * Lever splits a posting across `description` (company intro plus overview),
+ * `lists` (one `{text, content}` per section: responsibilities, requirements,
+ * location details) and `additional` (benefits, EEO). Only the first used to
+ * reach the description, so requirements were invisible to filters and to
+ * the assistant (issue #64). Reassemble the whole posting as HTML and let
+ * normalize() render the headings and bullets.
+ */
+function buildDescription(job) {
+  const parts = [job.description || job.descriptionPlain || ''];
+  for (const list of job.lists || []) {
+    const heading = (list.text || '').trim();
+    parts.push((heading ? `<h3>${escapeHtml(heading)}</h3>` : '') + (list.content || ''));
+  }
+  parts.push(job.additional || job.additionalPlain || '');
+  return parts.filter(Boolean).join('\n');
+}
+
+// `lists[].text` is plain text ("Skills & Experience"). Escaped, normalize()
+// decodes it back; raw, a stray `<` would be stripped as a tag.
+function escapeHtml(s) {
+  return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+}
 
-    return normalize({
-      companySlug: slug,
-      // Lever's API doesn't return the company name at the board or job level,
-      // so the slug is the honest fallback. `categories.team` is the team within
-      // the company ("Payments Platform"), not the company itself.
-      company: titleCaseSlug(slug),
-      title: job.text || '',
-      department: job.categories?.department || job.categories?.team || '',
-      location: job.categories?.location || '',
-      description: stripHtml(job.descriptionPlain || job.description || ''),
-      url: job.hostedUrl || '',
-      postedAt: job.createdAt ? new Date(job.createdAt).toISOString() : null,
-      salary,
-      metadata: {
-        leverId: job.id,
-        team: job.categories?.team || '',
-        commitment: job.categories?.commitment || '', // Full-time, Part-time, etc.
-        workplaceType: job.workplaceType || '',
-      },
-    }, 'lever');
-  });
+/**
+ * Lever publishes `salaryRange: {min, max, currency, interval}` on boards
+ * that state pay. Boards that don't sometimes put the range in the title.
+ */
+function parseLeverSalary(range, title) {
+  const min = range?.min || null;
+  const max = range?.max || null;
+  if (min || max) {
+    return {
+      min,
+      max,
+      currency: range.currency || 'USD',
+      period: PERIODS[range.interval] || null,
+      source: 'ats',
+    };
+  }
+  return extractSalaryFromText(title || '');
 }
 
 function titleCaseSlug(slug) {
@@ -55,19 +102,6 @@ function titleCaseSlug(slug) {
   return slug.charAt(0).toUpperCase() + slug.slice(1);
 }
 
-function parseLeverSalary(commitment, title) {
-  // Lever doesn't have a salary field, but sometimes it's in the title
-  const match = (title || '').match(/\$[\d,]+\s*[-–]\s*\$[\d,]+/);
-  if (!match) return null;
-  const nums = match[0].match(/[\d,]+/g);
-  if (!nums || nums.length < 2) return null;
-  return {
-    min: parseInt(nums[0].replace(/,/g, '')),
-    max: parseInt(nums[1].replace(/,/g, '')),
-    currency: 'USD',
-  };
-}
-
 export async function hasLever(slug) {
   try {
     const resp = await fetch(`${BASE_URL}/${slug}?mode=json`, { method: 'HEAD' });

package/src/adapters/recruitee.js

@@ -1,4 +1,4 @@
-import { normalize, stripHtml } from '../normalizer.js';
+import { normalize } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 /**
@@ -6,9 +6,16 @@ import { atsErrorFromStatus } from '../errors.js';
  * Public API, no auth required.
  * Docs: https://docs.recruitee.com/reference/offers
  *
- * Single GET returns every offer with the full HTML description
- * inline — no N+1 (unlike SmartRecruiters), no XML (unlike
- * TeamTailor/Personio). The simplest adapter shape in the toolkit.
+ * Single GET returns every offer inline — no N+1 (unlike SmartRecruiters),
+ * no XML (unlike TeamTailor/Personio). The simplest adapter shape in the
+ * toolkit.
+ *
+ * Each offer carries two HTML fields, `description` and `requirements`.
+ * Which one holds the role depends on the tenant's template (and sometimes
+ * the posting): some keep the duties in `description` and the candidate
+ * profile in `requirements`, others put a company intro in `description`
+ * and everything else in `requirements`. Neither alone is the posting, so
+ * both are joined before normalize() strips them (issue #65).
  *
  * @param {string} slug - Recruitee company subdomain (e.g., 'vandebron')
  * @returns {Promise<Array>} Normalized job objects
@@ -30,13 +37,7 @@ export async function fetchRecruitee(slug) {
     let location = place;
     if (offer.remote) location = place ? `Remote - ${place}` : 'Remote';
 
-    let postedAt = null;
-    if (offer.created_at) {
-      // Recruitee returns "2026-05-13 07:38:11 UTC"; coerce to ISO.
-      const iso = offer.created_at.replace(' UTC', 'Z').replace(' ', 'T');
-      const d = new Date(iso);
-      if (!Number.isNaN(d.getTime())) postedAt = d.toISOString();
-    }
+    const createdAt = toIso(offer.created_at);
 
     return normalize({
       companySlug: slug,
@@ -44,19 +45,71 @@ export async function fetchRecruitee(slug) {
       title: offer.title || '',
       department: offer.department || '',
       location,
-      description: stripHtml(offer.description || ''),
+      locations: (offer.locations || []).map(l => [l.city, l.country].filter(Boolean).join(', ')),
+      workplace: parseRecruiteeWorkplace(offer),
+      description: [offer.description, offer.requirements].filter(Boolean).join('\n'),
       url: offer.careers_url || offer.careers_apply_url || '',
-      postedAt,
-      salary: null, // No structured salary; normalizer parses from text
+      // created_at can predate publication by years on long-lived offers,
+      // so it is not a posting date. published_at is.
+      postedAt: toIso(offer.published_at) || createdAt,
+      salary: parseRecruiteeSalary(offer.salary),
       metadata: {
         recruiteeId: offer.guid || offer.id,
         employmentType: offer.employment_type_code || '',
         category: offer.category_code || '',
+        createdAt,
       },
     }, 'recruitee');
   });
 }
 
+/**
+ * Recruitee returns "2026-05-13 07:38:11 UTC"; coerce to ISO.
+ */
+function toIso(ts) {
+  if (!ts) return null;
+  const d = new Date(ts.replace(' UTC', 'Z').replace(' ', 'T'));
+  return Number.isNaN(d.getTime()) ? null : d.toISOString();
+}
+
+/**
+ * Recruitee sends three booleans, not one enum. Hybrid wins when remote is
+ * also set, and on_site alone is onsite. All false is no signal.
+ */
+function parseRecruiteeWorkplace(offer) {
+  if (offer.hybrid) return 'hybrid';
+  if (offer.remote) return 'remote';
+  if (offer.on_site) return 'onsite';
+  return null;
+}
+
+const PERIODS = new Set(['year', 'month', 'hour']);
+
+/**
+ * Recruitee sends `salary` as `{min, max, period, currency}` with string
+ * amounts. Offers without pay still carry the object, either all-null or
+ * as a "0"/"0" placeholder, so anything without a positive side returns
+ * null and normalize() falls back to the posting text.
+ */
+function parseRecruiteeSalary(salary) {
+  if (!salary) return null;
+  const min = toAmount(salary.min);
+  const max = toAmount(salary.max);
+  if (min === null && max === null) return null;
+  return {
+    min,
+    max,
+    currency: (salary.currency || '').toUpperCase(),
+    period: PERIODS.has(salary.period) ? salary.period : null,
+    source: 'ats',
+  };
+}
+
+function toAmount(value) {
+  const n = parseFloat(value);
+  return Number.isFinite(n) && n > 0 ? n : null;
+}
+
 /**
  * Check if a company has a Recruitee career site.
  */

package/src/adapters/smartrecruiters.js

@@ -1,4 +1,4 @@
-import { normalize, stripHtml } from '../normalizer.js';
+import { normalize } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 const BASE_URL = 'https://api.smartrecruiters.com/v1/companies';
@@ -10,7 +10,8 @@ const PAGE_SIZE = 100;
  * Docs: https://developers.smartrecruiters.com/reference/postingsget-1
  *
  * Two-step flow (unavoidable N+1):
- *   - The postings LIST endpoint omits the job description entirely.
+ *   - The postings LIST endpoint omits the job description entirely,
+ *     and the structured `compensation` block with it.
  *   - jd-intel's contract is "full JD text", so we must fetch each
  *     posting's DETAIL endpoint to get jobAd.sections.
  * Large enterprise tenants with hundreds of openings will therefore be
@@ -46,6 +47,7 @@ export async function fetchSmartrecruiters(slug) {
   const jobs = await Promise.all(postings.map(async (p) => {
     let sections = {};
     let postingUrl = '';
+    let salary = null;
 
     try {
       const detailResp = await fetch(`${BASE_URL}/${slug}/postings/${p.id}`);
@@ -53,6 +55,7 @@ export async function fetchSmartrecruiters(slug) {
         const detail = await detailResp.json();
         sections = detail.jobAd?.sections || {};
         postingUrl = detail.postingUrl || detail.applyUrl || '';
+        salary = parseCompensation(detail.compensation);
       }
     } catch {
       // Detail fetch failed: fall back to list-only fields (no description).
@@ -68,8 +71,14 @@ export async function fetchSmartrecruiters(slug) {
     const place = loc.fullLocation
       || [loc.city, loc.region, loc.country].filter(Boolean).join(', ');
     let location = place;
-    if (loc.remote) location = `Remote - ${place}`.replace(/ - $/, ' ');
-    else if (loc.hybrid) location = `Hybrid - ${place}`.replace(/ - $/, ' ');
+    let workplace = null;
+    if (loc.remote) {
+      location = `Remote - ${place}`.replace(/ - $/, ' ');
+      workplace = 'remote';
+    } else if (loc.hybrid) {
+      location = `Hybrid - ${place}`.replace(/ - $/, ' ');
+      workplace = 'hybrid';
+    }
 
     return normalize({
       companySlug: slug,
@@ -77,10 +86,11 @@ export async function fetchSmartrecruiters(slug) {
       title: p.name || '',
       department: p.department?.label || p.function?.label || '',
       location,
-      description: stripHtml(description),
+      workplace,
+      description,
       url: postingUrl,
       postedAt: p.releasedDate || null,
-      salary: null, // SmartRecruiters has no structured salary; normalizer parses text
+      salary, // null when the detail has no compensation; normalize() then parses text
       metadata: {
         smartRecruitersId: p.id,
         refNumber: p.refNumber || '',
@@ -94,6 +104,31 @@ export async function fetchSmartrecruiters(slug) {
   return jobs;
 }
 
+const PERIODS = { YEARLY: 'year', MONTHLY: 'month', HOURLY: 'hour' };
+
+/**
+ * Map the detail response's `compensation` to the shared salary shape.
+ *
+ * SmartRecruiters publishes `{min?, max?, currency, period}`, and both
+ * one-sided cases occur (a "max only" cap, a "from" floor), so each bound
+ * is passed through as null when absent rather than dropping the whole
+ * range. The period is kept as published: a MONTHLY figure is not
+ * annualized because tenants occasionally mislabel it (issue #70).
+ */
+function parseCompensation(comp) {
+  if (!comp || !comp.currency) return null;
+  const min = Number.isFinite(comp.min) ? comp.min : null;
+  const max = Number.isFinite(comp.max) ? comp.max : null;
+  if (min === null && max === null) return null;
+  return {
+    min,
+    max,
+    currency: comp.currency,
+    period: PERIODS[comp.period] ?? null,
+    source: 'ats',
+  };
+}
+
 /**
  * Check if a company exists on SmartRecruiters.
  * (HEAD isn't reliably supported on the postings endpoint, so use a

package/src/adapters/teamtailor.js

@@ -1,4 +1,4 @@
-import { normalize, stripHtml } from '../normalizer.js';
+import { normalize, decodeEntities } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 /**
@@ -16,10 +16,11 @@ import { atsErrorFromStatus } from '../errors.js';
  * to a custom domain (e.g. jobs.tibber.com).
  *
  * RSS quirk: descriptions are HTML-entity-encoded inside the XML
- * (`<p>...`). We decode that outer layer to real HTML, then
- * hand it to stripHtml() which strips tags and resolves the inner
- * entities. Decode order matters — `&` resolves LAST so that
- * double-encoded sequences (`&`) collapse correctly.
+ * (`<p>...`). We decode that outer layer to real HTML with the
+ * shared decodeEntities() and hand the HTML to normalize(), which
+ * strips tags and resolves the inner entities. Decode order matters —
+ * `&` resolves LAST so double-encoded sequences (`&`)
+ * collapse by one layer per pass.
  *
  * @param {string} slug - TeamTailor career-site slug (e.g., 'tibber')
  * @returns {Promise<Array>} Normalized job objects
@@ -28,6 +29,9 @@ import { atsErrorFromStatus } from '../errors.js';
 // segment, e.g. crunchbase.na.teamtailor.com. '' is the base host.
 const TT_REGIONS = ['', 'na', 'eu'];
 
+// Feeds send `none`, `hybrid`, `fully` or `onsite`. `none` is no signal.
+const REMOTE_STATUS = { hybrid: 'hybrid', fully: 'remote', onsite: 'onsite' };
+
 /**
  * Resolve which TeamTailor host actually serves this slug's feed.
  * Returns the first 200 Response, throws on a non-404 error, or
@@ -64,8 +68,8 @@ export async function fetchTeamtailor(slug) {
   const items = [...xml.matchAll(/<item>([\s\S]*?)<\/item>/g)].map(m => m[1]);
 
   return items.map(item => {
-    const pick = (tag) => {
-      const m = item.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`));
+    const pick = (tag, src = item) => {
+      const m = src.match(new RegExp(`<${tag}[^>]*>([\\s\\S]*?)</${tag}>`));
       return m ? m[1].trim() : '';
     };
 
@@ -78,6 +82,12 @@ export async function fetchTeamtailor(slug) {
     const country = decodeEntities(pick('tt:country'));
     const remoteStatus = decodeEntities(pick('remoteStatus'));
 
+    // One <tt:location> per office the posting is open in, read the same
+    // way as the primary above so the entries line up.
+    const locations = [...item.matchAll(/<tt:location>([\s\S]*?)<\/tt:location>/g)].map(m =>
+      [decodeEntities(pick('tt:city', m[1])), decodeEntities(pick('tt:country', m[1]))].filter(Boolean).join(', ')
+    );
+
     let location = [city, country].filter(Boolean).join(', ');
     if (/remote/i.test(remoteStatus)) {
       location = location ? `Remote - ${location}` : 'Remote';
@@ -95,7 +105,9 @@ export async function fetchTeamtailor(slug) {
       title,
       department,
       location,
-      description: stripHtml(decodeEntities(pick('description'))),
+      locations,
+      workplace: REMOTE_STATUS[remoteStatus.toLowerCase()] || null,
+      description: decodeEntities(pick('description')),
       url: link,
       postedAt,
       salary: null, // No structured salary; normalizer parses from text
@@ -107,22 +119,6 @@ export async function fetchTeamtailor(slug) {
   });
 }
 
-/**
- * Decode the RSS entity/CDATA layer to real HTML.
- * `&amp;` is intentionally resolved LAST.
- */
-function decodeEntities(s) {
-  if (!s) return '';
-  return s
-    .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1')
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-    .replace(/&quot;/g, '"')
-    .replace(/&#39;/g, "'")
-    .replace(/&apos;/g, "'")
-    .replace(/&amp;/g, '&');
-}
-
 /**
  * Check if a company has a TeamTailor career site.
  */

package/src/adapters/workday.js

@@ -1,9 +1,14 @@
-import { normalize, stripHtml } from '../normalizer.js';
+import { normalize } from '../normalizer.js';
 import { atsErrorFromStatus } from '../errors.js';
 
 const MAX_DETAIL_FETCHES = 100;
 const LIST_PAGE_SIZE = 20;
-const LIST_PAGE_HARD_CAP = 100; // <= 2000 list items scanned per request
+// Upper bound on list pages per call: 100 pages of 20 = at most 2000
+// postings scanned. Paging usually stops sooner, on a short page or when
+// offset reaches the first page's total (see the loop below).
+const LIST_PAGE_HARD_CAP = 100;
+// A multi-location posting's list row reads "2 Locations", "14 Locations".
+const MULTI_LOCATION = /^\s*\d+\s+locations?\s*$/;
 
 /**
  * Fetch jobs from a Workday tenant via the public "CXS" JSON API.
@@ -40,6 +45,7 @@ export async function fetchWorkday(slug, ctx = {}) {
   const postings = [];
   let offset = 0;
   let pages = 0;
+  let firstTotal = 0;
   while (pages < LIST_PAGE_HARD_CAP) {
     const resp = await fetch(`${base}/jobs`, {
       method: 'POST',
@@ -48,19 +54,24 @@ export async function fetchWorkday(slug, ctx = {}) {
     });
 
     if (!resp.ok) {
-      if (resp.status === 404) return []; // wrong site / no such board
       if (offset === 0) {
+        if (resp.status === 404) return []; // wrong site / no such board
         throw atsErrorFromStatus(resp.status, `Workday API error for ${slug} (${tenant}/${env}/${site}): ${resp.status}`);
       }
-      break; // mid-paging failure: keep what we have
+      break; // mid-paging failure (any status): keep what we have
     }
 
     const data = await resp.json();
     const page = data.jobPostings || [];
+    // Some tenants report the real `total` only at offset 0 and send
+    // `total: 0` on every later page, so only the first page's figure
+    // is trusted. A short page is the other stop signal.
+    if (pages === 0) firstTotal = data.total || 0;
     postings.push(...page);
     pages += 1;
     offset += LIST_PAGE_SIZE;
-    if (page.length === 0 || offset >= (data.total || 0)) break;
+    if (page.length < LIST_PAGE_SIZE) break;
+    if (firstTotal > 0 && offset >= firstTotal) break;
   }
 
   // 2. Filter-aware candidate selection BEFORE the N+1 detail cost.
@@ -76,6 +87,9 @@ export async function fetchWorkday(slug, ctx = {}) {
     const inc = fc.locationIncludes.map(s => String(s).toLowerCase());
     candidates = candidates.filter(p => {
       const loc = (p.locationsText || '').toLowerCase();
+      // "2 Locations" says nothing about where. The row stays a candidate
+      // and the pass after hydration decides on the detail's location list.
+      if (MULTI_LOCATION.test(loc)) return true;
       return inc.some(s => loc.includes(s));
     });
   }
@@ -91,16 +105,21 @@ export async function fetchWorkday(slug, ctx = {}) {
   }
 
   // 3. Bound the detail-fetch set.
-  //    NOTE: huge-tenant coverage is intentionally capped for v1
-  //    (Salesforce ~1398 postings). A description `filter` is applied
-  //    by the library AFTER this returns, so for that case we keep the
-  //    full backstop instead of truncating tightly to `limit` (which
-  //    could hydrate jobs that all fail the regex while better matches
-  //    go unscanned). Proper fix (smart pagination / rate-limited
-  //    concurrency / surfaced truncation) is tracked in #26, to be
-  //    designed alongside retry/rate-limit work (#7).
+  //    NOTE: huge-tenant coverage is intentionally capped for v1. Two
+  //    caps apply: the list scan above stops at LIST_PAGE_HARD_CAP pages
+  //    (2000 postings, enough for Salesforce's ~1398), and the detail set
+  //    is cut to MAX_DETAIL_FETCHES here. A description `filter` is
+  //    applied by the library AFTER this returns, so for that case we
+  //    keep the full backstop instead of truncating tightly to `limit`
+  //    (which could hydrate jobs that all fail the regex while better
+  //    matches go unscanned). The library pages with `offset` after this
+  //    returns, so the budget covers the page plus what precedes it.
+  //    Proper fix (smart pagination / rate-limited concurrency / surfaced
+  //    truncation) is tracked in #26, to be designed alongside
+  //    retry/rate-limit work (#7).
   const limit = typeof fc.limit === 'number' && fc.limit > 0 ? fc.limit : 100;
-  const cap = fc.filter ? MAX_DETAIL_FETCHES : Math.min(limit, MAX_DETAIL_FETCHES);
+  const skip = typeof fc.offset === 'number' && fc.offset > 0 ? fc.offset : 0;
+  const cap = fc.filter ? MAX_DETAIL_FETCHES : Math.min(skip + limit, MAX_DETAIL_FETCHES);
   candidates = candidates.slice(0, cap);
 
   // 4. Hydrate descriptions via the per-posting detail endpoint.
@@ -126,7 +145,9 @@ export async function fetchWorkday(slug, ctx = {}) {
       title: p.title || info.title || '',
       department: '',
       location: info.location || p.locationsText || '',
-      description: stripHtml(info.jobDescription || ''),
+      locations: info.additionalLocations || [],
+      workplace: parseWorkdayRemoteType(info.remoteType),
+      description: info.jobDescription || '',
       url: `https://${tenant}.${env}.myworkdayjobs.com/${site}${externalPath}`,
       postedAt: parseWorkdayDate(info.startDate) || normalizePostedOn(p.postedOn),
       salary: null, // normalizer extracts from description text
@@ -142,6 +163,20 @@ export async function fetchWorkday(slug, ctx = {}) {
   return jobs;
 }
 
+/**
+ * Detail `remoteType` is free text set per tenant: "Remote", "Hybrid",
+ * "Office - Flexible", "On-site". A flexible office arrangement counts as
+ * hybrid, so that check runs before the office one. Some tenants send no
+ * value at all; the location string decides then.
+ */
+function parseWorkdayRemoteType(remoteType) {
+  const s = String(remoteType || '').toLowerCase();
+  if (/remote/.test(s)) return 'remote';
+  if (/hybrid|flexible/.test(s)) return 'hybrid';
+  if (/office|on-?site/.test(s)) return 'onsite';
+  return null;
+}
+
 /**
  * Workday list `postedOn` is a relative string ("Posted Today",
  * "Posted 5 Days Ago", "Posted 30+ Days Ago"). Decide membership in

package/src/cli.js

@@ -9,6 +9,8 @@
  *   jd-intel registry search <query>
  */
 
+import { realpathSync } from 'node:fs';
+import { fileURLToPath } from 'node:url';
 import { fetchJobs } from './index.js';
 import { detectAts, searchRegistry } from './registry.js';
 
@@ -85,7 +87,7 @@ async function main() {
       console.log(`Found ${jobs.length} jobs\n`);
 
       for (const job of jobs.slice(0, 20)) {
-        const salary = job.salary ? ` | $${job.salary.min?.toLocaleString()}-$${job.salary.max?.toLocaleString()}` : '';
+        const salary = job.salary ? ` | ${formatSalary(job.salary)}` : '';
         const loc = job.location ? ` | ${job.location}` : '';
         const dept = job.department ? ` [${job.department}]` : '';
         console.log(`  ${job.title}${dept}${loc}${salary}`);
@@ -162,8 +164,8 @@ Fetch options:
   --title-filter pattern          Regex matched against TITLE only (role identity)
   --filter pattern                Regex matched across title, department, description (topic/scope)
   --posted-within-days N          Only jobs posted in the last N days
-  --location-include "A,B,C"      Keep jobs whose location contains any of these
-  --location-exclude "A,B,C"      Drop jobs whose location contains any of these
+  --location-include "A,B,C"      Keep jobs where any listed location contains one of these
+  --location-exclude "A,B,C"      Drop jobs only when every listed location contains one of these
   --limit N                       Cap results (default 100)
   --json                          Output full JSON
 
@@ -184,7 +186,32 @@ Examples:
   }
 }
 
-main().catch(err => {
-  console.error('Error:', err.message);
-  process.exit(1);
-});
+export function formatSalary({ min, max, currency, period }) {
+  const hasMin = min != null;
+  const hasMax = max != null;
+  let range;
+  if (hasMin && hasMax) range = `${min.toLocaleString()}-${max.toLocaleString()}`;
+  else if (hasMin) range = `from ${min.toLocaleString()}`;
+  else range = `up to ${max.toLocaleString()}`;
+  const unit = period === 'hour' ? '/hr' : period === 'month' ? '/mo' : '';
+  return `${range} ${currency}${unit}`;
+}
+
+// Boot only when this file is the script Node was started with, so a test
+// can import formatSalary without running a command. argv[1] is resolved
+// through realpath because npm installs the bin as a symlink into .bin/,
+// while import.meta.url already points at the real file.
+function isEntrypoint() {
+  try {
+    return realpathSync(process.argv[1]) === fileURLToPath(import.meta.url);
+  } catch {
+    return false;
+  }
+}
+
+if (isEntrypoint()) {
+  main().catch(err => {
+    console.error('Error:', err.message);
+    process.exit(1);
+  });
+}

package/src/filters.js

@@ -4,14 +4,33 @@
  * Facts go here (deterministic field matches). Interpretations stay with the
  * caller — this module does substring matching on structured fields, nothing
  * semantic.
+ *
+ * Returns the page as an array. applyFiltersDetailed returns the same page
+ * plus total_matched, the match count before offset and limit.
  */
 export function applyFilters(jobs, options = {}) {
+  return applyFiltersDetailed(jobs, options).jobs;
+}
+
+/**
+ * Filter, sort, then page.
+ *
+ * Order is applied after the filters and before offset and limit, so a cut
+ * drops the oldest matches first. 'newest' sorts by postedAt descending with
+ * undated jobs last and ties broken by id, which keeps pages deterministic.
+ * 'board' keeps the order the adapter returned.
+ *
+ * @returns {{ jobs: Array, total_matched: number }}
+ */
+export function applyFiltersDetailed(jobs, options = {}) {
   const {
     titleFilter,
     filter,
     postedWithinDays,
     locationIncludes,
     locationExcludes,
+    order = 'newest',
+    offset = 0,
     limit = 100,
   } = options;
 
@@ -42,25 +61,60 @@ export function applyFilters(jobs, options = {}) {
 
   if (Array.isArray(locationIncludes) && locationIncludes.length > 0) {
     const matchers = locationIncludes.map(makeLocationMatcher);
-    result = result.filter(j => {
-      const loc = (j.location || '').toLowerCase();
-      return matchers.some(m => m(loc));
-    });
+    result = result.filter(j => jobLocations(j).some(loc => matchers.some(m => m(loc))));
   }
 
   if (Array.isArray(locationExcludes) && locationExcludes.length > 0) {
     const matchers = locationExcludes.map(makeLocationMatcher);
-    result = result.filter(j => {
-      const loc = (j.location || '').toLowerCase();
-      return !matchers.some(m => m(loc));
-    });
+    result = result.filter(j => !jobLocations(j).every(loc => matchers.some(m => m(loc))));
   }
 
-  if (typeof limit === 'number' && result.length > limit) {
-    result = result.slice(0, limit);
+  const total_matched = result.length;
+
+  if (order !== 'board') {
+    result = [...result].sort(byNewest);
   }
 
-  return result;
+  const start = typeof offset === 'number' && offset > 0 ? offset : 0;
+  const end = typeof limit === 'number' ? start + limit : undefined;
+  if (start > 0 || (end !== undefined && result.length > end)) {
+    result = result.slice(start, end);
+  }
+
+  return { jobs: result, total_matched };
+}
+
+/**
+ * Every location a job is open in, lowercased. A job passes an include when
+ * any of them matches and is dropped by an exclude only when all of them
+ * match: a role open in Berlin and New York is still open in Berlin for
+ * someone excluding the US (issue #68). Jobs from before `locations`
+ * existed fall back to the single `location` string.
+ */
+function jobLocations(job) {
+  const list = Array.isArray(job.locations) && job.locations.length > 0
+    ? job.locations
+    : [job.location || ''];
+  return list.map(loc => String(loc).toLowerCase());
+}
+
+function postedTime(job) {
+  if (!job.postedAt) return null;
+  const t = new Date(job.postedAt).getTime();
+  return Number.isFinite(t) ? t : null;
+}
+
+function byNewest(a, b) {
+  const ta = postedTime(a);
+  const tb = postedTime(b);
+  if (ta !== tb) {
+    if (ta === null) return 1;
+    if (tb === null) return -1;
+    return tb - ta;
+  }
+  const ia = a.id || '';
+  const ib = b.id || '';
+  return ia < ib ? -1 : ia > ib ? 1 : 0;
 }
 
 /**

package/src/index.js

@@ -8,11 +8,23 @@
 
 import { ADAPTERS, ATS_NAMES } from './adapters/index.js';
 import { loadRegistry, searchRegistry, detectAts, findAtsBySlug, findEntryBySlug, getRegistrySource } from './registry.js';
-import { applyFilters } from './filters.js';
+import { applyFiltersDetailed } from './filters.js';
 
 /**
  * Fetch jobs from a company's ATS board.
  *
+ * Same options as fetchJobsDetailed; returns the page as an array.
+ *
+ * @returns {Promise<Array>} Normalized, filtered job objects
+ */
+export async function fetchJobs(options = {}) {
+  const { jobs } = await fetchJobsDetailed(options);
+  return jobs;
+}
+
+/**
+ * Fetch jobs from a company's ATS board, with the match count.
+ *
  * @param {Object} options
  * @param {string} options.company - Company slug or name
  * @param {string} [options.ats] - Specific ATS platform. If omitted, auto-detects.
@@ -20,12 +32,14 @@ import { applyFilters } from './filters.js';
  * @param {string} [options.titleFilter] - Regex matched against title only. Use for role identity ("product manager", "staff engineer").
  * @param {string} [options.filter] - Regex matched across title, department, description. Use for topic/scope.
  * @param {number} [options.postedWithinDays] - Only return jobs posted within N days.
- * @param {string[]} [options.locationIncludes] - Keep jobs whose location contains any of these (case-insensitive).
- * @param {string[]} [options.locationExcludes] - Drop jobs whose location contains any of these (case-insensitive).
- * @param {number} [options.limit=100] - Maximum jobs to return after filtering.
- * @returns {Promise<Array>} Normalized, filtered job objects
+ * @param {string[]} [options.locationIncludes] - Keep jobs where any listed location contains any of these (case-insensitive).
+ * @param {string[]} [options.locationExcludes] - Drop jobs only when every listed location contains one of these (case-insensitive).
+ * @param {'newest'|'board'} [options.order='newest'] - 'newest': by postedAt descending, undated last, ties by id. 'board': the adapter's own order.
+ * @param {number} [options.offset=0] - Matches to skip after sorting (paging).
+ * @param {number} [options.limit=100] - Maximum jobs to return after offset.
+ * @returns {Promise<{ jobs: Array, total_matched: number }>} The page, plus the match count before offset and limit
  */
-export async function fetchJobs({
+export async function fetchJobsDetailed({
   company,
   ats,
   config,
@@ -34,6 +48,8 @@ export async function fetchJobs({
   postedWithinDays,
   locationIncludes,
   locationExcludes,
+  order = 'newest',
+  offset = 0,
   limit = 100,
 } = {}) {
   if (!company) throw new Error('Company slug required');
@@ -45,7 +61,7 @@ export async function fetchJobs({
   // adapters declare fetch{Name}(slug) and ignore extra positional args
   // (JS no-op), so this is backward-compatible. Filter-aware adapters
   // (e.g. Workday) use it to avoid mass detail-fetching on huge tenants.
-  const filterContext = { titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, limit };
+  const filterContext = { titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, offset, limit };
 
   let jobs;
   if (ats) {
@@ -93,7 +109,7 @@ export async function fetchJobs({
     }
   }
 
-  return applyFilters(jobs, { titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, limit });
+  return applyFiltersDetailed(jobs, { titleFilter, filter, postedWithinDays, locationIncludes, locationExcludes, order, offset, limit });
 }
 
 /**
@@ -134,7 +150,7 @@ export { fetchLever } from './adapters/lever.js';
 export { fetchAshby } from './adapters/ashby.js';
 
 // Re-export filter logic for reuse (e.g., by the MCP server)
-export { applyFilters } from './filters.js';
+export { applyFilters, applyFiltersDetailed } from './filters.js';
 
 // Re-export the list of supported ATS names (e.g. so the MCP layer can report
 // the full set detectAts probes, instead of hardcoding a stale subset).

package/src/normalizer.js

@@ -13,20 +13,35 @@ export function jobId(company, title, ats, location = '') {
 
 /**
  * Normalize a raw ATS job object into the unified schema.
+ *
+ * Adapters pass `description` as HTML. This is the one place it is
+ * stripped and decoded (issue #66): a second pass would delete text the
+ * author escaped on purpose (`<5 years`) and leave entities the first
+ * pass exposed (`—` -> `—`) as literal noise.
+ *
+ * `raw.workplace` is the ATS's own arrangement, already mapped by the
+ * adapter to 'remote' | 'hybrid' | 'onsite', or null when the platform
+ * gives no signal. `raw.locations` lists every place the posting is open
+ * in; `location` stays the primary because it feeds the id (issue #68).
  */
 export function normalize(raw, ats) {
   const now = new Date().toISOString();
+  const description = stripHtml(raw.description || '');
+  const location = raw.location || '';
+  const workplace = resolveWorkplace(raw.workplace, location);
   return {
-    id: jobId(raw.company || raw.companySlug, raw.title, ats, raw.location || ''),
+    id: jobId(raw.company || raw.companySlug, raw.title, ats, location),
     company: raw.company || raw.companySlug || '',
     companySlug: raw.companySlug || '',
     ats,
     title: raw.title || '',
     department: raw.department || '',
-    location: raw.location || '',
-    locationType: detectLocationType(raw.location || ''),
-    salary: raw.salary || extractSalaryFromText(raw.description || ''),
-    description: stripHtml(raw.description || ''),
+    location,
+    locations: uniqueLocations(location, raw.locations),
+    locationType: workplace.type,
+    workplace,
+    salary: raw.salary || extractSalaryFromText(description),
+    description,
     url: raw.url || '',
     postedAt: raw.postedAt || null,
     firstSeen: now,
@@ -36,62 +51,203 @@ export function normalize(raw, ats) {
   };
 }
 
+const CURRENCY_CODES = 'USD|EUR|GBP|CAD|AUD|NZD|CHF|SEK|NOK|DKK|PLN|CZK|HUF|INR|SGD|HKD|JPY|CNY|BRL|MXN|ZAR|AED|ILS';
+const SYMBOL_CURRENCY = { $: 'USD', '€': 'EUR', '£': 'GBP' };
+
+// A number as job posts write it: 1,234,567 / 1.234.567 / 1234, with an
+// optional one- or two-digit decimal part (211.4, 40.50, 60.000,50).
+// Exactly three digits after a dot are a thousands group, the way Dutch
+// and German boards write it: "€60.000" is sixty thousand, not sixty.
+const NUMBER =
+  '\\d{1,3}(?:,\\d{3})+(?:\\.\\d{1,2})?' +
+  '|\\d{1,3}(?:\\.\\d{3})+(?:,\\d{1,2})?' +
+  '|\\d+(?:[.,]\\d{1,2})?';
+
+// One side of a range: optional code before, optional symbol, the number,
+// optional K, optional code after. The lookarounds keep the number from
+// starting or ending inside a longer one ("234.567" out of "1.234.567").
+const amountPattern = (p) =>
+  `(?:\\b(?<${p}CodeBefore>${CURRENCY_CODES})\\s?)?` +
+  `(?<${p}Sym>[$€£])?\\s?` +
+  `(?<![\\d.,])(?<${p}Num>${NUMBER})(?!\\d|[.,]\\d)\\s?` +
+  `(?<${p}K>[kK]\\b)?` +
+  `(?:\\s?(?<${p}CodeAfter>${CURRENCY_CODES})\\b)?`;
+
+const SALARY_RANGE = new RegExp(
+  `${amountPattern('lo')}\\s*(?:[-–—]|\\bto\\b)\\s*${amountPattern('hi')}`,
+  'g'
+);
+
+const HOUR_RE = /\b(?:per|an|each)\s+hour\b|\/\s*(?:hr|hour)\b|\bhourly\b/i;
+const MONTH_RE = /\b(?:per|a|each)\s+month\b|\/\s*(?:mo|month)\b|\bmonthly\b/i;
+const YEAR_RE = /\b(?:per|a|each)\s+(?:year|annum)\b|\/\s*(?:yr|year)\b|\b(?:annual(?:ly|ized)?|yearly)\b/i;
+
 /**
- * Detect location type from location string.
- */
-/**
- * Extract salary range from job description text.
- * Matches patterns like: $162,400 - $243,600 or $150K-$200K
+ * Extract a salary range from decoded job text.
+ *
+ * Accepts hyphen, en dash, em dash or "to" between the two amounts, an
+ * optional ISO currency code before, between or after them, `$` / EUR /
+ * GBP symbols, decimal K shorthand ($211.4K), and thousands grouped with
+ * either a comma or a dot (60,000 and 60.000 are both sixty thousand).
+ * A code wins over a symbol, so "$120,000 - $150,000 CAD" is CAD. Ranges
+ * with no currency marker at all (years, headcounts) are ignored.
+ *
+ * @returns {{min:number,max:number,currency:string,period:('year'|'month'|'hour'|null),source:'text'}|null}
  */
-function extractSalaryFromText(text) {
+export function extractSalaryFromText(text) {
   if (!text) return null;
-  // Match: $162,400 - $243,600 (full numbers)
-  const fullMatch = text.match(/\$([\d,]+)\s*[-–]\s*\$([\d,]+)/);
-  if (fullMatch) {
-    return {
-      min: parseInt(fullMatch[1].replace(/,/g, '')),
-      max: parseInt(fullMatch[2].replace(/,/g, '')),
-      currency: 'USD',
-    };
-  }
-  // Match: $150K - $200K (shorthand)
-  const kMatch = text.match(/\$(\d+)[kK]\s*[-–]\s*\$(\d+)[kK]/);
-  if (kMatch) {
+  for (const m of text.matchAll(SALARY_RANGE)) {
+    const g = m.groups;
+    const end = m.index + m[0].length;
+    const after = text.slice(end, end + 40);
+    // "$20 - $30 million" is a revenue figure, not pay.
+    if (/^\s*(?:million|billion|m|bn?)\b/i.test(after)) continue;
+
+    const code = g.loCodeBefore || g.loCodeAfter || g.hiCodeBefore || g.hiCodeAfter;
+    const sym = g.loSym || g.hiSym;
+    if (!code && !sym) continue;
+
+    let min = parseAmount(g.loNum);
+    let max = parseAmount(g.hiNum);
+    if (g.loK || g.hiK) {
+      // "$150-200K" carries the K once for both sides.
+      if (min < 1000) min = Math.round(min * 1000);
+      if (max < 1000) max = Math.round(max * 1000);
+    }
+    if (!(min > 0) || !(max > 0)) continue;
+
+    const before = text.slice(Math.max(0, m.index - 40), m.index);
     return {
-      min: parseInt(kMatch[1]) * 1000,
-      max: parseInt(kMatch[2]) * 1000,
-      currency: 'USD',
+      min,
+      max,
+      currency: (code || SYMBOL_CURRENCY[sym]).toUpperCase(),
+      period: detectPeriod(before, after, min),
+      source: 'text',
     };
   }
   return null;
 }
 
-function detectLocationType(location) {
-  const lower = location.toLowerCase();
-  if (/remote/i.test(lower)) return 'remote';
-  if (/hybrid/i.test(lower)) return 'hybrid';
-  if (/on-?site/i.test(lower)) return 'onsite';
-  return location ? 'onsite' : 'unknown';
+// Dots grouping thousands mean a comma is the decimal mark, and vice versa.
+function parseAmount(s) {
+  if (/^\d{1,3}(?:\.\d{3})+/.test(s)) return Number(s.replace(/\./g, '').replace(',', '.'));
+  return Number(s.replace(/,(?=\d{3})/g, '').replace(',', '.'));
+}
+
+function detectPeriod(before, after, min) {
+  const explicit = periodWord(after) || periodWord(before);
+  if (explicit) return explicit;
+  return min >= 10000 ? 'year' : null;
+}
+
+function periodWord(text) {
+  if (HOUR_RE.test(text)) return 'hour';
+  if (MONTH_RE.test(text)) return 'month';
+  if (YEAR_RE.test(text)) return 'year';
+  return null;
+}
+
+const WORKPLACE_TYPES = new Set(['remote', 'hybrid', 'onsite']);
+
+/**
+ * The platform's own value wins. Without one, a keyword in the location
+ * string is the next best signal. Without either the type is 'unknown':
+ * a city name alone does not say the role is onsite, and a guessed
+ * 'onsite' reads as a fact to whoever consumes it.
+ *
+ * @returns {{type:('remote'|'hybrid'|'onsite'|'unknown'), source:('ats'|'text'|null)}}
+ */
+function resolveWorkplace(native, location) {
+  if (WORKPLACE_TYPES.has(native)) return { type: native, source: 'ats' };
+  const guessed = workplaceFromText(location);
+  if (guessed) return { type: guessed, source: 'text' };
+  return { type: 'unknown', source: null };
+}
+
+function workplaceFromText(location) {
+  const lower = (location || '').toLowerCase();
+  if (/remote/.test(lower)) return 'remote';
+  if (/hybrid/.test(lower)) return 'hybrid';
+  if (/on-?site/.test(lower)) return 'onsite';
+  return null;
+}
+
+function uniqueLocations(primary, extra) {
+  const out = [];
+  const seen = new Set();
+  for (const loc of [primary, ...(Array.isArray(extra) ? extra : [])]) {
+    const s = typeof loc === 'string' ? loc.trim() : '';
+    if (!s || seen.has(s.toLowerCase())) continue;
+    seen.add(s.toLowerCase());
+    out.push(s);
+  }
+  return out;
 }
 
 /**
  * Strip HTML tags and convert to clean text.
+ *
+ * Block closers become line breaks and list items become bullets before
+ * the remaining tags are removed. Entities are decoded LAST, so a literal
+ * `&lt;` in the source text never turns into a tag that gets stripped.
  */
 export function stripHtml(html) {
   if (!html) return '';
-  return html
+  const text = html
     .replace(/<br\s*\/?>/gi, '\n')
-    .replace(/<\/p>/gi, '\n\n')
-    .replace(/<\/li>/gi, '\n')
-    .replace(/<li>/gi, '- ')
-    .replace(/<\/h[1-6]>/gi, '\n\n')
-    .replace(/<h[1-6][^>]*>/gi, '## ')
-    .replace(/<[^>]+>/g, '')
-    .replace(/&amp;/g, '&')
-    .replace(/&lt;/g, '<')
-    .replace(/&gt;/g, '>')
-    .replace(/&nbsp;/g, ' ')
-    .replace(/&#\d+;/g, '')
+    .replace(/<\/(?:p|h[1-6])\s*>/gi, '\n\n')
+    .replace(/<\/(?:li|div|td|tr|ul|ol|table|section)\s*>/gi, '\n')
+    // Word-pasted markup (Lever lists, issue #64) opens a <p> inside each
+    // <li>; swallowing it keeps the item text on the bullet's line.
+    .replace(/<li\b[^>]*>\s*(?:<p\b[^>]*>\s*)?/gi, '- ')
+    .replace(/<h[1-6]\b[^>]*>/gi, '## ')
+    .replace(/<[^>]+>/g, '');
+  return decodeEntities(text)
+    .replace(/\u00a0/g, ' ')
     .replace(/\n{3,}/g, '\n\n')
     .trim();
 }
+
+const NAMED_ENTITIES = {
+  lt: '<', gt: '>', quot: '"', apos: "'", nbsp: '\u00a0',
+  mdash: '—', ndash: '–', hellip: '…',
+  lsquo: '‘', rsquo: '’', ldquo: '“', rdquo: '”',
+  sbquo: '‚', bdquo: '„', laquo: '«', raquo: '»',
+  bull: '•', middot: '·', copy: '©', reg: '®', trade: '™',
+  deg: '°', times: '×', euro: '€', pound: '£', yen: '¥', cent: '¢',
+  agrave: 'à', aacute: 'á', acirc: 'â', atilde: 'ã', auml: 'ä', aring: 'å', aelig: 'æ',
+  ccedil: 'ç', egrave: 'è', eacute: 'é', ecirc: 'ê', euml: 'ë',
+  igrave: 'ì', iacute: 'í', icirc: 'î', iuml: 'ï', ntilde: 'ñ',
+  ograve: 'ò', oacute: 'ó', ocirc: 'ô', otilde: 'õ', ouml: 'ö', oslash: 'ø',
+  ugrave: 'ù', uacute: 'ú', ucirc: 'û', uuml: 'ü', yacute: 'ý', yuml: 'ÿ', szlig: 'ß',
+  Agrave: 'À', Aacute: 'Á', Acirc: 'Â', Atilde: 'Ã', Auml: 'Ä', Aring: 'Å', AElig: 'Æ',
+  Ccedil: 'Ç', Egrave: 'È', Eacute: 'É', Ecirc: 'Ê', Euml: 'Ë',
+  Igrave: 'Ì', Iacute: 'Í', Icirc: 'Î', Iuml: 'Ï', Ntilde: 'Ñ',
+  Ograve: 'Ò', Oacute: 'Ó', Ocirc: 'Ô', Otilde: 'Õ', Ouml: 'Ö', Oslash: 'Ø',
+  Ugrave: 'Ù', Uacute: 'Ú', Ucirc: 'Û', Uuml: 'Ü', Yacute: 'Ý',
+};
+
+/**
+ * Decode one layer of entity encoding (and unwrap CDATA) to real text.
+ *
+ * Decimal and hex references go through String.fromCodePoint, named
+ * references through the table above. `&amp;` is intentionally resolved
+ * LAST so double-encoded sequences (`&amp;mdash;`, `&amp;amp;`) collapse
+ * by exactly one layer per call. Used for the outer escaping Greenhouse
+ * and the Teamtailor RSS feed apply, and as stripHtml's final step.
+ */
+export function decodeEntities(s) {
+  if (!s) return '';
+  return s
+    .replace(/<!\[CDATA\[([\s\S]*?)\]\]>/g, '$1')
+    .replace(/&#(\d+);/g, (m, dec) => codePointToString(parseInt(dec, 10), m))
+    .replace(/&#[xX]([0-9a-fA-F]+);/g, (m, hex) => codePointToString(parseInt(hex, 16), m))
+    .replace(/&([A-Za-z][A-Za-z0-9]*);/g, (m, name) =>
+      (name !== 'amp' && Object.hasOwn(NAMED_ENTITIES, name)) ? NAMED_ENTITIES[name] : m)
+    .replace(/&amp;/g, '&');
+}
+
+function codePointToString(cp, fallback) {
+  if (!cp || cp > 0x10ffff || (cp >= 0xd800 && cp <= 0xdfff)) return fallback;
+  return String.fromCodePoint(cp);
+}