co-maintainer 0.5.0 → 0.5.1-beta.2

package/dist/src/services/remote_review.js

@@ -1,4 +1,5 @@
 import { VERSION } from "../version.js";
+import { CliError } from "../cli/error.js";
 import { resolvedFromFirstReview, revisionStats, sortResolvedFindings, summaryCounts, toJsonFinding, } from "../cli/review_result.js";
 import { parseFindings } from "../pr/findings.js";
 import { codegraphToolHandlersForBridge } from "../pr/codegraph_tools.js";
@@ -7,23 +8,51 @@ import { buildCarryPromptSection, classifyCarryItems, guideRebuiltSince, increme
 import { remoteBridgeToolHandlers } from "../remote/tool_bridge.js";
 import { revisionFromSubmitJson } from "../remote/revision_from_submit.js";
 import { closeRemoteSession, openRemoteSession, setRemoteSyncResult, } from "../remote/server/sessions.js";
-import { readConfig } from "../config.js";
+import { readConfig, remoteByokPolicy } from "../config.js";
+import { dropByokKey, getByokKey, hasByokKey, registerByokKey, } from "../remote/server/byok_keys.js";
 import { reviewBlockingFrom } from "../review/blocking.js";
 import { loadGuides } from "../review/guides.js";
 import { withLogSink } from "../util/log.js";
 import { cancel, registerHandler } from "./jobs.js";
 import { recordAiCost } from "./setup.js";
+import { addResponseCost, costColumns, costUsage, emptyTally, settle, } from "../util/cost.js";
 import { findRepoByFullName } from "../store/repos.js";
 import { deleteRemoteReviewInput, findRemoteReviewInputByRequest, getRemoteReviewInput, insertRemoteReviewInput, } from "../store/remote_review_inputs.js";
 import { insertFinding, listCarryableFindingsForReview, } from "../store/findings.js";
 import { deleteSubjectRevision, getOrCreateRemoteSubject, getSubjectRevision, parseRevisionFiles, parseVisiblePaths, saveSubjectRevision, } from "../store/subjects.js";
 import { getReviewByJobId, insertRemoteReview, setReviewStatus, } from "../store/reviews.js";
 import { insertJob, listJobsByQueueKey, setJobStatus } from "../store/jobs.js";
+import { getAppDb } from "../store/app_db.js";
 const REPO_UNAVAILABLE = "Sorry, we could not access this repository.";
+/** A remote review failure whose `code` the client can branch on. `runJob`
+ * stores `error.message`, so the text is what reaches the client's abort
+ * message. */
+class RemoteReviewError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.name = "RemoteReviewError";
+        this.code = code;
+    }
+}
 function remoteQueueKey(repo, branch, tokenId) {
     return `remote:${repo}:${branch}:${tokenId}`;
 }
