@godscene/web 1.7.11

package/dist/es/cdp-proxy-manager.mjs

@@ -0,0 +1,217 @@
+import { spawn } from "node:child_process";
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import node_http from "node:http";
+import { join } from "node:path";
+import { getDebug } from "@godscene/shared/logger";
+import { PROXY_ENDPOINT_FILE, PROXY_PID_FILE, PROXY_UPSTREAM_FILE } from "./cdp-proxy-constants.mjs";
+import { cleanupTargetIdFile } from "./cdp-target-store.mjs";
+const debug = getDebug('mcp:cdp:proxy');
+const PROXY_TERM_GRACE_MS = 2000;
+const PROXY_TERM_POLL_MS = 50;
+const PROXY_STDERR_BUFFER_LIMIT = 8192;
+const PROXY_STARTUP_TIMEOUT_MS = 10000;
+function isPageLevelEndpoint(endpoint) {
+    return /\/devtools\/page\//.test(endpoint);
+}
+function resolveBrowserEndpoint(pageEndpoint) {
+    return new Promise((resolve, reject)=>{
+        let host;
+        try {
+            const url = new URL(pageEndpoint);
+            host = url.host;
+        } catch  {
+            reject(new Error(`Invalid CDP endpoint URL: ${pageEndpoint}`));
+            return;
+        }
+        const req = node_http.get(`http://${host}/json/version`, {
+            timeout: 5000
+        }, (res)=>{
+            if (res.statusCode && res.statusCode >= 400) {
+                reject(new Error(`/json/version returned HTTP ${res.statusCode}`));
+                res.resume();
+                return;
+            }
+            let data = '';
+            res.on('data', (chunk)=>{
+                data += chunk.toString();
+            });
+            res.on('end', ()=>{
+                try {
+                    const info = JSON.parse(data);
+                    if (info.webSocketDebuggerUrl) resolve(info.webSocketDebuggerUrl);
+                    else reject(new Error('webSocketDebuggerUrl not found in /json/version response'));
+                } catch  {
+                    reject(new Error(`Failed to parse /json/version response: ${data}`));
+                }
+            });
+        });
+        req.on('error', (err)=>reject(new Error(`Failed to fetch /json/version: ${err.message}`)));
+        req.on('timeout', ()=>{
+            req.destroy();
+            reject(new Error('Timeout fetching /json/version'));
+        });
+    });
+}
+function isProxyAlive() {
+    if (!existsSync(PROXY_PID_FILE)) return false;
+    try {
+        const pid = Number(readFileSync(PROXY_PID_FILE, 'utf-8').trim());
+        process.kill(pid, 0);
+        return true;
+    } catch  {
+        return false;
+    }
+}
+function readProxyEndpoint() {
+    if (!existsSync(PROXY_ENDPOINT_FILE)) return null;
+    try {
+        return readFileSync(PROXY_ENDPOINT_FILE, 'utf-8').trim();
+    } catch  {
+        return null;
+    }
+}
+function readProxyUpstream() {
+    if (!existsSync(PROXY_UPSTREAM_FILE)) return null;
+    try {
+        return readFileSync(PROXY_UPSTREAM_FILE, 'utf-8').trim();
+    } catch  {
+        return null;
+    }
+}
+function sweepProxyMetadataFiles() {
+    try {
+        if (existsSync(PROXY_ENDPOINT_FILE)) unlinkSync(PROXY_ENDPOINT_FILE);
+    } catch  {}
+    try {
+        if (existsSync(PROXY_PID_FILE)) unlinkSync(PROXY_PID_FILE);
+    } catch  {}
+    try {
+        if (existsSync(PROXY_UPSTREAM_FILE)) unlinkSync(PROXY_UPSTREAM_FILE);
+    } catch  {}
+}
+async function killProxy() {
+    cleanupTargetIdFile();
+    if (!existsSync(PROXY_PID_FILE)) return;
+    let pid;
+    try {
+        pid = Number(readFileSync(PROXY_PID_FILE, 'utf-8').trim());
+        if (!Number.isFinite(pid)) return void sweepProxyMetadataFiles();
+    } catch (err) {
+        debug('killProxy: cannot read pid file: %s', err);
+        sweepProxyMetadataFiles();
+        return;
+    }
+    try {
+        process.kill(pid, 'SIGTERM');
+        debug('Sent SIGTERM to proxy pid %d', pid);
+    } catch (err) {
+        debug('killProxy: SIGTERM failed (pid %d): %s', pid, err);
+        sweepProxyMetadataFiles();
+        return;
+    }
+    const deadline = Date.now() + PROXY_TERM_GRACE_MS;
+    while(Date.now() < deadline && existsSync(PROXY_PID_FILE))await new Promise((r)=>setTimeout(r, PROXY_TERM_POLL_MS));
+    if (existsSync(PROXY_PID_FILE)) {
+        debug('proxy pid %d did not clean up within %dms, forcing SIGKILL', pid, PROXY_TERM_GRACE_MS);
+        try {
+            process.kill(pid, 'SIGKILL');
+        } catch  {}
+        sweepProxyMetadataFiles();
+    }
+}
+function spawnProxy(chromeEndpoint) {
+    return new Promise((resolve, reject)=>{
+        const proxyScript = join(__dirname, 'cdp-proxy.js');
+        const proc = spawn(process.execPath, [
+            proxyScript,
+            chromeEndpoint
+        ], {
+            detached: true,
+            stdio: [
+                'ignore',
+                'pipe',
+                'pipe'
+            ]
+        });
+        proc.unref();
+        let output = '';
+        let stderrBuf = '';
+        let settled = false;
+        const appendStderr = (chunk)=>{
+            stderrBuf += chunk.toString();
+            if (stderrBuf.length > PROXY_STDERR_BUFFER_LIMIT) stderrBuf = stderrBuf.slice(-PROXY_STDERR_BUFFER_LIMIT);
+        };
+        proc.stderr.on('data', appendStderr);
+        const formatStderr = ()=>{
+            const trimmed = stderrBuf.trim();
+            return trimmed ? ` (stderr: ${trimmed})` : '';
+        };
+        const timer = setTimeout(()=>{
+            if (!settled) {
+                settled = true;
+                reject(new Error(`Proxy startup timeout (${PROXY_STARTUP_TIMEOUT_MS / 1000}s)${formatStderr()}`));
+            }
+        }, PROXY_STARTUP_TIMEOUT_MS);
+        const onData = (chunk)=>{
+            output += chunk.toString();
+            const lines = output.split('\n');
+            for (const line of lines)if (line.trim()) try {
+                const parsed = JSON.parse(line);
+                if (parsed.endpoint && !settled) {
+                    settled = true;
+                    clearTimeout(timer);
+                    proc.stdout.removeListener('data', onData);
+                    proc.stderr.removeListener('data', appendStderr);
+                    proc.stdout.destroy();
+                    proc.stderr.destroy();
+                    resolve(parsed.endpoint);
+                    return;
+                }
+            } catch  {}
+        };
+        proc.stdout.on('data', onData);
+        proc.on('error', (err)=>{
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                reject(new Error(`Failed to spawn proxy: ${err.message}`));
+            }
+        });
+        proc.on('exit', (code, signal)=>{
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                const how = signal ? `signal ${signal}` : `code ${code}`;
+                reject(new Error(`Proxy exited with ${how} before ready${formatStderr()}`));
+            }
+        });
+    });
+}
+async function getProxyEndpoint(chromeEndpoint) {
+    let browserEndpoint = chromeEndpoint;
+    if (isPageLevelEndpoint(chromeEndpoint)) {
+        debug('Page-level CDP endpoint detected, resolving via /json/version: %s', chromeEndpoint);
+        try {
+            browserEndpoint = await resolveBrowserEndpoint(chromeEndpoint);
+            debug('Resolved browser endpoint: %s', browserEndpoint);
+        } catch (err) {
+            throw new Error(`Cannot use page-level CDP endpoint directly. Puppeteer requires a browser-level endpoint (e.g., ws://host:port/devtools/browser/<id>). Auto-resolution via /json/version failed: ${err.message}. Please provide a browser-level CDP endpoint instead.`);
+        }
+    }
+    if (isProxyAlive()) {
+        const endpoint = readProxyEndpoint();
+        const savedUpstream = readProxyUpstream();
+        if (endpoint) if (!savedUpstream || savedUpstream === browserEndpoint) return endpoint;
+        else {
+            debug('Proxy connected to different upstream (%s), killing', savedUpstream);
+            await killProxy();
+        }
+    }
+    try {
+        return await spawnProxy(browserEndpoint);
+    } catch (err) {
+        console.warn(`[cdp] proxy failed, falling back to direct connection: ${err}`);
+        return browserEndpoint;
+    }
+}
+export { getProxyEndpoint, isProxyAlive, killProxy, readProxyEndpoint, readProxyUpstream };

