@volter/browser-python 0.1.0

package/dist/sqlite-coherence.js

@@ -0,0 +1,167 @@
+import { BrowserFileCoherenceClient, coherentFileFamily, } from "@volter/browser-runtime/browser-file-coherence.js";
+import { BrowserFileLockClient } from "@volter/browser-runtime/browser-file-locks.js";
+/** Serializes unchanged CPython sqlite connections with every browser lane. */
+export class PythonSqliteCoherence {
+    filesystem;
+    locks;
+    coherence;
+    counts = new Map();
+    owner;
+    constructor(filesystem, locks, coherence, ownerPrefix) {
+        this.filesystem = filesystem;
+        this.locks = locks;
+        this.coherence = coherence;
+        this.owner = `${ownerPrefix}:sqlite`;
+    }
+    install(pyodide) {
+        pyodide.globals.set("_browser_runtime_sqlite_acquire", (path) => this.acquire(path));
+        pyodide.globals.set("_browser_runtime_sqlite_release", (path) => this.release(path));
+        return pyodide.runPythonAsync(PYTHON_SQLITE_BOOTSTRAP);
+    }
+    releaseAll() {
+        for (const path of [...this.counts.keys()]) {
+            this.counts.set(path, 1);
+            this.release(path);
+        }
+    }
+    acquire(path) {
+        if (!path.startsWith("/") || path.includes("\0"))
+            throw new Error("Invalid SQLite path.");
+        const count = this.counts.get(path) ?? 0;
+        if (count > 0) {
+            this.counts.set(path, count + 1);
+            return;
+        }
+        const response = this.locks.request({
+            operation: "set",
+            owner: this.owner,
+            namespace: "posix",
+            path,
+            range: { start: 0 },
+            mode: "write",
+            pid: 1,
+            blocking: true,
+        });
+        if (response.result < 0)
+            throw new Error(`SQLite lock acquisition failed with ${response.result}.`);
+        try {
+            for (const member of coherentFileFamily(path))
+                this.writeLocal(member, this.coherence.pull(member));
+            this.counts.set(path, 1);
+        }
+        catch (error) {
+            this.locks.request({
+                operation: "unlock",
+                owner: this.owner,
+                namespace: "posix",
+                path,
+                range: { start: 0 },
+            });
+            throw error;
+        }
+    }
+    release(path) {
+        const count = this.counts.get(path) ?? 0;
+        if (count > 1) {
+            this.counts.set(path, count - 1);
+            return;
+        }
+        if (count === 0)
+            return;
+        for (const member of coherentFileFamily(path))
+            this.coherence.push(member, this.readLocal(member));
+        const response = this.locks.request({
+            operation: "unlock",
+            owner: this.owner,
+            namespace: "posix",
+            path,
+            range: { start: 0 },
+        });
+        if (response.result < 0)
+            throw new Error(`SQLite lock release failed with ${response.result}.`);
+        this.counts.delete(path);
+    }
+    readLocal(path) {
+        if (!this.filesystem.analyzePath(path).exists)
+            return;
+        const stat = this.filesystem.stat(path);
+        if ((stat.mode & 0o170000) === 0o040000)
+            return;
+        const mtimeMs = stat.mtime instanceof Date ? stat.mtime.getTime() : stat.mtime;
+        return {
+            bytes: this.filesystem.readFile(path),
+            mode: stat.mode & 0o7777,
+            ...(typeof mtimeMs === "number" && Number.isFinite(mtimeMs) ? { mtimeMs } : {}),
+        };
+    }
+    writeLocal(path, file) {
+        if (!file) {
+            if (this.filesystem.analyzePath(path).exists
+                && (this.filesystem.stat(path).mode & 0o170000) !== 0o040000)
+                this.filesystem.unlink(path);
+            return;
+        }
+        const parent = path.slice(0, path.lastIndexOf("/")) || "/";
+        if (!this.filesystem.analyzePath(parent).exists)
+            this.filesystem.mkdirTree(parent);
+        this.filesystem.writeFile(path, file.bytes);
+        if (file.mode !== undefined)
+            this.filesystem.chmod(path, file.mode);
+        if (file.mtimeMs !== undefined)
+            this.filesystem.utime(path, file.mtimeMs, file.mtimeMs);
+    }
+}
+const PYTHON_SQLITE_BOOTSTRAP = String.raw `
+import os as _browser_runtime_sqlite_os, sqlite3 as _browser_runtime_sqlite
+
+_browser_runtime_sqlite_connect_original = _browser_runtime_sqlite.connect
+
+def _browser_runtime_sqlite_path(database, uri=False):
+    try:
+        value = _browser_runtime_sqlite_os.fspath(database)
+    except TypeError:
+        return None
+    if isinstance(value, bytes):
+        value = _browser_runtime_sqlite_os.fsdecode(value)
+    if value == ":memory:" or value.startswith("file::memory:"):
+        return None
+    if uri and value.startswith("file:"):
+        value = value[5:].split("?", 1)[0]
+    return _browser_runtime_sqlite_os.path.abspath(value)
+
+class _BrowserRuntimeSqliteConnection(_browser_runtime_sqlite.Connection):
+    def __init__(self, *args, **kwargs):
+        database = args[0] if args else kwargs.get("database")
+        self._browser_runtime_path = _browser_runtime_sqlite_path(database, bool(kwargs.get("uri", False)))
+        self._browser_runtime_released = False
+        if self._browser_runtime_path:
+            _browser_runtime_sqlite_acquire(self._browser_runtime_path)
+        try:
+            super().__init__(*args, **kwargs)
+        except BaseException:
+            if self._browser_runtime_path:
+                _browser_runtime_sqlite_release(self._browser_runtime_path)
+                self._browser_runtime_released = True
+            raise
+
+    def close(self):
+        if self._browser_runtime_released:
+            return super().close()
+        try:
+            return super().close()
+        finally:
+            if self._browser_runtime_path:
+                _browser_runtime_sqlite_release(self._browser_runtime_path)
+            self._browser_runtime_released = True
+
+def _browser_runtime_sqlite_connect(database, *args, **kwargs):
+    factory = kwargs.get("factory")
+    if factory is not None and factory is not _browser_runtime_sqlite.Connection:
+        raise NotImplementedError("custom sqlite connection factories are not yet supported by browser coherence")
+    kwargs["factory"] = _BrowserRuntimeSqliteConnection
+    return _browser_runtime_sqlite_connect_original(database, *args, **kwargs)
+
+_browser_runtime_sqlite.connect = _browser_runtime_sqlite_connect
+_browser_runtime_sqlite.dbapi2.connect = _browser_runtime_sqlite_connect
+`;
+//# sourceMappingURL=sqlite-coherence.js.map