-function reviewOptionsForRepo(repo, useCodegraph) {
+/** True only for a provider *authentication* rejection: the providers raise
+ * `openrouter_unauthorized`, `openai_unauthorized`, `anthropic_unauthorized`
+ * and `opencode_unauthorized`. The list is explicit so an unrelated error that
+ * happens to end in `_unauthorized` is not relabelled as a bad client key.
+ */
+function isProviderAuthError(error) {
+    return (error instanceof CliError &&
+        [
+            "openrouter_unauthorized",
+            "openai_unauthorized",
+            "anthropic_unauthorized",
+            "opencode_unauthorized",
+        ].includes(error.code));
+}
+function reviewOptionsForRepo(repo, useCodegraph, aiToken) {
     const config = readConfig();
     return {
         command: "review",
@@ -37,7 +66,7 @@ function reviewOptionsForRepo(repo, useCodegraph) {
         auth: config.auth ?? "gh",
         githubPat: config.githubPat,
         ai: config.ai ?? "openrouter",
-        aiToken: config.token,
+        aiToken: aiToken ?? config.token,
         lowModel: config.lowModel,
         highModel: config.highModel,
         synthesisVersion: 16,
@@ -54,10 +83,16 @@ function supersedeActiveRemoteJobs(queueKey, supersededBy) {
     for (const job of listJobsByQueueKey(queueKey, ["queued", "running"])) {
         if (job.id === supersededBy)
             continue;
+        // A superseded job never becomes terminal through `runJob`, so its BYOK
+        // key must be dropped here or it would sit in memory for the process
+        // lifetime, and its input row must go too so a later retry is not blocked
+        // by a dead row.
+        dropByokKey(job.id);
         if (job.status === "running") {
             cancel(job.id, "superseded");
         }
         else {
+            deleteRemoteReviewInput(job.id);
             setJobStatus(job.id, "canceled", {
                 superseded_by: supersededBy,
                 cancel_reason: "superseded",
@@ -69,6 +104,16 @@ export function submitRemoteReview(token, body) {
     const requestId = String(body.requestId);
     const existing = findRemoteReviewInputByRequest(token.id, requestId);
     if (existing) {
+        // A retried submit must not change who pays: the key is not in the body
+        // this time, so re-register it from the first request's recorded policy.
+        const bill = existing.billed_to === "byok" ? "byok" : "server";
+        if (bill === "byok" && !hasByokKey(existing.job_id)) {
+            return {
+                error: "Your key was not kept. Submit the review again.",
+                status: 409,
+                code: "byok_key_lost",
+            };
+        }
         const review = getReviewByJobId(existing.job_id);
         if (review) {
             return { jobId: existing.job_id, reviewId: review.id };
@@ -78,6 +123,24 @@ export function submitRemoteReview(token, body) {
     if (!repoRow || repoRow.active !== 1) {
         return { error: REPO_UNAVAILABLE, status: 404, code: "repo_unavailable" };
     }
+    const byokRaw = body.byok;
+    const submittedKey = byokRaw && typeof byokRaw.key === "string" ? byokRaw.key : undefined;
+    const policy = remoteByokPolicy();
+    if (policy === "off" && submittedKey !== undefined) {
+        return {
+            error: "This server does not accept your own key.",
+            status: 403,
+            code: "byok_not_allowed",
+        };
+    }
+    if (policy === "require" && submittedKey === undefined) {
+        return {
+            error: "This server requires your own key. Run with --remote-byok.",
+            status: 403,
+            code: "byok_required",
+        };
+    }
+    const billedTo = submittedKey !== undefined ? "byok" : "server";
     if (typeof body.branch !== "string") {
         return {
             error: "branch must be a string",
@@ -102,26 +165,50 @@ export function submitRemoteReview(token, body) {
         capabilitiesJson: JSON.stringify(capabilities),
         requestId,
         tokenId: token.id,
+        billedTo,
     });
+    // The review and job rows go in one transaction so a failure cannot leave a
+    // partially written submission behind: no review with no job, and no queued
+    // job whose input row points a retry at a job that never really started.
+    // The key is registered only after COMMIT, so it never outlives a failed
+    // setup.
     const config = readConfig();
-    insertRemoteReview({
-        id: reviewId,
-        subjectId: subject.id,
-        repo: repoRow.full_name,
-        branch,
-        tokenId: token.id,
-        tokenName: token.name,
-        jobId,
-        scope: "remote",
-        model: config.highModel ?? "unknown",
-    });
-    insertJob({
-        id: jobId,
-        type: "remote_review",
-        repo: repoRow.full_name,
-        queueKey,
-        args: { subjectId: subject.id, requestId, reviewId },
-    });
+    const db = getAppDb();
+    db.exec("BEGIN");
+    try {
+        insertRemoteReview({
+            id: reviewId,
+            subjectId: subject.id,
+            repo: repoRow.full_name,
+            branch,
+            tokenId: token.id,
+            tokenName: token.name,
+            jobId,
+            scope: "remote",
+            model: config.highModel ?? "unknown",
+        });
+        insertJob({
+            id: jobId,
+            type: "remote_review",
+            repo: repoRow.full_name,
+            queueKey,
+            args: { subjectId: subject.id, requestId, reviewId },
+        });
+        db.exec("COMMIT");
+    }
+    catch (error) {
+        db.exec("ROLLBACK");
+        // Nothing of this submission survives, so the input row must go too, or a
+        // retry with the same request id would find a row whose key is gone and be
+        // told byok_key_lost.
+        deleteRemoteReviewInput(jobId);
+        throw error;
+    }
+    // The key is pulled out of the body before anything persists it: it lives
+    // only in this process's memory, tied to the job.
+    if (billedTo === "byok" && submittedKey !== undefined) {
+        registerByokKey(jobId, submittedKey);
+    }
     openRemoteSession({
         jobId,
         reviewId,
@@ -147,22 +234,31 @@ export function registerRemoteReviewHandler() {
             setReviewStatus(reviewId, "running");
             log("info", `remote review started for ${job.repo}`);
             let completed = false;
+            // A BYOK review runs on the client's key, never the server's. If the key
+            // is gone (a restart between submit and run), stop with a typed message
+            // instead of silently falling back to the server key.
+            const billedTo = input.billed_to === "byok" ? "byok" : "server";
+            const byokKey = billedTo === "byok" ? getByokKey(job.id) : undefined;
             try {
+                if (billedTo === "byok" && byokKey === undefined) {
+                    throw new RemoteReviewError("byok_key_lost", "Your key was not kept across a server restart. Submit the review again.");
+                }
                 const revision = revisionFromSubmitJson(JSON.parse(input.revision_json));
                 const caps = JSON.parse(input.capabilities_json);
                 const allowed = new Set((caps.tools ?? [])
                     .map((tool) => tool.name)
                     .filter((name) => typeof name === "string" && name));
                 const useCodegraph = allowed.size > 0;
-                const options = reviewOptionsForRepo(job.repo, useCodegraph);
+                const options = reviewOptionsForRepo(job.repo, useCodegraph, byokKey);
                 if (!options.aiToken || options.ai === "none") {
                     throw new Error("server AI is not configured for remote review");
                 }
+                const billed = byokKey !== undefined ? "byok" : "server";
                 const extras = {};
                 if (subjectId) {
                     const subjectRevision = getSubjectRevision(subjectId);
                     // A guide rebuilt after the previous review invalidates its verdicts
-                    // and its "unchanged" suppression (CORE-42 / F03): start fresh so a
+                    // and its "unchanged" suppression: start fresh so a
                     // stale finding cannot mask a new one.
                     const guideRebuilt = subjectRevision !== undefined &&
                         guideRebuiltSince(subjectRevision.guide_built_at, (await loadGuides(job.repo)).guideBuiltAt);
@@ -198,15 +294,11 @@ export function registerRemoteReviewHandler() {
                 const started = performance.now();
                 let tokensIn = 0;
                 let tokensOut = 0;
-                let costUsd = 0;
-                let costKnown = true;
+                const costTally = emptyTally();
                 const result = await withLogSink((phase, message) => log("info", `[${phase}] ${message}`), () => reviewWorkspaceRevision(revision, options, "remote", async (response) => {
                     tokensIn += response.tokensIn;
                     tokensOut += response.tokensOut;
-                    if (response.cost === undefined)
-                        costKnown = false;
-                    else
-                        costUsd = (costUsd ?? 0) + response.cost;
+                    addResponseCost(costTally, response);
                     await recordAiCost(job.repo, "remote_review", response);
                 }, undefined, (message) => log("info", message), extras));
                 if (signal.aborted)
@@ -227,11 +319,7 @@ export function registerRemoteReviewHandler() {
                     codegraph: { state: result.codegraphState },
                     summary: summaryCounts(findings, blockingMode),
                     findings: findings.map((row) => toJsonFinding(row, blockingMode)),
-                    usage: {
-                        tokensIn,
-                        tokensOut,
-                        costUsd: costKnown ? costUsd : null,
-                    },
+                    usage: { tokensIn, tokensOut, ...costUsage(costTally) },
                     remote: { jobId: job.id, reviewId, clientVersion: VERSION },
                 });
                 setReviewStatus(reviewId, "done", {
@@ -240,7 +328,8 @@ export function registerRemoteReviewHandler() {
                     duration_ms: durationMs,
                     tokens_in: tokensIn,
                     tokens_out: tokensOut,
-                    cost: costKnown ? costUsd : null,
+                    billed_to: billed,
+                    ...costColumns(settle(costTally)),
                 });
                 if (subjectId) {
                     saveSubjectRevision({
@@ -271,11 +360,29 @@ export function registerRemoteReviewHandler() {
                 completed = true;
                 log("info", `remote review finished (${findings.length} findings)`);
             }
+            catch (error) {
+                // Only an authentication rejection proves the client's key is bad, so
+                // only that becomes `byok_rejected`. A provider outage, a parse error
+                // or a local failure must surface as itself rather than telling the
+                // user their key was refused. `byok_key_lost` is thrown before this
+                // try, so it is not remapped.
+                if (byokKey !== undefined &&
+                    !signal.aborted &&
+                    isProviderAuthError(error)) {
+                    throw new RemoteReviewError("byok_rejected", "The AI provider rejected your own key.");
+                }
+                throw error;
+            }
             finally {
+                dropByokKey(job.id);
                 if (!completed) {
+                    // Reached on failure and on the aborted early return above.
                     if (signal.aborted) {
                         setReviewStatus(reviewId, "aborted");
                     }
+                    else {
+                        setReviewStatus(reviewId, "failed");
+                    }
                     deleteRemoteReviewInput(job.id);
                     closeRemoteSession(job.id);
                 }

package/dist/src/services/remote_review_abort.d.ts

@@ -1,3 +1,7 @@
 /** Queued remote reviews never enter the handler; sync the review row when the
- * job is canceled from the dashboard or token deactivation. */
+ * job is canceled from the dashboard or token deactivation. The BYOK key and
+ * the input row are dropped here too: a queued job canceled before it ever
+ * runs must not leave the client's key in memory, and a later retry with the
+ * same request id must be free to start over instead of finding a dead row
+ * whose key is gone. */
 export declare function abortQueuedRemoteReviewRow(jobId: string): void;

package/dist/src/services/remote_review_abort.js

@@ -1,7 +1,15 @@
 import { getReviewByJobId, setReviewStatus } from "../store/reviews.js";
+import { deleteRemoteReviewInput } from "../store/remote_review_inputs.js";
+import { dropByokKey } from "../remote/server/byok_keys.js";
 /** Queued remote reviews never enter the handler; sync the review row when the
- * job is canceled from the dashboard or token deactivation. */
+ * job is canceled from the dashboard or token deactivation. The BYOK key and
+ * the input row are dropped here too: a queued job canceled before it ever
+ * runs must not leave the client's key in memory, and a later retry with the
+ * same request id must be free to start over instead of finding a dead row
+ * whose key is gone. */
 export function abortQueuedRemoteReviewRow(jobId) {
+    dropByokKey(jobId);
+    deleteRemoteReviewInput(jobId);
     const review = getReviewByJobId(jobId);
     if (!review || review.kind !== "remote")
         return;

package/dist/src/services/review.d.ts

@@ -14,7 +14,7 @@ export declare function splitInline(findings: ParsedFinding[], files: Json[]): {
     leftover: ParsedFinding[];
 };
 export declare function reviewEvent(findingsCount: number): "REQUEST_CHANGES" | "COMMENT";
-/** The GitHub review event for a set of stored findings (CORE-41).
+/** The GitHub review event for a set of stored findings.
  *
  * `model` keeps the 0.4.13 behavior: any finding requests changes, because the
  * model's label already decided. `severity` ignores that label and requests

package/dist/src/services/review.js

@@ -10,6 +10,7 @@ import { stripSuggestion, suggestionAnchor, withoutSuggestionLine, } from "../pr
 import { githubPullRequestToRevision } from "../pr/github_revision.js";
 import { anchorTextFromPatch, buildCarryPromptSection, classifyCarryItems, guideRebuiltSince, incrementalDiffPaths, parsePreviousVerdicts, resolveCarryOutcomes, } from "../review/carry_over.js";
 import { runReviewEngine } from "../review/engine.js";
+import { addResponseCost, costColumns, emptyTally, settle, } from "../util/cost.js";
 import { loadGuides } from "../review/guides.js";
 import { reviewBlockingFrom, isBlocking, DEFAULT_REVIEW_BLOCKING, } from "../review/blocking.js";
 import { matchRepeat } from "../pr/rounds.js";
@@ -26,7 +27,7 @@ export function humanCopy(text) {
     // The semicolon is prose and always goes. The em dash is left alone here:
     // this function also sanitizes a finding title, and a title posted before
     // 0.5.0 uses ` — ` as its path/symbol separator, which the legacy heading
-    // reader still needs (CORE-83 keeps that one allowlisted exception).
+    // reader still needs (the copy guard keeps that one allowlisted exception).
     return outsideCode(redact(text), (prose) => prose.replaceAll(";", "."));
 }
 function hasForbiddenCopy(text) {
@@ -66,7 +67,7 @@ export function splitInline(findings, files) {
 export function reviewEvent(findingsCount) {
     return findingsCount > 0 ? "REQUEST_CHANGES" : "COMMENT";
 }
-/** The GitHub review event for a set of stored findings (CORE-41).
+/** The GitHub review event for a set of stored findings.
  *
  * `model` keeps the 0.4.13 behavior: any finding requests changes, because the
  * model's label already decided. `severity` ignores that label and requests
@@ -139,6 +140,8 @@ export function reviewOptions(repo, prNumber) {
         ghConcurrent: 1,
         aiConcurrent: 1,
         auth: "gh",
+        // With no provider saved the App review stays on OpenRouter, the same
+        // fallback the CLI review uses.
         ai: config.ai && config.ai !== "none" ? config.ai : "openrouter",
         aiToken: config.token,
         highModel: config.highModel,
@@ -457,6 +460,16 @@ async function runReviewJobCore(job, log, client, ai) {
     }
     const options = reviewOptions(job.repo, job.pr_number);
     const args = JSON.parse(job.args || "{}");
+    // A maintainer asked for this review by label or comment: acknowledge it.
+    // Best effort, a missing reaction must never fail the review itself.
+    if (args.requestReaction && !existing) {
+        try {
+            await post(github, args.requestReaction, { content: "eyes" });
+        }
+        catch (error) {
+            log("info", `could not react to the review request: ${String(error)}`);
+        }
+    }
     const pr = await github.request(`repos/${job.repo}/pulls/${job.pr_number}`);
     const headSha = String(pr.head?.sha ?? "");
     const mergeBase = String(pr.base?.sha ?? "");
@@ -546,7 +559,7 @@ async function runReviewJobCore(job, log, client, ai) {
     let carryPrevious = null;
     const extras = {};
     // A guide rebuilt after the previous review invalidates that review's
-    // verdicts and its "unchanged" suppression (CORE-42 / F03). Treat the run as
+    // verdicts and its "unchanged" suppression. Treat the run as
     // if it had started fresh: carry-over off, every changed file back in scope,
     // so a stale finding can never mask a new one.
     const guideRebuilt = subjectRevision !== undefined &&
@@ -575,7 +588,8 @@ async function runReviewJobCore(job, log, client, ai) {
         carryItems = classifyCarryItems(carryPrevious, revision, carryPrevious.visiblePaths, guidesBefore.guideBuiltAt);
         extras.carryPrompt = buildCarryPromptSection(carryItems, revision);
     }
-    const response = await runReviewEngine(github, options, undefined, snapshot, ai ?? aiFor(options), (message) => log("info", message), extras);
+    const costTally = emptyTally();
+    const response = await runReviewEngine(github, options, async (call) => addResponseCost(costTally, call), snapshot, ai ?? aiFor(options), (message) => log("info", message), extras);
     guideBuiltAt = response.guideBuiltAt;
     const visiblePaths = new Set(response.visiblePaths);
     if (carryPrevious) {
@@ -650,7 +664,7 @@ async function runReviewJobCore(job, log, client, ai) {
         closed_count: closedCount,
         tokens_in: response.tokensIn,
         tokens_out: response.tokensOut,
-        cost: response.cost,
+        ...costColumns(settle(costTally)),
     });
     saveSubjectRevision({
         subjectId: subject.id,

package/dist/src/services/review_policy.d.ts

@@ -0,0 +1,116 @@
+/** The review policy engine.
+ *
+ * A policy is an ordered list of rules. The first rule whose conditions all
+ * hold decides what happens to a pull request, and when none holds the policy's
+ * default action does. This file is pure: no database, no GitHub, no clock, so
+ * every branch of it is a table test. `webhook.ts` gathers the facts and acts on
+ * the answer. */
+export declare const ASSOCIATIONS: readonly ["OWNER", "MEMBER", "COLLABORATOR", "CONTRIBUTOR", "FIRST_TIME_CONTRIBUTOR", "FIRST_TIMER", "NONE"];
+export type Association = (typeof ASSOCIATIONS)[number];
+export declare const ACTIONS: readonly ["review", "on-request", "skip"];
+export type PolicyAction = (typeof ACTIONS)[number];
+export type RuleWhen = {
+    association?: Association[];
+    fork?: boolean;
+    draft?: boolean;
+    bot?: boolean;
+    /** The pull request has at least one of these labels. */
+    labels?: string[];
+    targetBranch?: string[];
+    changedLines?: {
+        min?: number;
+        max?: number;
+    };
+};
+export type PolicyRule = {
+    name?: string;
+    when: RuleWhen;
+    action: PolicyAction;
+    /** A fixed skip reason. Only the rules derived from the old per repository
+     * switches set it, so their skips read exactly as they always did. */
+    reason?: string;
+};
+export type ReviewPolicy = {
+    rules: PolicyRule[];
+    default: PolicyAction;
+    defaultReason?: string;
+    requestLabel: string;
+    requestCommand: string;
+    requesters: Association[];
+    /** `head`: a request covers the commit it was made on. `pull-request`: the
+     * first request covers every later push. */
+    approvalScope: "head" | "pull-request";
+    /** Reviews a pull request may get from the webhook. Unset means no limit. */
+    maxRounds?: number;
+};
+export type PolicyInput = Partial<ReviewPolicy>;
+/** What is known about a pull request. A fact GitHub did not send is left out,
+ * and a rule that asks about it does not match. */
+export type PolicyFacts = {
+    association?: string;
+    fork?: boolean;
+    draft: boolean;
+    bot: boolean;
+    labels?: string[];
+    targetBranch?: string;
+    changedLines?: number;
+};
+export type PolicyDecision = {
+    action: PolicyAction;
+    /** 1 based position of the rule that decided, `null` for the default. */
+    rule: number | null;
+    reason: string;
+};
+export declare const DEFAULT_POLICY_SETTINGS: {
+    readonly requestLabel: "co-maintainer:review";
+    readonly requestCommand: "/co-maintainer review";
+    readonly requesters: ("OWNER" | "MEMBER" | "COLLABORATOR" | "CONTRIBUTOR" | "FIRST_TIME_CONTRIBUTOR" | "FIRST_TIMER" | "NONE")[];
+    readonly approvalScope: "head";
+};
+export declare const TEMPLATES: Record<string, PolicyInput>;
+export declare const TEMPLATE_NAMES: string[];
+export declare function withDefaults(input: PolicyInput): ReviewPolicy;
+/** The policy the three old per repository switches amount to, so a repository
+ * nobody has given a policy keeps behaving exactly as before. Switched off
+ * means everything is skipped, and the drafts and bots switches only matter
+ * while it is on. */
+export declare function legacyPolicy(settings: {
+    auto_review: number;
+    skip_drafts: number;
+    skip_bots: number;
+}): ReviewPolicy;
+export declare function evaluatePolicy(policy: ReviewPolicy, facts: PolicyFacts): PolicyDecision;
+/** Whether a pull request that a policy leaves waiting for a request may be
+ * reviewed without a new one. Only the `pull-request` scope carries an earlier
+ * request forward, and only once something was actually reviewed or queued. */
+export declare function carriesEarlierRequest(policy: ReviewPolicy, hasEarlierReview: boolean): boolean;
+/** Whether `body` starts with the request command as a whole word. */
+export declare function isRequestCommand(body: string, command: string): boolean;
+type Check<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    problem: string;
+};
+/** Turns stored or user supplied policy data into a policy, or says what is
+ * wrong with it. A string names a template, an object is a full policy where
+ * every setting but the rules can be left out. */
+export declare function parsePolicy(value: unknown): Check<ReviewPolicy>;
+/** What the dashboard shows next to each template, one plain sentence each. */
+export declare const TEMPLATE_INFO: {
+    name: string;
+    label: string;
+    description: string;
+}[];
+/** The policy as short sentences a maintainer can read before saving it. */
+export declare function describePolicy(policy: ReviewPolicy): string[];
+/** What to store for a policy: the template's name when the policy is exactly
+ * that template with the default settings, the whole policy otherwise. */
+export declare function storedPolicyValue(policy: ReviewPolicy): string | ReviewPolicy;
+/** What a form or API caller sent, as the value to store. `null` clears the
+ * choice, and `"legacy"` (the simple switches) is only for one repository. */
+export declare function policyToStore(value: unknown, options: {
+    allowLegacy: boolean;
+}): Check<string | null>;
+export {};