package/dist/es/cdp-proxy.mjs

@@ -0,0 +1,151 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { createServer } from "node:http";
+import ws_0, { WebSocketServer } from "ws";
+import { PROXY_ENDPOINT_FILE, PROXY_PID_FILE, PROXY_UPSTREAM_FILE } from "./cdp-proxy-constants.mjs";
+const IDLE_TIMEOUT_MS = 300000;
+const chromeEndpoint = process.argv[2];
+if (!chromeEndpoint) {
+    process.stderr.write('Usage: node cdp-proxy.js <chrome-ws-endpoint>\n');
+    process.exit(1);
+}
+function cleanupIfOwned() {
+    try {
+        if (!existsSync(PROXY_PID_FILE)) return;
+        const pid = Number(readFileSync(PROXY_PID_FILE, 'utf-8').trim());
+        if (pid !== process.pid) return;
+    } catch  {
+        return;
+    }
+    try {
+        if (existsSync(PROXY_ENDPOINT_FILE)) unlinkSync(PROXY_ENDPOINT_FILE);
+    } catch  {}
+    try {
+        if (existsSync(PROXY_PID_FILE)) unlinkSync(PROXY_PID_FILE);
+    } catch  {}
+    try {
+        if (existsSync(PROXY_UPSTREAM_FILE)) unlinkSync(PROXY_UPSTREAM_FILE);
+    } catch  {}
+}
+const STDERR_FLUSH_FALLBACK_MS = 500;
+function exitWithStderr(message, code = 0) {
+    let exited = false;
+    const doExit = ()=>{
+        if (exited) return;
+        exited = true;
+        process.exit(code);
+    };
+    const fallback = setTimeout(doExit, STDERR_FLUSH_FALLBACK_MS);
+    fallback.unref?.();
+    try {
+        process.stderr.write(message, ()=>doExit());
+    } catch  {
+        doExit();
+    }
+}
+function shutdown(reason) {
+    cleanupIfOwned();
+    exitWithStderr(`[cdp-proxy] shutting down: ${reason}\n`, 0);
+}
+process.on('SIGTERM', ()=>shutdown('SIGTERM'));
+process.on('SIGINT', ()=>shutdown('SIGINT'));
+process.on('uncaughtException', (e)=>shutdown(`uncaught: ${e.message}`));
+let idleTimer = null;
+function resetIdleTimer() {
+    if (idleTimer) clearTimeout(idleTimer);
+    idleTimer = setTimeout(()=>shutdown('idle timeout (5min)'), IDLE_TIMEOUT_MS);
+}
+resetIdleTimer();
+const clients = new Set();
+let reconnecting = false;
+let needsUpstreamReconnect = false;
+const pendingUpstreamMessages = [];
+function createUpstream(endpoint) {
+    const ws = new ws_0(endpoint);
+    ws.on('error', (err)=>{
+        reconnecting = false;
+        shutdown(`upstream error: ${err.message}`);
+    });
+    ws.on('close', (code, reasonBuf)=>{
+        if (reconnecting) return;
+        const reason = reasonBuf?.toString?.() || '';
+        const detail = reason ? ` (code=${code}, reason=${reason})` : ` (code=${code})`;
+        shutdown(`upstream closed${detail}`);
+    });
+    ws.on('message', (data, isBinary)=>{
+        resetIdleTimer();
+        for (const client of clients)if (client.readyState === ws_0.OPEN) client.send(data, {
+            binary: isBinary
+        });
+    });
+    ws.on('open', ()=>{
+        reconnecting = false;
+        for (const msg of pendingUpstreamMessages)ws.send(msg.data, {
+            binary: msg.isBinary
+        });
+        pendingUpstreamMessages.length = 0;
+    });
+    return ws;
+}
+let upstream = createUpstream(chromeEndpoint);
+function reconnectUpstream() {
+    reconnecting = true;
+    upstream.removeAllListeners();
+    upstream.close();
+    upstream = createUpstream(chromeEndpoint);
+    resetIdleTimer();
+}
+const httpServer = createServer((_req, res)=>{
+    res.writeHead(404);
+    res.end();
+});
+const wss = new WebSocketServer({
+    server: httpServer
+});
+wss.on('connection', (clientWs)=>{
+    if (needsUpstreamReconnect && upstream.readyState === ws_0.OPEN) {
+        reconnectUpstream();
+        needsUpstreamReconnect = false;
+    }
+    clients.add(clientWs);
+    resetIdleTimer();
+    clientWs.on('message', (data, isBinary)=>{
+        resetIdleTimer();
+        if (upstream.readyState === ws_0.OPEN) upstream.send(data, {
+            binary: isBinary
+        });
+        else pendingUpstreamMessages.push({
+            data,
+            isBinary
+        });
+    });
+    const removeClient = ()=>{
+        clients.delete(clientWs);
+        if (0 === clients.size) {
+            pendingUpstreamMessages.length = 0;
+            needsUpstreamReconnect = true;
+        }
+    };
+    clientWs.on('close', removeClient);
+    clientWs.on('error', removeClient);
+});
+upstream.once('open', ()=>{
+    if (existsSync(PROXY_PID_FILE)) try {
+        const existingPid = Number(readFileSync(PROXY_PID_FILE, 'utf-8').trim());
+        if (existingPid !== process.pid) try {
+            process.kill(existingPid, 0);
+            exitWithStderr(`[cdp-proxy] duplicate proxy detected (existing pid=${existingPid})\n`, 0);
+            return;
+        } catch  {}
+    } catch  {}
+    httpServer.listen(0, '127.0.0.1', ()=>{
+        const addr = httpServer.address();
+        if (!addr || 'string' == typeof addr) return void shutdown('failed to get server address');
+        const proxyEndpoint = `ws://127.0.0.1:${addr.port}/devtools/browser`;
+        writeFileSync(PROXY_ENDPOINT_FILE, proxyEndpoint);
+        writeFileSync(PROXY_PID_FILE, String(process.pid));
+        writeFileSync(PROXY_UPSTREAM_FILE, chromeEndpoint);
+        process.stdout.write(`${JSON.stringify({
+            endpoint: proxyEndpoint
+        })}\n`);
+    });
+});

