@ttctl/core 0.0.0 → 0.1.0-rc.1

package/dist/services/jobs/index.js

@@ -0,0 +1,753 @@
+// SPDX-License-Identifier: AGPL-3.0-only
+// Copyright (C) 2026 Oleksii PELYKH
+import { buildDryRunPreview } from "../../transport.js";
+import { callGatewayShared } from "../_shared/transport.js";
+export class JobsError extends Error {
+    code;
+    name = "JobsError";
+    constructor(code, message, options) {
+        super(message, options);
+        this.code = code;
+    }
+}
+/**
+ * Default values for {@link ListOptions} pagination fields when the
+ * caller does not specify them. Mirrors the pre-#138 hardcoded values
+ * in `JOBS_LIST_QUERY` (`page: 0, pageSize: 20` on the wire — `page:
+ * 1, perPage: 20` user-facing). Exposed so tests can assert against
+ * the same constants the production code uses.
+ */
+export const DEFAULT_PAGE = 1;
+export const DEFAULT_PER_PAGE = 20;
+// ---------------------------------------------------------------------
+// GraphQL operation strings (full-document queries — no APQ pinning)
+//
+// Mirror the captured documents in
+// `../research/graphql/gateway/operations/mobile/`, but with selection
+// sets trimmed to the shape this service surfaces. Operation NAMES are
+// kept distinct from the captured names because (a) we trim aggressively
+// and (b) the captured names refer to flows we don't implement (e.g.
+// `InitialJobs` selects fragments unrelated to this service's contract).
+// ---------------------------------------------------------------------
+// Pagination variable types (issue #138):
+//
+// - `$page: Int` — nullable Int; server defaults to 0 when omitted.
+//   Verified empirically: BlogPosts, GetJobsForDashboard, and
+//   GetTalentReferralTrackers (in
+//   `research/graphql/gateway/operations/`) all declare `$page: Int`.
+//
+// - `$pageSize: PageSize` — CUSTOM SCALAR, NOT `Int`. Captured operations
+//   use the named `PageSize` scalar. The pre-#138 hardcoded literal
+//   `pageSize: 20` worked because GraphQL accepts integer literals for
+//   custom scalars without type-checking; once we extracted the value
+//   to a variable, the server validated and (correctly) rejected
+//   `Int` in a `PageSize`-typed position. The fix is to declare the
+//   variable with the actual server type. Verified empirically: live
+//   API returned HTTP 400 `Variable "$pageSize" of type "Int!" used
+//   in position expecting type "PageSize"` during E2E pre-merge
+//   verification — schema/contract validation rule caught it.
+const JOBS_LIST_QUERY = `query JobsList($skills: [String!], $keywords: [String!], $excludeSkills: [String!], $excludeKeywords: [String!], $commitments: [JobCommitmentFilterEnum!], $workTypes: [JobWorkTypeSlug!], $estimatedLengths: [EstimatedLengthFilterEnum!], $notInterested: BooleanFilter, $saved: BooleanFilter, $sortTarget: String, $page: Int, $pageSize: PageSize) {
+  viewer {
+    __typename
+    id
+    eligibleJobs(
+      page: $page
+      pageSize: $pageSize
+      sortTarget: $sortTarget
+      skills: $skills
+      keywords: $keywords
+      excludeSkills: $excludeSkills
+      excludeKeywords: $excludeKeywords
+      commitmentsV2: $commitments
+      workTypesV2: $workTypes
+      estimatedLengths: $estimatedLengths
+      filter: { notInterested: $notInterested, saved: $saved }
+    ) {
+      __typename
+      entities {
+        __typename
+        id
+        title
+        url
+        commitment { __typename slug }
+        workType { __typename slug }
+        specialization { __typename title }
+        expectedHours
+        maxRate
+        startDate
+        postedWhen
+        viewed
+        saved
+        notInterested
+        client { __typename id fullName }
+      }
+      totalCount
+    }
+  }
+}`;
+const JOB_SHOW_QUERY = `query JobShow($id: ID!) {
+  viewer {
+    __typename
+    id
+    job(id: $id) {
+      __typename
+      id
+      title
+      url
+      descriptionMd
+      commitment { __typename slug }
+      workType { __typename slug }
+      specialization { __typename title }
+      expectedHours
+      minimumHoursPerBillingCycle
+      maxRate
+      startDate
+      postedWhen
+      viewed
+      saved
+      notInterested
+      isCoaching
+      isToptalProject
+      semiMonthlyBilling
+      positionsCount
+      jobTimeZone {
+        __typename
+        verbose
+        hoursOverlap
+        workingTimeFrom
+        workingTimeTo
+      }
+      client {
+        __typename
+        id
+        city
+        countryName
+        fullName
+        industry
+        isEnterprise
+        website
+        linkedin
+        teamSize { __typename value }
+      }
+      jobSkillSetsV2 {
+        __typename
+        edges {
+          __typename
+          node {
+            __typename
+            rating
+            isOptional
+            theSkill { __typename id name }
+          }
+        }
+      }
+      languages { __typename id name }
+    }
+  }
+}`;
+const MARK_JOB_SAVED_MUTATION = `mutation JobMarkSaved($jobID: ID!) {
+  job(id: $jobID) {
+    __typename
+    markSaved(input: {}) {
+      __typename
+      success
+      errors { __typename key message code }
+      job { __typename id saved notInterested viewed }
+    }
+  }
+}`;
+const MARK_JOB_NOT_INTERESTED_MUTATION = `mutation JobMarkNotInterested($jobID: ID!, $reason: String!) {
+  job(id: $jobID) {
+    __typename
+    markNotInterested(input: { reason: $reason }) {
+      __typename
+      success
+      errors { __typename key message code }
+      job { __typename id saved notInterested viewed }
+    }
+  }
+}`;
+const MARK_JOB_VIEWED_MUTATION = `mutation JobMarkViewed($jobID: ID!) {
+  job(id: $jobID) {
+    __typename
+    markViewed(input: {}) {
+      __typename
+      success
+      errors { __typename key message code }
+      job { __typename id saved notInterested viewed }
+    }
+  }
+}`;
+const CLEAR_JOB_INTEREST_MUTATION = `mutation JobClearInterest($jobID: ID!) {
+  job(id: $jobID) {
+    __typename
+    clearInterestStatus(input: {}) {
+      __typename
+      success
+      errors { __typename key message code }
+      job { __typename id saved notInterested viewed }
+    }
+  }
+}`;
+const JOB_SEARCH_SUBSCRIPTION_QUERY = `query JobSearchSubscriptionShow {
+  viewer {
+    __typename
+    id
+    searchSubscription {
+      __typename
+      skills
+      keywords
+      excludeSkills
+      excludeKeywords
+      commitmentsV2
+      workTypesV2
+      estimatedLengths
+      excludeUnspecifiedBudget
+    }
+  }
+}`;
+const START_JOB_SUBSCRIPTION_MUTATION = `mutation JobSearchSubscriptionStart($skills: [String!], $keywords: [String!], $excludeSkills: [String!], $excludeKeywords: [String!], $excludeUnspecifiedBudget: Boolean, $commitments: [JobCommitmentFilterEnum!], $workTypes: [JobWorkTypeSlug!], $estimatedLengths: [EstimatedLengthFilterEnum!]) {
+  searchSubscription {
+    __typename
+    start(input: {
+      skills: $skills
+      keywords: $keywords
+      excludeSkills: $excludeSkills
+      excludeKeywords: $excludeKeywords
+      excludeUnspecifiedBudget: $excludeUnspecifiedBudget
+      commitmentsV2: $commitments
+      workTypesV2: $workTypes
+      estimatedLengths: $estimatedLengths
+    }) {
+      __typename
+      success
+      errors { __typename key message code }
+      viewer {
+        __typename
+        id
+        searchSubscription {
+          __typename
+          skills
+          keywords
+          excludeSkills
+          excludeKeywords
+          commitmentsV2
+          workTypesV2
+          estimatedLengths
+          excludeUnspecifiedBudget
+        }
+      }
+    }
+  }
+}`;
+const TERMINATE_JOB_SUBSCRIPTION_MUTATION = `mutation JobSearchSubscriptionTerminate {
+  searchSubscription {
+    __typename
+    terminate(input: {}) {
+      __typename
+      success
+      errors { __typename key message code }
+    }
+  }
+}`;
+// The mobile-gateway returns at least two distinct GraphQL error
+// messages that both mean "no such job from the caller's perspective":
+//   - `"Record not found"`     for some lookup paths (kept for safety;
+//                              originally inferred, not yet observed)
+//   - `"Invalid ID"`           for malformed/unparseable IDs (live-
+//                              observed during #148 E2E — see #166)
+// A successful response with `viewer.eligibleJob === null` is the
+// third (live-observed) NOT_FOUND signal; that branch is handled
+// inline in `show()` and `markViewed()` and is not regex-driven.
+const NOT_FOUND_MESSAGE_PATTERN = /Record not found|Invalid ID/i;
+/**
+ * Thin per-service wrapper around {@link callGatewayShared} (issue
+ * #329). Pins the mobile-gateway surface and the {@link JobsError}
+ * domain class.
+ */
+async function callGateway(token, operationName, query, variables, schema) {
+    return callGatewayShared("mobile-gateway", token, operationName, query, variables, JobsError, {
+        schema,
+    });
+}
+function projectListItem(entity) {
+    return {
+        id: entity.id,
+        title: entity.title,
+        url: entity.url,
+        client: entity.client,
+        commitment: entity.commitment,
+        workType: entity.workType,
+        specialization: entity.specialization,
+        expectedHours: entity.expectedHours,
+        maxRate: entity.maxRate,
+        startDate: entity.startDate,
+        postedWhen: entity.postedWhen,
+        viewed: entity.viewed,
+        saved: entity.saved,
+        notInterested: entity.notInterested,
+    };
+}
+function projectJobDetail(entity) {
+    const skills = [];
+    const edges = entity.jobSkillSetsV2?.edges ?? [];
+    for (const edge of edges) {
+        const node = edge.node;
+        const theSkill = node.theSkill;
+        if (theSkill !== null) {
+            skills.push({
+                id: theSkill.id,
+                name: theSkill.name,
+                rating: node.rating,
+                isOptional: node.isOptional,
+            });
+        }
+    }
+    return {
+        ...projectListItem(entity),
+        descriptionMd: entity.descriptionMd,
+        minimumHoursPerBillingCycle: entity.minimumHoursPerBillingCycle,
+        isCoaching: entity.isCoaching,
+        isToptalProject: entity.isToptalProject,
+        semiMonthlyBilling: entity.semiMonthlyBilling,
+        positionsCount: entity.positionsCount,
+        jobTimeZone: entity.jobTimeZone,
+        client: entity.client,
+        skills,
+        languages: (entity.languages ?? []).map((lang) => ({ id: lang.id, name: lang.name })),
+    };
+}
+function projectSubscription(entity) {
+    if (entity === null) {
+        return { active: false, filters: null };
+    }
+    const filters = {};
+    if (entity.skills !== null)
+        filters.skills = entity.skills;
+    if (entity.keywords !== null)
+        filters.keywords = entity.keywords;
+    if (entity.excludeSkills !== null)
+        filters.excludeSkills = entity.excludeSkills;
+    if (entity.excludeKeywords !== null)
+        filters.excludeKeywords = entity.excludeKeywords;
+    if (entity.commitmentsV2 !== null)
+        filters.commitments = entity.commitmentsV2;
+    if (entity.workTypesV2 !== null)
+        filters.workTypes = entity.workTypesV2;
+    if (entity.estimatedLengths !== null)
+        filters.estimatedLengths = entity.estimatedLengths;
+    if (entity.excludeUnspecifiedBudget !== null)
+        filters.excludeUnspecifiedBudget = entity.excludeUnspecifiedBudget;
+    return { active: true, filters };
+}
+function formatMutationErrors(operationName, errors) {
+    if (errors === null || errors === undefined || errors.length === 0) {
+        return `${operationName}: mutation reported failure but returned no errors`;
+    }
+    return `${operationName}: ${errors
+        .map((e) => `${e.key ?? "(no key)"}: ${e.message ?? "(no message)"} (code: ${e.code ?? "unknown"})`)
+        .join("; ")}`;
+}
+function buildListVariables(opts, extras) {
+    // Pagination defaults: `page: 1, perPage: 20` map to the wire's
+    // 1-indexed `page: 1` (= first page). The captured `InitialJobs`
+    // operation hardcoded `page: 0` literally, but empirical E2E
+    // testing during #138 verification revealed the wire's `page` field
+    // is **1-indexed** — `page: 0` and `page: 1` both return the same
+    // first slice (the gateway treats 0 as a default-to-first alias).
+    // Pages 2, 3, … navigate normally. The pre-#138 hardcoded `page: 0`
+    // worked because of this aliasing, NOT because the wire is
+    // 0-indexed. The user-facing `--page` is 1-indexed and threads
+    // through verbatim; no subtraction.
+    const page = opts.page ?? DEFAULT_PAGE;
+    const perPage = opts.perPage ?? DEFAULT_PER_PAGE;
+    const variables = {
+        skills: opts.skills && opts.skills.length > 0 ? opts.skills : null,
+        keywords: opts.keywords && opts.keywords.length > 0 ? opts.keywords : null,
+        excludeSkills: opts.excludeSkills && opts.excludeSkills.length > 0 ? opts.excludeSkills : null,
+        excludeKeywords: opts.excludeKeywords && opts.excludeKeywords.length > 0 ? opts.excludeKeywords : null,
+        commitments: opts.commitments && opts.commitments.length > 0 ? opts.commitments : null,
+        workTypes: opts.workTypes && opts.workTypes.length > 0 ? opts.workTypes : null,
+        estimatedLengths: opts.estimatedLengths && opts.estimatedLengths.length > 0 ? opts.estimatedLengths : null,
+        sortTarget: opts.sortTarget ?? null,
+        page,
+        pageSize: perPage,
+    };
+    variables["saved"] = extras.saved !== undefined ? { eq: extras.saved } : null;
+    variables["notInterested"] = extras.notInterested !== undefined ? { eq: extras.notInterested } : null;
+    return variables;
+}
+// ---------------------------------------------------------------------
+// Public surface
+// ---------------------------------------------------------------------
+/**
+ * Browse current job opportunities (default sort, paginated).
+ *
+ * Filters fold straight through to the wire (`eligibleJobs`
+ * arguments). Empty arrays / undefined values pass as `null`, letting
+ * the server apply its defaults.
+ *
+ * Pagination (#138): `opts.page` (1-indexed) and `opts.perPage` are
+ * forwarded to the wire's 1-indexed `eligibleJobs.page` and
+ * `pageSize`. Defaults: `page: 1, perPage: 20`. The wire's `page` is
+ * 1-indexed — see {@link buildListVariables} for the empirical
+ * findings from #138 E2E verification. Returns a {@link
+ * JobListPage} carrying `totalCount` so callers can render
+ * offset-style pagination metadata.
+ */
+export async function list(token, opts = {}) {
+    const page = opts.page ?? DEFAULT_PAGE;
+    const perPage = opts.perPage ?? DEFAULT_PER_PAGE;
+    const data = await callGateway(token, "JobsList", JOBS_LIST_QUERY, buildListVariables(opts, {}));
+    if (data.viewer === null) {
+        throw new JobsError("NO_VIEWER", "Session is valid but no viewer is bound to it.");
+    }
+    if (data.viewer.eligibleJobs === null) {
+        return { items: [], totalCount: 0, page, perPage };
+    }
+    const items = (data.viewer.eligibleJobs.entities ?? []).map(projectListItem);
+    return { items, totalCount: data.viewer.eligibleJobs.totalCount, page, perPage };
+}
+/**
+ * Fetch a single job by id. Throws `JobsError("NOT_FOUND")` for two
+ * wire shapes: top-level `Record not found` GraphQL error AND a
+ * successful response with `viewer.job === null`.
+ */
+export async function show(token, id) {
+    let data;
+    try {
+        data = await callGateway(token, "JobShow", JOB_SHOW_QUERY, { id });
+    }
+    catch (err) {
+        if (err instanceof JobsError && err.code === "GRAPHQL_ERROR" && NOT_FOUND_MESSAGE_PATTERN.test(err.message)) {
+            throw new JobsError("NOT_FOUND", `No job found with id "${id}" (or you don't have access to it).`, {
+                cause: err,
+            });
+        }
+        throw err;
+    }
+    if (data.viewer === null) {
+        throw new JobsError("NO_VIEWER", "Session is valid but no viewer is bound to it.");
+    }
+    if (data.viewer.job === null) {
+        throw new JobsError("NOT_FOUND", `No job found with id "${id}" (or you don't have access to it).`);
+    }
+    return projectJobDetail(data.viewer.job);
+}
+/**
+ * List saved jobs (the bookmark / favorites view).
+ *
+ * Implementation: `eligibleJobs` with `filter: { saved: { eq: true } }`
+ * — the same projection as {@link list} so the CLI can reuse the table
+ * renderer.
+ *
+ * Pagination (#138): accepts `opts.page` / `opts.perPage`; returns
+ * a {@link JobListPage} for offset-style envelope rendering.
+ */
+export async function saved(token, opts = {}) {
+    const page = opts.page ?? DEFAULT_PAGE;
+    const perPage = opts.perPage ?? DEFAULT_PER_PAGE;
+    const data = await callGateway(token, "JobsList", JOBS_LIST_QUERY, buildListVariables(opts, { saved: true }));
+    if (data.viewer === null) {
+        throw new JobsError("NO_VIEWER", "Session is valid but no viewer is bound to it.");
+    }
+    if (data.viewer.eligibleJobs === null) {
+        return { items: [], totalCount: 0, page, perPage };
+    }
+    const items = (data.viewer.eligibleJobs.entities ?? []).map(projectListItem);
+    return { items, totalCount: data.viewer.eligibleJobs.totalCount, page, perPage };
+}
+/**
+ * List jobs marked as not-interested. Implementation: `eligibleJobs`
+ * with `filter: { notInterested: { eq: true } }`.
+ *
+ * Pagination (#138): accepts `opts.page` / `opts.perPage`; returns
+ * a {@link JobListPage} for offset-style envelope rendering.
+ */
+export async function notInterestedList(token, opts = {}) {
+    const page = opts.page ?? DEFAULT_PAGE;
+    const perPage = opts.perPage ?? DEFAULT_PER_PAGE;
+    const data = await callGateway(token, "JobsList", JOBS_LIST_QUERY, buildListVariables(opts, { notInterested: true }));
+    if (data.viewer === null) {
+        throw new JobsError("NO_VIEWER", "Session is valid but no viewer is bound to it.");
+    }
+    if (data.viewer.eligibleJobs === null) {
+        return { items: [], totalCount: 0, page, perPage };
+    }
+    const items = (data.viewer.eligibleJobs.entities ?? []).map(projectListItem);
+    return { items, totalCount: data.viewer.eligibleJobs.totalCount, page, perPage };
+}
+/**
+ * List jobs marked as viewed.
+ *
+ * **R1 — Wire-shape gap**: the `eligibleJobs` query exposes filters
+ * only for `saved` and `notInterested`, not `viewed`. This function
+ * fetches the requested page of jobs ({@link list}) and applies a
+ * client-side filter on the `viewed` boolean. The result is scoped to
+ * the items the server returned on that page — pagination shifts the
+ * underlying fetch window, but the client-side filter on `viewed`
+ * still happens AFTER the page is returned, so the resulting list can
+ * be shorter than `perPage`. A wire-level filter would be the right
+ * long-term fix and is tracked as a follow-up.
+ *
+ * Pagination (#138): accepts `opts.page` / `opts.perPage`. The
+ * returned {@link JobListPage} carries the `totalCount` of the
+ * underlying paginated fetch (pre-filter) — `items.length` reflects
+ * the post-filter shape and can be smaller.
+ */
+export async function viewedList(token, opts = {}) {
+    const page = await list(token, opts);
+    return { ...page, items: page.items.filter((it) => it.viewed === true) };
+}
+/**
+ * Mark a job as saved (bookmark). The wire mutation
+ * (`MarkJobAsSaved`) toggles `saved=true` and clears `notInterested=false`
+ * if it was set — the server's interest-status model is one-of-three
+ * (`saved` | `not-interested` | `cleared`).
+ *
+ * Dry-run path (issue #162): when invoked with `options.dryRun === true`,
+ * builds a {@link DryRunPreview} of the mutation without invoking the
+ * gateway transport and returns it wrapped in {@link
+ * JobsDryRunPreviewOutcome}. The bearer token is redacted per the
+ * `DryRunPreview` contract; the `jobID` variable carries the caller's
+ * literal id (no sibling read needed for this surface).
+ */
+export async function save(token, id, options = {}) {
+    const variables = { jobID: id };
+    if (options.dryRun === true) {
+        return {
+            kind: "preview",
+            preview: buildDryRunPreview({
+                surface: "mobile-gateway",
+                authToken: token,
+                body: { operationName: "JobMarkSaved", query: MARK_JOB_SAVED_MUTATION, variables },
+            }),
+        };
+    }
+    const data = await callGateway(token, "JobMarkSaved", MARK_JOB_SAVED_MUTATION, variables);
+    return { kind: "applied", result: narrowMutation(data, "markSaved", id, "JobMarkSaved") };
+}
+/**
+ * Clear all interest-status flags on a job. The CLI exposes this as
+ * `jobs unsave <id>` (matching the AC) — semantically it also clears
+ * `notInterested` because the wire only offers one path
+ * (`ClearJobInterestStatus`) to clear EITHER signal. Callers wanting
+ * the "remove saved without affecting not-interested" semantics aren't
+ * supported by the wire; they would need to re-mark not-interested
+ * after.
+ *
+ * Delegates to {@link clearInterest} (same wire operation
+ * `JobClearInterest`) — the dry-run preview therefore reports
+ * `operationName: "JobClearInterest"`. The CLI envelope's
+ * surface-level `operation` field is `jobs.unsave` (kept distinct so
+ * users see the verb they invoked).
+ */
+export async function unsave(token, id, options = {}) {
+    return clearInterest(token, id, options);
+}
+/**
+ * Mark a job as not-interested with the supplied reason. The wire
+ * mutation (`MarkJobAsNotInterested`) toggles `notInterested=true`
+ * and clears `saved=false` if it was set.
+ *
+ * `reason` is server-side `String!` — rejects empty strings with
+ * `code=blank, key=reason`. Caller must supply a non-empty value; the
+ * wire does not validate against a closed enum, so free-text is fine.
+ *
+ * Dry-run path (issue #162): when invoked with `options.dryRun === true`,
+ * builds a {@link DryRunPreview} of the mutation without invoking the
+ * gateway transport and returns it wrapped in {@link
+ * JobsDryRunPreviewOutcome}. The `reason` variable is preserved in the
+ * preview's variables payload (it carries no session-bound material) so
+ * callers can verify the wire-shape end-to-end.
+ */
+export async function notInterested(token, id, opts, options = {}) {
+    const variables = { jobID: id, reason: opts.reason };
+    if (options.dryRun === true) {
+        return {
+            kind: "preview",
+            preview: buildDryRunPreview({
+                surface: "mobile-gateway",
+                authToken: token,
+                body: { operationName: "JobMarkNotInterested", query: MARK_JOB_NOT_INTERESTED_MUTATION, variables },
+            }),
+        };
+    }
+    const data = await callGateway(token, "JobMarkNotInterested", MARK_JOB_NOT_INTERESTED_MUTATION, variables);
+    return { kind: "applied", result: narrowMutation(data, "markNotInterested", id, "JobMarkNotInterested") };
+}
+/**
+ * Mark a job as viewed (UX-only signal — typically the UI auto-marks
+ * on detail-page open; this surface lets the CLI do it explicitly).
+ *
+ * Dry-run path (issue #162): when invoked with `options.dryRun === true`,
+ * builds a {@link DryRunPreview} of the mutation without invoking the
+ * gateway transport and returns it wrapped in {@link
+ * JobsDryRunPreviewOutcome}.
+ */
+export async function markViewed(token, id, options = {}) {
+    const variables = { jobID: id };
+    if (options.dryRun === true) {
+        return {
+            kind: "preview",
+            preview: buildDryRunPreview({
+                surface: "mobile-gateway",
+                authToken: token,
+                body: { operationName: "JobMarkViewed", query: MARK_JOB_VIEWED_MUTATION, variables },
+            }),
+        };
+    }
+    const data = await callGateway(token, "JobMarkViewed", MARK_JOB_VIEWED_MUTATION, variables);
+    return { kind: "applied", result: narrowMutation(data, "markViewed", id, "JobMarkViewed") };
+}
+/**
+ * Clear the interest-status flags (both `saved` and `notInterested`)
+ * on a job. The wire's "undo" path for either save or not-interested.
+ *
+ * Dry-run path (issue #162): when invoked with `options.dryRun === true`,
+ * builds a {@link DryRunPreview} of the mutation without invoking the
+ * gateway transport and returns it wrapped in {@link
+ * JobsDryRunPreviewOutcome}.
+ */
+export async function clearInterest(token, id, options = {}) {
+    const variables = { jobID: id };
+    if (options.dryRun === true) {
+        return {
+            kind: "preview",
+            preview: buildDryRunPreview({
+                surface: "mobile-gateway",
+                authToken: token,
+                body: { operationName: "JobClearInterest", query: CLEAR_JOB_INTEREST_MUTATION, variables },
+            }),
+        };
+    }
+    const data = await callGateway(token, "JobClearInterest", CLEAR_JOB_INTEREST_MUTATION, variables);
+    return { kind: "applied", result: narrowMutation(data, "clearInterestStatus", id, "JobClearInterest") };
+}
+function narrowMutation(data, field, id, operationName) {
+    if (data.job === null) {
+        throw new JobsError("NOT_FOUND", `No job found with id "${id}" (or you don't have access to it).`);
+    }
+    const result = data.job[field];
+    if (result === null || result === undefined) {
+        throw new JobsError("UNKNOWN", `${operationName} returned a null payload for field "${field}".`);
+    }
+    if (!result.success) {
+        throw new JobsError("MUTATION_ERROR", formatMutationErrors(operationName, result.errors));
+    }
+    if (result.job === null) {
+        throw new JobsError("UNKNOWN", `${operationName} returned success but the \`job\` payload was null.`);
+    }
+    return {
+        id: result.job.id,
+        saved: result.job.saved,
+        notInterested: result.job.notInterested,
+        viewed: result.job.viewed,
+    };
+}
+/**
+ * Show the current job-search subscription state. Returns
+ * `{ active: false, filters: null }` when no subscription is active.
+ *
+ * **R2**: the wire models a single subscription per viewer — there is
+ * no list. The CLI's `search list` maps this to a 0-or-1 envelope.
+ */
+export async function searchSubscriptionShow(token) {
+    const data = await callGateway(token, "JobSearchSubscriptionShow", JOB_SEARCH_SUBSCRIPTION_QUERY, {});
+    if (data.viewer === null) {
+        throw new JobsError("NO_VIEWER", "Session is valid but no viewer is bound to it.");
+    }
+    return projectSubscription(data.viewer.searchSubscription);
+}
+/**
+ * Start the job-search subscription with the supplied filters. If a
+ * subscription is already active, the wire's `start` mutation replaces
+ * it (the server does NOT error on "already subscribed").
+ *
+ * Returns the post-mutation subscription state.
+ *
+ * Dry-run path (issue #162): when invoked with `options.dryRun === true`,
+ * builds a {@link DryRunPreview} of the mutation without invoking the
+ * gateway transport and returns it wrapped in {@link
+ * JobsDryRunPreviewOutcome}. The filters payload is normalised
+ * identically to the apply path so the preview's `variables` reflect
+ * the exact wire shape that WOULD have been sent.
+ */
+export async function searchSubscriptionSave(token, filters, options = {}) {
+    const variables = {
+        skills: filters.skills && filters.skills.length > 0 ? filters.skills : null,
+        keywords: filters.keywords && filters.keywords.length > 0 ? filters.keywords : null,
+        excludeSkills: filters.excludeSkills && filters.excludeSkills.length > 0 ? filters.excludeSkills : null,
+        excludeKeywords: filters.excludeKeywords && filters.excludeKeywords.length > 0 ? filters.excludeKeywords : null,
+        commitments: filters.commitments && filters.commitments.length > 0 ? filters.commitments : null,
+        workTypes: filters.workTypes && filters.workTypes.length > 0 ? filters.workTypes : null,
+        estimatedLengths: filters.estimatedLengths && filters.estimatedLengths.length > 0 ? filters.estimatedLengths : null,
+        excludeUnspecifiedBudget: filters.excludeUnspecifiedBudget ?? null,
+    };
+    if (options.dryRun === true) {
+        return {
+            kind: "preview",
+            preview: buildDryRunPreview({
+                surface: "mobile-gateway",
+                authToken: token,
+                body: { operationName: "JobSearchSubscriptionStart", query: START_JOB_SUBSCRIPTION_MUTATION, variables },
+            }),
+        };
+    }
+    const data = await callGateway(token, "JobSearchSubscriptionStart", START_JOB_SUBSCRIPTION_MUTATION, variables);
+    if (data.searchSubscription === null) {
+        throw new JobsError("UNKNOWN", "JobSearchSubscriptionStart returned a null `searchSubscription` payload.");
+    }
+    const result = data.searchSubscription.start;
+    if (result === null) {
+        throw new JobsError("UNKNOWN", "JobSearchSubscriptionStart returned a null `start` payload.");
+    }
+    if (!result.success) {
+        throw new JobsError("MUTATION_ERROR", formatMutationErrors("JobSearchSubscriptionStart", result.errors));
+    }
+    return { kind: "applied", result: projectSubscription(result.viewer?.searchSubscription ?? null) };
+}
+/**
+ * Terminate the active job-search subscription. The wire's `terminate`
+ * mutation is idempotent — terminating a non-active subscription
+ * returns `success: true` with no errors.
+ *
+ * Returns `{ terminated: true }` on success. The post-terminate
+ * subscription state is implicit (`active: false`) and is not re-
+ * fetched here.
+ *
+ * Dry-run path (issue #162): when invoked with `options.dryRun === true`,
+ * builds a {@link DryRunPreview} of the mutation without invoking the
+ * gateway transport and returns it wrapped in {@link
+ * JobsDryRunPreviewOutcome}. The variables payload is `{}` (the wire
+ * `terminate` mutation takes no variables).
+ */
+export async function searchSubscriptionRemove(token, options = {}) {
+    if (options.dryRun === true) {
+        return {
+            kind: "preview",
+            preview: buildDryRunPreview({
+                surface: "mobile-gateway",
+                authToken: token,
+                body: {
+                    operationName: "JobSearchSubscriptionTerminate",
+                    query: TERMINATE_JOB_SUBSCRIPTION_MUTATION,
+                    variables: {},
+                },
+            }),
+        };
+    }
+    const data = await callGateway(token, "JobSearchSubscriptionTerminate", TERMINATE_JOB_SUBSCRIPTION_MUTATION, {});
+    if (data.searchSubscription === null) {
+        throw new JobsError("UNKNOWN", "JobSearchSubscriptionTerminate returned a null `searchSubscription` payload.");
+    }
+    const result = data.searchSubscription.terminate;
+    if (result === null) {
+        throw new JobsError("UNKNOWN", "JobSearchSubscriptionTerminate returned a null `terminate` payload.");
+    }
+    if (!result.success) {
+        throw new JobsError("MUTATION_ERROR", formatMutationErrors("JobSearchSubscriptionTerminate", result.errors));
+    }
+    return { kind: "applied", result: { terminated: true } };
+}
+//# sourceMappingURL=index.js.map