@poolzin/pool-bot 2026.2.0 → 2026.2.2

package/dist/browser/pw-tools-core.interactions.js

@@ -1,4 +1,4 @@
-import { ensurePageState, getPageForTargetId, refLocator, restoreRoleRefsForTarget, } from "./pw-session.js";
+import { ensurePageState, forceDisconnectPlaywrightForTarget, getPageForTargetId, refLocator, restoreRoleRefsForTarget, } from "./pw-session.js";
 import { normalizeTimeoutMs, requireRef, toAIFriendlyError } from "./pw-tools-core.shared.js";
 export async function highlightViaPlaywright(opts) {
     const page = await getPageForTargetId(opts);
@@ -160,40 +160,138 @@ export async function fillFormViaPlaywright(opts) {
 }
 export async function evaluateViaPlaywright(opts) {
     const fnText = String(opts.fn ?? "").trim();
-    if (!fnText)
+    if (!fnText) {
         throw new Error("function is required");
+    }
     const page = await getPageForTargetId(opts);
     ensurePageState(page);
     restoreRoleRefsForTarget({ cdpUrl: opts.cdpUrl, targetId: opts.targetId, page });
-    if (opts.ref) {
-        const locator = refLocator(page, opts.ref);
-        // Use Function constructor at runtime to avoid esbuild adding __name helper
-        // which doesn't exist in the browser context
+    // Clamp evaluate timeout to prevent permanently blocking Playwright's command queue.
+    // Without this, a long-running async evaluate blocks all subsequent page operations
+    // because Playwright serializes CDP commands per page.
+    //
+    // NOTE: Playwright's { timeout } on evaluate only applies to installing the function,
+    // NOT to its execution time. We must inject a Promise.race timeout into the browser
+    // context itself so async functions are bounded.
+    const outerTimeout = normalizeTimeoutMs(opts.timeoutMs, 20_000);
+    // Leave headroom for routing/serialization overhead so the outer request timeout
+    // doesn't fire first and strand a long-running evaluate.
+    let evaluateTimeout = Math.max(1000, Math.min(120_000, outerTimeout - 500));
+    evaluateTimeout = Math.min(evaluateTimeout, outerTimeout);
+    const signal = opts.signal;
+    let abortListener;
+    let abortReject;
+    let abortPromise;
+    if (signal) {
+        abortPromise = new Promise((_, reject) => {
+            abortReject = reject;
+        });
+        // Ensure the abort promise never becomes an unhandled rejection if we throw early.
+        void abortPromise.catch(() => { });
+    }
+    if (signal) {
+        const disconnect = () => {
+            void forceDisconnectPlaywrightForTarget({
+                cdpUrl: opts.cdpUrl,
+                targetId: opts.targetId,
+                reason: "evaluate aborted",
+            }).catch(() => { });
+        };
+        if (signal.aborted) {
+            disconnect();
+            throw signal.reason ?? new Error("aborted");
+        }
+        abortListener = () => {
+            disconnect();
+            abortReject?.(signal.reason ?? new Error("aborted"));
+        };
+        signal.addEventListener("abort", abortListener, { once: true });
+        // If the signal aborted between the initial check and listener registration, handle it.
+        if (signal.aborted) {
+            abortListener();
+            throw signal.reason ?? new Error("aborted");
+        }
+    }
+    try {
+        if (opts.ref) {
+            const locator = refLocator(page, opts.ref);
+            // eslint-disable-next-line @typescript-eslint/no-implied-eval -- required for browser-context eval
+            const elementEvaluator = new Function("el", "args", `
+        "use strict";
+        var fnBody = args.fnBody, timeoutMs = args.timeoutMs;
+        try {
+          var candidate = eval("(" + fnBody + ")");
+          var result = typeof candidate === "function" ? candidate(el) : candidate;
+          if (result && typeof result.then === "function") {
+            return Promise.race([
+              result,
+              new Promise(function(_, reject) {
+                setTimeout(function() { reject(new Error("evaluate timed out after " + timeoutMs + "ms")); }, timeoutMs);
+              })
+            ]);
+          }
+          return result;
+        } catch (err) {
+          throw new Error("Invalid evaluate function: " + (err && err.message ? err.message : String(err)));
+        }
+        `);
+            const evalPromise = locator.evaluate(elementEvaluator, {
+                fnBody: fnText,
+                timeoutMs: evaluateTimeout,
+            });
+            if (!abortPromise) {
+                return await evalPromise;
+            }
+            try {
+                return await Promise.race([evalPromise, abortPromise]);
+            }
+            catch (err) {
+                // If abort wins the race, the underlying evaluate may reject later; ensure we don't
+                // surface it as an unhandled rejection.
+                void evalPromise.catch(() => { });
+                throw err;
+            }
+        }
         // eslint-disable-next-line @typescript-eslint/no-implied-eval -- required for browser-context eval
-        const elementEvaluator = new Function("el", "fnBody", `
-      "use strict";
-      try {
-        var candidate = eval("(" + fnBody + ")");
-        return typeof candidate === "function" ? candidate(el) : candidate;
-      } catch (err) {
-        throw new Error("Invalid evaluate function: " + (err && err.message ? err.message : String(err)));
-      }
+        const browserEvaluator = new Function("args", `
+        "use strict";
+        var fnBody = args.fnBody, timeoutMs = args.timeoutMs;
+        try {
+          var candidate = eval("(" + fnBody + ")");
+          var result = typeof candidate === "function" ? candidate() : candidate;
+          if (result && typeof result.then === "function") {
+            return Promise.race([
+              result,
+              new Promise(function(_, reject) {
+                setTimeout(function() { reject(new Error("evaluate timed out after " + timeoutMs + "ms")); }, timeoutMs);
+              })
+            ]);
+          }
+          return result;
+        } catch (err) {
+          throw new Error("Invalid evaluate function: " + (err && err.message ? err.message : String(err)));
+        }
       `);
-        return await locator.evaluate(elementEvaluator, fnText);
+        const evalPromise = page.evaluate(browserEvaluator, {
+            fnBody: fnText,
+            timeoutMs: evaluateTimeout,
+        });
+        if (!abortPromise) {
+            return await evalPromise;
+        }
+        try {
+            return await Promise.race([evalPromise, abortPromise]);
+        }
+        catch (err) {
+            void evalPromise.catch(() => { });
+            throw err;
+        }
     }
-    // Use Function constructor at runtime to avoid esbuild adding __name helper
-    // which doesn't exist in the browser context
-    // eslint-disable-next-line @typescript-eslint/no-implied-eval -- required for browser-context eval
-    const browserEvaluator = new Function("fnBody", `
-    "use strict";
-    try {
-      var candidate = eval("(" + fnBody + ")");
-      return typeof candidate === "function" ? candidate() : candidate;
-    } catch (err) {
-      throw new Error("Invalid evaluate function: " + (err && err.message ? err.message : String(err)));
+    finally {
+        if (signal && abortListener) {
+            signal.removeEventListener("abort", abortListener);
+        }
     }
-    `);
-    return await page.evaluate(browserEvaluator, fnText);
 }
 export async function scrollIntoViewViaPlaywright(opts) {
     const page = await getPageForTargetId(opts);

package/dist/browser/pw-tools-core.responses.js

@@ -70,7 +70,7 @@ export async function responseBodyViaPlaywright(opts) {
         }
     }
     catch (err) {
-        throw new Error(`Failed to read response body for "${url}": ${String(err)}`);
+        throw new Error(`Failed to read response body for "${url}": ${String(err)}`, { cause: err });
     }
     const trimmed = bodyText.length > maxChars ? bodyText.slice(0, maxChars) : bodyText;
     return {

package/dist/browser/pw-tools-core.state.js

@@ -100,7 +100,7 @@ export async function setTimezoneViaPlaywright(opts) {
             if (msg.includes("Timezone override is already in effect"))
                 return;
             if (msg.includes("Invalid timezone"))
-                throw new Error(`Invalid timezone ID: ${timezoneId}`);
+                throw new Error(`Invalid timezone ID: ${timezoneId}`, { cause: err });
             throw err;
         }
     });

package/dist/browser/routes/agent.act.js

@@ -4,8 +4,9 @@ import { jsonError, toBoolean, toNumber, toStringArray, toStringOrEmpty } from "
 export function registerBrowserAgentActRoutes(app, ctx) {
     app.post("/act", async (req, res) => {
         const profileCtx = resolveProfileContext(req, res, ctx);
-        if (!profileCtx)
+        if (!profileCtx) {
             return;
+        }
         const body = readBody(req);
         const kindRaw = toStringOrEmpty(body.kind);
         if (!isActKind(kindRaw)) {
@@ -20,20 +21,23 @@ export function registerBrowserAgentActRoutes(app, ctx) {
             const tab = await profileCtx.ensureTabAvailable(targetId);
             const cdpUrl = profileCtx.profile.cdpUrl;
             const pw = await requirePwAi(res, `act:${kind}`);
-            if (!pw)
+            if (!pw) {
                 return;
+            }
             const evaluateEnabled = ctx.state().resolved.evaluateEnabled;
             switch (kind) {
                 case "click": {
                     const ref = toStringOrEmpty(body.ref);
-                    if (!ref)
+                    if (!ref) {
                         return jsonError(res, 400, "ref is required");
+                    }
                     const doubleClick = toBoolean(body.doubleClick) ?? false;
                     const timeoutMs = toNumber(body.timeoutMs);
                     const buttonRaw = toStringOrEmpty(body.button) || "";
                     const button = buttonRaw ? parseClickButton(buttonRaw) : undefined;
-                    if (buttonRaw && !button)
+                    if (buttonRaw && !button) {
                         return jsonError(res, 400, "button must be left|right|middle");
+                    }
                     const modifiersRaw = toStringArray(body.modifiers) ?? [];
                     const parsedModifiers = parseClickModifiers(modifiersRaw);
                     if (parsedModifiers.error) {
@@ -46,21 +50,26 @@ export function registerBrowserAgentActRoutes(app, ctx) {
                         ref,
                         doubleClick,
                     };
-                    if (button)
+                    if (button) {
                         clickRequest.button = button;
-                    if (modifiers)
+                    }
+                    if (modifiers) {
                         clickRequest.modifiers = modifiers;
-                    if (timeoutMs)
+                    }
+                    if (timeoutMs) {
                         clickRequest.timeoutMs = timeoutMs;
+                    }
                     await pw.clickViaPlaywright(clickRequest);
                     return res.json({ ok: true, targetId: tab.targetId, url: tab.url });
                 }
                 case "type": {
                     const ref = toStringOrEmpty(body.ref);
-                    if (!ref)
+                    if (!ref) {
                         return jsonError(res, 400, "ref is required");
-                    if (typeof body.text !== "string")
+                    }
+                    if (typeof body.text !== "string") {
                         return jsonError(res, 400, "text is required");
+                    }
                     const text = body.text;
                     const submit = toBoolean(body.submit) ?? false;
                     const slowly = toBoolean(body.slowly) ?? false;
@@ -73,15 +82,17 @@ export function registerBrowserAgentActRoutes(app, ctx) {
                         submit,
                         slowly,
                     };
-                    if (timeoutMs)
+                    if (timeoutMs) {
                         typeRequest.timeoutMs = timeoutMs;
+                    }
                     await pw.typeViaPlaywright(typeRequest);
                     return res.json({ ok: true, targetId: tab.targetId });
                 }
                 case "press": {
                     const key = toStringOrEmpty(body.key);
-                    if (!key)
+                    if (!key) {
                         return jsonError(res, 400, "key is required");
+                    }
                     const delayMs = toNumber(body.delayMs);
                     await pw.pressKeyViaPlaywright({
                         cdpUrl,
@@ -93,8 +104,9 @@ export function registerBrowserAgentActRoutes(app, ctx) {
                 }
                 case "hover": {
                     const ref = toStringOrEmpty(body.ref);
-                    if (!ref)
+                    if (!ref) {
                         return jsonError(res, 400, "ref is required");
+                    }
                     const timeoutMs = toNumber(body.timeoutMs);
                     await pw.hoverViaPlaywright({
                         cdpUrl,
@@ -106,24 +118,27 @@ export function registerBrowserAgentActRoutes(app, ctx) {
                 }
                 case "scrollIntoView": {
                     const ref = toStringOrEmpty(body.ref);
-                    if (!ref)
+                    if (!ref) {
                         return jsonError(res, 400, "ref is required");
+                    }
                     const timeoutMs = toNumber(body.timeoutMs);
                     const scrollRequest = {
                         cdpUrl,
                         targetId: tab.targetId,
                         ref,
                     };
-                    if (timeoutMs)
+                    if (timeoutMs) {
                         scrollRequest.timeoutMs = timeoutMs;
+                    }
                     await pw.scrollIntoViewViaPlaywright(scrollRequest);
                     return res.json({ ok: true, targetId: tab.targetId });
                 }
                 case "drag": {
                     const startRef = toStringOrEmpty(body.startRef);
                     const endRef = toStringOrEmpty(body.endRef);
-                    if (!startRef || !endRef)
+                    if (!startRef || !endRef) {
                         return jsonError(res, 400, "startRef and endRef are required");
+                    }
                     const timeoutMs = toNumber(body.timeoutMs);
                     await pw.dragViaPlaywright({
                         cdpUrl,
@@ -137,8 +152,9 @@ export function registerBrowserAgentActRoutes(app, ctx) {
                 case "select": {
                     const ref = toStringOrEmpty(body.ref);
                     const values = toStringArray(body.values);
-                    if (!ref || !values?.length)
+                    if (!ref || !values?.length) {
                         return jsonError(res, 400, "ref and values are required");
+                    }
                     const timeoutMs = toNumber(body.timeoutMs);
                     await pw.selectOptionViaPlaywright({
                         cdpUrl,
@@ -153,13 +169,15 @@ export function registerBrowserAgentActRoutes(app, ctx) {
                     const rawFields = Array.isArray(body.fields) ? body.fields : [];
                     const fields = rawFields
                         .map((field) => {
-                        if (!field || typeof field !== "object")
+                        if (!field || typeof field !== "object") {
                             return null;
+                        }
                         const rec = field;
                         const ref = toStringOrEmpty(rec.ref);
                         const type = toStringOrEmpty(rec.type);
-                        if (!ref || !type)
+                        if (!ref || !type) {
                             return null;
+                        }
                         const value = typeof rec.value === "string" ||
                             typeof rec.value === "number" ||
                             typeof rec.value === "boolean"
@@ -169,8 +187,9 @@ export function registerBrowserAgentActRoutes(app, ctx) {
                         return parsed;
                     })
                         .filter((field) => field !== null);
-                    if (!fields.length)
+                    if (!fields.length) {
                         return jsonError(res, 400, "fields are required");
+                    }
                     const timeoutMs = toNumber(body.timeoutMs);
                     await pw.fillFormViaPlaywright({
                         cdpUrl,
@@ -183,8 +202,9 @@ export function registerBrowserAgentActRoutes(app, ctx) {
                 case "resize": {
                     const width = toNumber(body.width);
                     const height = toNumber(body.height);
-                    if (!width || !height)
+                    if (!width || !height) {
                         return jsonError(res, 400, "width and height are required");
+                    }
                     await pw.resizeViewportViaPlaywright({
                         cdpUrl,
                         targetId: tab.targetId,
@@ -244,15 +264,22 @@ export function registerBrowserAgentActRoutes(app, ctx) {
                         ].join("\n"));
                     }
                     const fn = toStringOrEmpty(body.fn);
-                    if (!fn)
+                    if (!fn) {
                         return jsonError(res, 400, "fn is required");
+                    }
                     const ref = toStringOrEmpty(body.ref) || undefined;
-                    const result = await pw.evaluateViaPlaywright({
+                    const evalTimeoutMs = toNumber(body.timeoutMs);
+                    const evalRequest = {
                         cdpUrl,
                         targetId: tab.targetId,
                         fn,
                         ref,
-                    });
+                        signal: req.signal,
+                    };
+                    if (evalTimeoutMs !== undefined) {
+                        evalRequest.timeoutMs = evalTimeoutMs;
+                    }
+                    const result = await pw.evaluateViaPlaywright(evalRequest);
                     return res.json({
                         ok: true,
                         targetId: tab.targetId,
@@ -275,8 +302,9 @@ export function registerBrowserAgentActRoutes(app, ctx) {
     });
     app.post("/hooks/file-chooser", async (req, res) => {
         const profileCtx = resolveProfileContext(req, res, ctx);
-        if (!profileCtx)
+        if (!profileCtx) {
             return;
+        }
         const body = readBody(req);
         const targetId = toStringOrEmpty(body.targetId) || undefined;
         const ref = toStringOrEmpty(body.ref) || undefined;
@@ -284,13 +312,15 @@ export function registerBrowserAgentActRoutes(app, ctx) {
         const element = toStringOrEmpty(body.element) || undefined;
         const paths = toStringArray(body.paths) ?? [];
         const timeoutMs = toNumber(body.timeoutMs);
-        if (!paths.length)
+        if (!paths.length) {
             return jsonError(res, 400, "paths are required");
+        }
         try {
             const tab = await profileCtx.ensureTabAvailable(targetId);
             const pw = await requirePwAi(res, "file chooser hook");
-            if (!pw)
+            if (!pw) {
                 return;
+            }
             if (inputRef || element) {
                 if (ref) {
                     return jsonError(res, 400, "ref cannot be combined with inputRef/element");
@@ -326,20 +356,23 @@ export function registerBrowserAgentActRoutes(app, ctx) {
     });
     app.post("/hooks/dialog", async (req, res) => {
         const profileCtx = resolveProfileContext(req, res, ctx);
-        if (!profileCtx)
+        if (!profileCtx) {
             return;
+        }
         const body = readBody(req);
         const targetId = toStringOrEmpty(body.targetId) || undefined;
         const accept = toBoolean(body.accept);
         const promptText = toStringOrEmpty(body.promptText) || undefined;
         const timeoutMs = toNumber(body.timeoutMs);
-        if (accept === undefined)
+        if (accept === undefined) {
             return jsonError(res, 400, "accept is required");
+        }
         try {
             const tab = await profileCtx.ensureTabAvailable(targetId);
             const pw = await requirePwAi(res, "dialog hook");
-            if (!pw)
+            if (!pw) {
                 return;
+            }
             await pw.armDialogViaPlaywright({
                 cdpUrl: profileCtx.profile.cdpUrl,
                 targetId: tab.targetId,
@@ -355,8 +388,9 @@ export function registerBrowserAgentActRoutes(app, ctx) {
     });
     app.post("/wait/download", async (req, res) => {
         const profileCtx = resolveProfileContext(req, res, ctx);
-        if (!profileCtx)
+        if (!profileCtx) {
             return;
+        }
         const body = readBody(req);
         const targetId = toStringOrEmpty(body.targetId) || undefined;
         const out = toStringOrEmpty(body.path) || undefined;
@@ -364,8 +398,9 @@ export function registerBrowserAgentActRoutes(app, ctx) {
         try {
             const tab = await profileCtx.ensureTabAvailable(targetId);
             const pw = await requirePwAi(res, "wait for download");
-            if (!pw)
+            if (!pw) {
                 return;
+            }
             const result = await pw.waitForDownloadViaPlaywright({
                 cdpUrl: profileCtx.profile.cdpUrl,
                 targetId: tab.targetId,
@@ -380,22 +415,26 @@ export function registerBrowserAgentActRoutes(app, ctx) {
     });
     app.post("/download", async (req, res) => {
         const profileCtx = resolveProfileContext(req, res, ctx);
-        if (!profileCtx)
+        if (!profileCtx) {
             return;
+        }
         const body = readBody(req);
         const targetId = toStringOrEmpty(body.targetId) || undefined;
         const ref = toStringOrEmpty(body.ref);
         const out = toStringOrEmpty(body.path);
         const timeoutMs = toNumber(body.timeoutMs);
-        if (!ref)
+        if (!ref) {
             return jsonError(res, 400, "ref is required");
-        if (!out)
+        }
+        if (!out) {
             return jsonError(res, 400, "path is required");
+        }
         try {
             const tab = await profileCtx.ensureTabAvailable(targetId);
             const pw = await requirePwAi(res, "download");
-            if (!pw)
+            if (!pw) {
                 return;
+            }
             const result = await pw.downloadViaPlaywright({
                 cdpUrl: profileCtx.profile.cdpUrl,
                 targetId: tab.targetId,
@@ -411,20 +450,23 @@ export function registerBrowserAgentActRoutes(app, ctx) {
     });
     app.post("/response/body", async (req, res) => {
         const profileCtx = resolveProfileContext(req, res, ctx);
-        if (!profileCtx)
+        if (!profileCtx) {
             return;
+        }
         const body = readBody(req);
         const targetId = toStringOrEmpty(body.targetId) || undefined;
         const url = toStringOrEmpty(body.url);
         const timeoutMs = toNumber(body.timeoutMs);
         const maxChars = toNumber(body.maxChars);
-        if (!url)
+        if (!url) {
             return jsonError(res, 400, "url is required");
+        }
         try {
             const tab = await profileCtx.ensureTabAvailable(targetId);
             const pw = await requirePwAi(res, "response body");
-            if (!pw)
+            if (!pw) {
                 return;
+            }
             const result = await pw.responseBodyViaPlaywright({
                 cdpUrl: profileCtx.profile.cdpUrl,
                 targetId: tab.targetId,
@@ -440,18 +482,21 @@ export function registerBrowserAgentActRoutes(app, ctx) {
     });
     app.post("/highlight", async (req, res) => {
         const profileCtx = resolveProfileContext(req, res, ctx);
-        if (!profileCtx)
+        if (!profileCtx) {
             return;
+        }
         const body = readBody(req);
         const targetId = toStringOrEmpty(body.targetId) || undefined;
         const ref = toStringOrEmpty(body.ref);
-        if (!ref)
+        if (!ref) {
             return jsonError(res, 400, "ref is required");
+        }
         try {
             const tab = await profileCtx.ensureTabAvailable(targetId);
             const pw = await requirePwAi(res, "highlight");
-            if (!pw)
+            if (!pw) {
                 return;
+            }
             await pw.highlightViaPlaywright({
                 cdpUrl: profileCtx.profile.cdpUrl,
                 targetId: tab.targetId,

package/dist/browser/routes/dispatcher.js

@@ -1,7 +1,5 @@
 import { registerBrowserRoutes } from "./index.js";
-function escapeRegex(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
+import { escapeRegExp } from "../../utils.js";
 function compileRoute(path) {
     const paramNames = [];
     const parts = path.split("/").map((part) => {
@@ -10,7 +8,7 @@ function compileRoute(path) {
             paramNames.push(name);
             return "([^/]+)";
         }
-        return escapeRegex(part);
+        return escapeRegExp(part);
     });
     return { regex: new RegExp(`^${parts.join("/")}$`), paramNames };
 }
@@ -41,6 +39,7 @@ export function createBrowserRouteDispatcher(ctx) {
             const path = normalizePath(req.path);
             const query = req.query ?? {};
             const body = req.body;
+            const signal = req.signal;
             const match = registry.routes.find((route) => {
                 if (route.method !== method)
                     return false;
@@ -75,6 +74,7 @@ export function createBrowserRouteDispatcher(ctx) {
                     params,
                     query,
                     body,
+                    signal,
                 }, res);
             }
             catch (err) {

package/dist/browser/screenshot.js

@@ -16,7 +16,7 @@ export async function normalizeBrowserScreenshot(buffer, opts) {
     const sideGrid = [sideStart, 1800, 1600, 1400, 1200, 1000, 800]
         .map((v) => Math.min(maxSide, v))
         .filter((v, i, arr) => v > 0 && arr.indexOf(v) === i)
-        .sort((a, b) => b - a);
+        .toSorted((a, b) => b - a);
     let smallest = null;
     for (const side of sideGrid) {
         for (const quality of qualities) {

package/dist/browser/server.js

@@ -17,6 +17,19 @@ export async function startBrowserControlServerFromConfig() {
         return null;
     const app = express();
     app.use(express.json({ limit: "1mb" }));
+    app.use((req, res, next) => {
+        const ctrl = new AbortController();
+        const abort = () => ctrl.abort(new Error("request aborted"));
+        req.once("aborted", abort);
+        res.once("close", () => {
+            if (!res.writableEnded) {
+                abort();
+            }
+        });
+        // Make the signal available to browser route handlers (best-effort).
+        req.signal = ctrl.signal;
+        next();
+    });
     const ctx = createBrowserRouteContext({
         getState: () => state,
     });

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.1.41",
-  "commit": "b5ac4e052499a0af9a58c0e535c5f8a21da0c270",
-  "builtAt": "2026-02-12T00:03:57.467Z"
+  "version": "2026.2.2",
+  "commit": "84e7160aa161f8c42b9f4a276ea99d44597d7f19",
+  "builtAt": "2026-02-12T23:46:09.256Z"
 }