package/dist/sqlite-coherence.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite-coherence.js","sourceRoot":"","sources":["../src/sqlite-coherence.ts"],"names":[],"mappings":"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"}

package/dist/subprocess-bridge.d.ts

@@ -0,0 +1,12 @@
+import type { PyodideRuntime } from "./pyodide-runtime.js";
+/** Synchronous CPython subprocess calls backed by the page's shared process host. */
+export declare class PythonProcessClient {
+    private readonly pyodide;
+    private readonly port;
+    private nextRequestId;
+    constructor(pyodide: PyodideRuntime, port: MessagePort);
+    private run;
+    private exchange;
+}
+export declare const PYTHON_SUBPROCESS_BOOTSTRAP: string;
+//# sourceMappingURL=subprocess-bridge.d.ts.map

package/dist/subprocess-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"subprocess-bridge.d.ts","sourceRoot":"","sources":["../src/subprocess-bridge.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAO3D,qFAAqF;AACrF,qBAAa,mBAAmB;IAI5B,OAAO,CAAC,QAAQ,CAAC,OAAO;IACxB,OAAO,CAAC,QAAQ,CAAC,IAAI;IAJvB,OAAO,CAAC,aAAa,CAAK;gBAGP,OAAO,EAAE,cAAc,EACvB,IAAI,EAAE,WAAW;IAMpC,OAAO,CAAC,GAAG;IA0CX,OAAO,CAAC,QAAQ;CA8BjB;AAED,eAAO,MAAM,2BAA2B,QAuUvC,CAAC"}

