baychat 0.27.1 → 0.29.0

package/dist/connect-claude.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.cmdConnectClaude = cmdConnectClaude;
+exports.channelReport = channelReport;
 const commands_1 = require("./commands");
 const config_1 = require("./config");
 const bay_mcp_1 = require("./bay-mcp");
@@ -9,6 +10,8 @@ const runtime_install_1 = require("./runtime-install");
 const bay_mcp_2 = require("./bay-mcp");
 const context_hooks_command_1 = require("./context-hooks-command");
 const launch_1 = require("./channel/launch");
+const plugin_1 = require("./channel/plugin");
+const ws_1 = require("./relay/ws");
 /** One-time Claude setup reuses a valid login, registers MCP, and refreshes its skill. */
 async function cmdConnectClaude(opts = {}) {
     try {
@@ -46,7 +49,8 @@ async function cmdConnectClaude(opts = {}) {
             console.log("  " + line);
         if (!registered)
             return 1;
-        reportChannel(registerChannel());
+        for (const line of channelReport(registerChannel(), { version: process.version, webSocket: (0, ws_1.hasBuiltInWebSocket)() }))
+            console.log(line);
         console.log('  Restart Claude Code once, then use /baychat <name> "<group>".');
         return 0;
     }
@@ -66,7 +70,12 @@ function registerChannel() {
         const problem = (0, context_hooks_command_1.launchProblem)(launch);
         if (problem)
             return { skipped: problem };
-        return (0, launch_1.registerChannelWithClaude)(launch, (0, bay_mcp_2.realClaudeRun)())
+        const run = (0, bay_mcp_2.realClaudeRun)();
+        // The plugin first: it updates with the npm package and is the form Anthropic can approve.
+        // Where this Claude Code cannot install it, the same server is registered by hand.
+        if ((0, plugin_1.installPluginWithClaude)(run))
+            return "registered";
+        return (0, launch_1.registerChannelWithClaude)(launch, run)
             ? "registered"
             : { skipped: "Claude Code did not accept the channel server." };
     }
@@ -74,13 +83,25 @@ function registerChannel() {
         return { skipped: err instanceof Error ? err.message : String(err) };
     }
 }
-function reportChannel(result) {
-    if (result === "registered") {
-        console.log("✓ BayChat channel added to Claude Code (wakes a session with no Monitor deadline)");
-        console.log(`  Start Claude Code with \`${launch_1.CHANNEL_LAUNCH_COMMAND}\` (or \`baychat start\`) to use it.`);
-        console.log("  Without it, incoming messages use the native WebSocket Monitor as before.");
-        return;
+/**
+ * What `connect` says about the channel. Installed on a Node without the built-in WebSocket it is
+ * installed but cannot start (Claude Code shows it failed, sessions fall back to the Monitor) —
+ * said here, at the moment of setup, rather than discovered as a silent session later.
+ */
+function channelReport(result, node) {
+    if (result !== "registered") {
+        return [
+            `  BayChat channel not added: ${result.skipped}`,
+            "  Incoming messages use native WebSocket Monitor; the session will verify its connection after joining.",
+        ];
+    }
+    const lines = [
+        "✓ BayChat channel added to Claude Code (wakes a session with no Monitor deadline)",
+        `  Start Claude Code with \`${launch_1.CHANNEL_LAUNCH_COMMAND}\` (or \`baychat start\`) to use it.`,
+        "  Without it, incoming messages use the native WebSocket Monitor as before.",
+    ];
+    if (!node.webSocket) {
+        lines.push(`  ⚠ This Node (${node.version}) has no built-in WebSocket, so the channel cannot start yet: it needs Node ${ws_1.WEBSOCKET_MIN_NODE}+.`, "    Until then sessions use the Monitor, and the relay long-polls instead of using its WebSocket.", `    To fix: ${ws_1.NODE_UPGRADE_HINT}.`);
     }
-    console.log(`  BayChat channel not added: ${result.skipped}`);
-    console.log("  Incoming messages use native WebSocket Monitor; the session will verify its connection after joining.");
+    return lines;
 }

package/dist/device-login.js

@@ -37,11 +37,11 @@ exports.parseBayLogins = parseBayLogins;
 exports.startDeviceLogin = startDeviceLogin;
 exports.finishDeviceLogin = finishDeviceLogin;
 const fs = __importStar(require("node:fs"));
-const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
 const zod_1 = require("zod");
 const api_1 = require("./api");
+const machine_name_1 = require("./machine-name");
 const config_1 = require("./config");
 const bayLoginSchema = zod_1.z.object({
     bayId: zod_1.z.string().min(1),
@@ -103,7 +103,7 @@ async function startDeviceLogin(baseUrl) {
             Date.parse(previous.expiresAt) > Date.now()) {
             return { url: previous.url, expiresAt: previous.expiresAt };
         }
-        const request = await (0, api_1.createDeviceLink)(base, os.hostname().slice(0, 60));
+        const request = await (0, api_1.createDeviceLink)(base, (0, machine_name_1.machineName)());
         const parsed = pendingSchema.safeParse({ ...request, baseUrl: base });
         if (!parsed.success)
             throw new Error("BayChat returned an invalid login link. Try baychat login --start again.");

package/dist/doctor-command.js

@@ -54,6 +54,7 @@ const registry_1 = require("./relay/registry");
 const credential_refresh_1 = require("./credential-refresh");
 const client_paths_1 = require("./client-paths");
 const runtime_binary_1 = require("./runtime-binary");
+const ws_1 = require("./relay/ws");
 /** How long `claude mcp list` may take before we treat it as unanswerable. */
 const MCP_LIST_TIMEOUT_MS = 15_000;
 /**
@@ -95,6 +96,7 @@ async function currentDoctorEnv() {
         now: Date.now(),
         device: (0, config_1.loadDeviceCredentials)(),
         relay: await (0, commands_1.tryRelayStatus)(),
+        node: { version: process.version, webSocket: (0, ws_1.hasBuiltInWebSocket)() },
         targets: registry.all(),
         readText(filePath) {
             try {

package/dist/doctor.js

@@ -71,6 +71,11 @@ const agents_1 = require("./relay/acp/agents");
 const policy_1 = require("./relay/acp/policy");
 const runtime_binary_1 = require("./runtime-binary");
 const runtimes_1 = require("./runtimes");
+const runtime_install_1 = require("./runtime-install");
+const launch_1 = require("./channel/launch");
+const plugin_1 = require("./channel/plugin");
+const transport_1 = require("./relay/transport");
+const ws_1 = require("./relay/ws");
 /**
  * The runtimes worth reporting on.
  *
@@ -99,6 +104,14 @@ const SETUP_COMMAND = {
     cursor: "baychat connect cursor",
     desktop: "baychat connect desktop",
 };
+/**
+ * What rewrites a stale skill without signing in again. `baychat update` reinstalls Claude
+ * Code's skill as part of re-registering it; `baychat login` would too, but only after an
+ * interactive phone approval the person does not need.
+ */
+const SKILL_REFRESH_COMMAND = {
+    claude: "baychat update",
+};
 function setupCommand(runtime) {
     return SETUP_COMMAND[runtime] ?? `baychat connect ${runtime}`;
 }
@@ -217,6 +230,11 @@ function acpChecks(env) {
                 remedy: row.installHint,
             };
         }
+        // The relay refuses this binary before every turn; say so here rather than "pass".
+        const binaryProblem = (0, agents_1.binaryRefusal)(row, bin.path, bin.version);
+        if (binaryProblem) {
+            return { name, status: "fail", detail: `${row.label} on this computer will not be started`, remedy: binaryProblem };
+        }
         const folder = (0, policy_1.checkFolder)(policy, row.id, t.acp.cwd);
         if (!folder.ok) {
             return {
@@ -411,6 +429,18 @@ function relayCheck(env) {
     const transport = env.relay.transport
         ? `, transport ${env.relay.transport}${env.relay.transportDetail ? ` (${env.relay.transportDetail})` : ""}`
         : "";
+    if (env.relay.transport === "long-poll" && env.relay.transportDetail === transport_1.NO_WEBSOCKET_DETAIL) {
+        // The relay's OWN Node has no WebSocket, so it long-polls for good — and the server throttles
+        // that ("Too many update polls", 15,000 times in three days on one laptop). A failure, not a
+        // pass with a note. Which fix depends on the Node this doctor runs on: if it has WebSocket,
+        // restarting the relay from it is enough (`update` rewrites the service with this Node).
+        return {
+            name: "relay",
+            status: "fail",
+            detail: `running (pid ${env.relay.pid}) but long-polling: its Node has no built-in WebSocket (Node ${ws_1.WEBSOCKET_MIN_NODE}+), and the server throttles the polls`,
+            remedy: env.node.webSocket ? `baychat update — restarts the relay on this Node (${env.node.version})` : ws_1.NODE_UPGRADE_HINT,
+        };
+    }
     return { name: "relay", status: "pass", detail: `running (pid ${env.relay.pid})${transport}` };
 }
 function pendingCheck(env) {
@@ -459,12 +489,72 @@ function runtimeReport(runtime, env) {
             ],
         };
     }
+    const extra = RUNTIME_EXTRA_CHECKS[runtime];
     return {
         runtime,
         label: spec.label,
-        checks: [mcp, skill, binaryCheck(runtime, env), sessionCheck(runtime, env)],
+        checks: [mcp, skill, binaryCheck(runtime, env), sessionCheck(runtime, env), ...(extra ? [extra(env)] : [])],
     };
 }
+/** Checks only one runtime has. Claude Code alone has the wake-up channel. */
+const RUNTIME_EXTRA_CHECKS = {
+    claude: channelCheck,
+};
+/** `baychat@baychat 0.28.0`; Claude Code records "unknown" for a manifest that names no version. */
+function pluginLabel(version) {
+    return version === "unknown" ? "baychat@baychat (version unknown)" : `baychat@baychat ${version}`;
+}
+/** What installs the channel, in either form (docs/features/CLAUDE_CODE_CHANNEL.md). */
+const CHANNEL_SETUP_COMMAND = "baychat connect claude";
+/**
+ * Is Claude Code's wake-up channel installed in a form that can deliver?
+ *
+ * Two forms count: BayChat's plugin, switched on AND declaring the channel in its own manifest,
+ * or the hand-registered `baychat_channel` server. Not having either is a `skip` — a session then
+ * listens through a Monitor, which works.
+ *
+ * A `baychat@baychat` that is switched on but carries no channel is a FAILURE, because it is what
+ * a silently failed setup leaves behind: computers set up before the channel have a skill-only
+ * plugin of that very name, from a GitHub catalog also called `baychat`. On those `connect claude`
+ * used to see "already installed", remove the hand-registered server and report success, leaving
+ * the channel nowhere (2026-10-03). Its remedy replaces the old catalog (`channel/plugin.ts`).
+ */
+function channelCheck(env) {
+    const files = { home: env.home, read: env.readText };
+    const installed = (0, plugin_1.installedPlugin)(files);
+    const enabled = (0, plugin_1.pluginEnabled)(files);
+    if (enabled && installed.state !== "channel") {
+        const origin = (0, plugin_1.baychatMarketplace)(files);
+        const from = origin.kind === "foreign" ? ` — the old skill-only plugin, from ${origin.source}` : "";
+        const what = installed.state === "absent"
+            ? "baychat@baychat is switched on but not installed"
+            : `${pluginLabel(installed.version)} is switched on but carries no channel: ${installed.why}`;
+        return { name: "channel", status: "fail", detail: `${what}${from}`, remedy: CHANNEL_SETUP_COMMAND };
+    }
+    const forms = [
+        ...(enabled && installed.state === "channel" ? [`plugin ${pluginLabel(installed.version)}`] : []),
+        ...((0, launch_1.channelRegistered)((0, launch_1.claudeUserConfigPath)(env.home), (p) => env.readText(p) ?? "") ? ["server baychat_channel"] : []),
+    ];
+    if (forms.length === 0) {
+        return {
+            name: "channel",
+            status: "skip",
+            detail: "not set up — sessions listen through a Monitor, which ends every 30 minutes",
+            remedy: CHANNEL_SETUP_COMMAND,
+        };
+    }
+    if (!env.node.webSocket) {
+        // Set up, and unable to run: the channel needs the built-in WebSocket, so Claude Code would
+        // show it failed and every session would quietly fall back to the Monitor.
+        return {
+            name: "channel",
+            status: "fail",
+            detail: `${forms.join(" + ")}, but this Node (${env.node.version}) has no built-in WebSocket — the channel needs Node ${ws_1.WEBSOCKET_MIN_NODE}+ and cannot start`,
+            remedy: ws_1.NODE_UPGRADE_HINT,
+        };
+    }
+    return { name: "channel", status: "pass", detail: `${forms.join(" + ")} — start sessions with \`baychat claude\`` };
+}
 /**
  * Is BayChat actually registered as an MCP server for this runtime?
  *
@@ -549,13 +639,17 @@ function skillCheck(runtime, env) {
     //
     // A doc that is wrong is worse than one that is missing, because a missing one
     // sends the agent looking.
-    const current = (0, runtimes_1.renderCommandFor)(runtime);
+    //
+    // Compared against what the INSTALLER writes, not against the full workflow: Claude
+    // Code and Codex get a bootstrap that loads the workflow at run time, so comparing
+    // against the workflow failed every machine `baychat update` had just refreshed.
+    const current = (0, runtime_install_1.skillFileBody)(runtime);
     if (current !== null && installed.trim() !== current.trim()) {
         return {
             name: "skill",
             status: "fail",
             detail: `${display(file, env)} is out of date — it does not match the skill this version installs`,
-            remedy: setupCommand(runtime),
+            remedy: SKILL_REFRESH_COMMAND[runtime] ?? setupCommand(runtime),
         };
     }
     return { name: "skill", status: "pass", detail: `${display(file, env)} (current)` };

package/dist/help-topics.js

@@ -162,9 +162,10 @@ There is no timeout by design. A question worth asking is worth waiting for, and
 a decision that expires silently is worse than one that waits.
 
 \`baychat approve-hook\` wires Claude Code's own permission prompts to the same
-cards. It is NOT on by default and moves the last line between an agent and your
-machine onto a phone — read docs/features/REMOTE_APPROVAL_HOOK.md before enabling
-it. It fails CLOSED: every error denies.`,
+cards. It is on only for Claude Code sessions BayChat starts (from the phone,
+\`baychat claude\` or \`baychat start\`), never for a plain \`claude\`, and it moves
+the last line between an agent and your machine onto a phone — read
+docs/features/REMOTE_APPROVAL_HOOK.md. It fails CLOSED: every error denies.`,
 };
 exports.HELP_TOPICS = [GROUPS, SESSIONS, TOOLS, APPROVALS];
 /** Exact name first, then keyword, then a substring of the body. */

package/dist/launch/claude-trust.js

@@ -0,0 +1,221 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRUST_KEY = void 0;
+exports.claudeConfigPath = claudeConfigPath;
+exports.trustKeysFor = trustKeysFor;
+exports.isFolderTrusted = isFolderTrusted;
+exports.trustProblemText = trustProblemText;
+exports.trustFolder = trustFolder;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+/**
+ * Claude Code's "Quick safety check" (workspace trust), read — and, only at the computer, written.
+ *
+ * A `claude` started unattended in a folder Claude Code has not trusted sits at
+ * "Is this a project you created or one you trust? ❯ No, exit / Yes, I trust this folder"
+ * forever, with nobody there to answer. Claude Code records the answer in `~/.claude.json`
+ * (or `$CLAUDE_CONFIG_DIR/.claude.json`) as `projects["<absolute path>"].hasTrustDialogAccepted`.
+ * (Key verified against the real file on Claude Code 2.1.289.)
+ *
+ * ── WHO MAY WRITE TRUST ───────────────────────────────────────────────────────────────
+ * Only a person at this computer, through `baychat launch add` answering y. The relay only READS
+ * (`isFolderTrusted`) and refuses with FOLDER_NOT_TRUSTED; nothing that arrives over the network
+ * ever calls `trustFolder`.
+ *
+ * The file holds the person's whole Claude Code state (and may hold secrets), so the write is
+ * as small as it can be: that one boolean on that one project key, everything else re-serialised
+ * unchanged, a `.bak` copy first, then a temp file renamed over the original with its mode.
+ * A missing or unparsable file is never written: we report and let the person run `claude`.
+ */
+exports.TRUST_KEY = "hasTrustDialogAccepted";
+/** `$CLAUDE_CONFIG_DIR/.claude.json` when set (as Claude Code does), else `~/.claude.json`. */
+function claudeConfigPath(env = process.env, home = os.homedir()) {
+    const dir = env.CLAUDE_CONFIG_DIR?.trim();
+    return dir ? path.join(dir, ".claude.json") : path.join(home, ".claude.json");
+}
+/**
+ * The keys Claude Code may have recorded for `folder`: the path as given, its realpath, and on
+ * macOS the same path with and without `/private` (/tmp, /var and /etc are symlinks there).
+ */
+function trustKeysFor(folder, platform = process.platform) {
+    const keys = new Set([folder]);
+    try {
+        keys.add(fs.realpathSync(folder));
+    }
+    catch {
+        // A folder that does not resolve is checked by the name given only.
+    }
+    if (platform === "darwin") {
+        for (const k of [...keys]) {
+            const m = /^\/private(\/(?:tmp|var|etc)(?:\/.*)?)$/.exec(k);
+            if (m)
+                keys.add(m[1]);
+            else if (/^\/(?:tmp|var|etc)(?:\/|$)/.test(k))
+                keys.add(`/private${k}`);
+        }
+    }
+    return [...keys];
+}
+function readConfig(file) {
+    let raw;
+    try {
+        raw = fs.readFileSync(file, "utf8");
+    }
+    catch (err) {
+        return { ok: false, reason: err.code === "ENOENT" ? "CONFIG_MISSING" : "CONFIG_UNREADABLE" };
+    }
+    let json;
+    try {
+        json = JSON.parse(raw);
+    }
+    catch {
+        return { ok: false, reason: "CONFIG_UNPARSABLE" };
+    }
+    if (!json || typeof json !== "object" || Array.isArray(json))
+        return { ok: false, reason: "CONFIG_UNPARSABLE" };
+    const projects = json.projects;
+    if (projects !== undefined && (!projects || typeof projects !== "object" || Array.isArray(projects))) {
+        return { ok: false, reason: "CONFIG_UNPARSABLE" };
+    }
+    return { ok: true, raw, json: json };
+}
+/** Read-only: has Claude Code's trust dialog been accepted for `folder` (under any of its names)? */
+function isFolderTrusted(folder, file = claudeConfigPath()) {
+    const parsed = readConfig(file);
+    if (!parsed.ok)
+        return false;
+    const projects = (parsed.json.projects ?? {});
+    return trustKeysFor(folder).some((key) => {
+        const entry = Object.prototype.hasOwnProperty.call(projects, key) ? projects[key] : undefined;
+        return !!entry && typeof entry === "object" && entry[exports.TRUST_KEY] === true;
+    });
+}
+/** A sentence for each problem, for the person at the terminal. */
+function trustProblemText(reason, file) {
+    switch (reason) {
+        case "CONFIG_MISSING":
+            return `${file} does not exist yet (Claude Code has not run on this computer).`;
+        case "CONFIG_UNREADABLE":
+            return `${file} could not be read.`;
+        case "CONFIG_UNPARSABLE":
+            return `${file} is not the JSON BayChat expects, so it was left alone.`;
+        case "CONFIG_UNSAFE":
+            return `${file} holds numbers BayChat could not rewrite exactly, so it was left alone.`;
+        case "CONFIG_CHANGING":
+            return `${file} kept changing while BayChat tried to write it (is Claude Code busy?).`;
+        case "WRITE_FAILED":
+            return `${file} could not be written.`;
+    }
+}
+/**
+ * Set `projects[folder].hasTrustDialogAccepted = true` and nothing else. `folder` should be the
+ * realpath (the spot's stored path). Called ONLY from `baychat launch add` after a person said y.
+ */
+function trustFolder(folder, file = claudeConfigPath()) {
+    // Write through a symlinked ~/.claude.json (dotfile managers) instead of replacing the link.
+    let target = file;
+    try {
+        target = fs.realpathSync(file);
+    }
+    catch {
+        // Missing: readConfig reports it below.
+    }
+    for (let attempt = 0; attempt < 3; attempt++) {
+        const parsed = readConfig(target);
+        if (!parsed.ok)
+            return parsed;
+        if (hasLossyNumbers(parsed.raw))
+            return { ok: false, reason: "CONFIG_UNSAFE" };
+        const projects = (parsed.json.projects ?? {});
+        const current = Object.prototype.hasOwnProperty.call(projects, folder) ? projects[folder] : undefined;
+        if (current !== undefined && (!current || typeof current !== "object" || Array.isArray(current))) {
+            return { ok: false, reason: "CONFIG_UNPARSABLE" };
+        }
+        if (current?.[exports.TRUST_KEY] === true)
+            return { ok: true, changed: false };
+        const next = {
+            ...parsed.json,
+            projects: { ...projects, [folder]: { ...(current ?? {}), [exports.TRUST_KEY]: true } },
+        };
+        const text = serialiseLike(parsed.raw, next);
+        let mode;
+        try {
+            mode = fs.statSync(target).mode & 0o777;
+            const bak = `${target}.bak`;
+            fs.copyFileSync(target, bak);
+            fs.chmodSync(bak, mode);
+        }
+        catch {
+            return { ok: false, reason: "WRITE_FAILED" };
+        }
+        const tmp = path.join(path.dirname(target), `.${path.basename(target)}.baychat-${process.pid}-${Date.now()}.tmp`);
+        try {
+            fs.writeFileSync(tmp, text, { mode });
+            fs.chmodSync(tmp, mode); // writeFile's mode is masked by the umask
+            // Claude Code rewrites this file often. If it changed since we read it, start over
+            // rather than rename our older copy over its newer one.
+            if (fs.readFileSync(target, "utf8") !== parsed.raw) {
+                fs.rmSync(tmp, { force: true });
+                continue;
+            }
+            fs.renameSync(tmp, target);
+            return { ok: true, changed: true };
+        }
+        catch {
+            fs.rmSync(tmp, { force: true });
+            return { ok: false, reason: "WRITE_FAILED" };
+        }
+    }
+    return { ok: false, reason: "CONFIG_CHANGING" };
+}
+/** JSON.stringify in the file's own style: its indent, and its trailing newline or lack of one. */
+function serialiseLike(raw, value) {
+    const indent = /^\{\r?\n(\t| +)"/.exec(raw)?.[1] ?? (raw.trimStart().startsWith("{\n") ? 2 : 0);
+    const body = JSON.stringify(value, null, indent);
+    return raw.endsWith("\n") ? `${body}\n` : body;
+}
+/**
+ * A number JSON.parse cannot hold exactly (more than 15 significant digits) would be silently
+ * changed by the rewrite. Strings are blanked first so ids and tokens inside quotes don't count.
+ */
+function hasLossyNumbers(raw) {
+    const outsideStrings = raw.replace(/"(?:[^"\\]|\\.)*"/g, '""');
+    return (outsideStrings.match(/-?\d+(?:\.\d+)?(?:[eE][+-]?\d+)?/g) ?? []).some((n) => {
+        const digits = n.replace(/^-/, "").split(/[eE]/)[0].replace(".", "").replace(/^0+/, "");
+        return digits.length > 15;
+    });
+}