package/dist/es/cdp-target-store.mjs

@@ -0,0 +1,26 @@
+import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { getDebug } from "@godscene/shared/logger";
+import { TARGET_ID_FILE } from "./cdp-proxy-constants.mjs";
+const debug = getDebug('mcp:cdp:target-store');
+function readSavedTargetId() {
+    if (!existsSync(TARGET_ID_FILE)) return null;
+    try {
+        return readFileSync(TARGET_ID_FILE, 'utf-8').trim() || null;
+    } catch  {
+        return null;
+    }
+}
+function saveTargetId(targetId) {
+    try {
+        writeFileSync(TARGET_ID_FILE, targetId, 'utf-8');
+        debug('Saved targetId: %s', targetId);
+    } catch (err) {
+        debug('Failed to save targetId: %s', err);
+    }
+}
+function cleanupTargetIdFile() {
+    try {
+        if (existsSync(TARGET_ID_FILE)) unlinkSync(TARGET_ID_FILE);
+    } catch  {}
+}
+export { cleanupTargetIdFile, readSavedTargetId, saveTargetId };

package/dist/es/chrome-extension/agent.mjs

@@ -0,0 +1,8 @@
+import { Agent } from "@godscene/core/agent";
+import { BROWSER_NAVIGATION_ERROR_PATTERN } from "../puppeteer/base-page.mjs";
+class ChromeExtensionProxyPageAgent extends Agent {
+    isRetryableContextError(error) {
+        return error instanceof Error && BROWSER_NAVIGATION_ERROR_PATTERN.test(error.message);
+    }
+}
+export { ChromeExtensionProxyPageAgent };