package/dist/subprocess-bridge.js

@@ -0,0 +1,407 @@
+import { restorePythonSnapshot } from "./filesystem.js";
+const RESPONSE_BYTES = 16 * 1024 * 1024;
+const TIMEOUT_MS = 30_000;
+const POPEN_TIMEOUT_MS = 5 * 60_000;
+/** Synchronous CPython subprocess calls backed by the page's shared process host. */
+export class PythonProcessClient {
+    pyodide;
+    port;
+    nextRequestId = 1;
+    constructor(pyodide, port) {
+        this.pyodide = pyodide;
+        this.port = port;
+        pyodide.globals.set("__browser_runtime_run_process", (payload) => this.run(payload));
+        pyodide.globals.set("__browser_runtime_process_exchange", (payload) => this.exchange(payload));
+    }
+    run(payload) {
+        const request = JSON.parse(payload);
+        const controlBuffer = new SharedArrayBuffer(2 * Int32Array.BYTES_PER_ELEMENT);
+        const responseBuffer = new SharedArrayBuffer(RESPONSE_BYTES);
+        const control = new Int32Array(controlBuffer);
+        const requestId = this.nextRequestId++;
+        this.port.postMessage({
+            type: "process-run",
+            requestId,
+            ...request,
+            control: controlBuffer,
+            response: responseBuffer,
+        });
+        const result = Atomics.wait(control, 0, 0, TIMEOUT_MS);
+        if (result === "timed-out" || Atomics.load(control, 0) !== 1) {
+            this.port.postMessage({ type: "process-cancel", requestId });
+            throw new Error("Python subprocess timed out after 30 seconds.");
+        }
+        const length = Atomics.load(control, 1);
+        if (!Number.isSafeInteger(length) || length < 0 || length > responseBuffer.byteLength) {
+            throw new Error("Invalid Python subprocess response.");
+        }
+        // TextDecoder deliberately rejects SAB-backed views. Copy out of shared
+        // memory once the host has published the completion state.
+        const responseBytes = new Uint8Array(length);
+        responseBytes.set(new Uint8Array(responseBuffer, 0, length));
+        const response = JSON.parse(new TextDecoder().decode(responseBytes));
+        if (response.error)
+            throw new Error(response.error);
+        if (!response.result || !response.filesystem)
+            throw new Error("Incomplete Python subprocess response.");
+        restorePythonSnapshot(this.pyodide.FS, response.filesystem);
+        return JSON.stringify(response.result);
+    }
+    exchange(payload) {
+        const request = JSON.parse(payload);
+        const controlBuffer = new SharedArrayBuffer(2 * Int32Array.BYTES_PER_ELEMENT);
+        const responseBuffer = new SharedArrayBuffer(RESPONSE_BYTES);
+        const control = new Int32Array(controlBuffer);
+        this.port.postMessage({
+            ...request,
+            requestId: this.nextRequestId++,
+            control: controlBuffer,
+            response: responseBuffer,
+        });
+        const result = Atomics.wait(control, 0, 0, POPEN_TIMEOUT_MS);
+        if (result === "timed-out" || Atomics.load(control, 0) !== 1) {
+            throw new Error("Python Popen operation timed out after 5 minutes.");
+        }
+        const length = Atomics.load(control, 1);
+        if (!Number.isSafeInteger(length) || length < 0 || length > responseBuffer.byteLength) {
+            throw new Error("Invalid Python Popen response.");
+        }
+        const responseBytes = new Uint8Array(length);
+        responseBytes.set(new Uint8Array(responseBuffer, 0, length));
+        const response = JSON.parse(new TextDecoder().decode(responseBytes));
+        if (response.filesystem)
+            restorePythonSnapshot(this.pyodide.FS, response.filesystem);
+        if (response.error)
+            throw new Error(response.error);
+        return JSON.stringify(response);
+    }
+}
+export const PYTHON_SUBPROCESS_BOOTSTRAP = String.raw `
+import base64 as __browser_runtime_base64
+import codecs as _browser_runtime_codecs
+import json as __browser_runtime_json
+import os
+import shlex as __browser_runtime_shlex
+import subprocess as __browser_runtime_subprocess
+import sys
+
+def __browser_runtime_subprocess_run(args, *, stdin=None, input=None, stdout=None, stderr=None,
+                               capture_output=False, shell=False, cwd=None, timeout=None,
+                               check=False, encoding=None, errors=None, text=False, env=None, **kwargs):
+    if timeout is not None:
+        raise NotImplementedError("browser subprocess timeout is fixed at 30 seconds")
+    if kwargs:
+        raise NotImplementedError("unsupported browser subprocess options: " + ", ".join(kwargs.keys()))
+    if capture_output:
+        if stdout is not None or stderr is not None:
+            raise ValueError("stdout and stderr arguments may not be used with capture_output")
+        stdout = stderr = __browser_runtime_subprocess.PIPE
+    if stdin not in (None, __browser_runtime_subprocess.PIPE, __browser_runtime_subprocess.DEVNULL):
+        raise NotImplementedError("browser subprocess stdin must be PIPE, DEVNULL, or None")
+    if stdout not in (None, __browser_runtime_subprocess.PIPE, __browser_runtime_subprocess.DEVNULL):
+        raise NotImplementedError("browser subprocess stdout must be PIPE, DEVNULL, or None")
+    if stderr not in (None, __browser_runtime_subprocess.PIPE, __browser_runtime_subprocess.DEVNULL, __browser_runtime_subprocess.STDOUT):
+        raise NotImplementedError("browser subprocess stderr must be PIPE, DEVNULL, STDOUT, or None")
+    if input is not None and stdin not in (None, __browser_runtime_subprocess.PIPE):
+        raise ValueError("stdin argument may not be used with input")
+    if isinstance(args, str):
+        command = args if shell else __browser_runtime_shlex.join([args])
+    else:
+        command = __browser_runtime_shlex.join([str(value) for value in args])
+    if input is None:
+        input_bytes = b""
+    elif isinstance(input, str):
+        input_bytes = input.encode(encoding or "utf-8", errors or "strict")
+    else:
+        input_bytes = bytes(input)
+    payload = __browser_runtime_json.dumps({
+        "command": command,
+        "cwd": os.path.abspath(cwd or os.getcwd()),
+        "env": {str(key): str(value) for key, value in (env or os.environ).items()},
+        "stdinBase64": __browser_runtime_base64.b64encode(input_bytes).decode("ascii"),
+    })
+    result = __browser_runtime_json.loads(__browser_runtime_run_process(payload))
+    use_text = text or encoding is not None or errors is not None
+    out_text, err_text = result["stdout"], result["stderr"]
+    if stderr == __browser_runtime_subprocess.STDOUT:
+        out_text += err_text
+        err_text = ""
+    if stdout != __browser_runtime_subprocess.PIPE:
+        if stdout != __browser_runtime_subprocess.DEVNULL and out_text:
+            sys.stdout.write(out_text)
+        completed_stdout = None
+    else:
+        completed_stdout = out_text if use_text else out_text.encode(encoding or "utf-8", errors or "strict")
+    if stderr not in (__browser_runtime_subprocess.PIPE, __browser_runtime_subprocess.STDOUT):
+        if stderr != __browser_runtime_subprocess.DEVNULL and err_text:
+            sys.stderr.write(err_text)
+        completed_stderr = None
+    else:
+        completed_stderr = None if stderr == __browser_runtime_subprocess.STDOUT else (err_text if use_text else err_text.encode(encoding or "utf-8", errors or "strict"))
+    completed = __browser_runtime_subprocess.CompletedProcess(args, int(result["exitCode"]), completed_stdout, completed_stderr)
+    if check:
+        completed.check_returncode()
+    return completed
+
+def __browser_runtime_subprocess_call(*popenargs, timeout=None, **kwargs):
+    return __browser_runtime_subprocess_run(*popenargs, timeout=timeout, **kwargs).returncode
+
+def __browser_runtime_subprocess_check_call(*popenargs, **kwargs):
+    result = __browser_runtime_subprocess_run(*popenargs, **kwargs)
+    result.check_returncode()
+    return 0
+
+def __browser_runtime_process_command(args, shell):
+    if isinstance(args, str):
+        return args if shell else __browser_runtime_shlex.join([args])
+    return __browser_runtime_shlex.join([str(value) for value in args])
+
+def __browser_runtime_process_action(payload):
+    return __browser_runtime_json.loads(__browser_runtime_process_exchange(__browser_runtime_json.dumps(payload)))
+
+_browser_runtime_base64 = __browser_runtime_base64
+_browser_runtime_process_action = __browser_runtime_process_action
+_browser_runtime_process_command = __browser_runtime_process_command
+_browser_runtime_subprocess = __browser_runtime_subprocess
+
+class __browser_runtime_BrowserPipe:
+    def __init__(self, process, stream, writable=False):
+        self.process = process
+        self.stream = stream
+        self.writable = writable
+        self.closed = False
+        self._buffer = "" if self.process.text_mode else bytearray()
+        self._decoder = _browser_runtime_codecs.getincrementaldecoder(self.process.encoding)(self.process.errors) if self.process.text_mode else None
+        self._eof = False
+
+    def write(self, value):
+        if not self.writable or self.closed:
+            raise ValueError("write to closed or read-only browser subprocess pipe")
+        raw = value.encode(self.process.encoding, self.process.errors) if isinstance(value, str) else bytes(value)
+        result = self.process._action("write", stdinBase64=_browser_runtime_base64.b64encode(raw).decode("ascii"))
+        return len(value) if isinstance(value, str) else int(result.get("written", len(raw)))
+
+    def flush(self):
+        if self.closed:
+            raise ValueError("flush of closed browser subprocess pipe")
+
+    def close(self):
+        if self.closed:
+            return
+        self.closed = True
+        if self.writable:
+            self.process._action("close")
+
+    def _pull(self, maximum=65536):
+        if self.writable or self.closed:
+            raise ValueError("read from closed or write-only browser subprocess pipe")
+        if self._eof:
+            return
+        result = self.process._action("read", stream=self.stream, maximum=maximum)
+        raw = _browser_runtime_base64.b64decode(result.get("dataBase64", ""))
+        self._eof = bool(result.get("eof", False))
+        if self.process.text_mode:
+            self._buffer += self._decoder.decode(raw, final=self._eof)
+        elif raw:
+            self._buffer.extend(raw)
+
+    def read(self, size=-1):
+        if size is None or size < 0:
+            while not self._eof:
+                self._pull()
+            value = self._buffer if self.process.text_mode else bytes(self._buffer)
+            self._buffer = "" if self.process.text_mode else bytearray()
+            return value
+        if size == 0:
+            return "" if self.process.text_mode else b""
+        while not self._buffer and not self._eof:
+            self._pull(min(max(size, 1), 1048576))
+        count = min(size, len(self._buffer))
+        value = self._buffer[:count] if self.process.text_mode else bytes(self._buffer[:count])
+        if self.process.text_mode:
+            self._buffer = self._buffer[count:]
+        else:
+            del self._buffer[:count]
+        return value
+
+    def readline(self, size=-1):
+        limit = None if size is None or size < 0 else size
+        newline_value = "\n" if self.process.text_mode else b"\n"
+        while not self._eof and newline_value not in self._buffer and (limit is None or len(self._buffer) < limit):
+            self._pull()
+        newline = self._buffer.find(newline_value)
+        count = len(self._buffer) if newline < 0 else newline + 1
+        if limit is not None:
+            count = min(count, limit)
+        value = self._buffer[:count] if self.process.text_mode else bytes(self._buffer[:count])
+        if self.process.text_mode:
+            self._buffer = self._buffer[count:]
+        else:
+            del self._buffer[:count]
+        return value
+
+    def readlines(self, hint=-1):
+        lines = []
+        total = 0
+        while True:
+            line = self.readline()
+            if not line:
+                break
+            lines.append(line)
+            total += len(line)
+            if hint is not None and hint >= 0 and total >= hint:
+                break
+        return lines
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        line = self.readline()
+        if not line:
+            raise StopIteration
+        return line
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, value, traceback):
+        self.close()
+
+_browser_runtime_BrowserPipe = __browser_runtime_BrowserPipe
+
+class __browser_runtime_BrowserPopen:
+    def __init__(self, args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None,
+                 preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None,
+                 universal_newlines=None, startupinfo=None, creationflags=0,
+                 restore_signals=True, start_new_session=False, pass_fds=(), *, user=None,
+                 group=None, extra_groups=None, encoding=None, errors=None, text=None,
+                 umask=-1, pipesize=-1, process_group=None):
+        unsupported = {
+            "executable": executable, "preexec_fn": preexec_fn, "startupinfo": startupinfo,
+            "creationflags": creationflags or None, "start_new_session": start_new_session or None,
+            "pass_fds": pass_fds or None, "user": user, "group": group,
+            "extra_groups": extra_groups, "umask": None if umask == -1 else umask,
+            "pipesize": None if pipesize == -1 else pipesize, "process_group": process_group,
+        }
+        rejected = [name for name, value in unsupported.items() if value is not None]
+        if rejected:
+            raise NotImplementedError("unsupported browser Popen options: " + ", ".join(rejected))
+        if stdin not in (None, _browser_runtime_subprocess.PIPE, _browser_runtime_subprocess.DEVNULL):
+            raise NotImplementedError("browser Popen stdin must be PIPE, DEVNULL, or None")
+        if stdout not in (None, _browser_runtime_subprocess.PIPE, _browser_runtime_subprocess.DEVNULL):
+            raise NotImplementedError("browser Popen stdout must be PIPE, DEVNULL, or None")
+        if stderr not in (None, _browser_runtime_subprocess.PIPE, _browser_runtime_subprocess.DEVNULL, _browser_runtime_subprocess.STDOUT):
+            raise NotImplementedError("browser Popen stderr must be PIPE, DEVNULL, STDOUT, or None")
+        self.args = args
+        self.returncode = None
+        self.encoding = encoding or "utf-8"
+        self.errors = errors or "strict"
+        self.text_mode = bool(text or universal_newlines or encoding is not None or errors is not None)
+        self._stdout_mode = stdout
+        self._stderr_mode = stderr
+        self._stdout = "" if self.text_mode else b""
+        self._stderr = "" if self.text_mode else b""
+        self._completion = None
+        result = _browser_runtime_process_action({
+            "type": "process-start",
+            "command": _browser_runtime_process_command(args, shell),
+            "cwd": os.path.abspath(cwd or os.getcwd()),
+            "env": {str(key): str(value) for key, value in (env or os.environ).items()},
+            "stdinPipe": stdin == _browser_runtime_subprocess.PIPE,
+            "stdoutPipe": stdout == _browser_runtime_subprocess.PIPE,
+            "stderrPipe": stderr == _browser_runtime_subprocess.PIPE,
+            "stderrToStdout": stderr == _browser_runtime_subprocess.STDOUT,
+        })
+        self.pid = int(result["childId"])
+        self.stdin = _browser_runtime_BrowserPipe(self, "stdin", True) if stdin == _browser_runtime_subprocess.PIPE else None
+        self.stdout = _browser_runtime_BrowserPipe(self, "stdout") if stdout == _browser_runtime_subprocess.PIPE else None
+        self.stderr = _browser_runtime_BrowserPipe(self, "stderr") if stderr == _browser_runtime_subprocess.PIPE else None
+
+    def _action(self, action, **values):
+        return _browser_runtime_process_action({"type": "process-action", "childId": self.pid, "action": action, **values})
+
+    def _wait_result(self, input_value=None, close_stdin=False):
+        if self._completion is not None:
+            return self._completion
+        raw_input = b""
+        if input_value is not None:
+            if self.stdin is None:
+                raise ValueError("Cannot send input after starting communication without stdin=PIPE")
+            raw_input = input_value.encode(self.encoding, self.errors) if isinstance(input_value, str) else bytes(input_value)
+        result = self._action(
+            "wait",
+            stdinBase64=_browser_runtime_base64.b64encode(raw_input).decode("ascii"),
+            closeStdin=close_stdin,
+        )
+        completed = result["result"]
+        self.returncode = int(completed["exitCode"])
+        out_text, err_text = completed["stdout"], completed["stderr"]
+        if self._stdout_mode == _browser_runtime_subprocess.PIPE:
+            self._stdout = ("" if self.text_mode else b"") if self.stdout.closed else self.stdout.read()
+            out_text = ""
+        else:
+            self._stdout = "" if self.text_mode else b""
+        if self._stderr_mode == _browser_runtime_subprocess.PIPE:
+            self._stderr = ("" if self.text_mode else b"") if self.stderr.closed else self.stderr.read()
+            err_text = ""
+        else:
+            self._stderr = "" if self.text_mode else b""
+        if self._stderr_mode == _browser_runtime_subprocess.STDOUT and self._stdout_mode != _browser_runtime_subprocess.PIPE:
+            out_text += err_text
+            err_text = ""
+        if self._stdout_mode not in (_browser_runtime_subprocess.PIPE, _browser_runtime_subprocess.DEVNULL) and out_text:
+            sys.stdout.write(out_text)
+        if self._stderr_mode not in (_browser_runtime_subprocess.PIPE, _browser_runtime_subprocess.DEVNULL, _browser_runtime_subprocess.STDOUT) and err_text:
+            sys.stderr.write(err_text)
+        self._completion = completed
+        self._action("release")
+        return completed
+
+    def poll(self):
+        if self.returncode is None:
+            value = self._action("poll").get("returncode")
+            if value is not None:
+                self.returncode = int(value)
+        return self.returncode
+
+    def wait(self, timeout=None):
+        if timeout is not None:
+            raise NotImplementedError("browser Popen wait timeout is fixed at five minutes")
+        self._wait_result()
+        return self.returncode
+
+    def communicate(self, input=None, timeout=None):
+        if timeout is not None:
+            raise NotImplementedError("browser Popen communicate timeout is fixed at five minutes")
+        self._wait_result(input, self.stdin is not None)
+        if self.stdin is not None:
+            self.stdin.closed = True
+        return (
+            self._stdout if self._stdout_mode == _browser_runtime_subprocess.PIPE else None,
+            self._stderr if self._stderr_mode == _browser_runtime_subprocess.PIPE else None,
+        )
+
+    def terminate(self):
+        if self.returncode is None:
+            self._action("terminate")
+
+    kill = terminate
+
+    def send_signal(self, sig):
+        self.terminate()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, value, traceback):
+        if self.stdin is not None and not self.stdin.closed:
+            self.stdin.close()
+        self.wait()
+
+__browser_runtime_subprocess.run = __browser_runtime_subprocess_run
+__browser_runtime_subprocess.call = __browser_runtime_subprocess_call
+__browser_runtime_subprocess.check_call = __browser_runtime_subprocess_check_call
+__browser_runtime_subprocess.Popen = __browser_runtime_BrowserPopen
+`;
+//# sourceMappingURL=subprocess-bridge.js.map

package/dist/subprocess-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"subprocess-bridge.js","sourceRoot":"","sources":["../src/subprocess-bridge.ts"],"names":[],"mappings":"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"}

package/dist/worker.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=worker.d.ts.map

package/dist/worker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"worker.d.ts","sourceRoot":"","sources":["../src/worker.ts"],"names":[],"mappings":""}