@hadoku/jobplatform-worker 2.32.35 → 2.32.37

package/dist/index.js

@@ -216,10 +216,10 @@ async function postServiceEvent(env, ev) {
   });
   if (!res.ok) throw new Error(`monitoring-api answered ${res.status}`);
 }
-function runAfterResponse(c, label, work) {
+function runAfterResponse(c, label2, work) {
   const guarded = work.catch((error) => {
     logger.error("background work failed", {
-      task: label,
+      task: label2,
       error: error instanceof Error ? error.message : String(error)
     });
   });
@@ -231,7 +231,7 @@ function runAfterResponse(c, label, work) {
   }
   if (!ctx) {
     logger.error("no ExecutionContext — background work will not survive the response", {
-      task: label,
+      task: label2,
       hint: "the host worker must forward ctx: fetch(request, env, ctx) -> createFetchHandler(env)(request, ctx)"
     });
     return;
@@ -478,8 +478,20 @@ const ScoreBreakdownSchema = z.object({
   discipline_factor: z.number()
 }).openapi("ScoreBreakdown");
 const RoleTrackSchema = z.enum(["ic", "manager", "unknown"]).openapi("RoleTrack");
-const JobStateSchema = z.enum(["interested", "dismissed", "saved", "applied"]).openapi("JobState");
-const JobStateReadSchema = z.enum(["new", "interested", "dismissed", "saved", "applied"]).openapi("JobStateRead");
+const JOB_STATES = [
+  "interested",
+  "dismissed",
+  "saved",
+  "applied",
+  "interviewing",
+  "offered",
+  "rejected"
+];
+const JobStateSchema = z.enum(JOB_STATES).openapi("JobState");
+const JobStateReadSchema = z.enum(["new", ...JOB_STATES]).openapi("JobStateRead");
+function asJobStateRead(v) {
+  return v && JOB_STATES.includes(v) ? v : "new";
+}
 const ApplicationStatusSchema = z.enum(["queued", "filled", "approved", "submitted", "needs_manual", "failed", "job_closed"]).openapi("ApplicationStatus");
 const JobSummarySchema = z.object({
   id: z.string(),
@@ -520,6 +532,14 @@ const JobSummarySchema = z.object({
   vote: z.union([z.literal(1), z.literal(-1)]).nullable().optional(),
   vote_reasons: z.array(z.string()).optional()
 }).openapi("JobSummary");
+const PrioritySchema = z.union([z.literal(1), z.literal(2), z.literal(3)]);
+const TrackingSchema = z.object({
+  notes: z.string().nullable(),
+  priority: PrioritySchema.nullable(),
+  follow_up_at: z.string().nullable(),
+  contact_name: z.string().nullable(),
+  contact_email: z.string().nullable()
+}).openapi("Tracking");
 const JobDetailSchema = JobSummarySchema.extend({
   /**
    * Whether the form runner has an adapter for this posting. A PREDICTION
@@ -550,7 +570,9 @@ const JobDetailSchema = JobSummarySchema.extend({
   department: z.string().nullable(),
   scraper_used: z.string().nullable(),
   run_id: z.string().nullable(),
-  state_updated_at: z.string().nullable()
+  state_updated_at: z.string().nullable(),
+  /** V5 tracking; null when the caller has no state for this posting (or is anonymous). */
+  tracking: TrackingSchema.nullable()
 }).openapi("JobDetail");
 const FEEDBACK_REASONS = [
   // downvote-flavored
@@ -958,6 +980,114 @@ const AddProfileCompanyResponseSchema = S(
 const DeleteCompanyResponseSchema = S(
   z.object({ deleted: z.literal(true), id: z.string() })
 ).openapi("DeleteCompanyResponse");
+const PERSON_EVENT_KINDS = ["note", "interview", "contact", "follow_up"];
+const JobEventKindSchema = z.enum(["state", ...PERSON_EVENT_KINDS]).openapi("JobEventKind");
+const JobEventSchema = z.object({
+  id: z.number().int(),
+  job_id: z.string(),
+  kind: JobEventKindSchema,
+  from_state: JobStateSchema.nullable(),
+  to_state: JobStateSchema.nullable(),
+  note: z.string().nullable(),
+  occurred_at: z.string(),
+  created_at: z.string()
+}).openapi("JobEvent");
+const JobEventsResponseSchema = S(z.object({ events: z.array(JobEventSchema) })).openapi(
+  "JobEventsResponse"
+);
+const JobEventResponseSchema = S(z.object({ event: JobEventSchema })).openapi(
+  "JobEventResponse"
+);
+const NOTE_MAX = 5e3;
+const WhenSchema = z.string().regex(/^\d{4}-\d{2}-\d{2}(T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2})?)?$/, {
+  message: "a date (YYYY-MM-DD) or an ISO timestamp"
+});
+const AddJobEventSchema = z.object({
+  kind: z.enum(PERSON_EVENT_KINDS),
+  note: z.string().trim().min(1).max(NOTE_MAX),
+  /** When it happened; defaults to now. */
+  occurred_at: WhenSchema.optional()
+}).openapi("AddJobEvent");
+const SetTrackingSchema = z.object({
+  notes: z.string().max(NOTE_MAX).nullable().optional(),
+  priority: PrioritySchema.nullable().optional(),
+  follow_up_at: z.string().regex(/^\d{4}-\d{2}-\d{2}$/, { message: "a date, YYYY-MM-DD" }).nullable().optional(),
+  contact_name: z.string().trim().max(200).nullable().optional(),
+  contact_email: z.string().trim().email().max(320).nullable().optional()
+}).refine((o) => Object.values(o).some((v) => v !== void 0), {
+  message: "name at least one field to change"
+}).openapi("SetTracking");
+const TrackingResponseSchema = S(
+  z.object({ job_id: z.string(), tracking: TrackingSchema })
+).openapi("TrackingResponse");
+const PipelineItemSchema = z.object({
+  job_id: z.string(),
+  title: z.string(),
+  company: z.string(),
+  location: z.string(),
+  workplace_type: z.string(),
+  salary_min: z.number().nullable(),
+  salary_max: z.number().nullable(),
+  url: z.string(),
+  posted_date: z.string().nullable(),
+  state: JobStateSchema,
+  updated_at: z.string(),
+  tracking: TrackingSchema,
+  variant_slug: z.string().nullable(),
+  /** The apply queue's view of the same posting, when it has been queued. */
+  application_status: ApplicationStatusSchema.nullable(),
+  /** First time it moved to 'applied', from the timeline. */
+  applied_at: z.string().nullable(),
+  /** Newest timeline row, of any kind. */
+  last_event_at: z.string().nullable()
+}).openapi("PipelineItem");
+const PipelineResponseSchema = S(z.object({ items: z.array(PipelineItemSchema) })).openapi(
+  "PipelineResponse"
+);
+const BlockedCompanySchema = z.object({ company: z.string(), company_key: z.string(), created_at: z.string() }).openapi("BlockedCompany");
+const BlockedCompaniesResponseSchema = S(
+  z.object({ companies: z.array(BlockedCompanySchema) })
+).openapi("BlockedCompaniesResponse");
+const BlockCompanySchema = z.object({ company: z.string().trim().min(1).max(200) }).openapi("BlockCompany");
+const BlockedCompanyResponseSchema = S(z.object({ company: BlockedCompanySchema })).openapi(
+  "BlockedCompanyResponse"
+);
+const UnblockCompanyResponseSchema = S(
+  z.object({ company_key: z.string(), deleted: z.boolean() })
+).openapi("UnblockCompanyResponse");
+const InsightsSchema = z.object({
+  /** Postings in each state right now. */
+  states: z.record(z.string(), z.number().int()),
+  /** Postings that have EVER reached each stage, from the timeline, the apply queue and the state. */
+  reached: z.object({
+    applied: z.number().int(),
+    responded: z.number().int(),
+    interviewed: z.number().int(),
+    offered: z.number().int()
+  }),
+  /** Shares of `reached.applied`; null until something has been applied to. */
+  rates: z.object({
+    response: z.number().nullable(),
+    interview: z.number().nullable(),
+    offer: z.number().nullable()
+  }),
+  /** Applications per ISO week (Monday, UTC), oldest first, the last 12 weeks, zeros included. */
+  weekly_applied: z.array(z.object({ week: z.string(), count: z.number().int() })),
+  /** What the applied-to postings are, by workplace type. */
+  workplace: z.array(z.object({ workplace_type: z.string(), count: z.number().int() })),
+  /** Most-asked skills across the pipeline's postings (dismissed excluded). */
+  skills: z.array(
+    z.object({
+      skill: z.string(),
+      postings: z.number().int(),
+      /** Named in the stack of any of the caller's scoring profiles. */
+      in_stack: z.boolean()
+    })
+  ),
+  /** How many postings the skill counts were taken over. */
+  skill_postings: z.number().int()
+}).openapi("Insights");
+const InsightsResponseSchema = S(InsightsSchema).openapi("InsightsResponse");
 const app$5 = new OpenAPIHono();
 const healthRoute = createRoute({
   method: "get",
@@ -1466,7 +1596,7 @@ async function effectiveUserId(c, ownerName) {
     c.env.HADOKU_SERVICE_KEY ?? "",
     named,
     Date.now(),
-    (label, work) => runAfterResponse(c, label, work)
+    (label2, work) => runAfterResponse(c, label2, work)
   );
   if (isIdentityError(resolved)) {
     const status = [404, 409, 503].includes(resolved.status) ? resolved.status : 503;
@@ -1526,13 +1656,492 @@ function parseAtsSlug(url) {
   if (url.includes("gh_jid=")) {
     try {
       const host = new URL(url).hostname;
-      const slug = slugFromHost(host);
-      if (slug) return { ats: "greenhouse", slug };
+      const slug2 = slugFromHost(host);
+      if (slug2) return { ats: "greenhouse", slug: slug2 };
     } catch {
     }
   }
   return { ats: null, slug: null };
 }
+const US = [
+  ["arlington", "va", 38.8799, -77.1068],
+  ["austin", "tx", 30.2672, -97.7431],
+  ["round rock", "tx", 30.5083, -97.6789],
+  ["cedar park", "tx", 30.5052, -97.8203],
+  ["georgetown", "tx", 30.6333, -97.6778],
+  ["san marcos", "tx", 29.8833, -97.9414],
+  ["dallas", "tx", 32.7767, -96.797],
+  ["fort worth", "tx", 32.7555, -97.3308],
+  ["plano", "tx", 33.0198, -96.6989],
+  ["irving", "tx", 32.814, -96.9489],
+  ["frisco", "tx", 33.1507, -96.8236],
+  ["richardson", "tx", 32.9483, -96.7299],
+  ["arlington", "tx", 32.7357, -97.1081],
+  ["houston", "tx", 29.7604, -95.3698],
+  ["the woodlands", "tx", 30.1588, -95.4613],
+  ["sugar land", "tx", 29.6197, -95.6349],
+  ["san antonio", "tx", 29.4241, -98.4936],
+  ["el paso", "tx", 31.7619, -106.485],
+  ["lubbock", "tx", 33.5779, -101.8552],
+  ["midland", "tx", 31.9973, -102.0779],
+  ["san francisco", "ca", 37.7749, -122.4194],
+  ["oakland", "ca", 37.8044, -122.2712],
+  ["berkeley", "ca", 37.8715, -122.273],
+  ["san jose", "ca", 37.3382, -121.8863],
+  ["sunnyvale", "ca", 37.3688, -122.0363],
+  ["santa clara", "ca", 37.3541, -121.9552],
+  ["mountain view", "ca", 37.3861, -122.0839],
+  ["palo alto", "ca", 37.4419, -122.143],
+  ["menlo park", "ca", 37.453, -122.1817],
+  ["redwood city", "ca", 37.4852, -122.2364],
+  ["san mateo", "ca", 37.563, -122.3255],
+  ["cupertino", "ca", 37.323, -122.0322],
+  ["fremont", "ca", 37.5485, -121.9886],
+  ["pleasanton", "ca", 37.6624, -121.8747],
+  ["san ramon", "ca", 37.7799, -121.978],
+  ["walnut creek", "ca", 37.9101, -122.0652],
+  ["san rafael", "ca", 37.9735, -122.5311],
+  ["sacramento", "ca", 38.5816, -121.4944],
+  ["fresno", "ca", 36.7468, -119.7726],
+  ["los angeles", "ca", 34.0522, -118.2437],
+  ["santa monica", "ca", 34.0195, -118.4912],
+  ["culver city", "ca", 34.0211, -118.3965],
+  ["pasadena", "ca", 34.1478, -118.1445],
+  ["burbank", "ca", 34.1808, -118.309],
+  ["glendale", "ca", 34.1425, -118.2551],
+  ["long beach", "ca", 33.7701, -118.1937],
+  ["irvine", "ca", 33.6846, -117.8265],
+  ["newport beach", "ca", 33.6189, -117.9298],
+  ["anaheim", "ca", 33.8366, -117.9143],
+  ["san diego", "ca", 32.7157, -117.1611],
+  ["la jolla", "ca", 32.8328, -117.2713],
+  ["carlsbad", "ca", 33.1581, -117.3506],
+  ["riverside", "ca", 33.9806, -117.3755],
+  ["seattle", "wa", 47.6062, -122.3321],
+  ["bellevue", "wa", 47.6101, -122.2015],
+  ["redmond", "wa", 47.674, -122.1215],
+  ["kirkland", "wa", 47.6769, -122.206],
+  ["renton", "wa", 47.4829, -122.2171],
+  ["bothell", "wa", 47.7601, -122.2054],
+  ["tacoma", "wa", 47.2529, -122.4443],
+  ["olympia", "wa", 47.0379, -122.9007],
+  ["spokane", "wa", 47.6588, -117.426],
+  ["new york", "ny", 40.7128, -74.006],
+  ["manhattan", "ny", 40.7831, -73.9712],
+  ["brooklyn", "ny", 40.6782, -73.9442],
+  ["queens", "ny", 40.7282, -73.7949],
+  ["bronx", "ny", 40.8448, -73.8648],
+  ["staten island", "ny", 40.5795, -74.1502],
+  ["white plains", "ny", 41.034, -73.7629],
+  ["buffalo", "ny", 42.8864, -78.8784],
+  ["rochester", "ny", 43.1566, -77.6088],
+  ["albany", "ny", 42.6526, -73.7562],
+  ["jersey city", "nj", 40.7178, -74.0431],
+  ["hoboken", "nj", 40.744, -74.0324],
+  ["newark", "nj", 40.7357, -74.1724],
+  ["princeton", "nj", 40.3573, -74.6672],
+  ["boston", "ma", 42.3601, -71.0589],
+  ["cambridge", "ma", 42.3736, -71.1097],
+  ["somerville", "ma", 42.3876, -71.0995],
+  ["waltham", "ma", 42.3765, -71.2356],
+  ["burlington", "ma", 42.5048, -71.1956],
+  ["newton", "ma", 42.337, -71.2092],
+  ["quincy", "ma", 42.2529, -71.0023],
+  ["worcester", "ma", 42.2626, -71.8023],
+  ["providence", "ri", 41.824, -71.4128],
+  ["hartford", "ct", 41.7658, -72.6734],
+  ["stamford", "ct", 41.0534, -73.5387],
+  ["chicago", "il", 41.8781, -87.6298],
+  ["evanston", "il", 42.0451, -87.6877],
+  ["naperville", "il", 41.7508, -88.1535],
+  ["schaumburg", "il", 42.0334, -88.0834],
+  ["minneapolis", "mn", 44.9778, -93.265],
+  ["st. paul", "mn", 44.9537, -93.09],
+  ["bloomington", "mn", 44.8408, -93.2983],
+  ["detroit", "mi", 42.3314, -83.0458],
+  ["ann arbor", "mi", 42.2808, -83.743],
+  ["grand rapids", "mi", 42.9634, -85.6681],
+  ["columbus", "oh", 39.9612, -82.9988],
+  ["cleveland", "oh", 41.4993, -81.6944],
+  ["cincinnati", "oh", 39.1031, -84.512],
+  ["indianapolis", "in", 39.7684, -86.1581],
+  ["milwaukee", "wi", 43.0389, -87.9065],
+  ["madison", "wi", 43.0731, -89.4012],
+  ["st. louis", "mo", 38.627, -90.1994],
+  ["kansas city", "mo", 39.0997, -94.5786],
+  ["denver", "co", 39.7392, -104.9903],
+  ["boulder", "co", 40.015, -105.2705],
+  ["colorado springs", "co", 38.8339, -104.8214],
+  ["fort collins", "co", 40.5853, -105.0844],
+  ["broomfield", "co", 39.9205, -105.0867],
+  ["salt lake city", "ut", 40.7608, -111.891],
+  ["lehi", "ut", 40.3892, -111.8508],
+  ["provo", "ut", 40.2338, -111.6585],
+  ["draper", "ut", 40.5247, -111.8638],
+  ["phoenix", "az", 33.4484, -112.074],
+  ["scottsdale", "az", 33.4942, -111.9261],
+  ["tempe", "az", 33.4255, -111.94],
+  ["chandler", "az", 33.3062, -111.8413],
+  ["tucson", "az", 32.2226, -110.9747],
+  ["las vegas", "nv", 36.1699, -115.1398],
+  ["reno", "nv", 39.5296, -119.8138],
+  ["atlanta", "ga", 33.749, -84.388],
+  ["alpharetta", "ga", 34.0754, -84.2941],
+  ["marietta", "ga", 33.9526, -84.5499],
+  ["raleigh", "nc", 35.7796, -78.6382],
+  ["durham", "nc", 35.994, -78.8986],
+  ["chapel hill", "nc", 35.9132, -79.0558],
+  ["cary", "nc", 35.7915, -78.7811],
+  ["charlotte", "nc", 35.2271, -80.8431],
+  ["washington", "dc", 38.9072, -77.0369],
+  ["alexandria", "va", 38.8048, -77.0469],
+  ["mclean", "va", 38.9339, -77.1773],
+  ["tysons", "va", 38.9187, -77.2311],
+  ["reston", "va", 38.9586, -77.357],
+  ["herndon", "va", 38.9696, -77.3861],
+  ["richmond", "va", 37.5407, -77.436],
+  ["bethesda", "md", 38.9847, -77.0947],
+  ["baltimore", "md", 39.2904, -76.6122],
+  ["rockville", "md", 39.084, -77.1528],
+  ["philadelphia", "pa", 39.9526, -75.1652],
+  ["pittsburgh", "pa", 40.4406, -79.9959],
+  ["miami", "fl", 25.7617, -80.1918],
+  ["fort lauderdale", "fl", 26.1224, -80.1373],
+  ["tampa", "fl", 27.9506, -82.4572],
+  ["orlando", "fl", 28.5383, -81.3792],
+  ["jacksonville", "fl", 30.3322, -81.6557],
+  ["nashville", "tn", 36.1627, -86.7816],
+  ["memphis", "tn", 35.1495, -90.049],
+  ["portland", "or", 45.5152, -122.6784],
+  ["beaverton", "or", 45.4871, -122.8037],
+  ["hillsboro", "or", 45.5229, -122.9898],
+  ["boise", "id", 43.615, -116.2023],
+  // Added: suburbs and hubs the live corpus names that the port did not have.
+  ["foster city", "ca", 37.5585, -122.2711],
+  ["south san francisco", "ca", 37.6547, -122.4077],
+  ["emeryville", "ca", 37.8313, -122.2852],
+  ["milpitas", "ca", 37.4323, -121.8996],
+  ["los gatos", "ca", 37.2358, -121.9624],
+  ["san bruno", "ca", 37.6305, -122.4111],
+  ["hayward", "ca", 37.6688, -122.0808],
+  ["el segundo", "ca", 33.9192, -118.4165],
+  ["torrance", "ca", 33.8358, -118.3406],
+  ["hollywood", "fl", 26.0112, -80.1495],
+  ["boca raton", "fl", 26.3683, -80.1289],
+  ["new orleans", "la", 29.9511, -90.0715],
+  ["louisville", "ky", 38.2527, -85.7585],
+  ["oklahoma city", "ok", 35.4676, -97.5164],
+  ["omaha", "ne", 41.2565, -95.9345],
+  ["des moines", "ia", 41.5868, -93.625],
+  ["albuquerque", "nm", 35.0844, -106.6504],
+  ["honolulu", "hi", 21.3099, -157.8581],
+  ["anchorage", "ak", 61.2181, -149.9003],
+  ["burlington", "vt", 44.4759, -73.2121],
+  ["portland", "me", 43.6591, -70.2568]
+];
+const WORLD = [
+  // Canada
+  ["toronto", "ca-on", 43.6532, -79.3832],
+  ["etobicoke", "ca-on", 43.6205, -79.5132],
+  ["mississauga", "ca-on", 43.589, -79.6441],
+  ["waterloo", "ca-on", 43.4643, -80.5204],
+  ["ottawa", "ca-on", 45.4215, -75.6972],
+  ["montreal", "ca-qc", 45.5017, -73.5673],
+  ["vancouver", "ca-bc", 49.2827, -123.1207],
+  ["calgary", "ca-ab", 51.0447, -114.0719],
+  // Latin America
+  ["mexico city", "mx", 19.4326, -99.1332],
+  ["guadalajara", "mx", 20.6597, -103.3496],
+  ["sao paulo", "br", -23.5505, -46.6333],
+  ["rio de janeiro", "br", -22.9068, -43.1729],
+  ["buenos aires", "ar", -34.6037, -58.3816],
+  ["bogota", "co", 4.711, -74.0721],
+  ["santiago", "cl", -33.4489, -70.6693],
+  // Europe
+  ["london", "gb", 51.5074, -0.1278],
+  ["cambridge", "gb", 52.2053, 0.1218],
+  ["manchester", "gb", 53.4808, -2.2426],
+  ["edinburgh", "gb", 55.9533, -3.1883],
+  ["dublin", "ie", 53.3498, -6.2603],
+  ["cork", "ie", 51.8985, -8.4756],
+  ["berlin", "de", 52.52, 13.405],
+  ["munich", "de", 48.1351, 11.582],
+  ["hamburg", "de", 53.5511, 9.9937],
+  ["frankfurt", "de", 50.1109, 8.6821],
+  ["amsterdam", "nl", 52.3676, 4.9041],
+  ["paris", "fr", 48.8566, 2.3522],
+  ["brussels", "be", 50.8503, 4.3517],
+  ["zurich", "ch", 47.3769, 8.5417],
+  ["geneva", "ch", 46.2044, 6.1432],
+  ["vienna", "at", 48.2082, 16.3738],
+  ["stockholm", "se", 59.3293, 18.0686],
+  ["copenhagen", "dk", 55.6761, 12.5683],
+  ["oslo", "no", 59.9139, 10.7522],
+  ["helsinki", "fi", 60.1699, 24.9384],
+  ["madrid", "es", 40.4168, -3.7038],
+  ["barcelona", "es", 41.3874, 2.1686],
+  ["lisbon", "pt", 38.7223, -9.1393],
+  ["warsaw", "pl", 52.2297, 21.0122],
+  ["krakow", "pl", 50.0647, 19.945],
+  ["prague", "cz", 50.0755, 14.4378],
+  ["bucharest", "ro", 44.4268, 26.1025],
+  ["athens", "gr", 37.9838, 23.7275],
+  ["istanbul", "tr", 41.0082, 28.9784],
+  // Middle East and Africa
+  ["tel aviv", "il", 32.0853, 34.7818],
+  ["dubai", "ae", 25.2048, 55.2708],
+  ["riyadh", "sa", 24.7136, 46.6753],
+  ["abu dhabi", "ae", 24.4539, 54.3773],
+  ["cairo", "eg", 30.0444, 31.2357],
+  ["lagos", "ng", 6.5244, 3.3792],
+  ["nairobi", "ke", -1.2921, 36.8219],
+  ["cape town", "za", -33.9249, 18.4241],
+  // Asia-Pacific
+  ["bengaluru", "in", 12.9716, 77.5946],
+  ["hyderabad", "in", 17.385, 78.4867],
+  ["pune", "in", 18.5204, 73.8567],
+  ["mumbai", "in", 19.076, 72.8777],
+  ["chennai", "in", 13.0827, 80.2707],
+  ["gurugram", "in", 28.4595, 77.0266],
+  ["noida", "in", 28.5355, 77.391],
+  ["new delhi", "in", 28.6139, 77.209],
+  ["singapore", "sg", 1.3521, 103.8198],
+  ["kuala lumpur", "my", 3.139, 101.6869],
+  ["jakarta", "id", -6.2088, 106.8456],
+  ["manila", "ph", 14.5995, 120.9842],
+  ["tokyo", "jp", 35.6762, 139.6503],
+  ["osaka", "jp", 34.6937, 135.5023],
+  ["bangkok", "th", 13.7563, 100.5018],
+  ["seoul", "kr", 37.5665, 126.978],
+  ["taipei", "tw", 25.033, 121.5654],
+  ["taoyuan", "tw", 24.9936, 121.301],
+  ["hong kong", "hk", 22.3193, 114.1694],
+  ["shanghai", "cn", 31.2304, 121.4737],
+  ["beijing", "cn", 39.9042, 116.4074],
+  ["shenzhen", "cn", 22.5431, 114.0579],
+  ["sydney", "au", -33.8688, 151.2093],
+  ["melbourne", "au", -37.8136, 144.9631],
+  ["auckland", "nz", -36.8485, 174.7633],
+  // US places that share a name with one above, declared after it so the
+  // bare name keeps meaning the other: "Dublin" alone is Ireland.
+  ["dublin", "ca", 37.7022, -121.9358]
+];
+const ALIASES = {
+  "new york city": "new york|ny",
+  nyc: "new york|ny",
+  "st paul": "st. paul|mn",
+  "saint paul": "st. paul|mn",
+  "saint louis": "st. louis|mo",
+  "st louis": "st. louis|mo",
+  "washington dc": "washington|dc",
+  "washington d c": "washington|dc",
+  bangalore: "bengaluru|in",
+  gurgaon: "gurugram|in",
+  delhi: "new delhi|in",
+  munchen: "munich|de",
+  "tel aviv yafo": "tel aviv|il"
+};
+const US_STATES = {
+  al: "alabama",
+  ak: "alaska",
+  az: "arizona",
+  ar: "arkansas",
+  ca: "california",
+  co: "colorado",
+  ct: "connecticut",
+  de: "delaware",
+  fl: "florida",
+  ga: "georgia",
+  hi: "hawaii",
+  id: "idaho",
+  il: "illinois",
+  in: "indiana",
+  ia: "iowa",
+  ks: "kansas",
+  ky: "kentucky",
+  la: "louisiana",
+  me: "maine",
+  md: "maryland",
+  ma: "massachusetts",
+  mi: "michigan",
+  mn: "minnesota",
+  ms: "mississippi",
+  mo: "missouri",
+  mt: "montana",
+  ne: "nebraska",
+  nv: "nevada",
+  nh: "new hampshire",
+  nj: "new jersey",
+  nm: "new mexico",
+  ny: "new york",
+  nc: "north carolina",
+  nd: "north dakota",
+  oh: "ohio",
+  ok: "oklahoma",
+  or: "oregon",
+  pa: "pennsylvania",
+  ri: "rhode island",
+  sc: "south carolina",
+  sd: "south dakota",
+  tn: "tennessee",
+  tx: "texas",
+  ut: "utah",
+  vt: "vermont",
+  va: "virginia",
+  wa: "washington",
+  wv: "west virginia",
+  wi: "wisconsin",
+  wy: "wyoming",
+  dc: "district of columbia"
+};
+const COUNTRY_WORDS = {
+  "ca-on": ["canada", "ontario"],
+  "ca-qc": ["canada", "quebec"],
+  "ca-bc": ["canada", "british columbia"],
+  "ca-ab": ["canada", "alberta"],
+  mx: ["mexico"],
+  br: ["brazil", "brasil"],
+  ar: ["argentina"],
+  co: ["colombia"],
+  cl: ["chile"],
+  gb: ["uk", "united kingdom", "england", "scotland", "great britain"],
+  ie: ["ireland"],
+  de: ["germany", "deutschland"],
+  nl: ["netherlands"],
+  fr: ["france"],
+  be: ["belgium"],
+  ch: ["switzerland"],
+  at: ["austria"],
+  se: ["sweden"],
+  dk: ["denmark"],
+  no: ["norway"],
+  fi: ["finland"],
+  es: ["spain"],
+  pt: ["portugal"],
+  pl: ["poland"],
+  cz: ["czechia", "czech republic"],
+  ro: ["romania"],
+  gr: ["greece"],
+  tr: ["turkey", "turkiye"],
+  il: ["israel"],
+  ae: ["uae", "united arab emirates"],
+  eg: ["egypt"],
+  ng: ["nigeria"],
+  ke: ["kenya"],
+  za: ["south africa"],
+  in: ["india"],
+  sg: ["singapore"],
+  my: ["malaysia"],
+  id: ["indonesia"],
+  ph: ["philippines"],
+  jp: ["japan"],
+  kr: ["korea", "south korea"],
+  tw: ["taiwan"],
+  hk: ["hong kong"],
+  cn: ["china"],
+  au: ["australia"],
+  nz: ["new zealand"],
+  th: ["thailand"],
+  sa: ["saudi arabia"]
+};
+function fold(s) {
+  return ` ${s.normalize("NFD").replace(/[̀-ͯ]/g, "").toLowerCase().replace(/[^a-z0-9]+/g, " ").trim()} `;
+}
+function slug(name) {
+  return fold(name).trim().replace(/ /g, "-");
+}
+const PLACES = [...US, ...WORLD].map(([name, region, lat, lng]) => ({
+  key: `${slug(name)}-${region}`,
+  name,
+  region,
+  lat,
+  lng
+}));
+const BY_KEY = new Map(PLACES.map((p) => [p.key, p]));
+const BY_PHRASE = /* @__PURE__ */ new Map();
+function addPhrase(phrase, place) {
+  const f = fold(phrase);
+  const list = BY_PHRASE.get(f) ?? [];
+  if (!list.includes(place)) list.push(place);
+  BY_PHRASE.set(f, list);
+}
+for (const p of PLACES) addPhrase(p.name, p);
+for (const [alias, target] of Object.entries(ALIASES)) {
+  const [name, region] = target.split("|");
+  const p = BY_KEY.get(`${slug(name)}-${region}`);
+  if (!p) throw new Error(`geo alias '${alias}' names no place (${target})`);
+  addPhrase(alias, p);
+}
+const PHRASES = [...BY_PHRASE.keys()].sort((a, b) => b.length - a.length);
+const STATE_NAMES = new Set(Object.values(US_STATES));
+const ALL_REGIONS = [...Object.keys(US_STATES), ...Object.keys(COUNTRY_WORDS)];
+function regionNamed(raw, folded, region) {
+  const stateName = US_STATES[region];
+  if (stateName) {
+    const code = region.toUpperCase();
+    if (new RegExp(`(?:^|[^A-Za-z])${code}(?:[^A-Za-z]|$)`).test(raw)) return true;
+    if (region === "dc" && /\bD\.C\.?/.test(raw)) return true;
+    return folded.includes(` ${stateName} `);
+  }
+  return (COUNTRY_WORDS[region] ?? []).some((w) => folded.includes(fold(w)));
+}
+function soleRegion(raw, folded) {
+  const named = ALL_REGIONS.filter((r) => regionNamed(raw, folded, r));
+  return named.length === 1 ? named[0] : null;
+}
+const SEGMENT = /\s*[|;/]\s*|\s+or\s+|\s+and\s+/;
+function placesInSegment(raw, found) {
+  const evidenceText = fold(raw);
+  let folded = evidenceText;
+  const sole = soleRegion(raw, evidenceText);
+  for (const phrase of PHRASES) {
+    if (!folded.includes(phrase)) continue;
+    const candidates = BY_PHRASE.get(phrase);
+    const evidenced = candidates.filter((p) => regionNamed(raw, evidenceText, p.region));
+    let pick = evidenced[0];
+    if (!pick) {
+      const first = candidates[0];
+      const isOtherState = STATE_NAMES.has(first.name) && US_STATES[first.region] !== first.name;
+      const elsewhere = sole !== null && !candidates.some((p) => p.region === sole);
+      if (!isOtherState && !elsewhere) pick = first;
+    }
+    if (pick && !found.includes(pick)) found.push(pick);
+    folded = folded.split(phrase).join(" | ");
+  }
+}
+function findPlaces(location) {
+  if (!location) return [];
+  const found = [];
+  for (const segment of location.split(SEGMENT)) {
+    if (segment.trim()) placesInSegment(segment, found);
+  }
+  return found;
+}
+function geoKeys(location) {
+  const keys = findPlaces(location).map((p) => p.key);
+  return keys.length ? `|${keys.join("|")}|` : "";
+}
+const EARTH_RADIUS_MILES = 3958.8;
+function milesBetween(a, b) {
+  const rad = (d) => d * Math.PI / 180;
+  const dLat = rad(b.lat - a.lat);
+  const dLng = rad(b.lng - a.lng);
+  const h = Math.sin(dLat / 2) ** 2 + Math.cos(rad(a.lat)) * Math.cos(rad(b.lat)) * Math.sin(dLng / 2) ** 2;
+  return 2 * EARTH_RADIUS_MILES * Math.asin(Math.sqrt(h));
+}
+function resolvePlace(q) {
+  return BY_KEY.get(q.trim().toLowerCase()) ?? findPlaces(q)[0] ?? null;
+}
+function placesWithin(center, miles) {
+  return PLACES.map((p) => ({ p, d: milesBetween(center, p) })).filter(({ d }) => d <= miles).sort((a, b) => a.d - b.d).map(({ p }) => p);
+}
+function searchPlaces(q, limit = 10) {
+  const f = fold(q).trim();
+  if (!f) return [];
+  const starts = PLACES.filter((p) => fold(p.name).trim().startsWith(f));
+  const contains = PLACES.filter((p) => !starts.includes(p) && fold(p.name).includes(f));
+  return [...starts, ...contains].slice(0, limit);
+}
 const AMOUNT = String.raw`(?:\$\s*(\d{2,3}(?:,\d{3})+|\d{2,3}(?:\.\d+)?[kK])|(\d{2,3}(?:,\d{3})+|\d{2,3}(?:\.\d+)?[kK])\s*(?=USD))`;
 const RANGE_RE = new RegExp(`${AMOUNT}(?:\\s*USD)?\\s*(?:[-–—]|to)\\s*${AMOUNT}(?:\\s*USD)?`, "g");
 const NON_ANNUAL_CONTEXT = /(?:per\s+hour|hourly|\/\s*(?:hr|hour)|per\s+month|monthly|per\s+week|weekly|per\s+day)/i;
@@ -2025,6 +2634,7 @@ async function rankNewJobs(db) {
 app$4.use("/ingest", requireMinTier("friend"));
 app$4.use("/ingest/backfill-slugs", requireMinTier("friend"));
 app$4.use("/ingest/backfill-roles", requireMinTier("friend"));
+app$4.use("/ingest/backfill-geo", requireMinTier("friend"));
 app$4.use("/ingest/backfill-salary", requireMinTier("friend"));
 app$4.use("/ingest/cull", requireMinTier("friend"));
 app$4.use("/ingest/rebuild-rank", requireMinTier("friend"));
@@ -2066,8 +2676,8 @@ app$4.openapi(ingestRoute, async (c) => {
     const salaryMax = structuredMax ?? prose?.max ?? null;
     const parsed = parseAtsSlug(job.url);
     const ats = parsed.ats ?? (board_slug ? source : null);
-    const slug = board_slug ?? parsed.slug;
-    const slugSource = slug === null ? null : board_slug ? "scraped" : "guessed";
+    const slug2 = board_slug ?? parsed.slug;
+    const slugSource = slug2 === null ? null : board_slug ? "scraped" : "guessed";
     const role = classifyRole(job.title, job.description);
     return db.prepare(
       `INSERT OR IGNORE INTO jobs (
@@ -2075,8 +2685,8 @@ app$4.openapi(ingestRoute, async (c) => {
 					job_type, workplace_type, salary_min, salary_max,
 					description, posted_date, application_url, department,
 					scraper_used, raw, scraped_at, last_seen_at, ats, slug,
-					role_track, role_level, slug_source
-				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
+					role_track, role_level, slug_source, geo_keys
+				) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`
     ).bind(
       job.id,
       job.url,
@@ -2097,10 +2707,11 @@ app$4.openapi(ingestRoute, async (c) => {
       now,
       now,
       ats,
-      slug,
+      slug2,
       role.track,
       role.level,
-      slugSource
+      slugSource,
+      geoKeys(job.location)
     );
   });
   const inserted = [];
@@ -2201,12 +2812,12 @@ app$4.openapi(backfillRoute, async (c) => {
   let updated = 0;
   let unmatched = 0;
   for (const row of rows.results) {
-    const { ats, slug } = parseAtsSlug(row.url);
-    if (ats === null && slug === null) {
+    const { ats, slug: slug2 } = parseAtsSlug(row.url);
+    if (ats === null && slug2 === null) {
       unmatched++;
       continue;
     }
-    await db.prepare("UPDATE jobs SET ats = ?, slug = ? WHERE id = ?").bind(ats, slug, row.id).run();
+    await db.prepare("UPDATE jobs SET ats = ?, slug = ? WHERE id = ?").bind(ats, slug2, row.id).run();
     updated++;
   }
   const remainingRow = await db.prepare("SELECT COUNT(*) as n FROM jobs WHERE ats IS NULL OR slug IS NULL").first();
@@ -2339,6 +2950,81 @@ app$4.openapi(backfillRolesRoute, async (c) => {
     }
   });
 });
+const backfillGeoRoute = createRoute({
+  method: "post",
+  path: "/ingest/backfill-geo",
+  tags: ["Ingest"],
+  summary: "Populate jobs.geo_keys from each posting's location",
+  description: "Bounded by `limit` (default 1000) per call. Default mode: rows still NULL, loop until `has_more` is false. `reread=true`: every row by id, passing back `next_after` as `after` until `has_more` is false.",
+  request: {
+    query: z.object({
+      limit: z.coerce.number().int().min(1).max(2e3).default(1e3),
+      reread: z.enum(["true", "false"]).default("false"),
+      after: z.string().default("").openapi({ description: "reread only: the id to resume after" })
+    })
+  },
+  responses: {
+    200: {
+      description: "Backfill batch complete",
+      content: {
+        "application/json": {
+          schema: z.object({
+            success: z.literal(true),
+            data: z.object({
+              scanned: z.number(),
+              placed: z.number(),
+              remaining: z.number().nullable(),
+              next_after: z.string().nullable(),
+              has_more: z.boolean()
+            })
+          }).openapi("BackfillGeoResponse")
+        }
+      }
+    }
+  }
+});
+app$4.openapi(backfillGeoRoute, async (c) => {
+  const { limit, reread, after } = c.req.valid("query");
+  const db = c.env.JOB_PLATFORM_DB;
+  const all = reread === "true";
+  const rows = await db.prepare(
+    all ? "SELECT id, location FROM jobs WHERE id > ? ORDER BY id LIMIT ?" : "SELECT id, location FROM jobs WHERE geo_keys IS NULL LIMIT ?"
+  ).bind(...all ? [after, limit] : [limit]).all();
+  let placed = 0;
+  const stmts = rows.results.map((row) => {
+    const keys = geoKeys(row.location ?? "");
+    if (keys) placed++;
+    return db.prepare("UPDATE jobs SET geo_keys = ? WHERE id = ?").bind(keys, row.id);
+  });
+  for (let i = 0; i < stmts.length; i += INGEST_BATCH_CHUNK) {
+    await db.batch(stmts.slice(i, i + INGEST_BATCH_CHUNK));
+  }
+  if (all) {
+    const last = rows.results.at(-1)?.id ?? null;
+    return c.json({
+      success: true,
+      data: {
+        scanned: rows.results.length,
+        placed,
+        remaining: null,
+        next_after: last,
+        has_more: rows.results.length === limit
+      }
+    });
+  }
+  const remainingRow = await db.prepare("SELECT COUNT(*) AS n FROM jobs WHERE geo_keys IS NULL").first();
+  const remaining = remainingRow?.n ?? 0;
+  return c.json({
+    success: true,
+    data: {
+      scanned: rows.results.length,
+      placed,
+      remaining,
+      next_after: null,
+      has_more: remaining > 0
+    }
+  });
+});
 const directivesRoute = createRoute({
   method: "get",
   path: "/directives",
@@ -2743,7 +3429,7 @@ async function requireIdentity(c, next) {
       c.env.HADOKU_SERVICE_KEY ?? "",
       owner,
       Date.now(),
-      (label, work) => runAfterResponse(c, label, work)
+      (label2, work) => runAfterResponse(c, label2, work)
     );
     if (isIdentityError(resolved)) {
       const status = [404, 409, 503].includes(resolved.status) ? resolved.status : 503;
@@ -3036,7 +3722,7 @@ app$3.openapi(
     const userId = await currentUserId(c);
     const db = c.env.JOB_PLATFORM_DB;
     const { profileId } = c.req.valid("param");
-    const { ats, slug, display_name } = c.req.valid("json");
+    const { ats, slug: slug2, display_name } = c.req.valid("json");
     if (!await ownedProfile(db, userId, profileId)) {
       return c.json(
         {
@@ -3052,10 +3738,10 @@ app$3.openapi(
     await db.prepare(
       `INSERT OR IGNORE INTO profile_companies (id, profile_id, ats, slug, display_name, target_id, added_at)
 				 VALUES (?, ?, ?, ?, ?, NULL, ?)`
-    ).bind(id, profileId, ats, slug, display_name, now).run();
+    ).bind(id, profileId, ats, slug2, display_name, now).run();
     const row = await db.prepare(
       "SELECT id, ats, slug, display_name, added_at FROM profile_companies WHERE profile_id = ? AND ats = ? AND slug = ?"
-    ).bind(profileId, ats, slug).first();
+    ).bind(profileId, ats, slug2).first();
     let searchTriggered = false;
     try {
       await triggerSearch(c.env);
@@ -3156,6 +3842,7 @@ function deserializeProfile(r) {
   };
 }
 const profileRoutes = app$3;
+const MAX_NEARBY = 80;
 const LIGHT_CANDIDATE_CAP = 5e4;
 const FULL_SCORE_CAP = 800;
 const ID_CHUNK = 100;
@@ -3226,7 +3913,7 @@ function registerFeedRoute(app2) {
         query: z.object({
           ownerName: ownerNameQuery.shape.ownerName,
           profile_id: z.string().optional().openapi({ description: "Filter/score by profile. Omit to list all jobs unscored." }),
-          state: z.enum(["interested", "dismissed", "saved", "applied", "new"]).optional().openapi({
+          state: z.enum(["new", ...JOB_STATES]).optional().openapi({
             description: 'Filter to a single triage state for the authed user. Requires admin/friend auth. "new" filters to jobs without any state row.'
           }),
           hide_dismissed: z.enum(["true", "false"]).optional().openapi({
@@ -3244,6 +3931,13 @@ function registerFeedRoute(app2) {
             description: "Filter to one workplace type (e.g. full-remote only)."
           }),
           min_score: z.coerce.number().min(0).max(1).default(0).openapi({ description: "Minimum score filter" }),
+          near: z.string().trim().min(1).max(100).optional().openapi({
+            description: 'Radius filter centre: a place key from GET /locations, or free text ("Seattle, WA"). Keeps postings that name a place within radius_miles of it (and remote ones, unless include_remote=false). A posting whose location names no known place is only kept as remote. 400 when nothing matches.'
+          }),
+          radius_miles: z.coerce.number().int().min(1).max(500).default(25).openapi({ description: "Radius for near=, in miles." }),
+          include_remote: z.enum(["true", "false"]).default("true").openapi({
+            description: "With near=, also keep remote postings wherever they are."
+          }),
           min_salary: z.coerce.number().min(0).optional().openapi({
             description: "View filter: drop jobs whose salary_max is below this. Jobs with no listed salary are kept — most postings omit it, and hiding them would hide the corpus."
           })
@@ -3254,6 +3948,10 @@ function registerFeedRoute(app2) {
           description: "Job list",
           content: { "application/json": { schema: JobsResponseSchema } }
         },
+        400: {
+          description: "near= names no known place",
+          content: { "application/json": { schema: ErrorResponseSchema } }
+        },
         401: {
           description: "state= requires auth",
           content: { "application/json": { schema: ErrorResponseSchema } }
@@ -3288,7 +3986,10 @@ function registerFeedRoute(app2) {
         sort,
         workplace,
         min_score,
-        min_salary
+        min_salary,
+        near,
+        radius_miles,
+        include_remote
       } = c.req.valid("query");
       const hideDismissed = hideDismissedRaw === "true";
       const hideQueued = hideQueuedRaw === "true";
@@ -3338,6 +4039,24 @@ function registerFeedRoute(app2) {
         wheres.push("(j.salary_max IS NULL OR j.salary_max >= ?)");
         whereBinds.push(min_salary);
       }
+      if (near) {
+        const center = resolvePlace(near);
+        if (!center) {
+          return c.json(
+            {
+              success: false,
+              error: "Bad request",
+              message: `No known place matches '${near}' — try GET /locations?q=`
+            },
+            400
+          );
+        }
+        const nearby = placesWithin(center, radius_miles).slice(0, MAX_NEARBY);
+        const terms = nearby.map(() => "j.geo_keys LIKE ?");
+        if (include_remote === "true") terms.unshift("j.workplace_type = 'remote'");
+        wheres.push(`(${terms.join(" OR ")})`);
+        whereBinds.push(...nearby.map((p) => `%|${p.key}|%`));
+      }
       if (userId) {
         if (stateFilter === "new") {
           wheres.push("js.state IS NULL");
@@ -3348,6 +4067,13 @@ function registerFeedRoute(app2) {
           wheres.push("(js.state IS NULL OR js.state != 'dismissed')");
         }
         if (hideQueued && !stateFilter) wheres.push("ap.id IS NULL");
+        if (!stateFilter) {
+          wheres.push(
+            `NOT EXISTS (SELECT 1 FROM blocked_companies b
+						  WHERE b.user_id = ? AND b.company_key = LOWER(TRIM(j.company)))`
+          );
+          whereBinds.push(userId);
+        }
       }
       const whereClause = wheres.length > 0 ? `WHERE ${wheres.join(" AND ")}` : "";
       const andWheres = wheres.length > 0 ? ` AND ${wheres.join(" AND ")}` : "";
@@ -3471,7 +4197,7 @@ function registerFeedRoute(app2) {
               r.row_vote
             ),
             score_breakdown: breakdown,
-            state: userId ? r.row_state ?? "new" : null,
+            state: userId ? asJobStateRead(r.row_state) : null,
             application_status: asApplicationStatus(r.row_application),
             vote: r.row_vote ?? null,
             vote_reasons: r.row_vote_reasons ? String(r.row_vote_reasons).split(",") : []
@@ -3547,7 +4273,7 @@ function registerFeedRoute(app2) {
         role_level: asRoleLevel(r.role_level),
         score: 0,
         score_breakdown: ZERO_BREAKDOWN,
-        state: userId ? r.row_state ?? "new" : null,
+        state: userId ? asJobStateRead(r.row_state) : null,
         application_status: asApplicationStatus(r.row_application)
       }));
       return c.json(
@@ -3654,7 +4380,7 @@ function registerPacketsRoute(app2) {
         title: r.title,
         company: r.company,
         location: r.location,
-        state: r.state,
+        state: asJobStateRead(r.state),
         variant_slug: r.variant_slug,
         updated_at: r.updated_at
       }));
@@ -3701,6 +4427,318 @@ function applyTier(applicationUrl, ats) {
   if (KNOWN_UNSUPPORTED.some((h) => host === h || host.endsWith(`.${h}`))) return "unsupported";
   return "unknown";
 }
+const IDENTITY_ERRORS = {
+  404: {
+    description: "No such owner name, or no such job",
+    content: { "application/json": { schema: IdentityErrorResponseSchema } }
+  },
+  409: {
+    description: "That owner name has never signed in, or the posting is not in the pipeline",
+    content: { "application/json": { schema: IdentityErrorResponseSchema } }
+  },
+  503: {
+    description: "Identity could not be resolved right now — retry",
+    content: { "application/json": { schema: IdentityErrorResponseSchema } }
+  }
+};
+const FORBIDDEN$1 = {
+  description: "Forbidden",
+  content: { "application/json": { schema: IdentityErrorResponseSchema } }
+};
+const EVENT_COLS = "id, job_id, kind, from_state, to_state, note, occurred_at, created_at";
+const TRACKING_COLS = "notes, priority, follow_up_at, contact_name, contact_email";
+function stateOrNull(v) {
+  const s = asJobStateRead(v);
+  return s === "new" ? null : s;
+}
+function toEvent(r) {
+  return {
+    ...r,
+    kind: r.kind,
+    from_state: stateOrNull(r.from_state),
+    to_state: stateOrNull(r.to_state)
+  };
+}
+function asPriority(p) {
+  return p === 1 || p === 2 || p === 3 ? p : null;
+}
+function toTracking(r) {
+  return {
+    notes: r.notes,
+    priority: asPriority(r.priority),
+    follow_up_at: r.follow_up_at,
+    contact_name: r.contact_name,
+    contact_email: r.contact_email
+  };
+}
+function notInPipeline(id) {
+  return {
+    success: false,
+    error: "Conflict",
+    message: `Job '${id}' is not in your pipeline — set its state first (PUT /jobs/${id}/state)`
+  };
+}
+function jobNotFound(id) {
+  return { success: false, error: "Not found", message: `Job '${id}' not found` };
+}
+async function stateOf(db, jobId, userId) {
+  const row = await db.prepare(
+    `SELECT j.id, js.state FROM jobs j
+			 LEFT JOIN job_states js ON js.job_id = j.id AND js.user_id = ?
+			 WHERE j.id = ?`
+  ).bind(userId, jobId).first();
+  if (!row) return "missing";
+  return row.state ? "tracked" : "untracked";
+}
+function registerPipelineRoutes(app2) {
+  app2.get("/pipeline", gateAuthed);
+  app2.patch("/jobs/:id/tracking", gateAuthed);
+  app2.get("/jobs/:id/events", gateAuthed);
+  app2.post("/jobs/:id/events", gateAuthed);
+  app2.delete("/jobs/:id/events/:eventId", gateAuthed);
+  app2.openapi(
+    createRoute({
+      method: "get",
+      path: "/pipeline",
+      tags: ["Pipeline"],
+      summary: "Every posting in the caller's pipeline, most recently changed first",
+      request: {
+        query: ownerNameQuery.extend({
+          include_dismissed: z.enum(["true", "false"]).optional().openapi({
+            description: "Dismissed postings are left out unless this is true."
+          })
+        })
+      },
+      responses: {
+        200: {
+          description: "Pipeline",
+          content: { "application/json": { schema: PipelineResponseSchema } }
+        },
+        403: FORBIDDEN$1,
+        ...IDENTITY_ERRORS
+      }
+    }),
+    async (c) => {
+      const { ownerName, include_dismissed } = c.req.valid("query");
+      const who = await effectiveUserId(c, ownerName);
+      if (isEffectiveUserError(who)) return c.json(who.error.body, who.error.status);
+      const dismissed = include_dismissed === "true" ? "" : "AND js.state != 'dismissed'";
+      const rows = await c.env.JOB_PLATFORM_DB.prepare(
+        `SELECT js.job_id, j.title, j.company, j.location, j.workplace_type,
+				        j.salary_min, j.salary_max, j.url, j.posted_date,
+				        js.state, js.updated_at, js.variant_slug,
+				        js.notes, js.priority, js.follow_up_at, js.contact_name, js.contact_email,
+				        ap.status AS application_status,
+				        (SELECT MIN(e.occurred_at) FROM job_events e
+				          WHERE e.job_id = js.job_id AND e.user_id = js.user_id
+				            AND e.kind = 'state' AND e.to_state = 'applied') AS applied_at,
+				        (SELECT MAX(e.occurred_at) FROM job_events e
+				          WHERE e.job_id = js.job_id AND e.user_id = js.user_id) AS last_event_at
+				 FROM job_states js
+				 JOIN jobs j ON j.id = js.job_id
+				 LEFT JOIN applications ap ON ap.job_id = js.job_id AND ap.user_id = js.user_id
+				 WHERE js.user_id = ? ${dismissed}
+				 ORDER BY js.updated_at DESC`
+      ).bind(who.userId).all();
+      const items = rows.results.flatMap((r) => {
+        const state = stateOrNull(r.state);
+        if (!state) return [];
+        return [
+          {
+            job_id: r.job_id,
+            title: r.title,
+            company: r.company,
+            location: r.location,
+            workplace_type: r.workplace_type,
+            salary_min: r.salary_min,
+            salary_max: r.salary_max,
+            url: r.url,
+            posted_date: r.posted_date,
+            state,
+            updated_at: r.updated_at,
+            tracking: toTracking(r),
+            variant_slug: r.variant_slug,
+            application_status: asApplicationStatus(r.application_status),
+            applied_at: r.applied_at,
+            last_event_at: r.last_event_at
+          }
+        ];
+      });
+      return c.json({ success: true, data: { items } }, 200);
+    }
+  );
+  app2.openapi(
+    createRoute({
+      method: "patch",
+      path: "/jobs/{id}/tracking",
+      tags: ["Pipeline"],
+      summary: "Change what the caller tracks about one application; null clears a field",
+      request: {
+        params: z.object({ id: z.string() }),
+        query: ownerNameQuery,
+        body: { content: { "application/json": { schema: SetTrackingSchema } } }
+      },
+      responses: {
+        200: {
+          description: "Tracking after the change",
+          content: { "application/json": { schema: TrackingResponseSchema } }
+        },
+        403: FORBIDDEN$1,
+        ...IDENTITY_ERRORS
+      }
+    }),
+    async (c) => {
+      const { id } = c.req.valid("param");
+      const { ownerName } = c.req.valid("query");
+      const body = c.req.valid("json");
+      const who = await effectiveUserId(c, ownerName);
+      if (isEffectiveUserError(who)) return c.json(who.error.body, who.error.status);
+      const db = c.env.JOB_PLATFORM_DB;
+      const sets = [];
+      const binds = [];
+      for (const col of [
+        "notes",
+        "priority",
+        "follow_up_at",
+        "contact_name",
+        "contact_email"
+      ]) {
+        const v = body[col];
+        if (v === void 0) continue;
+        sets.push(`${col} = ?`);
+        binds.push(typeof v === "string" && v.trim() === "" ? null : v);
+      }
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const row = await db.prepare(
+        `UPDATE job_states SET ${sets.join(", ")}, updated_at = ?
+					 WHERE job_id = ? AND user_id = ?
+					 RETURNING ${TRACKING_COLS}`
+      ).bind(...binds, now, id, who.userId).first();
+      if (!row) {
+        const s = await stateOf(db, id, who.userId);
+        return s === "missing" ? c.json(jobNotFound(id), 404) : c.json(notInPipeline(id), 409);
+      }
+      return c.json(
+        { success: true, data: { job_id: id, tracking: toTracking(row) } },
+        200
+      );
+    }
+  );
+  app2.openapi(
+    createRoute({
+      method: "get",
+      path: "/jobs/{id}/events",
+      tags: ["Pipeline"],
+      summary: "One posting's timeline for the caller, oldest first",
+      request: { params: z.object({ id: z.string() }), query: ownerNameQuery },
+      responses: {
+        200: {
+          description: "Timeline (empty for a posting with none)",
+          content: { "application/json": { schema: JobEventsResponseSchema } }
+        },
+        403: FORBIDDEN$1,
+        ...IDENTITY_ERRORS
+      }
+    }),
+    async (c) => {
+      const { id } = c.req.valid("param");
+      const { ownerName } = c.req.valid("query");
+      const who = await effectiveUserId(c, ownerName);
+      if (isEffectiveUserError(who)) return c.json(who.error.body, who.error.status);
+      const rows = await c.env.JOB_PLATFORM_DB.prepare(
+        `SELECT ${EVENT_COLS} FROM job_events
+				 WHERE job_id = ? AND user_id = ?
+				 ORDER BY occurred_at, id`
+      ).bind(id, who.userId).all();
+      return c.json({ success: true, data: { events: rows.results.map(toEvent) } }, 200);
+    }
+  );
+  app2.openapi(
+    createRoute({
+      method: "post",
+      path: "/jobs/{id}/events",
+      tags: ["Pipeline"],
+      summary: "Log something that happened on one application",
+      request: {
+        params: z.object({ id: z.string() }),
+        query: ownerNameQuery,
+        body: { content: { "application/json": { schema: AddJobEventSchema } } }
+      },
+      responses: {
+        201: {
+          description: "Logged",
+          content: { "application/json": { schema: JobEventResponseSchema } }
+        },
+        403: FORBIDDEN$1,
+        ...IDENTITY_ERRORS
+      }
+    }),
+    async (c) => {
+      const { id } = c.req.valid("param");
+      const { ownerName } = c.req.valid("query");
+      const body = c.req.valid("json");
+      const who = await effectiveUserId(c, ownerName);
+      if (isEffectiveUserError(who)) return c.json(who.error.body, who.error.status);
+      const db = c.env.JOB_PLATFORM_DB;
+      const s = await stateOf(db, id, who.userId);
+      if (s === "missing") return c.json(jobNotFound(id), 404);
+      if (s === "untracked") return c.json(notInPipeline(id), 409);
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      const occurred = body.occurred_at ? new Date(
+        body.occurred_at.length === 10 ? `${body.occurred_at}T00:00:00Z` : body.occurred_at
+      ).toISOString() : now;
+      const row = await db.prepare(
+        `INSERT INTO job_events
+					   (job_id, user_id, kind, from_state, to_state, note, occurred_at, created_at)
+					 VALUES (?, ?, ?, NULL, NULL, ?, ?, ?)
+					 RETURNING ${EVENT_COLS}`
+      ).bind(id, who.userId, body.kind, body.note, occurred, now).first();
+      if (!row) throw new Error("job_events INSERT … RETURNING returned no row");
+      return c.json({ success: true, data: { event: toEvent(row) } }, 201);
+    }
+  );
+  app2.openapi(
+    createRoute({
+      method: "delete",
+      path: "/jobs/{id}/events/{eventId}",
+      tags: ["Pipeline"],
+      summary: "Remove a note/interview/contact/follow-up the caller logged",
+      request: {
+        params: z.object({ id: z.string(), eventId: z.coerce.number().int().positive() }),
+        query: ownerNameQuery
+      },
+      responses: {
+        200: {
+          description: "Removed (or already absent)",
+          content: {
+            "application/json": {
+              schema: z.object({
+                success: z.literal(true),
+                data: z.object({ id: z.number().int(), deleted: z.boolean() })
+              }).openapi("DeleteJobEventResponse")
+            }
+          }
+        },
+        403: FORBIDDEN$1,
+        ...IDENTITY_ERRORS
+      }
+    }),
+    async (c) => {
+      const { id, eventId } = c.req.valid("param");
+      const { ownerName } = c.req.valid("query");
+      const who = await effectiveUserId(c, ownerName);
+      if (isEffectiveUserError(who)) return c.json(who.error.body, who.error.status);
+      const res = await c.env.JOB_PLATFORM_DB.prepare(
+        `DELETE FROM job_events
+				 WHERE id = ? AND job_id = ? AND user_id = ? AND kind != 'state'`
+      ).bind(eventId, id, who.userId).run();
+      return c.json(
+        { success: true, data: { id: eventId, deleted: (res.meta?.changes ?? 0) > 0 } },
+        200
+      );
+    }
+  );
+}
 function registerDetailRoute(app2) {
   app2.openapi(
     createRoute({
@@ -3758,6 +4796,7 @@ function registerDetailRoute(app2) {
       const userId = await maybeUserId(c);
       let state = null;
       let stateUpdatedAt = null;
+      let tracking = null;
       let applyVerified = false;
       if (userId && row.ats && row.slug) {
         const proven = await db.prepare(
@@ -3779,12 +4818,15 @@ function registerDetailRoute(app2) {
       let applicationStatus = null;
       if (userId) {
         const [stateRes, appRes] = await db.batch([
-          db.prepare("SELECT state, updated_at FROM job_states WHERE job_id = ? AND user_id = ?").bind(id, userId),
+          db.prepare(
+            `SELECT state, updated_at, ${TRACKING_COLS} FROM job_states WHERE job_id = ? AND user_id = ?`
+          ).bind(id, userId),
           db.prepare("SELECT status FROM applications WHERE job_id = ? AND user_id = ?").bind(id, userId)
         ]);
         const stateRow = stateRes.results[0];
-        state = stateRow ? stateRow.state : "new";
+        state = asJobStateRead(stateRow?.state);
         stateUpdatedAt = stateRow?.updated_at ?? null;
+        tracking = stateRow ? toTracking(stateRow) : null;
         const appRow = appRes.results[0];
         applicationStatus = appRow?.status ?? null;
       }
@@ -3820,7 +4862,8 @@ function registerDetailRoute(app2) {
         score_breakdown,
         state,
         application_status: asApplicationStatus(applicationStatus),
-        state_updated_at: stateUpdatedAt
+        state_updated_at: stateUpdatedAt,
+        tracking
       };
       return c.json({ success: true, data: { job } }, 200);
     }
@@ -3865,7 +4908,11 @@ function registerStateRoutes(app2) {
       const { id } = c.req.valid("param");
       const body = c.req.valid("json");
       const db = c.env.JOB_PLATFORM_DB;
-      const exists = await db.prepare("SELECT id FROM jobs WHERE id = ?").bind(id).first();
+      const exists = await db.prepare(
+        `SELECT j.id, js.state AS prev FROM jobs j
+					 LEFT JOIN job_states js ON js.job_id = j.id AND js.user_id = ?
+					 WHERE j.id = ?`
+      ).bind(userId, id).first();
       if (!exists) {
         return c.json(
           { success: false, error: "Not found", message: `Job '${id}' not found` },
@@ -3874,14 +4921,26 @@ function registerStateRoutes(app2) {
       }
       const now = (/* @__PURE__ */ new Date()).toISOString();
       const variantSlug = body.variant_slug ?? null;
-      await db.prepare(
+      const upsert = db.prepare(
         `INSERT INTO job_states (job_id, user_id, state, notes, updated_at, variant_slug)
 					 VALUES (?, ?, ?, NULL, ?, ?)
 					 ON CONFLICT (job_id, user_id) DO UPDATE SET
 					   state = excluded.state,
 					   updated_at = excluded.updated_at,
 					   variant_slug = COALESCE(excluded.variant_slug, job_states.variant_slug)`
-      ).bind(id, userId, body.state, now, variantSlug).run();
+      ).bind(id, userId, body.state, now, variantSlug);
+      if (exists.prev === body.state) {
+        await upsert.run();
+      } else {
+        await db.batch([
+          upsert,
+          db.prepare(
+            `INSERT INTO job_events
+							   (job_id, user_id, kind, from_state, to_state, note, occurred_at, created_at)
+							 VALUES (?, ?, 'state', ?, ?, NULL, ?, ?)`
+          ).bind(id, userId, exists.prev, body.state, now, now)
+        ]);
+      }
       return c.json(
         {
           success: true,
@@ -3896,7 +4955,7 @@ function registerStateRoutes(app2) {
       method: "delete",
       path: "/jobs/{id}/state",
       tags: ["Jobs"],
-      summary: 'Clear triage state for a job — returns the row to implicit "new"',
+      summary: 'Clear triage state for a job — returns the row to implicit "new" and drops its timeline',
       request: {
         params: z.object({ id: z.string() })
       },
@@ -3927,9 +4986,11 @@ function registerStateRoutes(app2) {
         );
       }
       const { id } = c.req.valid("param");
-      const result = await c.env.JOB_PLATFORM_DB.prepare(
-        "DELETE FROM job_states WHERE job_id = ? AND user_id = ?"
-      ).bind(id, userId).run();
+      const db = c.env.JOB_PLATFORM_DB;
+      const [result] = await db.batch([
+        db.prepare("DELETE FROM job_states WHERE job_id = ? AND user_id = ?").bind(id, userId),
+        db.prepare("DELETE FROM job_events WHERE job_id = ? AND user_id = ?").bind(id, userId)
+      ]);
       const deleted = (result.meta?.changes ?? 0) > 0;
       return c.json({ success: true, data: { job_id: id, deleted } }, 200);
     }
@@ -4059,8 +5120,8 @@ async function callResumeBinding(env, path, payload) {
     body: JSON.stringify(payload)
   });
 }
-async function fetchMintedResume(env, slug) {
-  const res = await resumeViaEdge(env, `/resume/api/resume?v=${encodeURIComponent(slug)}`, {
+async function fetchMintedResume(env, slug2) {
+  const res = await resumeViaEdge(env, `/resume/api/resume?v=${encodeURIComponent(slug2)}`, {
     method: "GET"
   });
   if (!res.ok) return { expired: true };
@@ -4173,13 +5234,22 @@ function registerTailoringRoutes(app2) {
       );
     }
     const now = (/* @__PURE__ */ new Date()).toISOString();
-    await c.env.JOB_PLATFORM_DB.prepare(
-      `INSERT INTO job_states (job_id, user_id, state, notes, updated_at, variant_slug)
-			 VALUES (?, ?, 'saved', NULL, ?, ?)
-			 ON CONFLICT (job_id, user_id) DO UPDATE SET
-			   variant_slug = excluded.variant_slug,
-			   updated_at = excluded.updated_at`
-    ).bind(id, who.userId, now, variant.slug).run();
+    const db = c.env.JOB_PLATFORM_DB;
+    await db.batch([
+      db.prepare(
+        `INSERT INTO job_events
+					   (job_id, user_id, kind, from_state, to_state, note, occurred_at, created_at)
+					 SELECT ?1, ?2, 'state', NULL, 'saved', NULL, ?3, ?3
+					 WHERE NOT EXISTS (SELECT 1 FROM job_states WHERE job_id = ?1 AND user_id = ?2)`
+      ).bind(id, who.userId, now),
+      db.prepare(
+        `INSERT INTO job_states (job_id, user_id, state, notes, updated_at, variant_slug)
+					 VALUES (?, ?, 'saved', NULL, ?, ?)
+					 ON CONFLICT (job_id, user_id) DO UPDATE SET
+					   variant_slug = excluded.variant_slug,
+					   updated_at = excluded.updated_at`
+      ).bind(id, who.userId, now, variant.slug)
+    ]);
     const url = `https://hadoku.me/resume?v=${encodeURIComponent(variant.slug)}`;
     return c.json({ success: true, data: { slug: variant.slug, url } }, 200);
   });
@@ -4195,8 +5265,8 @@ function registerTailoringRoutes(app2) {
       const row = userId ? await c.env.JOB_PLATFORM_DB.prepare(
         "SELECT variant_slug FROM job_states WHERE job_id = ? AND user_id = ?"
       ).bind(id, userId).first() : null;
-      const slug = row?.variant_slug ?? null;
-      if (!slug) {
+      const slug2 = row?.variant_slug ?? null;
+      if (!slug2) {
         return c.json(
           {
             success: false,
@@ -4206,13 +5276,13 @@ function registerTailoringRoutes(app2) {
           400
         );
       }
-      const minted = await fetchMintedResume(c.env, slug);
+      const minted = await fetchMintedResume(c.env, slug2);
       if ("expired" in minted) {
         return c.json(
           {
             success: false,
             error: "Bad request",
-            message: `The packet for this job ('${slug}') has expired; re-prepare it or post resume_markdown.`
+            message: `The packet for this job ('${slug2}') has expired; re-prepare it or post resume_markdown.`
           },
           400
         );
@@ -4936,7 +6006,7 @@ function registerOwnerRoutes(app2) {
         c.env.HADOKU_SERVICE_KEY ?? "",
         name,
         Date.now(),
-        (label, work) => runAfterResponse(c, label, work)
+        (label2, work) => runAfterResponse(c, label2, work)
       );
       if (isIdentityError(resolved)) {
         const status = [400, 404, 409, 503].includes(resolved.status) ? resolved.status : 503;
@@ -4954,8 +6024,10 @@ function registerOwnerRoutes(app2) {
       await db.batch([
         db.prepare("UPDATE applications SET user_id = ?, updated_at = ? WHERE id = ?").bind(resolved.userId, now, id),
         db.prepare(
-          `INSERT OR REPLACE INTO job_states (job_id, user_id, state, notes, updated_at, variant_slug)
-						 SELECT job_id, ?, state, notes, ?, variant_slug
+          `INSERT OR REPLACE INTO job_states (job_id, user_id, state, notes, updated_at, variant_slug,
+						   priority, follow_up_at, contact_name, contact_email)
+						 SELECT job_id, ?, state, notes, ?, variant_slug,
+						   priority, follow_up_at, contact_name, contact_email
 						 FROM job_states WHERE job_id = ? AND user_id = ?`
         ).bind(resolved.userId, now, row.job_id, row.user_id)
       ]);
@@ -5558,7 +6630,7 @@ function registerFillRoutes(app2) {
 				 WHERE user_id = ? AND job_id = ?`
     ).bind(who.userId, id).first();
     const state = await db.prepare("SELECT variant_slug FROM job_states WHERE user_id = ? AND job_id = ?").bind(who.userId, id).first();
-    const slug = app_?.variant_slug || state?.variant_slug || "";
+    const slug2 = app_?.variant_slug || state?.variant_slug || "";
     const evidence = parseEvidence(app_?.evidence ?? null) ?? {};
     const answers = typeof evidence.answers === "object" && evidence.answers !== null ? evidence.answers : {};
     const options = typeof evidence.options === "object" && evidence.options !== null ? evidence.options : {};
@@ -5570,7 +6642,7 @@ function registerFillRoutes(app2) {
         success: true,
         data: {
           job,
-          application: app_ ? { id: app_.id, status: app_.status, variant_slug: slug } : null,
+          application: app_ ? { id: app_.id, status: app_.status, variant_slug: slug2 } : null,
           profile: profile?.profile ?? null,
           // What the approved fill entered, keyed by the runner's normalised
           // question — the primary source, because it is what was reviewed.
@@ -5580,24 +6652,475 @@ function registerFillRoutes(app2) {
           // Every saved answer by its question, for anything the fill did
           // not record (a field added since, a structured block).
           standing: Object.fromEntries(standing.results.map((r) => [r.question, r.answer])),
-          resume_pdf_url: slug ? `${RESUME_PDF_URL}?v=${encodeURIComponent(slug)}` : null
+          resume_pdf_url: slug2 ? `${RESUME_PDF_URL}?v=${encodeURIComponent(slug2)}` : null
         }
       },
       200
     );
   });
 }
+const ERRORS$1 = {
+  403: {
+    description: "Forbidden",
+    content: { "application/json": { schema: IdentityErrorResponseSchema } }
+  },
+  404: {
+    description: "No such owner name",
+    content: { "application/json": { schema: IdentityErrorResponseSchema } }
+  },
+  409: {
+    description: "That owner name has never signed in",
+    content: { "application/json": { schema: IdentityErrorResponseSchema } }
+  },
+  503: {
+    description: "Identity could not be resolved right now — retry",
+    content: { "application/json": { schema: IdentityErrorResponseSchema } }
+  }
+};
+function registerBlockedRoutes(app2) {
+  app2.get("/blocked-companies", gateAuthed);
+  app2.put("/blocked-companies", gateAuthed);
+  app2.delete("/blocked-companies", gateAuthed);
+  app2.openapi(
+    createRoute({
+      method: "get",
+      path: "/blocked-companies",
+      tags: ["Feed"],
+      summary: "The companies the caller has blocked from their feed",
+      request: { query: ownerNameQuery },
+      responses: {
+        200: {
+          description: "Blocked companies, newest first",
+          content: { "application/json": { schema: BlockedCompaniesResponseSchema } }
+        },
+        ...ERRORS$1
+      }
+    }),
+    async (c) => {
+      const who = await effectiveUserId(c, c.req.valid("query").ownerName);
+      if (isEffectiveUserError(who)) return c.json(who.error.body, who.error.status);
+      const rows = await c.env.JOB_PLATFORM_DB.prepare(
+        `SELECT company, company_key, created_at FROM blocked_companies
+				 WHERE user_id = ? ORDER BY created_at DESC`
+      ).bind(who.userId).all();
+      return c.json({ success: true, data: { companies: rows.results } }, 200);
+    }
+  );
+  app2.openapi(
+    createRoute({
+      method: "put",
+      path: "/blocked-companies",
+      tags: ["Feed"],
+      summary: "Block a company from the caller's feed (idempotent)",
+      request: {
+        query: ownerNameQuery,
+        body: { content: { "application/json": { schema: BlockCompanySchema } } }
+      },
+      responses: {
+        200: {
+          description: "Blocked (or already was — the first spelling is kept)",
+          content: { "application/json": { schema: BlockedCompanyResponseSchema } }
+        },
+        ...ERRORS$1
+      }
+    }),
+    async (c) => {
+      const who = await effectiveUserId(c, c.req.valid("query").ownerName);
+      if (isEffectiveUserError(who)) return c.json(who.error.body, who.error.status);
+      const { company } = c.req.valid("json");
+      const db = c.env.JOB_PLATFORM_DB;
+      const now = (/* @__PURE__ */ new Date()).toISOString();
+      await db.prepare(
+        `INSERT INTO blocked_companies (user_id, company_key, company, created_at)
+					 VALUES (?1, LOWER(TRIM(?2)), TRIM(?2), ?3)
+					 ON CONFLICT (user_id, company_key) DO NOTHING`
+      ).bind(who.userId, company, now).run();
+      const row = await db.prepare(
+        `SELECT company, company_key, created_at FROM blocked_companies
+					 WHERE user_id = ? AND company_key = LOWER(TRIM(?))`
+      ).bind(who.userId, company).first();
+      if (!row) throw new Error("blocked_companies row missing straight after its insert");
+      return c.json({ success: true, data: { company: row } }, 200);
+    }
+  );
+  app2.openapi(
+    createRoute({
+      method: "delete",
+      path: "/blocked-companies",
+      tags: ["Feed"],
+      summary: "Unblock a company",
+      request: {
+        query: ownerNameQuery.extend({
+          company: z.string().trim().min(1).max(200).openapi({
+            description: "The company, in any case — matched the way it was blocked."
+          })
+        })
+      },
+      responses: {
+        200: {
+          description: "Unblocked (or was not blocked)",
+          content: { "application/json": { schema: UnblockCompanyResponseSchema } }
+        },
+        ...ERRORS$1
+      }
+    }),
+    async (c) => {
+      const { ownerName, company } = c.req.valid("query");
+      const who = await effectiveUserId(c, ownerName);
+      if (isEffectiveUserError(who)) return c.json(who.error.body, who.error.status);
+      const row = await c.env.JOB_PLATFORM_DB.prepare(
+        `DELETE FROM blocked_companies WHERE user_id = ? AND company_key = LOWER(TRIM(?))
+				 RETURNING company_key`
+      ).bind(who.userId, company).first();
+      return c.json(
+        {
+          success: true,
+          data: { company_key: row?.company_key ?? company.toLowerCase(), deleted: !!row }
+        },
+        200
+      );
+    }
+  );
+}
+const SKILLS = [
+  // Languages
+  { name: "python", aliases: ["python"] },
+  { name: "javascript", aliases: ["javascript"] },
+  { name: "typescript", aliases: ["typescript"] },
+  { name: "java", aliases: ["java"] },
+  { name: "kotlin", aliases: ["kotlin"] },
+  { name: "c++", aliases: ["c++"] },
+  { name: "c#", aliases: ["c#"] },
+  { name: "rust", aliases: ["rust"] },
+  { name: "ruby", aliases: ["ruby"] },
+  { name: "php", aliases: ["php"] },
+  { name: "swift", aliases: ["swift"] },
+  { name: "scala", aliases: ["scala"] },
+  { name: "sql", aliases: ["sql"] },
+  { name: "bash", aliases: ["bash", "shell scripting"] },
+  // Frontend
+  { name: "react", aliases: ["react", "reactjs", "react.js"] },
+  { name: "vue", aliases: ["vue", "vue.js", "vuejs"] },
+  { name: "angular", aliases: ["angular"] },
+  { name: "svelte", aliases: ["svelte"] },
+  { name: "next.js", aliases: ["next.js", "nextjs"] },
+  { name: "redux", aliases: ["redux"] },
+  { name: "tailwind", aliases: ["tailwind", "tailwindcss"] },
+  { name: "graphql", aliases: ["graphql"] },
+  // Backend
+  { name: "node.js", aliases: ["node.js", "nodejs", "node"] },
+  { name: "django", aliases: ["django"] },
+  { name: "flask", aliases: ["flask"] },
+  { name: "fastapi", aliases: ["fastapi"] },
+  { name: "spring", aliases: ["spring", "spring boot"] },
+  { name: "rails", aliases: ["rails", "ruby on rails"] },
+  { name: ".net", aliases: [".net", "asp.net"] },
+  { name: "grpc", aliases: ["grpc"] },
+  { name: "rest", aliases: ["rest", "restful", "rest api", "rest apis"] },
+  { name: "microservices", aliases: ["microservices", "microservice"] },
+  // Data stores
+  { name: "postgresql", aliases: ["postgresql", "postgres"] },
+  { name: "mysql", aliases: ["mysql"] },
+  { name: "mongodb", aliases: ["mongodb", "mongo"] },
+  { name: "redis", aliases: ["redis"] },
+  { name: "elasticsearch", aliases: ["elasticsearch", "opensearch"] },
+  { name: "dynamodb", aliases: ["dynamodb"] },
+  { name: "cassandra", aliases: ["cassandra"] },
+  { name: "snowflake", aliases: ["snowflake"] },
+  // Cloud and infrastructure
+  { name: "aws", aliases: ["aws", "amazon web services"] },
+  { name: "gcp", aliases: ["gcp", "google cloud"] },
+  { name: "azure", aliases: ["azure"] },
+  { name: "docker", aliases: ["docker"] },
+  { name: "kubernetes", aliases: ["kubernetes", "k8s"] },
+  { name: "terraform", aliases: ["terraform"] },
+  { name: "ansible", aliases: ["ansible"] },
+  { name: "helm", aliases: ["helm"] },
+  { name: "ci/cd", aliases: ["ci/cd", "continuous integration"] },
+  { name: "github actions", aliases: ["github actions"] },
+  { name: "linux", aliases: ["linux"] },
+  // Streaming and distributed systems
+  { name: "kafka", aliases: ["kafka"] },
+  { name: "rabbitmq", aliases: ["rabbitmq"] },
+  { name: "spark", aliases: ["spark", "pyspark"] },
+  { name: "airflow", aliases: ["airflow"] },
+  { name: "distributed systems", aliases: ["distributed systems"] },
+  // ML and data
+  { name: "machine learning", aliases: ["machine learning"] },
+  { name: "deep learning", aliases: ["deep learning"] },
+  { name: "llm", aliases: ["llm", "llms", "large language model", "large language models"] },
+  { name: "pytorch", aliases: ["pytorch"] },
+  { name: "tensorflow", aliases: ["tensorflow"] },
+  { name: "pandas", aliases: ["pandas"] },
+  { name: "etl", aliases: ["etl"] },
+  // Security and identity
+  { name: "security", aliases: ["cybersecurity", "information security", "application security"] },
+  { name: "oauth", aliases: ["oauth", "oauth2", "oidc", "openid connect"] }
+];
+const GO_RE = new RegExp(
+  [
+    String.raw`\b(?:golang|go\s*lang(?:uage)?)\b`,
+    String.raw`\bgo\s+(?:developer|engineer|dev|code|programming|backend)\b`,
+    String.raw`\b(?:built|written|implemented|develop(?:ed)?|experience|coding|proficient|fluency|programming|looking for|seeking)\s+(?:in|with|for)?\s*go\b`,
+    String.raw`(?:\bpython|\bjava|\bc\+\+|\brust|\bc#|\bkubernetes|\bdocker|\btypescript|\breact|\bkafka|\baws)[,\s/]+go\b`,
+    String.raw`\bgo[,\s/]+(?:python|java|rust|c\+\+|c#|kubernetes|docker|typescript|react|kafka|aws)\b`
+  ].join("|"),
+  "i"
+);
+function escape(s) {
+  return s.replace(/[.*+?^${}()|[\]\\/#]/g, "\\$&");
+}
+const MATCHERS = SKILLS.map(({ name, aliases }) => [
+  new RegExp(
+    `(?:^|[^a-z0-9+#.])(?:${aliases.map(escape).join("|")})(?=$|[^a-z0-9+#]|\\.(?:[^a-z0-9]|$))`,
+    "i"
+  ),
+  name
+]);
+function plain(text) {
+  return text.replace(/<[^>]*>/g, " ").replace(/&nbsp;|&#160;/gi, " ").replace(/&amp;/gi, "&");
+}
+function extractSkills(text) {
+  const t = plain(text);
+  const found = [];
+  for (const [re, name] of MATCHERS) if (re.test(t)) found.push(name);
+  if (GO_RE.test(t)) found.push("go");
+  return found;
+}
+function canonicalSkill(term) {
+  const t = term.trim().toLowerCase();
+  if (t === "go" || t === "golang") return "go";
+  for (const { name, aliases } of SKILLS) if (aliases.includes(t)) return name;
+  return t;
+}
+const WEEKS = 12;
+const TOP_SKILLS = 15;
+const APPLIED_OR_LATER = /* @__PURE__ */ new Set(["applied", "interviewing", "offered", "rejected"]);
+const INTERVIEWED = /* @__PURE__ */ new Set(["interviewing", "offered"]);
+function weekOf(iso) {
+  const d = new Date(iso);
+  const sinceMonday = (d.getUTCDay() + 6) % 7;
+  d.setUTCDate(d.getUTCDate() - sinceMonday);
+  return d.toISOString().slice(0, 10);
+}
+function parseList(raw) {
+  try {
+    const v = JSON.parse(raw);
+    return Array.isArray(v) ? v.filter((x) => typeof x === "string") : [];
+  } catch {
+    return [];
+  }
+}
+const ERRORS = {
+  403: {
+    description: "Forbidden",
+    content: { "application/json": { schema: IdentityErrorResponseSchema } }
+  },
+  404: {
+    description: "No such owner name",
+    content: { "application/json": { schema: IdentityErrorResponseSchema } }
+  },
+  409: {
+    description: "That owner name has never signed in",
+    content: { "application/json": { schema: IdentityErrorResponseSchema } }
+  },
+  503: {
+    description: "Identity could not be resolved right now — retry",
+    content: { "application/json": { schema: IdentityErrorResponseSchema } }
+  }
+};
+function registerInsightsRoute(app2) {
+  app2.get("/insights", gateAuthed);
+  app2.openapi(
+    createRoute({
+      method: "get",
+      path: "/insights",
+      tags: ["Pipeline"],
+      summary: "The caller's funnel, response rates, weekly pace, workplace mix and skill demand",
+      request: { query: ownerNameQuery },
+      responses: {
+        200: {
+          description: "Insights",
+          content: { "application/json": { schema: InsightsResponseSchema } }
+        },
+        ...ERRORS
+      }
+    }),
+    async (c) => {
+      const who = await effectiveUserId(c, c.req.valid("query").ownerName);
+      if (isEffectiveUserError(who)) return c.json(who.error.body, who.error.status);
+      const db = c.env.JOB_PLATFORM_DB;
+      const [stateCounts, rows, transitions, submitted, profiles] = await db.batch([
+        db.prepare("SELECT state, COUNT(*) AS n FROM job_states WHERE user_id = ? GROUP BY state").bind(who.userId),
+        // Dismissed postings are counted above and nowhere else: they are not
+        // part of the search, and there can be thousands of them.
+        db.prepare(
+          `SELECT js.job_id, js.state, js.updated_at, j.workplace_type, j.description
+						 FROM job_states js JOIN jobs j ON j.id = js.job_id
+						 WHERE js.user_id = ? AND js.state != 'dismissed'`
+        ).bind(who.userId),
+        db.prepare(
+          `SELECT job_id, to_state, occurred_at FROM job_events
+						 WHERE user_id = ? AND kind = 'state'`
+        ).bind(who.userId),
+        db.prepare(
+          `SELECT job_id, updated_at FROM applications
+						 WHERE user_id = ? AND status = 'submitted'`
+        ).bind(who.userId),
+        db.prepare("SELECT stack FROM profiles WHERE user_id = ?").bind(who.userId)
+      ]);
+      const states = {};
+      for (const r of stateCounts.results) states[r.state] = r.n;
+      const been = /* @__PURE__ */ new Map();
+      const appliedAt = /* @__PURE__ */ new Map();
+      const earliest = (id, at) => {
+        const cur = appliedAt.get(id);
+        if (!cur || at < cur) appliedAt.set(id, at);
+      };
+      const mark = (id, state) => {
+        let s = been.get(id);
+        if (!s) been.set(id, s = /* @__PURE__ */ new Set());
+        s.add(state);
+      };
+      for (const t of transitions.results) {
+        if (!t.to_state) continue;
+        mark(t.job_id, t.to_state);
+        if (t.to_state === "applied") earliest(t.job_id, t.occurred_at);
+      }
+      for (const a of submitted.results) {
+        mark(a.job_id, "applied");
+        earliest(a.job_id, a.updated_at);
+      }
+      const pipeline = rows.results;
+      const workplaceById = /* @__PURE__ */ new Map();
+      for (const r of pipeline) {
+        mark(r.job_id, r.state);
+        workplaceById.set(r.job_id, r.workplace_type || "unknown");
+        if (APPLIED_OR_LATER.has(r.state)) earliest(r.job_id, r.updated_at);
+      }
+      let applied = 0;
+      let interviewed = 0;
+      let offered = 0;
+      let responded = 0;
+      const workplace = /* @__PURE__ */ new Map();
+      for (const [id, s] of been) {
+        const isApplied = [...s].some((x) => APPLIED_OR_LATER.has(x));
+        if (!isApplied) continue;
+        applied++;
+        const iv = [...s].some((x) => INTERVIEWED.has(x));
+        if (iv) interviewed++;
+        if (s.has("offered")) offered++;
+        if (iv || s.has("rejected")) responded++;
+        const w = workplaceById.get(id);
+        if (w) workplace.set(w, (workplace.get(w) ?? 0) + 1);
+      }
+      const share = (n) => applied ? n / applied : null;
+      const thisWeek = weekOf((/* @__PURE__ */ new Date()).toISOString());
+      const weeks = [];
+      for (let i = WEEKS - 1; i >= 0; i--) {
+        const d = /* @__PURE__ */ new Date(`${thisWeek}T00:00:00Z`);
+        d.setUTCDate(d.getUTCDate() - 7 * i);
+        weeks.push(d.toISOString().slice(0, 10));
+      }
+      const perWeek = new Map(weeks.map((w) => [w, 0]));
+      for (const at of appliedAt.values()) {
+        const w = weekOf(at);
+        if (perWeek.has(w)) perWeek.set(w, perWeek.get(w) + 1);
+      }
+      const stack = new Set(
+        profiles.results.flatMap(
+          (p) => parseList(p.stack).map(canonicalSkill)
+        )
+      );
+      const demand = /* @__PURE__ */ new Map();
+      let skillPostings = 0;
+      for (const r of pipeline) {
+        if (!r.description) continue;
+        skillPostings++;
+        for (const s of extractSkills(r.description)) demand.set(s, (demand.get(s) ?? 0) + 1);
+      }
+      const skills = [...demand].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0])).slice(0, TOP_SKILLS).map(([skill, postings]) => ({ skill, postings, in_stack: stack.has(skill) }));
+      return c.json(
+        {
+          success: true,
+          data: {
+            states,
+            reached: { applied, responded, interviewed, offered },
+            rates: {
+              response: share(responded),
+              interview: share(interviewed),
+              offer: share(offered)
+            },
+            weekly_applied: weeks.map((week) => ({ week, count: perWeek.get(week) })),
+            workplace: [...workplace].sort((a, b) => b[1] - a[1]).map(([workplace_type, count]) => ({ workplace_type, count })),
+            skills,
+            skill_postings: skillPostings
+          }
+        },
+        200
+      );
+    }
+  );
+}
+const LocationSchema = z.object({ key: z.string(), label: z.string(), lat: z.number(), lng: z.number() }).openapi("Location");
+function label(name, region) {
+  const title = name.replace(/\b[a-z]/g, (ch) => ch.toUpperCase());
+  return `${title}, ${region.toUpperCase()}`;
+}
+function registerLocationsRoute(app2) {
+  app2.openapi(
+    createRoute({
+      method: "get",
+      path: "/locations",
+      tags: ["Feed"],
+      summary: "Known places matching a prefix, for the feed’s near= filter",
+      request: {
+        query: z.object({
+          q: z.string().trim().min(1).max(100),
+          limit: z.coerce.number().int().min(1).max(25).default(10)
+        })
+      },
+      responses: {
+        200: {
+          description: "Matches, prefix matches first",
+          content: {
+            "application/json": {
+              schema: z.object({
+                success: z.literal(true),
+                data: z.object({ locations: z.array(LocationSchema) })
+              }).openapi("LocationsResponse")
+            }
+          }
+        }
+      }
+    }),
+    (c) => {
+      const { q, limit } = c.req.valid("query");
+      const locations = searchPlaces(q, limit).map((p) => ({
+        key: p.key,
+        label: label(p.name, p.region),
+        lat: p.lat,
+        lng: p.lng
+      }));
+      return c.json({ success: true, data: { locations } }, 200);
+    }
+  );
+}
 const app$2 = new OpenAPIHono();
 registerFeedRoute(app$2);
 registerPreflightRoute(app$2);
 registerPacketsRoute(app$2);
 registerDetailRoute(app$2);
 registerStateRoutes(app$2);
+registerPipelineRoutes(app$2);
 registerFeedbackRoutes(app$2);
 registerTailoringRoutes(app$2);
 registerApplicationRoutes(app$2);
 registerVerificationRoutes(app$2);
 registerFillRoutes(app$2);
+registerBlockedRoutes(app$2);
+registerInsightsRoute(app$2);
+registerLocationsRoute(app$2);
 registerAnswerRoutes(app$2);
 registerOwnerRoutes(app$2);
 const jobRoutes = app$2;
@@ -5703,12 +7226,14 @@ const ERASED_TABLES = [
   { table: "profiles", sql: "DELETE FROM profiles WHERE user_id = ?1" },
   { table: "profile_tombstones", sql: "DELETE FROM profile_tombstones WHERE user_id = ?1" },
   { table: "job_states", sql: "DELETE FROM job_states WHERE user_id = ?1" },
+  { table: "job_events", sql: "DELETE FROM job_events WHERE user_id = ?1" },
   { table: "job_feedback", sql: "DELETE FROM job_feedback WHERE user_id = ?1" },
   { table: "applications", sql: "DELETE FROM applications WHERE user_id = ?1" },
   { table: "application_answers", sql: "DELETE FROM application_answers WHERE user_id = ?1" },
   { table: "applicant_profiles", sql: "DELETE FROM applicant_profiles WHERE user_id = ?1" },
   { table: "mail_reconcile_state", sql: "DELETE FROM mail_reconcile_state WHERE user_id = ?1" },
   { table: "mail_unmatched", sql: "DELETE FROM mail_unmatched WHERE user_id = ?1" },
+  { table: "blocked_companies", sql: "DELETE FROM blocked_companies WHERE user_id = ?1" },
   { table: "owner_name_cache", sql: "DELETE FROM owner_name_cache WHERE user_id = ?1" }
 ];
 async function eraseUser(db, userId) {
@@ -5793,6 +7318,7 @@ function createScheduledHandler(_env) {
   };
 }
 export {
+  AddJobEventSchema,
   AddProfileCompanyResponseSchema,
   AddProfileCompanySchema,
   AnswerResponseSchema,
@@ -5805,6 +7331,10 @@ export {
   ApplicationSummarySchema,
   ApplicationsResponseSchema,
   ApplyRequestSchema,
+  BlockCompanySchema,
+  BlockedCompaniesResponseSchema,
+  BlockedCompanyResponseSchema,
+  BlockedCompanySchema,
   CompanyMatchSchema,
   CreateProfileSchema,
   DeleteCompanyResponseSchema,
@@ -5820,7 +7350,14 @@ export {
   IngestJobSchema,
   IngestPayloadSchema,
   IngestResponseSchema,
+  InsightsResponseSchema,
+  InsightsSchema,
+  JOB_STATES,
   JobDetailSchema,
+  JobEventKindSchema,
+  JobEventResponseSchema,
+  JobEventSchema,
+  JobEventsResponseSchema,
   JobFeedbackResponseSchema,
   JobResponseSchema,
   JobStateReadSchema,
@@ -5830,8 +7367,12 @@ export {
   JobsResponseSchema,
   MatchCompanyResponseSchema,
   MatchCompanySchema,
+  PERSON_EVENT_KINDS,
   PacketSummarySchema,
   PacketsResponseSchema,
+  PipelineItemSchema,
+  PipelineResponseSchema,
+  PrioritySchema,
   ProbeCompanyResponseSchema,
   ProbeCompanySchema,
   ProfileCompaniesResponseSchema,
@@ -5850,9 +7391,14 @@ export {
   SetApplicationStatusSchema,
   SetJobFeedbackSchema,
   SetJobStateSchema,
+  SetTrackingSchema,
+  TrackingResponseSchema,
+  TrackingSchema,
   UnansweredQuestionSchema,
   UnansweredResponseSchema,
+  UnblockCompanyResponseSchema,
   UpdateProfileSchema,
+  asJobStateRead,
   createFetchHandler,
   createJobPlatformHandler,
   createScheduledHandler