starpc 0.51.0 → 0.52.1

package/integration/cross-language/run.bash

@@ -1,11 +1,13 @@
 #!/bin/bash
 # Cross-language integration tests for starpc.
-# Runs all 12 server/client combinations across Go, TypeScript, Rust, and C++.
+# Runs all 21 server/client combinations across Go, TypeScript, Rust, C++, and Python.
 #
 # Usage:
-#   ./run.bash              # Run all pairs
-#   ./run.bash go:ts        # Run go-server+ts-client and ts-server+go-client
-#   ./run.bash go:ts go:rust # Run multiple pair filters
+#   ./run.bash                         # Run all pairs
+#   ./run.bash go:ts                   # Run go-server+ts-client and ts-server+go-client
+#   ./run.bash python:go               # Run python-server+go-client and go-server+python-client
+#   ./run.bash --nested ts:python      # Run nested TypeScript/Python pairs
+#   ./run.bash --nested go:ts go:python ts:python # Run nested Go/TypeScript/Python pairs
 set -eo pipefail
 
 SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
@@ -14,25 +16,79 @@ REPO_DIR="$(cd "$SCRIPT_DIR/../.." && pwd)"
 # Fixes errors with the generated esm using require()
 ESM_BANNER='import{fileURLToPath}from"node:url";import{dirname}from"node:path";import{createRequire as topLevelCreateRequire}from"node:module";const require=topLevelCreateRequire(import.meta.url);const __filename=fileURLToPath(import.meta.url);const __dirname=dirname(__filename);'
 