package/dist/es/chrome-extension/cdpInput.mjs

@@ -0,0 +1,172 @@
+/*! For license information please see cdpInput.mjs.LICENSE.txt */
+import { _keyDefinitions } from "@godscene/shared/us-keyboard-layout";
+import { assert } from "@godscene/shared/utils";
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) throw new TypeError("Cannot initialize the same private elements twice on an object");
+}
+function _class_apply_descriptor_get(receiver, descriptor) {
+    if (descriptor.get) return descriptor.get.call(receiver);
+    return descriptor.value;
+}
+function _class_apply_descriptor_set(receiver, descriptor, value) {
+    if (descriptor.set) descriptor.set.call(receiver, value);
+    else {
+        if (!descriptor.writable) throw new TypeError("attempted to set read only private field");
+        descriptor.value = value;
+    }
+}
+function _class_extract_field_descriptor(receiver, privateMap, action) {
+    if (!privateMap.has(receiver)) throw new TypeError("attempted to " + action + " private field on non-instance");
+    return privateMap.get(receiver);
+}
+function _class_private_field_get(receiver, privateMap) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "get");
+    return _class_apply_descriptor_get(receiver, descriptor);
+}
+function _class_private_field_init(obj, privateMap, value) {
+    _check_private_redeclaration(obj, privateMap);
+    privateMap.set(obj, value);
+}
+function _class_private_field_set(receiver, privateMap, value) {
+    var descriptor = _class_extract_field_descriptor(receiver, privateMap, "set");
+    _class_apply_descriptor_set(receiver, descriptor, value);
+    return value;
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) throw new TypeError("attempted to get private field on non-instance");
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+function _define_property(obj, key, value) {
+    if (key in obj) Object.defineProperty(obj, key, {
+        value: value,
+        enumerable: true,
+        configurable: true,
+        writable: true
+    });
+    else obj[key] = value;
+    return obj;
+}
+/**
+ * @license
+ * Copyright 2017 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */ var _pressedKeys = /*#__PURE__*/ new WeakMap(), _client = /*#__PURE__*/ new WeakMap(), _modifierBit = /*#__PURE__*/ new WeakSet(), _keyDescriptionForString = /*#__PURE__*/ new WeakSet();
+class CdpKeyboard {
+    updateClient(client) {
+        _class_private_field_set(this, _client, client);
+    }
+    async down(key, options = {
+        text: void 0,
+        commands: []
+    }) {
+        const description = _class_private_method_get(this, _keyDescriptionForString, keyDescriptionForString).call(this, key);
+        const autoRepeat = _class_private_field_get(this, _pressedKeys).has(description.code);
+        _class_private_field_get(this, _pressedKeys).add(description.code);
+        this._modifiers |= _class_private_method_get(this, _modifierBit, modifierBit).call(this, description.key);
+        const text = void 0 === options.text ? description.text : options.text;
+        await _class_private_field_get(this, _client).send('Input.dispatchKeyEvent', {
+            type: text ? 'keyDown' : 'rawKeyDown',
+            modifiers: this._modifiers,
+            windowsVirtualKeyCode: description.keyCode,
+            code: description.code,
+            key: description.key,
+            text: text,
+            unmodifiedText: text,
+            autoRepeat,
+            location: description.location,
+            isKeypad: 3 === description.location,
+            commands: options.commands
+        });
+    }
+    async up(key) {
+        const description = _class_private_method_get(this, _keyDescriptionForString, keyDescriptionForString).call(this, key);
+        this._modifiers &= ~_class_private_method_get(this, _modifierBit, modifierBit).call(this, description.key);
+        _class_private_field_get(this, _pressedKeys).delete(description.code);
+        await _class_private_field_get(this, _client).send('Input.dispatchKeyEvent', {
+            type: 'keyUp',
+            modifiers: this._modifiers,
+            key: description.key,
+            windowsVirtualKeyCode: description.keyCode,
+            code: description.code,
+            location: description.location
+        });
+    }
+    async sendCharacter(char) {
+        await _class_private_field_get(this, _client).send('Input.insertText', {
+            text: char
+        });
+    }
+    charIsKey(char) {
+        return !!_keyDefinitions[char];
+    }
+    async type(text, options = {}) {
+        const delay = options.delay || void 0;
+        for (const char of text)if (this.charIsKey(char)) await this.press(char, {
+            delay
+        });
+        else {
+            if (delay) await new Promise((f)=>setTimeout(f, delay));
+            await this.sendCharacter(char);
+        }
+    }
+    async press(key, options = {}) {
+        const { delay = null } = options;
+        const keys = Array.isArray(key) ? key : [
+            key
+        ];
+        for (const k of keys)await this.down(k, options);
+        if (delay) await new Promise((f)=>setTimeout(f, options.delay));
+        for (const k of [
+            ...keys
+        ].reverse())await this.up(k);
+    }
+    constructor(client){
+        _class_private_method_init(this, _modifierBit);
+        _class_private_method_init(this, _keyDescriptionForString);
+        _class_private_field_init(this, _pressedKeys, {
+            writable: true,
+            value: new Set()
+        });
+        _class_private_field_init(this, _client, {
+            writable: true,
+            value: void 0
+        });
+        _define_property(this, "_modifiers", 0);
+        _class_private_field_set(this, _client, client);
+    }
+}
+function modifierBit(key) {
+    if ('Alt' === key) return 1;
+    if ('Control' === key) return 2;
+    if ('Meta' === key) return 4;
+    if ('Shift' === key) return 8;
+    return 0;
+}
+function keyDescriptionForString(keyString) {
+    const shift = 8 & this._modifiers;
+    const description = {
+        key: '',
+        keyCode: 0,
+        code: '',
+        text: '',
+        location: 0
+    };
+    const definition = _keyDefinitions[keyString];
+    assert(definition, `Unknown key: "${keyString}"`);
+    if (definition.key) description.key = definition.key;
+    if (shift && definition.shiftKey) description.key = definition.shiftKey;
+    if (definition.keyCode) description.keyCode = definition.keyCode;
+    if (shift && definition.shiftKeyCode) description.keyCode = definition.shiftKeyCode;
+    if (definition.code) description.code = definition.code;
+    if (definition.location) description.location = definition.location;
+    if (1 === description.key.length) description.text = description.key;
+    if (definition.text) description.text = definition.text;
+    if (shift && definition.shiftText) description.text = definition.shiftText;
+    if (-9 & this._modifiers) description.text = '';
+    return description;
+}
+export { CdpKeyboard };

