concurrent-c-node 0.2.1__tar.gz → 0.4.0__tar.gz

{concurrent_c_node-0.2.1 → concurrent_c_node-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: concurrent-c-node
-Version: 0.2.1
+Version: 0.4.0
 Summary: JavaScript and npm packages from Python over the Concurrent-C bridge: one spawned Node child per domain, host-controlled lifetime.
 License: MIT
 Project-URL: Repository, https://github.com/sreekotay/concurrent-c
@@ -119,12 +119,22 @@ And *which packages* it sees is the working directory's
 Run Python in your project, get your project's packages: `npm install`
 next to your program is the whole setup.
 
+## Publishing
+
+From the Concurrent-C repo root (packs this wheel and the npm sibling):
+
+```
+./scripts/publish_bridges.sh              # → out/pypi/concurrent_c_node-* (+ npm tgz)
+./scripts/publish_bridges.sh --publish    # bump patch, pack, twine + npm publish
+```
+
 ## Measured
 
 From `python -m cc_node.examples.bench_wire` (sources under
 [`cc_node/examples/`](https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-node/cc_node/examples/))
-on a 4-vCPU x86-64 box, node 22 / python 3.11 (dated baselines under
-`perf/baselines/` in the repo):
+on a 4-vCPU x86-64 box, node 22 / python 3.11
+([`perf/baselines/cc_node_bridge_py_20260809.txt`](https://github.com/sreekotay/concurrent-c/blob/main/perf/baselines/cc_node_bridge_py_20260809.txt);
+catalog: [`perf/baselines/README.md`](https://github.com/sreekotay/concurrent-c/blob/main/perf/baselines/README.md)):
 
 | what | result |
 |---|---|
@@ -143,6 +153,11 @@ A worked tour (builtin Node modules, chains, callbacks, thenables,
 buffers — no npm install needed):
 `python -m cc_node.examples.use_node`.
 
+Adversarial multi-child storm (fanout, callback blizzard, shm hail,
+teardown derby): [`stress/bridge/`](https://github.com/sreekotay/concurrent-c/tree/main/stress/bridge)
+— `./stress/bridge/run.sh` (`CHAOS_SCALE=full` for bigger N; latency demos
+stay in `cc_node/examples/`).
+
 And when the hot path is YOUR code rather than an npm package, skip the
 wire entirely: a page of Concurrent-C (or C) exports as a native module
 for Python and Node both — 40-90ns calls, stable-ABI artifacts.  See

{concurrent_c_node-0.2.1 → concurrent_c_node-0.4.0}/README.md

@@ -108,12 +108,22 @@ And *which packages* it sees is the working directory's
 Run Python in your project, get your project's packages: `npm install`
 next to your program is the whole setup.
 
+## Publishing
+
+From the Concurrent-C repo root (packs this wheel and the npm sibling):
+
+```
+./scripts/publish_bridges.sh              # → out/pypi/concurrent_c_node-* (+ npm tgz)
+./scripts/publish_bridges.sh --publish    # bump patch, pack, twine + npm publish
+```
+
 ## Measured
 
 From `python -m cc_node.examples.bench_wire` (sources under
 [`cc_node/examples/`](https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-node/cc_node/examples/))
-on a 4-vCPU x86-64 box, node 22 / python 3.11 (dated baselines under
-`perf/baselines/` in the repo):
+on a 4-vCPU x86-64 box, node 22 / python 3.11
+([`perf/baselines/cc_node_bridge_py_20260809.txt`](https://github.com/sreekotay/concurrent-c/blob/main/perf/baselines/cc_node_bridge_py_20260809.txt);
+catalog: [`perf/baselines/README.md`](https://github.com/sreekotay/concurrent-c/blob/main/perf/baselines/README.md)):
 
 | what | result |
 |---|---|
@@ -132,6 +142,11 @@ A worked tour (builtin Node modules, chains, callbacks, thenables,
 buffers — no npm install needed):
 `python -m cc_node.examples.use_node`.
 
+Adversarial multi-child storm (fanout, callback blizzard, shm hail,
+teardown derby): [`stress/bridge/`](https://github.com/sreekotay/concurrent-c/tree/main/stress/bridge)
+— `./stress/bridge/run.sh` (`CHAOS_SCALE=full` for bigger N; latency demos
+stay in `cc_node/examples/`).
+
 And when the hot path is YOUR code rather than an npm package, skip the
 wire entirely: a page of Concurrent-C (or C) exports as a native module
 for Python and Node both — 40-90ns calls, stable-ABI artifacts.  See

{concurrent_c_node-0.2.1 → concurrent_c_node-0.4.0}/cc_node/__init__.py

@@ -107,9 +107,11 @@ class JsHandle:
                                      " (closed)" if self._d.closed else "")
 
     def __del__(self):
+        # Never nest a sync wire op from GC into an in-flight _req — that
+        # steals the outer reply (e.g. returning a callback arg handle).
         try:
             if not self._d.closed:
-                self._d._req("release", h=self._h)
+                self._d._queue_release(self._h)
         except Exception:
             pass
 
@@ -137,6 +139,11 @@ class Bridge:
         self._cbs = {}
         self._ncb = 1
         self._shm_out = []
+        self._depth = 0
+        self._parked = {}
+        self._pending_release = []
+        self._close_pending = False
+        self._destroy_done = False
         _live.append(self)
 
     # ---- wire ----
@@ -146,6 +153,56 @@ class Bridge:
         self._p.stdin.write(line.encode("utf-8"))
         self._p.stdin.flush()
 
+    def _queue_release(self, hid):
+        self._pending_release.append(hid)
+        if self._depth == 0:
+            self._flush_releases()
+
+    def _flush_releases(self):
+        while self._pending_release and not self.closed:
+            hid = self._pending_release.pop(0)
+            try:
+                self._req("release", h=hid)
+            except Exception:
+                pass
+
+    def _flush_shm(self):
+        # The child unlinks spill files as it decodes; this sweep only
+        # matters when it died first (ENOENT is the normal case).
+        for path in self._shm_out:
+            try:
+                os.unlink(path)
+            except OSError:
+                pass
+        del self._shm_out[:]
+
+    def _take_reply(self, msg):
+        if "e" in msg:
+            raise JsError(msg["e"])
+        return self._decode_result(msg)
+
+    def _wait_reply(self, rid):
+        parked = self._parked.pop(rid, None)
+        if parked is not None:
+            return self._take_reply(parked)
+        while True:
+            line = self._p.stdout.readline()
+            if not line:
+                self.closed = True
+                raise JsError("cc-node: the node child exited")
+            msg = json.loads(line)
+            if "cb" in msg:
+                self._serve_callback(msg)
+                continue
+            mid = msg.get("id")
+            if mid == rid:
+                return self._take_reply(msg)
+            if mid is not None:
+                # Nested _req (GC release, etc.) can overtake; park by id.
+                self._parked[mid] = msg
+                continue
+            raise JsError("cc-node: protocol violation (unexpected reply)")
+
     def _req(self, op, **kw):
         if self.closed:
             raise JsError("cc-node: bridge is closed")
@@ -153,35 +210,22 @@ class Bridge:
         self._nid += 1
         kw["id"] = rid
         kw["op"] = op
+        self._depth += 1
         try:
-            self._send(kw)
-        except (BrokenPipeError, ValueError):
-            self.closed = True
-            raise JsError("cc-node: the node child exited") from None
-        try:
-            while True:
-                line = self._p.stdout.readline()
-                if not line:
-                    self.closed = True
-                    raise JsError("cc-node: the node child exited")
-                msg = json.loads(line)
-                if "cb" in msg:
-                    self._serve_callback(msg)
-                    continue
-                if msg.get("id") == rid:
-                    if "e" in msg:
-                        raise JsError(msg["e"])
-                    return self._decode_result(msg)
-                raise JsError("cc-node: protocol violation (unexpected reply)")
+            try:
+                self._send(kw)
+            except (BrokenPipeError, ValueError):
+                self.closed = True
+                raise JsError("cc-node: the node child exited") from None
+            return self._wait_reply(rid)
         finally:
-            # The child unlinks spill files as it decodes; this sweep only
-            # matters when it died first (ENOENT is the normal case).
-            for path in self._shm_out:
-                try:
-                    os.unlink(path)
-                except OSError:
-                    pass
-            del self._shm_out[:]
+            self._depth -= 1
+            if self._depth == 0:
+                self._flush_shm()
+                if self._close_pending:
+                    self._finish_destroy()
+                else:
+                    self._flush_releases()
 
     def _serve_callback(self, msg):
         fn = self._cbs.get(msg["cb"])
@@ -309,13 +353,32 @@ class Bridge:
         return self._req("stats")
 
     def destroy(self):
-        if self.closed:
+        """Idempotent teardown.  Nested destroy (e.g. from a Python
+        callback while the broker waits on cbr) defers the farewell
+        close until the in-flight wire op unwinds — nesting close into
+        the cbr slot hangs the child."""
+        if self._destroy_done:
+            return
+        if self._depth > 0:
+            self.closed = True
+            self._close_pending = True
+            return
+        self._finish_destroy()
+
+    def _finish_destroy(self):
+        if self._destroy_done:
             return
+        self._destroy_done = True
+        self._close_pending = False
+        self.closed = True
         try:
-            self._req("close")
-        except JsError:
+            if self._p.poll() is None and self._p.stdin \
+                    and not self._p.stdin.closed:
+                rid = self._nid
+                self._nid += 1
+                self._send({"id": rid, "op": "close"})
+        except Exception:
             pass
-        self.closed = True
         try:
             self._p.stdin.close()
         except Exception:
@@ -323,7 +386,10 @@ class Bridge:
         try:
             self._p.wait(timeout=5)
         except Exception:
-            self._p.kill()
+            try:
+                self._p.kill()
+            except Exception:
+                pass
         if self in _live:
             _live.remove(self)
 

{concurrent_c_node-0.2.1 → concurrent_c_node-0.4.0}/concurrent_c_node.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: concurrent-c-node
-Version: 0.2.1
+Version: 0.4.0
 Summary: JavaScript and npm packages from Python over the Concurrent-C bridge: one spawned Node child per domain, host-controlled lifetime.
 License: MIT
 Project-URL: Repository, https://github.com/sreekotay/concurrent-c
@@ -119,12 +119,22 @@ And *which packages* it sees is the working directory's
 Run Python in your project, get your project's packages: `npm install`
 next to your program is the whole setup.
 
+## Publishing
+
+From the Concurrent-C repo root (packs this wheel and the npm sibling):
+
+```
+./scripts/publish_bridges.sh              # → out/pypi/concurrent_c_node-* (+ npm tgz)
+./scripts/publish_bridges.sh --publish    # bump patch, pack, twine + npm publish
+```
+
 ## Measured
 
 From `python -m cc_node.examples.bench_wire` (sources under
 [`cc_node/examples/`](https://github.com/sreekotay/concurrent-c/blob/main/pypi/cc-node/cc_node/examples/))
-on a 4-vCPU x86-64 box, node 22 / python 3.11 (dated baselines under
-`perf/baselines/` in the repo):
+on a 4-vCPU x86-64 box, node 22 / python 3.11
+([`perf/baselines/cc_node_bridge_py_20260809.txt`](https://github.com/sreekotay/concurrent-c/blob/main/perf/baselines/cc_node_bridge_py_20260809.txt);
+catalog: [`perf/baselines/README.md`](https://github.com/sreekotay/concurrent-c/blob/main/perf/baselines/README.md)):
 
 | what | result |
 |---|---|
@@ -143,6 +153,11 @@ A worked tour (builtin Node modules, chains, callbacks, thenables,
 buffers — no npm install needed):
 `python -m cc_node.examples.use_node`.
 
+Adversarial multi-child storm (fanout, callback blizzard, shm hail,
+teardown derby): [`stress/bridge/`](https://github.com/sreekotay/concurrent-c/tree/main/stress/bridge)
+— `./stress/bridge/run.sh` (`CHAOS_SCALE=full` for bigger N; latency demos
+stay in `cc_node/examples/`).
+
 And when the hot path is YOUR code rather than an npm package, skip the
 wire entirely: a page of Concurrent-C (or C) exports as a native module
 for Python and Node both — 40-90ns calls, stable-ABI artifacts.  See

{concurrent_c_node-0.2.1 → concurrent_c_node-0.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "concurrent-c-node"
-version = "0.2.1"
+version = "0.4.0"
 description = "JavaScript and npm packages from Python over the Concurrent-C bridge: one spawned Node child per domain, host-controlled lifetime."
 readme = "README.md"
 requires-python = ">=3.8"