-FILTERS=("$@")
+NESTED=false
+FILTERS=()
+for arg in "$@"; do
+    if [ "$arg" = "--nested" ]; then
+        NESTED=true
+    else
+        FILTERS+=("$arg")
+    fi
+done
+
+needs_language() {
+    local language="$1"
+    if [ ${#FILTERS[@]} -eq 0 ]; then
+        return 0
+    fi
+    for filter in "${FILTERS[@]}"; do
+        if [[ ":${filter}:" == *":${language}:"* ]]; then
+            return 0
+        fi
+    done
+    return 1
+}
 
 PASSED=0
 FAILED=0
 ERRORS=""
 
+SERVER_PID=""
 SERVER_LOG=""
+SERVER_EXIT_STATUS=0
+CLIENT_PID=""
+CLIENT_OUT=""
 
-# should_run checks if a test name matches the active filters.
+cleanup() {
+    if [ -n "${CLIENT_PID:-}" ]; then
+        kill "$CLIENT_PID" 2>/dev/null || true
+        wait "$CLIENT_PID" 2>/dev/null || true
+        CLIENT_PID=""
+    fi
+    if [ -n "${SERVER_PID:-}" ]; then
+        kill "$SERVER_PID" 2>/dev/null || true
+        wait "$SERVER_PID" 2>/dev/null || true
+        SERVER_PID=""
+    fi
+    if [ -n "${SERVER_LOG:-}" ]; then
+        rm -f "$SERVER_LOG"
+        SERVER_LOG=""
+    fi
+    if [ -n "${CLIENT_OUT:-}" ]; then
+        rm -f "$CLIENT_OUT"
+        CLIENT_OUT=""
+    fi
+}
+
+trap cleanup EXIT
+trap 'exit 130' INT
+trap 'exit 143' TERM
+
+# should_run checks if a server/client pair matches the active filters.
 # Returns 0 (true) if the test should run, 1 (false) otherwise.
 should_run() {
     local test_name="$1"
     if [ ${#FILTERS[@]} -eq 0 ]; then
         return 0
     fi
+    local server_language="${test_name%%-server*}"
+    local client_language="${test_name#*+ }"
+    client_language="${client_language%%-client*}"
     for filter in "${FILTERS[@]}"; do
         local lang1="${filter%%:*}"
         local lang2="${filter##*:}"
-        if [[ "$test_name" == *"${lang1}-"* && "$test_name" == *"${lang2}-"* ]]; then
+        if { [ "$server_language" = "$lang1" ] && [ "$client_language" = "$lang2" ]; } ||
+            { [ "$server_language" = "$lang2" ] && [ "$client_language" = "$lang1" ]; }; then
             return 0
         fi
     done
@@ -42,32 +98,39 @@ should_run() {
 # Build all binaries.
 echo "=== Building all integration binaries ==="
 
-echo "Building Go server/client..."
-go build -o "$SCRIPT_DIR/go-server/go-server" "$SCRIPT_DIR/go-server/"
-go build -o "$SCRIPT_DIR/go-client/go-client" "$SCRIPT_DIR/go-client/"
-
-echo "Building TypeScript server/client..."
-"$REPO_DIR/node_modules/.bin/esbuild" "$SCRIPT_DIR/ts-server.ts" \
-    --bundle --sourcemap --platform=node --format=esm \
-    --banner:js="$ESM_BANNER" \
-    --outfile="$SCRIPT_DIR/ts-server.mjs"
-"$REPO_DIR/node_modules/.bin/esbuild" "$SCRIPT_DIR/ts-client.ts" \
-    --bundle --sourcemap --platform=node --format=esm \
-    --banner:js="$ESM_BANNER" \
-    --outfile="$SCRIPT_DIR/ts-client.mjs"
-
-echo "Building Rust server/client..."
-cargo build --release -p echo-example --bin integration-server --bin integration-client
-
-echo "Vendoring Go dependencies (needed for C++ build)..."
-go mod vendor
-
-echo "Building C++ server/client..."
-mkdir -p "$REPO_DIR/build"
-pushd "$REPO_DIR/build" > /dev/null
-cmake "$REPO_DIR" -DCMAKE_BUILD_TYPE=Release > /dev/null 2>&1
-cmake --build . --target cpp-integration-server cpp-integration-client --parallel > /dev/null 2>&1
-popd > /dev/null
+if needs_language go; then
+    echo "Building Go server/client..."
+    go build -o "$SCRIPT_DIR/go-server/go-server" "$SCRIPT_DIR/go-server/"
+    go build -o "$SCRIPT_DIR/go-client/go-client" "$SCRIPT_DIR/go-client/"
+fi
+
+if needs_language ts; then
+    echo "Building TypeScript server/client..."
+    "$REPO_DIR/node_modules/.bin/esbuild" "$SCRIPT_DIR/ts-server.ts" \
+        --bundle --sourcemap --platform=node --format=esm \
+        --banner:js="$ESM_BANNER" \
+        --outfile="$SCRIPT_DIR/ts-server.mjs"
+    "$REPO_DIR/node_modules/.bin/esbuild" "$SCRIPT_DIR/ts-client.ts" \
+        --bundle --sourcemap --platform=node --format=esm \
+        --banner:js="$ESM_BANNER" \
+        --outfile="$SCRIPT_DIR/ts-client.mjs"
+fi
+
+if needs_language rust; then
+    echo "Building Rust server/client..."
+    cargo build --release -p echo-example --bin integration-server --bin integration-client
+fi
+
+if needs_language cpp; then
+    echo "Vendoring Go dependencies (needed for C++ build)..."
+    go mod vendor
+    echo "Building C++ server/client..."
+    mkdir -p "$REPO_DIR/build"
+    pushd "$REPO_DIR/build" > /dev/null
+    cmake "$REPO_DIR" -DCMAKE_BUILD_TYPE=Release > /dev/null 2>&1
+    cmake --build . --target cpp-integration-server cpp-integration-client --parallel > /dev/null 2>&1
+    popd > /dev/null
+fi
 
 # Binary paths.
 GO_SERVER="$SCRIPT_DIR/go-server/go-server"
@@ -78,6 +141,7 @@ RUST_SERVER="$REPO_DIR/target/release/integration-server"
 RUST_CLIENT="$REPO_DIR/target/release/integration-client"
 CPP_SERVER="$REPO_DIR/build/cpp-integration-server"
 CPP_CLIENT="$REPO_DIR/build/cpp-integration-client"
+PYTHON=(uv run --project "$REPO_DIR" python)
 
 start_server() {
     SERVER_LOG=$(mktemp)
@@ -95,8 +159,9 @@ start_server() {
     SERVER_ADDR=$(grep 'LISTENING' "$SERVER_LOG" 2>/dev/null | awk '{print $2}')
     if [ -z "$SERVER_ADDR" ]; then
         echo "FAILED: server did not start"
-        kill $SERVER_PID 2>/dev/null || true
-        wait $SERVER_PID 2>/dev/null || true
+        kill "$SERVER_PID" 2>/dev/null || true
+        wait "$SERVER_PID" 2>/dev/null || true
+        SERVER_PID=""
         rm -f "$SERVER_LOG"
         SERVER_LOG=""
         return 1
@@ -105,8 +170,36 @@ start_server() {
 }
 
 stop_server() {
-    kill $SERVER_PID 2>/dev/null || true
-    wait $SERVER_PID 2>/dev/null || true
+    kill "$SERVER_PID" 2>/dev/null || true
+    if wait "$SERVER_PID" 2>/dev/null; then
+        SERVER_EXIT_STATUS=0
+    else
+        SERVER_EXIT_STATUS=$?
+    fi
+    SERVER_PID=""
+}
+
+python_server_passed() {
+    local status="$1"
+    local log="$2"
+    [ "$status" -eq 0 ] && grep -qx "NESTED_CLEAN" "$log"
+}
+
+verify_python_server_guard() {
+    local log
+    log="$(mktemp)"
+    printf '%s\n' "NESTED_CLEAN" >"$log"
+    if python_server_passed 1 "$log"; then
+        rm -f "$log"
+        echo "runner guard accepted a nonzero Python server" >&2
+        return 1
+    fi
+    if ! python_server_passed 0 "$log"; then
+        rm -f "$log"
+        echo "runner guard rejected a clean Python server" >&2
+        return 1
+    fi
+    rm -f "$log"
 }
 
 # run_pair <test_name> <server_args...> -- <client_args...>
@@ -142,13 +235,25 @@ run_pair() {
         return
     fi
 
-    local client_out
-    client_out=$(mktemp)
+    CLIENT_OUT=$(mktemp)
     local client_ok=false
-    if "${cli_args[@]}" "$SERVER_ADDR" > "$client_out" 2>&1; then
+    timeout 60 "${cli_args[@]}" "$SERVER_ADDR" > "$CLIENT_OUT" 2>&1 &
+    CLIENT_PID=$!
+    if wait "$CLIENT_PID"; then
         client_ok=true
     fi
+    CLIENT_PID=""
     stop_server
+    if $NESTED && [[ "$test_name" == python-server* ]]; then
+        if ! verify_python_server_guard; then
+            client_ok=false
+            echo "    Python server result guard regression failed"
+        elif ! python_server_passed "$SERVER_EXIT_STATUS" "$SERVER_LOG"; then
+            client_ok=false
+            echo "    Python server failed nested shutdown (status $SERVER_EXIT_STATUS):"
+            sed 's/^/    /' "$SERVER_LOG"
+        fi
+    fi
 
     if $client_ok; then
         echo "PASSED"
@@ -158,9 +263,10 @@ run_pair() {
         FAILED=$((FAILED + 1))
         ERRORS="${ERRORS}\n  ${test_name}"
         echo "    client output:"
-        sed 's/^/    /' "$client_out"
+        sed 's/^/    /' "$CLIENT_OUT"
     fi
-    rm -f "$client_out" "$SERVER_LOG"
+    rm -f "$CLIENT_OUT" "$SERVER_LOG"
+    CLIENT_OUT=""
     SERVER_LOG=""
 }
 
@@ -168,29 +274,48 @@ echo ""
 echo "=== Running cross-language integration tests ==="
 echo ""
 
-# Go server combinations
-run_pair "go-server + go-client"   "$GO_SERVER" -- "$GO_CLIENT"
-run_pair "go-server + rust-client" "$GO_SERVER" -- "$RUST_CLIENT"
-run_pair "go-server + ts-client"   "$GO_SERVER" -- node "$TS_CLIENT"
-run_pair "go-server + cpp-client"  "$GO_SERVER" -- "$CPP_CLIENT"
-
-# Rust server combinations
-run_pair "rust-server + go-client"   "$RUST_SERVER" -- "$GO_CLIENT"
-run_pair "rust-server + rust-client" "$RUST_SERVER" -- "$RUST_CLIENT"
-run_pair "rust-server + ts-client"   "$RUST_SERVER" -- node "$TS_CLIENT"
-run_pair "rust-server + cpp-client"  "$RUST_SERVER" -- "$CPP_CLIENT"
-
-# TypeScript server combinations
-run_pair "ts-server + go-client"   node "$TS_SERVER" -- "$GO_CLIENT"
-run_pair "ts-server + rust-client" node "$TS_SERVER" -- "$RUST_CLIENT"
-run_pair "ts-server + ts-client"   node "$TS_SERVER" -- node "$TS_CLIENT"
-run_pair "ts-server + cpp-client"  node "$TS_SERVER" -- "$CPP_CLIENT"
-
-# C++ server combinations
-run_pair "cpp-server + go-client"   "$CPP_SERVER" -- "$GO_CLIENT"
-run_pair "cpp-server + rust-client" "$CPP_SERVER" -- "$RUST_CLIENT"
-run_pair "cpp-server + ts-client"   "$CPP_SERVER" -- node "$TS_CLIENT"
-run_pair "cpp-server + cpp-client"  "$CPP_SERVER" -- "$CPP_CLIENT"
+if $NESTED; then
+    # Nested streams have maintained Go, TypeScript, and Python endpoints.
+    run_pair "go-server + ts-client" "$GO_SERVER" -- node "$TS_CLIENT" --nested
+    run_pair "go-server + python-client" "$GO_SERVER" -- "${PYTHON[@]}" "$SCRIPT_DIR/python-client.py" --nested
+
+    run_pair "ts-server + go-client" node "$TS_SERVER" -- "$GO_CLIENT" --nested
+    run_pair "ts-server + python-client" node "$TS_SERVER" -- "${PYTHON[@]}" "$SCRIPT_DIR/python-client.py" --nested
+
+    run_pair "python-server + go-client" "${PYTHON[@]}" "$SCRIPT_DIR/python-server.py" -- "$GO_CLIENT" --nested-release
+    run_pair "python-server + ts-client" "${PYTHON[@]}" "$SCRIPT_DIR/python-server.py" -- node "$TS_CLIENT" --nested-release
+else
+    # Go server combinations
+    run_pair "go-server + go-client"   "$GO_SERVER" -- "$GO_CLIENT"
+    run_pair "go-server + rust-client" "$GO_SERVER" -- "$RUST_CLIENT"
+    run_pair "go-server + ts-client"   "$GO_SERVER" -- node "$TS_CLIENT"
+    run_pair "go-server + cpp-client"    "$GO_SERVER" -- "$CPP_CLIENT"
+    run_pair "go-server + python-client" "$GO_SERVER" -- "${PYTHON[@]}" "$SCRIPT_DIR/python-client.py"
+
+    # Rust server combinations
+    run_pair "rust-server + go-client"   "$RUST_SERVER" -- "$GO_CLIENT"
+    run_pair "rust-server + rust-client" "$RUST_SERVER" -- "$RUST_CLIENT"
+    run_pair "rust-server + ts-client"   "$RUST_SERVER" -- node "$TS_CLIENT"
+    run_pair "rust-server + cpp-client"  "$RUST_SERVER" -- "$CPP_CLIENT"
+
+    # TypeScript server combinations
+    run_pair "ts-server + go-client"   node "$TS_SERVER" -- "$GO_CLIENT"
+    run_pair "ts-server + rust-client" node "$TS_SERVER" -- "$RUST_CLIENT"
+    run_pair "ts-server + ts-client"   node "$TS_SERVER" -- node "$TS_CLIENT"
+    run_pair "ts-server + cpp-client"    node "$TS_SERVER" -- "$CPP_CLIENT"
+    run_pair "ts-server + python-client" node "$TS_SERVER" -- "${PYTHON[@]}" "$SCRIPT_DIR/python-client.py"
+
+    # Python server combinations
+    run_pair "python-server + go-client"     "${PYTHON[@]}" "$SCRIPT_DIR/python-server.py" -- "$GO_CLIENT"
+    run_pair "python-server + ts-client"     "${PYTHON[@]}" "$SCRIPT_DIR/python-server.py" -- node "$TS_CLIENT" lifecycle
+    run_pair "python-server + python-client" "${PYTHON[@]}" "$SCRIPT_DIR/python-server.py" -- "${PYTHON[@]}" "$SCRIPT_DIR/python-client.py"
+
+    # C++ server combinations
+    run_pair "cpp-server + go-client"   "$CPP_SERVER" -- "$GO_CLIENT"
+    run_pair "cpp-server + rust-client" "$CPP_SERVER" -- "$RUST_CLIENT"
+    run_pair "cpp-server + ts-client"   "$CPP_SERVER" -- node "$TS_CLIENT"
+    run_pair "cpp-server + cpp-client"  "$CPP_SERVER" -- "$CPP_CLIENT"
+fi
 
 echo ""
 echo "=== Results: ${PASSED} passed, ${FAILED} failed ==="

package/integration/cross-language/tcp-packet-stream.test.ts

@@ -0,0 +1,154 @@
+import net from 'net'
+import { afterEach, describe, expect, it, vi } from 'vitest'
+import { pushable } from 'it-pushable'
+
+import { tcpSocketToPacketStream } from './tcp-packet-stream.js'
+
+const sockets: net.Socket[] = []
+const servers: net.Server[] = []
+
+afterEach(() => {
+  for (const socket of sockets) socket.destroy()
+  for (const server of servers) server.close()
+  sockets.length = 0
+  servers.length = 0
+})
+
+describe('TCP PacketStream lifecycle', () => {
+  it('settles a blocked source when the peer ends cleanly', async () => {
+    const { local, peer } = await connectSockets()
+    const stream = tcpSocketToPacketStream(local)
+    const pending = stream.source.next()
+
+    peer.end()
+
+    await expect(settleBeforeTimeout(pending)).resolves.toEqual({
+      done: true,
+      value: undefined,
+    })
+  })
+
+  it('reports a truncated frame when the peer ends', async () => {
+    const { local, peer } = await connectSockets()
+    const stream = tcpSocketToPacketStream(local)
+    const pending = stream.source.next()
+
+    peer.end(Buffer.from([4, 0, 0, 0, 10, 1]))
+
+    await expect(settleBeforeTimeout(pending)).rejects.toThrow(
+      'truncated packet frame',
+    )
+  })
+
+  it('rejects a blocked source with the abort error', async () => {
+    const { local } = await connectSockets()
+    const stream = tcpSocketToPacketStream(local)
+    const pending = stream.source.next()
+    const error = new Error('stopped')
+
+    stream.abort(error)
+
+    await expect(settleBeforeTimeout(pending)).rejects.toBe(error)
+  })
+
+  it('settles a blocked sink when closed', async () => {
+    const { local } = await connectSockets()
+    const stream = tcpSocketToPacketStream(local)
+    const input = pushable<Uint8Array>({ objectMode: true })
+    const pending = stream.sink(input)
+
+    await stream.close()
+
+    await expect(pending).resolves.toBeUndefined()
+  })
+
+  it('settles an in-flight socket write when closed', async () => {
+    const { local } = await connectSockets()
+    const stream = tcpSocketToPacketStream(local)
+    const input = pushable<Uint8Array>({ objectMode: true })
+    const writeStarted = Promise.withResolvers<void>()
+    vi.spyOn(local, 'write').mockImplementation(((
+      _data: Uint8Array,
+      _callback: (error?: Error) => void,
+    ) => {
+      writeStarted.resolve()
+      return true
+    }) as typeof local.write)
+    input.push(new Uint8Array([1]))
+    const pending = stream.sink(input)
+    await writeStarted.promise
+
+    await stream.close()
+
+    await expect(settleBeforeTimeout(pending)).resolves.toBeUndefined()
+  })
+
+  it('rejects a blocked sink with the abort error', async () => {
+    const { local } = await connectSockets()
+    const stream = tcpSocketToPacketStream(local)
+    const input = pushable<Uint8Array>({ objectMode: true })
+    const pending = stream.sink(input)
+    const error = new Error('stopped')
+
+    stream.abort(error)
+
+    await expect(pending).rejects.toBe(error)
+  })
+
+  it('does not write ready input after close', async () => {
+    const { local, peer } = await connectSockets()
+    const stream = tcpSocketToPacketStream(local)
+    const input = pushable<Uint8Array>({ objectMode: true })
+    const received: Buffer[] = []
+    peer.on('data', (data) => {
+      if (typeof data !== 'string') received.push(data)
+    })
+    input.push(new Uint8Array([1]))
+
+    const pending = stream.sink(input)
+    await stream.close()
+    await pending
+    await new Promise<void>((resolve) => peer.once('close', () => resolve()))
+
+    expect(received).toEqual([])
+  })
+})
+
+async function connectSockets(): Promise<{
+  local: net.Socket
+  peer: net.Socket
+}> {
+  const accepted = Promise.withResolvers<net.Socket>()
+  const server = net.createServer((socket) => accepted.resolve(socket))
+  servers.push(server)
+  await new Promise<void>((resolve, reject) => {
+    server.once('error', reject)
+    server.listen(0, '127.0.0.1', resolve)
+  })
+  const address = server.address() as net.AddressInfo
+  const local = net.connect(address.port, address.address)
+  await new Promise<void>((resolve, reject) => {
+    local.once('connect', resolve)
+    local.once('error', reject)
+  })
+  const peer = await accepted.promise
+  sockets.push(local, peer)
+  return { local, peer }
+}
+
+async function settleBeforeTimeout<T>(promise: Promise<T>): Promise<T> {
+  let timeout: ReturnType<typeof setTimeout> | undefined
+  try {
+    return await Promise.race([
+      promise,
+      new Promise<never>((_resolve, reject) => {
+        timeout = setTimeout(
+          () => reject(new Error('source stayed blocked')),
+          500,
+        )
+      }),
+    ])
+  } finally {
+    clearTimeout(timeout)
+  }
+}

package/integration/cross-language/tcp-packet-stream.ts

@@ -0,0 +1,121 @@
+import net from 'net'
+import { pipe } from 'it-pipe'
+import { pushable } from 'it-pushable'
+import type { Source } from 'it-stream-types'
+
+import { combineUint8ArrayListTransform } from '../../srpc/array-list.js'
+import {
+  parseLengthPrefixTransform,
+  prependLengthPrefixTransform,
+} from '../../srpc/packet.js'
+import type { PacketStream } from '../../srpc/stream.js'
+import {
+  closeIterator,
+  sourceIterator,
+  TerminationGate,
+} from '../../srpc/termination.js'
+
+// tcpSocketToPacketStream wraps a Node.js TCP socket into a PacketStream.
+export function tcpSocketToPacketStream(socket: net.Socket): PacketStream {
+  const sourceTermination = new TerminationGate()
+  const sinkTermination = new TerminationGate()
+  const bytes = pushable<Uint8Array>({ objectMode: true })
+  let bytesEnded = false
+
+  const endBytes = (error?: Error) => {
+    if (bytesEnded) return
+    bytesEnded = true
+    bytes.end(error)
+  }
+  const terminate = (error?: Error): boolean => {
+    const first = sourceTermination.terminate(error)
+    sinkTermination.terminate(error)
+    endBytes(error)
+    return first
+  }
+
+  socket.on('data', (data: Buffer) => {
+    if (!bytesEnded) bytes.push(new Uint8Array(data))
+  })
+  socket.on('end', () => endBytes())
+  socket.on('error', (error) => terminate(error))
+  socket.on('close', () => {
+    endBytes()
+    sinkTermination.terminate()
+  })
+
+  const close = async (): Promise<void> => {
+    if (terminate()) socket.destroy()
+  }
+  const abort = (error: Error): void => {
+    if (terminate(error)) socket.destroy(error)
+  }
+
+  return {
+    close,
+    abort,
+    source: (async function* () {
+      const packets = pipe(
+        bytes,
+        parseLengthPrefixTransform(),
+        combineUint8ArrayListTransform(),
+      )[Symbol.asyncIterator]()
+      try {
+        while (true) {
+          const next = await sourceTermination.next(packets)
+          if ('terminated' in next) {
+            if (next.error) throw next.error
+            return
+          }
+          if ('error' in next) throw next.error
+          if (next.result.done) return
+          yield next.result.value
+        }
+      } finally {
+        closeIterator(packets)
+      }
+    })(),
+    sink: async (source: Source<Uint8Array>): Promise<void> => {
+      const iterator = sourceIterator(
+        pipe(source, prependLengthPrefixTransform()),
+      )
+      try {
+        while (true) {
+          const next = await sinkTermination.next(iterator)
+          if ('terminated' in next) {
+            if (next.error) throw next.error
+            return
+          }
+          if ('error' in next) throw next.error
+          if (next.result.done) {
+            socket.end()
+            return
+          }
+          const data =
+            next.result.value instanceof Uint8Array
+              ? next.result.value
+              : next.result.value.subarray()
+          const written = await sinkTermination.wait(
+            new Promise<void>((resolve, reject) => {
+              socket.write(data, (error) => {
+                if (error) reject(error)
+                else resolve()
+              })
+            }),
+          )
+          if ('terminated' in written) {
+            if (written.error) throw written.error
+            return
+          }
+          if ('error' in written) throw written.error
+        }
+      } catch (err) {
+        const error = err instanceof Error ? err : new Error(String(err))
+        abort(error)
+        throw error
+      } finally {
+        closeIterator(iterator)
+      }
+    },
+  }
+}