@zackbart/connecta 0.24.4 → 0.26.0

package/dist/operator-ui/model.d.ts

@@ -1,9 +1,44 @@
 import type { CatalogAccessObservation, CatalogDriftReport } from "../types.js";
+/**
+ * Which call path a tool takes, decided on the server by the same
+ * `isExplicitlyReadOnly` predicate discovery and invocation use
+ * (`src/tool-safety.ts`) and never re-derived in the browser: a second copy of
+ * the rule is a second place for it to be wrong.
+ *
+ * - `runs_in_programs` — explicitly read-only, so `execute_code` may call it.
+ * - `exempt` — not read-only, but the deployment's `execute.approval` lets a
+ *   program call it without pausing (#566). Still approval-required
+ *   everywhere else.
+ * - `needs_approval` — everything else: a program pauses for
+ *   `resume_execution`, and a direct call crosses `call_destructive_tool`.
+ *
+ * The badge renders from a table keyed by this union, so each value is one
+ * entry, not a branch.
+ */
+export type UiToolSafety = "runs_in_programs" | "exempt" | "needs_approval";
 export interface UiTool {
     name: string;
     address: string;
     description?: string;
+    /** Absent only in payloads older than the field; the page then shows no badge. */
+    safety?: UiToolSafety;
 }
+/**
+ * What went wrong with a connector, as a closed set the server chooses from.
+ * The browser keys both its on-screen description and a fixed fix prompt off
+ * this. There is deliberately no message beside it: a connector's status
+ * message can quote a downstream error body, so it goes to the deployment's
+ * log and never into the operator payload.
+ *
+ * `auth_required` splits by who has to act: a downstream OAuth grant
+ * (`oauth_required`, which also covers an expired or revoked grant — the
+ * status seam cannot tell those apart), an operator-managed credential slot
+ * (`credential_required`), or a secret that lives in deployment configuration
+ * (`auth_required`).
+ */
+export type UiProblem = "connector_unavailable" | "oauth_required" | "credential_required" | "auth_required" | "credential_mismatch" | "catalog_failed";
+/** A stored credential that cannot be used, by cause. */
+export type UiCredentialProblem = "credential_mismatch" | "credential_unreadable";
 interface UiCredentialField {
     name: string;
     label: string;
@@ -26,6 +61,8 @@ interface UiCredential {
     updatedAt?: string;
     testable: boolean;
     error?: string;
+    /** Present exactly when `error` is: the cause, for the fix prompt. */
+    problem?: UiCredentialProblem;
     /**
      * Something true and non-blocking about a working credential — today, that
      * the vault still holds fields the connector has stopped declaring.
@@ -45,7 +82,12 @@ export interface UiConnector {
         manageSharedAuth: boolean;
         connectPersonal: boolean;
     };
-    message?: string;
+    /**
+     * Why this connector is not usable, when it is not. See `UiProblem`. The
+     * only failure detail the payload carries; the status message behind it is
+     * logged on the server, not shipped.
+     */
+    problem?: UiProblem;
     authorizationUrl?: string;
     toolCount: number;
     tools: UiTool[];
@@ -77,6 +119,66 @@ export interface UiData {
     credentialManagement: CredentialManagementCapability;
     /** True when this interactive human may manage any visible OAuth connector. */
     oauthManagement: boolean;
+    /**
+     * Names of the `/mcp/<name>` pools this identity's grant admits. A pool
+     * whose grant refuses or throws is absent, exactly as the endpoint answers
+     * it with a 404, so the page never enumerates a pool its reader cannot open.
+     */
+    pools?: string[];
+    /** True when artifact pages are mounted and this identity may open them. */
+    artifactsEnabled?: boolean;
+}
+/**
+ * One row of the artifact library. Every field is a fact the store keeps or
+ * an enum; nothing here is a message, a log line, or a downstream's words.
+ */
+export interface UiArtifactRow {
+    id: string;
+    title: string;
+    kind: "html" | "markdown";
+    viewVersion: number;
+    updatedAt: string;
+    updatedBy: {
+        label: string;
+    };
+    archived: boolean;
+    freshness?: UiArtifactFreshness;
+}
+interface UiArtifactFreshness {
+    state: "unconfigured" | "current" | "stale";
+    schedule?: "manual" | "daily" | "weekly";
+    document?: string;
+    dueAt?: string;
+    last?: {
+        at: string;
+        status: "succeeded" | "unchanged" | "failed" | "superseded";
+    };
+    running?: boolean;
+}
+/** The viewer's payload: the page's facts and the one document its frame loads. */
+export interface UiArtifactView {
+    id: string;
+    title: string;
+    kind: "html" | "markdown";
+    archived: boolean;
+    snapshot: boolean;
+    latestViewVersion: number;
+    view: {
+        version: number;
+        at: string;
+        by: {
+            label: string;
+        };
+    };
+    documents: {
+        name: string;
+        version: number;
+        updatedAt: string;
+    }[];
+    url: string;
+    snapshotUrl: string;
+    document: string;
+    freshness?: UiArtifactFreshness;
 }
 export interface FilteredUiConnector {
     connector: UiConnector;

package/dist/operator-ui/setup-commands.js

@@ -0,0 +1,53 @@
+/**
+ * Client setup snippets for one MCP endpoint: the deployment's `/mcp` or a
+ * `/mcp/<pool>`. Three formats and no more — Claude Code's CLI, Codex's CLI,
+ * and the `mcpServers` JSON most other clients read — because a longer list
+ * is a list to keep current.
+ *
+ * None of them carries a credential. A client authenticates through the
+ * deployment's inbound auth — OAuth discovery where that is configured — and
+ * a token pasted into a snippet on this page would be one rendered by it.
+ */
+/**
+ * The name a client files this server under. Derived from the deployment's
+ * configured server name, reduced to the characters every client CLI accepts
+ * unquoted, with the pool appended so two endpoints never collide.
+ */
+export function clientServerName(serverName, pool) {
+    const base = (serverName ?? "")
+        .toLowerCase()
+        .replace(/[^a-z0-9_-]+/g, "-")
+        .replace(/-{2,}/g, "-")
+        .replace(/^-+|-+$/g, "")
+        .slice(0, 48) || "connecta";
+    return pool ? `${base}-${pool}` : base;
+}
+/** The URL for a pool: `/mcp` plus its name, which config limits to `[a-z0-9_-]`. */
+export function poolEndpointUrl(mcpUrl, pool) {
+    return `${mcpUrl.replace(/\/+$/, "")}/${encodeURIComponent(pool)}`;
+}
+/** POSIX single-quoting, only when the value needs it. */
+function shellWord(value) {
+    return /^[A-Za-z0-9_./:@%+=,~-]+$/.test(value)
+        ? value
+        : `'${value.replace(/'/g, `'"'"'`)}'`;
+}
+export function clientSetupCommands(name, url) {
+    return [
+        {
+            id: "claude",
+            label: "Claude Code",
+            text: `claude mcp add --transport http ${shellWord(name)} ${shellWord(url)}`,
+        },
+        {
+            id: "codex",
+            label: "Codex",
+            text: `codex mcp add ${shellWord(name)} --url ${shellWord(url)}`,
+        },
+        {
+            id: "json",
+            label: "JSON config",
+            text: JSON.stringify({ mcpServers: { [name]: { type: "http", url } } }, null, 2),
+        },
+    ];
+}

package/dist/operator-ui/view.js

@@ -1,20 +1,84 @@
+/** Pages the nav lists. A single artifact is reached from the library, not the nav. */
 export const OPERATOR_PAGES = [
     "connections",
     "activity",
+    "artifacts",
 ];
 export const PAGE_META = {
     connections: { path: "/", label: "Connections" },
     activity: { path: "/activity", label: "Activity" },
+    artifacts: { path: "/artifacts", label: "Artifacts" },
+    artifact: { path: "/artifacts", label: "Artifact" },
 };
 export function pageForPath(path) {
+    if (path.startsWith("/artifacts/"))
+        return "artifact";
     const match = OPERATOR_PAGES.find((page) => PAGE_META[page].path === path);
     return match ?? "connections";
 }
+/** Artifact pages load their own data and never ask `/ui/data` whether to open. */
+export function isArtifactPage(page) {
+    return page === "artifacts" || page === "artifact";
+}
+/**
+ * Where a viewer's frame gets its page: `/artifacts/<id>` or a snapshot,
+ * `/artifacts/<id>/v/<version>?d=<name>:<version>…`, mapped to its API call.
+ */
+export function artifactViewRequest(pathname, search) {
+    const match = /^\/artifacts\/([a-z0-9](?:[a-z0-9-]{0,62}[a-z0-9])?)(?:\/v\/(\d{1,9}))?$/.exec(pathname);
+    if (!match?.[1])
+        return undefined;
+    const params = new URLSearchParams();
+    if (match[2]) {
+        params.set("v", match[2]);
+        for (const pin of new URLSearchParams(search).getAll("d"))
+            params.append("d", pin);
+    }
+    const query = params.toString();
+    return `/artifacts/_api/view/${match[1]}${query ? `?${query}` : ""}`;
+}
 export function info(message) {
     return { message, tone: "info" };
 }
-export function failure(message) {
-    return { message, tone: "error" };
+export function failure(message, fix) {
+    return fix ? { message, tone: "error", fix } : { message, tone: "error" };
+}
+const REFUSED_COPY = {
+    oauth_disconnect: "OAuth disconnect failed. If the downstream refused it, the deployment's log has its reply.",
+    oauth_reconnect: "OAuth authorization could not restart. If the downstream refused it, the deployment's log has its reply.",
+    credential_test: "The credential test could not run.",
+};
+/** The route's answer to a finished OAuth action. Its state picks the sentence. */
+export function oauthDoneNotice(action, answer) {
+    if (action === "oauth_disconnect") {
+        return info("OAuth disconnected. Restart authorization when you are ready to reconnect.");
+    }
+    return info(answer?.state === "ok"
+        ? "OAuth reconnected."
+        : "Authorization restarted. Open the authorization link to reconnect.");
+}
+/** A credential Test's result. `ok` is the only part of the answer it reads. */
+export function credentialTestNotice(connectorId, answer) {
+    return answer?.ok === true
+        ? info("Credential is valid.")
+        : failure("Credential test failed: the downstream rejected the stored credential, or the test could not reach it. The deployment's log has the downstream's reply.", { kind: "credential_test_failed", connectorId });
+}
+/**
+ * A route that refused one of these actions. A credential Test that found
+ * nothing usable to test names the problem, which picks the same copy and fix
+ * prompt the Connections page uses for it; every other refusal gets the
+ * action's one sentence. `problem` is whatever the response carried, so it is
+ * checked, not trusted.
+ */
+export function refusedNotice(action, connectorId, problem) {
+    if (action === "credential_test" &&
+        (problem === "credential_required" || problem === "credential_mismatch")) {
+        return failure(PROBLEM_COPY[problem], { kind: problem, connectorId });
+    }
+    return failure(REFUSED_COPY[action], {
+        kind: action === "credential_test" ? "credential_test_failed" : "oauth_action_failed",
+        connectorId,
+    });
 }
 export function initialState(page) {
     return {
@@ -46,6 +110,13 @@ function identityScopedState() {
         activityEvents: [],
         activityCursor: null,
         activitySearch: "",
+        artifactPhase: "idle",
+        artifactNotice: null,
+        artifactRows: [],
+        artifactCursor: null,
+        artifactQuery: "",
+        artifactArchived: false,
+        artifactView: null,
     };
 }
 /**
@@ -150,6 +221,47 @@ export function connectorSummaryParts(summary) {
         { text: toolCountLabel(summary.tools), tone: "neutral" },
     ];
 }
+/**
+ * The badge for each call path, keyed by the server's classification so each
+ * state is a row here rather than a branch in a component.
+ */
+export const TOOL_SAFETY_BADGE = {
+    runs_in_programs: {
+        label: "runs in programs",
+        tone: "ok",
+        title: "Explicitly read-only: execute_code programs may call it without asking.",
+    },
+    exempt: {
+        label: "exempt from approval",
+        tone: "neutral",
+        title: "Not read-only, but this deployment's config lets programs call it without pausing. Each call still counts against the write budget and appears in activity; call_tool still refuses it.",
+    },
+    needs_approval: {
+        label: "asks for approval",
+        tone: "warn",
+        title: "Not explicitly read-only: a program pauses for resume_execution, and a direct call crosses call_destructive_tool — either way the host asks first.",
+    },
+};
+/**
+ * What the page says about a connector that is not usable, one fixed sentence
+ * per problem kind the server classified. This is the only account of a
+ * failure the Connections page renders: a connector's status message can quote
+ * a downstream error body, and a downstream error body can quote the secret
+ * that was just rejected, so the raw text stays in the deployment's log and
+ * never reaches the payload or the DOM. The fix prompt beside it is keyed off
+ * the same kind.
+ */
+const PROBLEM_COPY = {
+    connector_unavailable: "Unavailable: its status check or catalog load failed, or did not finish in time. The deployment's log has the downstream error.",
+    oauth_required: "Needs OAuth authorization: no grant is stored, or the stored grant expired or was revoked.",
+    credential_required: "Needs a credential: nothing usable is stored in its credential slot.",
+    auth_required: "Needs authorization. Its secret lives in deployment configuration, not on this page.",
+    credential_mismatch: "The stored credential does not match the fields this connector declares, so it cannot be used.",
+    catalog_failed: "Connected, but its tool catalog could not be loaded, so none of its tools are served.",
+};
+export function problemCopy(problem) {
+    return problem ? PROBLEM_COPY[problem] ?? null : null;
+}
 /** Who owns this connector's downstream credentials, in two words. */
 export function authScopeLabel(scope) {
     return scope === "personal" ? "personal auth" : "shared auth";
@@ -284,13 +396,26 @@ export function activitySummary(events) {
     const tools = new Set(events.map((event) => event.address)).size;
     return `${events.length} loaded call${events.length === 1 ? "" : "s"} · ${tools} tool${tools === 1 ? "" : "s"} · no arguments or results stored`;
 }
-const ACTIVITY_OUTCOMES = ["success", "error", "timeout", "cancelled"];
+// A pause and an approval are neither success nor failure: each gets its own
+// class, and the stylesheet paints neither as an error.
+const ACTIVITY_OUTCOMES = [
+    "success",
+    "error",
+    "timeout",
+    "cancelled",
+    "paused",
+    "approved",
+];
 export function activityOutcomeClass(outcome) {
     return ACTIVITY_OUTCOMES.includes(outcome) ? outcome : "error";
 }
 /** The one-line detail under an address: source, retries, and friction. */
 export function activityDetail(event) {
     const parts = [event.source];
+    if (event.approval === "tool")
+        parts.push("approved for the rest of the run");
+    if (event.approval === "call")
+        parts.push("approved for this call");
     if (event.attempts > 1)
         parts.push(`${event.attempts} attempts`);
     if (event.friction)

package/dist/program-source.js

@@ -0,0 +1,321 @@
+// Program source handling shared by every executor. Web-API only: execute_code
+// runs it before handing a program to QuickJS or a Dynamic Worker, and the
+// QuickJS normalizer runs it too for callers that drive that executor directly.
+/** A whole-program markdown fence, as QuickJS's normalizer recognizes one. */
+const FENCE = /^```[\w-]*\s*\n([\s\S]*?)\n?```$/;
+/** Intake accepts one JavaScript fence, optionally surrounded by prose. */
+const PROGRAM_FENCE = /^```(?:js|javascript)?[ \t]*\r?\n([\s\S]*?)\r?\n```[ \t]*$/gm;
+/** Leading whitespace and comments, which may precede the arrow expression. */
+const LEADING_TRIVIA = /^(?:\s+|\/\/[^\n]*|\/\*[\s\S]*?\*\/)+/;
+/** One character of an identifier, keyword, or number; `\\` for escapes. */
+const WORD = /[\w$\\\u0080-\uffff]/;
+/**
+ * Words after which a `/` begins a regular expression rather than dividing.
+ * Any other word is an identifier or a literal, which a `/` divides.
+ */
+const REGEX_AFTER_WORD = new Set([
+    "await", "case", "delete", "do", "else", "in", "instanceof", "new", "of",
+    "return", "throw", "typeof", "void", "yield",
+]);
+/**
+ * Remove the statement terminators after a program's arrow expression:
+ * `async () => { … };`, with any whitespace or comments around the trailing
+ * semicolons, becomes `async () => { … }` with those comments kept. Both
+ * executors evaluate a program as a parenthesized expression, where a
+ * terminator is a syntax error on QuickJS and, on a Dynamic Worker, either the
+ * same error or a program that silently returns `undefined`. Models often end
+ * a program with `};`, so P1 accepts it on both.
+ *
+ * Deliberately narrow, so it cannot broaden what a program is: only a program
+ * whose first token is `async` or `(` — what QuickJS treats as a function
+ * expression — and only when every semicolon at bracket depth zero trails it,
+ * with nothing but whitespace and comments after. `async () => 1; 2();` keeps
+ * both its semicolons, and a bare statement body is never touched, since its
+ * trailing `;` can be an empty loop body. A whole-program markdown fence is
+ * looked through, and dropped when a terminator came out from under it.
+ *
+ * A small lexer, not a parser: it skips strings, template literals (with
+ * `${}` nesting), comments, and regular expressions, telling a regex from a
+ * division by the token before it. Any source it cannot close — an
+ * unterminated string or comment, unbalanced brackets — comes back unchanged,
+ * so the executor reports the same error it always did.
+ */
+export function withoutProgramTerminator(code) {
+    const fenced = FENCE.exec(code.trim())?.[1];
+    const source = fenced === undefined ? code : fenced.trim();
+    const stripped = stripTerminators(source);
+    return stripped === source ? code : stripped;
+}
+/**
+ * Recover wrappers that models put around a single program. This runs in the
+ * host, so QuickJS and Dynamic Workers receive the same source. It does not
+ * turn arbitrary statements into a program: an arrow remains the contract.
+ */
+export function normalizeProgramSource(code) {
+    let source = code.trim();
+    const head = source.replace(LEADING_TRIVIA, "");
+    // A program may itself contain fenced Markdown in a comment or string. Once
+    // the source starts as a program, a fence inside it is data, never a wrapper.
+    if (!/^(?:async\b|\(|export\s+default\s+async\b)/.test(head)) {
+        const fences = [...source.matchAll(PROGRAM_FENCE)];
+        if (fences.length === 1) {
+            const fence = fences[0];
+            const outside = source.slice(0, fence.index) + source.slice(fence.index + fence[0].length);
+            const body = fence[1].trim();
+            const fencedHead = body.replace(LEADING_TRIVIA, "");
+            if (!outside.includes("```") && /^(?:async\b|\(|export\s+default\s+async\b)/.test(fencedHead)) {
+                source = body;
+            }
+        }
+    }
+    source = source.replace(/^export\s+default\s+(?=async\s*(?:\(|[A-Za-z_$]))/, "");
+    // The declaration must be the whole source. A scanner finds its own closing
+    // brace rather than mistaking a brace in a string or a second statement for
+    // the end of the function.
+    const named = /^async\s+function\s+([A-Za-z_$][\w$]*)\s*\(([^()]*)\)\s*\{/.exec(source);
+    if (named) {
+        const end = functionBodyEnd(source, named[0].length - 1);
+        if (end !== undefined && /^(?:\s|;|\/\/[^\n]*|\/\*[\s\S]*?\*\/)*$/.test(source.slice(end + 1))) {
+            // Invoke a named function expression inside the arrow. Its own name and
+            // `arguments` binding then work exactly as in the original declaration.
+            source = `async (...args) => (async function ${named[1]}(${named[2]}) {${source.slice(named[0].length, end)}})(...args)${source.slice(end + 1)}`;
+        }
+    }
+    return withoutProgramTerminator(source);
+}
+/** Find the matching closing brace of a named function's body. */
+function functionBodyEnd(source, open) {
+    let depth = 0;
+    let previous = "";
+    for (let i = open; i < source.length; i++) {
+        const c = source[i];
+        if (/\s/.test(c))
+            continue;
+        if (c === "/" && source[i + 1] === "/") {
+            const end = source.indexOf("\n", i + 2);
+            i = end === -1 ? source.length : end;
+            continue;
+        }
+        if (c === "/" && source[i + 1] === "*") {
+            const end = source.indexOf("*/", i + 2);
+            if (end === -1)
+                return undefined;
+            i = end + 1;
+            continue;
+        }
+        if (c === "'" || c === '"' || c === "`") {
+            let end = i + 1;
+            for (; end < source.length && source[end] !== c; end++) {
+                if (source[end] === "\\")
+                    end++;
+                else if (source[end] === "\n" && c !== "`")
+                    return undefined;
+            }
+            if (end >= source.length)
+                return undefined;
+            i = end;
+            previous = "0";
+            continue;
+        }
+        if (c === "/" && startsRegex(previous)) {
+            let end = i + 1;
+            let inClass = false;
+            for (; end < source.length; end++) {
+                const r = source[end];
+                if (r === "\n")
+                    return undefined;
+                if (r === "\\")
+                    end++;
+                else if (r === "[")
+                    inClass = true;
+                else if (r === "]")
+                    inClass = false;
+                else if (r === "/" && !inClass)
+                    break;
+            }
+            if (end >= source.length)
+                return undefined;
+            i = end;
+            previous = "0";
+            continue;
+        }
+        if (WORD.test(c)) {
+            let end = i + 1;
+            while (end < source.length && WORD.test(source[end]))
+                end++;
+            previous = source.slice(i, end);
+            i = end - 1;
+            continue;
+        }
+        if (c === "{")
+            depth++;
+        else if (c === "}") {
+            depth--;
+            if (depth === 0)
+                return i;
+            if (depth < 0)
+                return undefined;
+        }
+        previous = c;
+    }
+    return undefined;
+}
+function stripTerminators(source) {
+    const head = source.replace(LEADING_TRIVIA, "");
+    if (!/^async\b/.test(head) && !head.startsWith("("))
+        return source;
+    const n = source.length;
+    let depth = 0;
+    /** Bracket depth at which each open template substitution resumes its template. */
+    const substitutions = [];
+    /** Positions of the top-level semicolons, all of which must trail. */
+    const terminators = [];
+    /**
+     * The previous significant token: a punctuator character or a word, with a
+     * string, template, or regex literal recorded as `0` — a value, like a number.
+     */
+    let previous = "";
+    let i = 0;
+    /** Scan template text from `from` to its closing backtick or next `${`. */
+    const template = (from) => {
+        for (let j = from; j < n; j++) {
+            const c = source[j];
+            if (c === "\\") {
+                j++;
+            }
+            else if (c === "`") {
+                return j + 1;
+            }
+            else if (c === "$" && source[j + 1] === "{") {
+                substitutions.push(depth);
+                depth++;
+                return j + 2;
+            }
+        }
+        return undefined;
+    };
+    while (i < n) {
+        const c = source[i];
+        if (/\s/.test(c)) {
+            i++;
+            continue;
+        }
+        if (c === "/" && source[i + 1] === "/") {
+            const end = source.indexOf("\n", i);
+            i = end === -1 ? n : end;
+            continue;
+        }
+        if (c === "/" && source[i + 1] === "*") {
+            const end = source.indexOf("*/", i + 2);
+            if (end === -1)
+                return source;
+            i = end + 2;
+            continue;
+        }
+        if (c === ";") {
+            if (depth === 0)
+                terminators.push(i);
+            previous = ";";
+            i++;
+            continue;
+        }
+        // Code after a top-level semicolon means the program is more than one
+        // expression; that is for the executor to refuse, not for us to repair.
+        if (terminators.length > 0)
+            return source;
+        if (c === '"' || c === "'") {
+            let j = i + 1;
+            while (j < n && source[j] !== c) {
+                if (source[j] === "\n")
+                    return source;
+                j += source[j] === "\\" ? 2 : 1;
+            }
+            if (j >= n)
+                return source;
+            i = j + 1;
+            previous = "0";
+            continue;
+        }
+        if (c === "`") {
+            const end = template(i + 1);
+            if (end === undefined)
+                return source;
+            i = end;
+            previous = source[end - 1] === "`" ? "0" : "{";
+            continue;
+        }
+        if (c === "}" && substitutions.at(-1) === depth - 1) {
+            substitutions.pop();
+            depth--;
+            const end = template(i + 1);
+            if (end === undefined)
+                return source;
+            i = end;
+            previous = source[end - 1] === "`" ? "0" : "{";
+            continue;
+        }
+        if (c === "/" && startsRegex(previous)) {
+            let j = i + 1;
+            let inClass = false;
+            for (; j < n; j++) {
+                const r = source[j];
+                if (r === "\n")
+                    return source;
+                if (r === "\\")
+                    j++;
+                else if (r === "[")
+                    inClass = true;
+                else if (r === "]")
+                    inClass = false;
+                else if (r === "/" && !inClass)
+                    break;
+            }
+            if (j >= n)
+                return source;
+            i = j + 1;
+            while (i < n && /[\w$]/.test(source[i]))
+                i++;
+            previous = "0";
+            continue;
+        }
+        if (WORD.test(c)) {
+            let j = i + 1;
+            while (j < n && WORD.test(source[j]))
+                j++;
+            previous = source.slice(i, j);
+            i = j;
+            continue;
+        }
+        if (c === "(" || c === "[" || c === "{")
+            depth++;
+        else if (c === ")" || c === "]" || c === "}") {
+            if (depth === 0)
+                return source;
+            depth--;
+        }
+        previous = c;
+        i++;
+    }
+    if (depth !== 0 || substitutions.length > 0 || terminators.length === 0) {
+        return source;
+    }
+    let out = "";
+    let from = 0;
+    for (const at of terminators) {
+        out += source.slice(from, at);
+        from = at + 1;
+    }
+    return out + source.slice(from);
+}
+/** Whether a `/` after `previous` opens a regular expression. */
+function startsRegex(previous) {
+    if (previous === "")
+        return true;
+    if (WORD.test(previous[0])) {
+        // A number or an identifier divides; a keyword introduces an operand.
+        return REGEX_AFTER_WORD.has(previous);
+    }
+    // After a closing bracket a value precedes; after any other punctuator
+    // an operand is expected.
+    return previous !== ")" && previous !== "]" && previous !== "}";
+}