package/dist/es/chrome-extension/cdpInput.mjs.LICENSE.txt

@@ -0,0 +1,5 @@
+/**
+ * @license
+ * Copyright 2017 Google Inc.
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/es/chrome-extension/dynamic-scripts.mjs

@@ -0,0 +1,36 @@
+import node_fs from "node:fs";
+import { ifInBrowser, ifInWorker } from "@godscene/shared/utils";
+let scriptFileContentCache = null;
+const getHtmlElementScript = async ()=>{
+    const scriptFileToRetrieve = chrome.runtime.getURL("scripts/htmlElement.js");
+    if (scriptFileContentCache) return scriptFileContentCache;
+    if (ifInBrowser || ifInWorker) {
+        const script = await fetch(scriptFileToRetrieve);
+        scriptFileContentCache = await script.text();
+        return scriptFileContentCache;
+    }
+    return node_fs.readFileSync(scriptFileToRetrieve, 'utf8');
+};
+let waterFlowScriptFileContentCache = null;
+const injectWaterFlowAnimation = async ()=>{
+    const waterFlowScriptFileToRetrieve = chrome.runtime.getURL("scripts/water-flow.js");
+    if (waterFlowScriptFileContentCache) return waterFlowScriptFileContentCache;
+    if (ifInBrowser || ifInWorker) {
+        const script = await fetch(waterFlowScriptFileToRetrieve);
+        waterFlowScriptFileContentCache = await script.text();
+        return waterFlowScriptFileContentCache;
+    }
+    return node_fs.readFileSync(waterFlowScriptFileToRetrieve, 'utf8');
+};
+let stopWaterFlowScriptFileContentCache = null;
+const injectStopWaterFlowAnimation = async ()=>{
+    const stopWaterFlowScriptFileToRetrieve = chrome.runtime.getURL("scripts/stop-water-flow.js");
+    if (stopWaterFlowScriptFileContentCache) return stopWaterFlowScriptFileContentCache;
+    if (ifInBrowser || ifInWorker) {
+        const script = await fetch(stopWaterFlowScriptFileToRetrieve);
+        stopWaterFlowScriptFileContentCache = await script.text();
+        return stopWaterFlowScriptFileContentCache;
+    }
+    return node_fs.readFileSync(stopWaterFlowScriptFileToRetrieve, 'utf8');
+};
+export { getHtmlElementScript, injectStopWaterFlowAnimation, injectWaterFlowAnimation };

package/dist/es/chrome-extension/index.mjs

@@ -0,0 +1,5 @@
+import { ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED } from "@godscene/shared/common";
+import { ChromeExtensionProxyPageAgent } from "./agent.mjs";
+import page from "./page.mjs";
+import { overrideAIConfig } from "@godscene/shared/env";
+export { page as ChromeExtensionProxyPage, ChromeExtensionProxyPageAgent, ERROR_CODE_NOT_IMPLEMENTED_AS_DESIGNED, overrideAIConfig };