@cavuno/board 1.36.0 → 1.37.0

package/dist/doctor.mjs

@@ -0,0 +1,641 @@
+// src/constants.ts
+var DEFAULT_CAVUNO_API_URL = "https://api.cavuno.com";
+
+// src/skills.ts
+import { readFileSync } from "fs";
+import { dirname, resolve } from "path";
+import { fileURLToPath } from "url";
+function packageRoot() {
+  return resolve(dirname(fileURLToPath(import.meta.url)), "..");
+}
+function resolveFromPackageRoot(relativePath, baseDir) {
+  return resolve(baseDir ?? packageRoot(), relativePath);
+}
+function loadSkillManifest(baseDir) {
+  const manifestPath = resolveFromPackageRoot("skills/manifest.json", baseDir);
+  return JSON.parse(readFileSync(manifestPath, "utf8"));
+}
+function loadSkillCorpus(baseDir) {
+  const manifest = loadSkillManifest(baseDir);
+  return {
+    version: manifest.version,
+    skills: manifest.skills.map((skill) => ({
+      ...skill,
+      content: readFileSync(
+        resolveFromPackageRoot(skill.path, baseDir),
+        "utf8"
+      )
+    }))
+  };
+}
+
+// src/doctor/checks.ts
+function record(id, tier) {
+  return (status, detail) => ({
+    id,
+    tier,
+    status,
+    detail
+  });
+}
+var ENV_API_URL = record("env.api-url", 1);
+var ENV_BOARD_KEY = record("env.board-key", 1);
+var PK_RE = /^pk_[0-9a-f]{32}$/;
+function apiBase(apiUrl) {
+  return apiUrl.replace(/\/+$/, "");
+}
+function checkEnv(env) {
+  const results = [];
+  if (!env.apiUrl) {
+    results.push(ENV_API_URL("fail", "PUBLIC_CAVUNO_API_URL is not set"));
+  } else {
+    let origin = null;
+    try {
+      origin = new URL(env.apiUrl).origin;
+    } catch {
+      origin = null;
+    }
+    results.push(
+      origin ? ENV_API_URL("pass", origin) : ENV_API_URL(
+        "fail",
+        `PUBLIC_CAVUNO_API_URL is not a valid URL: ${env.apiUrl}`
+      )
+    );
+  }
+  if (!env.boardKey) {
+    results.push(ENV_BOARD_KEY("fail", "PUBLIC_CAVUNO_BOARD is not set"));
+  } else {
+    results.push(
+      PK_RE.test(env.boardKey) ? ENV_BOARD_KEY("pass", "pk_ key") : ENV_BOARD_KEY(
+        "fail",
+        "PUBLIC_CAVUNO_BOARD must be a publishable key (pk_ + 32 hex chars)"
+      )
+    );
+  }
+  return results;
+}
+var JOB_DETAIL_LINK_RE = /href="(\/companies\/[a-z0-9-]+\/jobs\/[a-z0-9-]+)"/i;
+function extractJobDetailLink(html) {
+  return html.match(JOB_DETAIL_LINK_RE)?.[1] ?? null;
+}
+var JSON_LD_RE = /<script[^>]*type="application\/ld\+json"[^>]*>([\s\S]*?)<\/script>/gi;
+function extractJobPostingJsonLd(html) {
+  for (const match of html.matchAll(JSON_LD_RE)) {
+    try {
+      const parsed = JSON.parse(match[1].trim());
+      if (parsed["@type"] === "JobPosting") return parsed;
+    } catch {
+    }
+  }
+  return null;
+}
+var LOC_RE = /<loc>([^<]+)<\/loc>/gi;
+function parseSitemap(xml) {
+  const kind = /<urlset[\s>]/i.test(xml) ? "urlset" : /<sitemapindex[\s>]/i.test(xml) ? "index" : null;
+  if (!kind) return null;
+  return { kind, urls: [...xml.matchAll(LOC_RE)].map((m) => m[1].trim()) };
+}
+function summarize(results) {
+  const passed = results.filter((r) => r.status === "pass").map((r) => r.id);
+  const failed = results.filter((r) => r.status === "fail").map((r) => r.id);
+  const skipped = results.filter((r) => r.status === "skip").map((r) => r.id);
+  return { exitCode: failed.length > 0 ? 1 : 0, passed, failed, skipped };
+}
+
+// src/doctor/probe.ts
+var FETCH_TIMEOUT_MS = 1e4;
+async function probe(fetchImpl, url) {
+  try {
+    const response = await fetchImpl(url, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS)
+    });
+    return {
+      ok: response.ok,
+      status: response.status,
+      body: await response.text()
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      status: 0,
+      body: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/doctor/read.ts
+var READ = {
+  home: record("read.home", 2),
+  jobs: record("read.jobs", 2),
+  jsonld: record("read.jsonld", 2),
+  sitemap: record("read.sitemap", 2),
+  robots: record("read.robots", 2)
+};
+function skipReadProbes(reason) {
+  return Object.values(READ).map((make) => make("skip", reason));
+}
+async function probeJobsAndJsonLd(fetchImpl, base) {
+  const jobs = await probe(fetchImpl, `${base}/jobs`);
+  const jobLink = jobs.ok ? extractJobDetailLink(jobs.body) : null;
+  const jobsResult = jobs.ok && jobLink ? READ.jobs("pass", `listing renders with job detail links (${jobLink})`) : READ.jobs(
+    "fail",
+    jobs.ok ? "listing renders but contains no /companies/{c}/jobs/{s} detail links" : `listing HTTP ${jobs.status}`
+  );
+  if (!jobLink) {
+    return [
+      jobsResult,
+      READ.jsonld(
+        "skip",
+        jobs.ok ? "not probed \u2014 the listing rendered no job detail link (see read.jobs failure)" : "not probed \u2014 the /jobs listing itself failed (see read.jobs failure)"
+      )
+    ];
+  }
+  const detail = await probe(fetchImpl, `${base}${jobLink}`);
+  const posting = detail.ok ? extractJobPostingJsonLd(detail.body) : null;
+  return [
+    jobsResult,
+    posting ? READ.jsonld(
+      "pass",
+      `JobPosting JSON-LD present (${String(posting.title ?? "")})`
+    ) : READ.jsonld(
+      "fail",
+      detail.ok ? "job detail page has no parseable JobPosting JSON-LD" : `job detail HTTP ${detail.status}`
+    )
+  ];
+}
+function onFrontend(base, locUrl) {
+  try {
+    const parsed = new URL(locUrl);
+    return `${base}${parsed.pathname}${parsed.search}`;
+  } catch {
+    return locUrl;
+  }
+}
+async function probeSitemap(fetchImpl, base) {
+  const sitemap = await probe(fetchImpl, `${base}/sitemap.xml`);
+  if (!sitemap.ok) {
+    return READ.sitemap("fail", `sitemap.xml HTTP ${sitemap.status}`);
+  }
+  const doc = parseSitemap(sitemap.body);
+  if (!doc || doc.urls.length === 0) {
+    return READ.sitemap(
+      "fail",
+      doc ? "sitemap.xml has no <loc> entries" : "sitemap.xml is not a sitemap"
+    );
+  }
+  let urls = doc.urls;
+  if (doc.kind === "index") {
+    const child = await probe(fetchImpl, onFrontend(base, urls[0]));
+    const childDoc = child.ok ? parseSitemap(child.body) : null;
+    if (!childDoc || childDoc.urls.length === 0) {
+      return READ.sitemap(
+        "fail",
+        `child sitemap ${urls[0]} ${child.ok ? "has no <loc> entries" : `HTTP ${child.status}`}`
+      );
+    }
+    urls = childDoc.urls;
+  }
+  const sampleUrl = onFrontend(base, urls[0]);
+  const sample = await probe(fetchImpl, sampleUrl);
+  return sample.ok ? READ.sitemap("pass", `${urls.length} entries; sample page resolves`) : READ.sitemap("fail", `sitemap page ${sampleUrl} \u2192 HTTP ${sample.status}`);
+}
+async function runReadProbes(fetchImpl, frontendUrl) {
+  const base = frontendUrl.replace(/\/$/, "");
+  const [home, jobsAndJsonLd, sitemap, robots] = await Promise.all([
+    probe(fetchImpl, base),
+    probeJobsAndJsonLd(fetchImpl, base),
+    probeSitemap(fetchImpl, base),
+    probe(fetchImpl, `${base}/robots.txt`)
+  ]);
+  return [
+    home.ok && /<(html|body|div|main)[\s>]/i.test(home.body) ? READ.home("pass", "home renders") : READ.home(
+      "fail",
+      home.ok ? "home returned 200 but no HTML document \u2014 captive portal or empty shell?" : `home HTTP ${home.status}`
+    ),
+    ...jobsAndJsonLd,
+    sitemap,
+    robots.ok && /user-agent\s*:/i.test(robots.body) ? READ.robots("pass", "present") : READ.robots(
+      "fail",
+      robots.ok ? "robots.txt returned 200 but has no User-agent directive" : `robots.txt HTTP ${robots.status}`
+    )
+  ];
+}
+
+// src/doctor/theme.ts
+import { createHash } from "crypto";
+import { existsSync, readFileSync as readFileSync2 } from "fs";
+import { join } from "path";
+var THEME = record("static.theme", 1);
+function checkThemeFreshness(projectRoot, context) {
+  const tokensPath = join(projectRoot, "src/tokens.css");
+  if (!existsSync(tokensPath)) {
+    return [
+      THEME(
+        "skip",
+        "board is not tokens-migrated (ADR-0065) \u2014 no src/tokens.css"
+      )
+    ];
+  }
+  const tokensHash = createHash("sha256").update(readFileSync2(tokensPath, "utf8"), "utf8").digest("hex");
+  const resolvedPath = join(projectRoot, "src/theme/resolved.ts");
+  const resolvedHash = existsSync(resolvedPath) ? readFileSync2(resolvedPath, "utf8").match(
+    /tokensHash = '([0-9a-f]{64})'/
+  )?.[1] ?? null : null;
+  if (resolvedHash !== tokensHash) {
+    return [
+      THEME(
+        "fail",
+        `src/theme/resolved.ts is ${resolvedHash ? "stale" : "missing"} \u2014 run \`npm run gen:theme\` (OG images render from it)`
+      )
+    ];
+  }
+  if (!context) {
+    return [
+      THEME(
+        "skip",
+        "local derivations fresh; platform snapshot unverified \u2014 board context unavailable"
+      )
+    ];
+  }
+  if (context.themeSnapshotHash !== tokensHash) {
+    return [
+      THEME(
+        "fail",
+        `platform theme snapshot is ${context.themeSnapshotHash ? "stale" : "missing"} \u2014 emails render ${context.themeSnapshotHash ? "an old" : "the legacy"} theme; sync it: \`npm run gen:theme -- --payload | npx convex run boards/themeSnapshot:sync\``
+      )
+    ];
+  }
+  return [
+    THEME(
+      "pass",
+      `tokens.css \u21C4 resolved module \u21C4 platform snapshot (${tokensHash.slice(0, 12)}\u2026)`
+    )
+  ];
+}
+
+// src/doctor/writes.ts
+var WRITE = {
+  board: record("write.board", 3),
+  register: record("write.register", 3),
+  login: record("write.login", 3),
+  email: record("write.email", 3),
+  apply: record("write.apply", 3),
+  alert: record("write.alert", 3)
+};
+var DEPENDENT_CHECKS = [
+  WRITE.register,
+  WRITE.login,
+  WRITE.email,
+  WRITE.apply,
+  WRITE.alert
+];
+function skipWriteProbes(reason) {
+  return Object.values(WRITE).map((make) => make("skip", reason));
+}
+var FETCH_TIMEOUT_MS2 = 1e4;
+var RESEND_API_BASE = "https://api.resend.com";
+async function request(fetchImpl, url, init) {
+  try {
+    const response = await fetchImpl(url, {
+      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS2),
+      ...init
+    });
+    let json = null;
+    try {
+      json = await response.json();
+    } catch {
+      json = null;
+    }
+    return { ok: response.ok, status: response.status, json };
+  } catch (error) {
+    return {
+      ok: false,
+      status: 0,
+      json: { error: error instanceof Error ? error.message : String(error) }
+    };
+  }
+}
+function post(fetchImpl, url, body, bearer) {
+  return request(fetchImpl, url, {
+    method: "POST",
+    headers: {
+      "content-type": "application/json",
+      accept: "application/json",
+      ...bearer ? { authorization: `Bearer ${bearer}` } : {}
+    },
+    body: JSON.stringify(body)
+  });
+}
+var sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function observeVerificationEmail(fetchImpl, apiKey, recipient, pollMs, timeoutMs) {
+  const deadline = Date.now() + timeoutMs;
+  const subjectMarker = `[To: ${recipient}]`;
+  do {
+    const list = await request(
+      fetchImpl,
+      `${RESEND_API_BASE}/emails?limit=20`,
+      {
+        headers: { authorization: `Bearer ${apiKey}` }
+      }
+    );
+    if (!list.ok) {
+      return WRITE.email(
+        "fail",
+        `Resend list returned HTTP ${list.status} \u2014 wrong RESEND_API_KEY?`
+      );
+    }
+    const items = list.json?.data ?? [];
+    const match = items.find(
+      (item) => item.subject?.includes(subjectMarker) || item.to?.includes(recipient)
+    );
+    if (match) {
+      return WRITE.email(
+        "pass",
+        `verification send observed in Resend for ${recipient}`
+      );
+    }
+    await sleep(pollMs);
+  } while (Date.now() < deadline);
+  return WRITE.email(
+    "fail",
+    `no verification send for ${recipient} appeared in Resend within ${timeoutMs}ms`
+  );
+}
+async function runWriteProbes(options) {
+  const { fetchImpl } = options;
+  const base = `${apiBase(options.env.apiUrl)}/v1/boards/${encodeURIComponent(options.env.boardKey)}`;
+  const nonce = options.nonce ?? `${Date.now().toString(36)}${Math.random().toString(36).slice(2, 8)}`;
+  const email = `doctor+${nonce}@cavuno.com`;
+  const password = `doctor-probe-${nonce}-A1!`;
+  let context = options.boardContext ?? null;
+  if (context === null) {
+    const r = await request(fetchImpl, base);
+    if (!r.ok) {
+      return [
+        WRITE.board("fail", `board context did not resolve (HTTP ${r.status})`),
+        ...DEPENDENT_CHECKS.map(
+          (make) => make("skip", "not run \u2014 the write gate failed (see write.board)")
+        )
+      ];
+    }
+    context = r.json ?? {};
+  }
+  if (context.sandbox !== true) {
+    return [
+      WRITE.board(
+        "fail",
+        "refusing write probes: this board is not the platform sandbox (`sandbox` is not true) \u2014 point PUBLIC_CAVUNO_BOARD at the sandbox pk_"
+      ),
+      ...DEPENDENT_CHECKS.map(
+        (make) => make("skip", "not run \u2014 the write gate failed (see write.board)")
+      )
+    ];
+  }
+  const results = [
+    WRITE.board("pass", "board is the platform sandbox")
+  ];
+  const registered = await post(fetchImpl, `${base}/auth/register`, {
+    role: "candidate",
+    method: "emailpass",
+    email,
+    password,
+    displayName: "Doctor Probe"
+  });
+  const sessionOk = (r) => r.ok && typeof r.json?.accessToken === "string";
+  results.push(
+    sessionOk(registered) ? WRITE.register("pass", `candidate registered (${email})`) : WRITE.register(
+      "fail",
+      `register returned HTTP ${registered.status}` + (registered.status === 429 ? " \u2014 rate-limited: register allows 5 signups / 15 min per IP; wait before rerunning" : "")
+    )
+  );
+  let accessToken = null;
+  if (sessionOk(registered)) {
+    const login = await post(fetchImpl, `${base}/auth/login`, {
+      email,
+      password
+    });
+    if (sessionOk(login)) {
+      accessToken = login.json.accessToken;
+      results.push(WRITE.login("pass", "emailpass login returns a session"));
+    } else {
+      results.push(WRITE.login("fail", `login returned HTTP ${login.status}`));
+    }
+  } else {
+    results.push(WRITE.login("skip", "not run \u2014 register failed"));
+  }
+  if (!sessionOk(registered)) {
+    results.push(WRITE.email("skip", "not run \u2014 register failed"));
+  } else if (!options.resendApiKey) {
+    results.push(
+      WRITE.email(
+        "skip",
+        "RESEND_API_KEY not set \u2014 the verification send was NOT verified (platform-operator check)"
+      )
+    );
+  } else {
+    results.push(
+      await observeVerificationEmail(
+        fetchImpl,
+        options.resendApiKey,
+        email,
+        options.emailPollMs ?? 2e3,
+        options.emailTimeoutMs ?? 3e4
+      )
+    );
+  }
+  if (!accessToken) {
+    results.push(WRITE.apply("skip", "not run \u2014 no session (see above)"));
+  } else {
+    const listing = await request(fetchImpl, `${base}/jobs?limit=1`);
+    const card = listing.json?.data?.[0];
+    if (!listing.ok || !card?.slug) {
+      results.push(
+        WRITE.apply(
+          "fail",
+          listing.ok ? "the board has no jobs to apply to \u2014 is the sandbox seeded?" : `jobs listing returned HTTP ${listing.status}`
+        )
+      );
+    } else {
+      const applied = await post(
+        fetchImpl,
+        `${base}/jobs/${encodeURIComponent(card.slug)}/apply`,
+        {},
+        accessToken
+      );
+      results.push(
+        applied.ok && typeof applied.json?.id === "string" ? WRITE.apply("pass", `applied to ${card.slug}`) : WRITE.apply("fail", `apply returned HTTP ${applied.status}`)
+      );
+    }
+  }
+  const alert = await post(fetchImpl, `${base}/job-alerts`, {
+    email,
+    consent: true
+  });
+  results.push(
+    alert.ok ? WRITE.alert("pass", "job-alert subscription accepted") : WRITE.alert("fail", `job-alerts returned HTTP ${alert.status}`)
+  );
+  return results;
+}
+
+// src/doctor/run.ts
+import { existsSync as existsSync2, readFileSync as readFileSync3 } from "fs";
+import { join as join2 } from "path";
+var STATIC_API = record("static.api", 1);
+var STATIC_BOARD = record("static.board", 1);
+var STATIC_SKILLS = record("static.skills", 1);
+async function checkApiReachable(fetchImpl, apiUrl) {
+  try {
+    new URL(apiUrl);
+  } catch {
+    return null;
+  }
+  const result = await probe(fetchImpl, `${apiBase(apiUrl)}/v1/openapi.json`);
+  if (!result.ok) {
+    return STATIC_API(
+      "fail",
+      `OpenAPI spec unreachable (HTTP ${result.status})`
+    );
+  }
+  try {
+    const parsed = JSON.parse(result.body);
+    if (typeof parsed.openapi !== "string") throw new Error("not a spec");
+  } catch {
+    return STATIC_API(
+      "fail",
+      "endpoint returned 200 but not an OpenAPI document \u2014 proxy or captive portal in the way?"
+    );
+  }
+  return STATIC_API("pass", "OpenAPI spec reachable");
+}
+async function checkBoardResolves(fetchImpl, env) {
+  const result = await probe(
+    fetchImpl,
+    `${apiBase(env.apiUrl)}/v1/boards/${encodeURIComponent(env.boardKey)}`
+  );
+  if (!result.ok) {
+    return {
+      result: STATIC_BOARD(
+        "fail",
+        `board did not resolve for this key (HTTP ${result.status}) \u2014 revoked or wrong key?`
+      ),
+      context: null
+    };
+  }
+  let parsed = null;
+  try {
+    parsed = JSON.parse(result.body);
+    if (typeof parsed !== "object" || parsed === null) throw new Error("shape");
+  } catch {
+    return {
+      result: STATIC_BOARD(
+        "fail",
+        "board endpoint returned 200 but not JSON \u2014 proxy or captive portal in the way?"
+      ),
+      context: null
+    };
+  }
+  return {
+    result: STATIC_BOARD("pass", "publishable key resolves the board"),
+    context: parsed
+  };
+}
+var SKILL_ROOTS = [
+  ".claude/skills",
+  ".agents/skills",
+  ".cursor/skills"
+];
+function checkSkillsFreshness(projectRoot) {
+  const roots = SKILL_ROOTS.map((root) => join2(projectRoot, root)).filter(
+    (root) => existsSync2(root)
+  );
+  if (roots.length === 0) {
+    return STATIC_SKILLS(
+      "skip",
+      "no .claude/skills, .agents/skills, or .cursor/skills directory \u2014 run `npx @cavuno/board setup` to install agent skills"
+    );
+  }
+  const corpus = loadSkillCorpus();
+  const stale = /* @__PURE__ */ new Set();
+  const seen = /* @__PURE__ */ new Set();
+  for (const root of roots) {
+    for (const skill of corpus.skills) {
+      const copied = join2(root, skill.name, "SKILL.md");
+      if (!existsSync2(copied)) continue;
+      seen.add(skill.name);
+      if (readFileSync3(copied, "utf8") !== skill.content) {
+        stale.add(skill.name);
+      }
+    }
+  }
+  const found = seen.size;
+  if (found === 0) {
+    return STATIC_SKILLS(
+      "skip",
+      "no cavuno-board-* skills installed \u2014 run `npx @cavuno/board setup`"
+    );
+  }
+  return stale.size === 0 ? STATIC_SKILLS(
+    "pass",
+    `${found} installed skills match v${corpus.version}`
+  ) : STATIC_SKILLS(
+    "fail",
+    `stale skills (re-run \`npx @cavuno/board setup\`): ${[...stale].join(", ")}`
+  );
+}
+async function runDoctor(options) {
+  const fetchImpl = options.fetchImpl ?? fetch;
+  const env = {
+    ...options.env,
+    apiUrl: options.env.apiUrl ?? DEFAULT_CAVUNO_API_URL
+  };
+  const results = [];
+  const envResults = checkEnv(env);
+  results.push(...envResults);
+  const envOk = envResults.every((r) => r.status === "pass");
+  if (env.apiUrl) {
+    const api = await checkApiReachable(fetchImpl, env.apiUrl);
+    results.push(
+      api ?? STATIC_API("skip", "API URL malformed \u2014 fix env.api-url first")
+    );
+  } else {
+    results.push(STATIC_API("skip", "PUBLIC_CAVUNO_API_URL not set"));
+  }
+  let boardContext = null;
+  if (envOk) {
+    const resolved = await checkBoardResolves(fetchImpl, env);
+    boardContext = resolved.context;
+    results.push(resolved.result);
+  } else {
+    results.push(STATIC_BOARD("skip", "env checks failed \u2014 fix them first"));
+  }
+  results.push(checkSkillsFreshness(options.projectRoot ?? process.cwd()));
+  results.push(
+    ...checkThemeFreshness(options.projectRoot ?? process.cwd(), boardContext)
+  );
+  results.push(
+    ...options.frontendUrl ? await runReadProbes(fetchImpl, options.frontendUrl) : skipReadProbes("no --frontend <url> given")
+  );
+  if (!options.sandbox) {
+    results.push(
+      ...skipWriteProbes(
+        "write probes not enabled \u2014 run with --sandbox against the platform sandbox"
+      )
+    );
+  } else if (!envOk) {
+    results.push(...skipWriteProbes("env checks failed \u2014 fix them first"));
+  } else {
+    results.push(
+      ...await runWriteProbes({
+        env,
+        fetchImpl,
+        resendApiKey: options.resendApiKey,
+        nonce: options.writeProbeNonce,
+        boardContext
+      })
+    );
+  }
+  return { results, summary: summarize(results) };
+}
+export {
+  runDoctor
+};

package/dist/filters.d.mts

@@ -1,5 +1,5 @@
 import { B as BoardLabelOverrides } from './ui-copy-CKfFTtLk.mjs';
-import { J as JobSort, E as EmploymentType, R as RemoteOption, S as Seniority } from './jobs-5qXIfBcR.mjs';
+import { J as JobSort, E as EmploymentType, R as RemoteOption, S as Seniority } from './jobs-CMCADU_-.mjs';
 
 declare const REMOTE_OPTIONS: readonly RemoteOption[];
 /**

package/dist/filters.d.ts

@@ -1,5 +1,5 @@
 import { B as BoardLabelOverrides } from './ui-copy-CKfFTtLk.js';
-import { J as JobSort, E as EmploymentType, R as RemoteOption, S as Seniority } from './jobs-5qXIfBcR.js';
+import { J as JobSort, E as EmploymentType, R as RemoteOption, S as Seniority } from './jobs-CMCADU_-.js';
 
 declare const REMOTE_OPTIONS: readonly RemoteOption[];
 /**