runmat 0.3.5 → 0.4.0

package/dist/generated/builtins/tan.js

@@ -0,0 +1,200 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "tan",
+    "category": "math/trigonometry",
+    "keywords": [
+        "tan",
+        "tangent",
+        "trigonometry",
+        "radians",
+        "gpu",
+        "like"
+    ],
+    "summary": "Element-wise tangent for scalars, vectors, matrices, complex numbers, or character arrays with MATLAB broadcasting and GPU acceleration.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Prefers provider unary_tan hooks; falls back to the host path when the hook is unavailable."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::trigonometry::tan::tests",
+        "integration": "builtins::math::trigonometry::tan::tests::tan_gpu_provider_roundtrip"
+    },
+    "description": "`y = tan(x)` computes the tangent of every element in `x`, interpreting each input value in radians.",
+    "behaviors": [
+        "Operates on scalars, vectors, matrices, and N-D tensors while respecting MATLAB's implicit-expansion (broadcasting) rules.",
+        "Logical and integer inputs are promoted to double precision (`true → 1.0`, `false → 0.0`) before the tangent is applied so downstream arithmetic mirrors MATLAB.",
+        "Character arrays operate on their Unicode code points and return dense double arrays of identical shape.",
+        "Complex inputs follow MATLAB’s analytic extension `tan(a + bi) = sin(2a)/(cos(2a) + cosh(2b)) + i·sinh(2b)/(cos(2a) + cosh(2b))`, propagating `NaN`/`Inf` components independently.",
+        "Appending `'like', prototype` mirrors the prototype’s class and residency for real numeric prototypes; complex prototypes currently raise a descriptive error so you can fall back to the default output rules.",
+        "`tan` accepts both host tensors and `gpuArray` inputs. GPU residency is preserved whenever the active provider exposes the `unary_tan` kernel or a fused elementwise implementation.",
+        "Strings and string arrays are rejected to match MATLAB’s numeric-only contract for the trigonometric family.",
+        "Empty inputs, singleton dimensions, and already-reduced shapes pass through unchanged to avoid unnecessary allocations."
+    ],
+    "examples": [
+        {
+            "description": "Getting the tangent of 45 degrees expressed in radians",
+            "input": "y = tan(pi/4)",
+            "output": "y = 1"
+        },
+        {
+            "description": "Applying tangent to a vector of sample angles",
+            "input": "theta = linspace(-pi/2 + 0.1, pi/2 - 0.1, 5);\nwave = tan(theta)",
+            "output": "wave = [-9.9666   -0.9047         0    0.9047    9.9666]"
+        },
+        {
+            "description": "Evaluating the tangent of a matrix on the GPU",
+            "input": "G = gpuArray([0 pi/6; pi/4 pi/3]);\nT = tan(G);\nresult = gather(T)",
+            "output": "result =\n         0    0.5774\n    1.0000    1.7321"
+        },
+        {
+            "description": "Computing the tangent of complex angles",
+            "input": "z = 1 + 0.5i;\ntz = tan(z)",
+            "output": "tz = 0.9654 + 0.2718i"
+        },
+        {
+            "description": "Using tangent to linearise small-angle approximations",
+            "input": "eps = [-1e-6 0 1e-6];\napprox = tan(eps)",
+            "output": "approx = [-1.0000e-06         0    1.0000e-06]"
+        },
+        {
+            "description": "Converting degrees to radians before using `tan`",
+            "input": "angles_in_deg = [0 30 60 89];\nradians = deg2rad(angles_in_deg);\nresult = tan(radians)",
+            "output": "result = [0    0.5774    1.7321   57.2899]"
+        },
+        {
+            "description": "Keeping the result on the GPU with `'like'`",
+            "input": "proto = gpuArray.zeros(1, 1, 'single');\nangles = gpuArray([0 pi/6 pi/4]);\ndeviceResult = tan(angles, 'like', proto);\ngathered = gather(deviceResult)",
+            "output": "gathered =\n  1x3 single\n         0    0.5774    1.0000"
+        },
+        {
+            "description": "Inspecting character codes with tangent",
+            "input": "codes = tan('ABC')",
+            "output": "codes =\n   -1.4700    0.0266    1.6523"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use the `tan` function?",
+            "answer": "Use `tan` whenever you need the tangent of angles expressed in radians—whether you are modelling waves, evaluating transfer functions, or analysing geometric relationships element-wise across large arrays."
+        },
+        {
+            "question": "What happens near odd multiples of `pi/2`?",
+            "answer": "Values that approach `(2k + 1)·pi/2` grow rapidly toward ±Inf, just like in MATLAB. RunMat preserves IEEE semantics, so you may observe very large magnitudes or `Inf`/-`Inf` where poles occur."
+        },
+        {
+            "question": "Does `tan` support complex numbers?",
+            "answer": "Yes. RunMat evaluates the analytic extension described above, handling real and imaginary components independently and propagating `NaN`/`Inf` values exactly as MATLAB does."
+        },
+        {
+            "question": "Can I keep the result on the GPU?",
+            "answer": "Yes. When a provider implements `unary_tan`, the result never leaves the device. If a fallback is required, RunMat gathers to the host, computes the result, and reapplies residency requests—including `'like'` outputs—before handing the value back."
+        },
+        {
+            "question": "How do I control units?",
+            "answer": "`tan` operates in radians. Convert degrees with `deg2rad` (or multiply by `pi/180`) before calling `tan`, or use MATLAB’s degree-specific builtins (`tand`, etc.) when available."
+        },
+        {
+            "question": "Does `tan` change the input type?",
+            "answer": "By default results are double precision. Passing `'like', prototype` preserves the prototype’s real numeric type (host or GPU). Complex prototypes are currently unsupported and raise a clear error."
+        },
+        {
+            "question": "Are logical arrays supported?",
+            "answer": "Yes. Logical arrays are promoted to `0.0`/`1.0` doubles before evaluation so downstream workflows remain compatible with MATLAB semantics."
+        },
+        {
+            "question": "Can I fuse `tan` with other elementwise operations?",
+            "answer": "Definitely. The fusion planner emits WGSL `tan` calls for GPU execution, and providers may specialise fused kernels for additional throughput."
+        }
+    ],
+    "links": [
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "cos",
+            "url": "./cos"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "acos",
+            "url": "./acos"
+        },
+        {
+            "label": "acosh",
+            "url": "./acosh"
+        },
+        {
+            "label": "asin",
+            "url": "./asin"
+        },
+        {
+            "label": "asinh",
+            "url": "./asinh"
+        },
+        {
+            "label": "atan",
+            "url": "./atan"
+        },
+        {
+            "label": "atan2",
+            "url": "./atan2"
+        },
+        {
+            "label": "atanh",
+            "url": "./atanh"
+        },
+        {
+            "label": "cosh",
+            "url": "./cosh"
+        },
+        {
+            "label": "sinh",
+            "url": "./sinh"
+        },
+        {
+            "label": "tanh",
+            "url": "./tanh"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/trigonometry/tan.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/trigonometry/tan.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. The fusion planner keeps tensors on the GPU whenever the active provider exposes the necessary kernels (such as `unary_tan`). Manual `gpuArray` / `gather` calls remain supported for MATLAB compatibility or when you need to pin residency before interacting with external code.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active and the selected provider implements `unary_tan`, the operation executes entirely on the GPU, keeping inputs and outputs resident in device memory.",
+        "If the provider declines the request, RunMat gathers the data to the host, evaluates the tangent with the reference implementation, and reapplies any residency requests (including `'like'` prototypes that expect GPU outputs) before returning.",
+        "Fusion planning groups neighbouring elementwise operators, so even when a fallback occurs, subsequent GPU-capable steps can resume on-device without redundant transfers."
+    ],
+    "key": "tan",
+    "slug": "tan",
+    "categoryPath": [
+        "math",
+        "trigonometry"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=tan.js.map

package/dist/generated/builtins/tan.js.map

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

package/dist/generated/builtins/tanh.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinDoc } from "../../builtins.js";
+declare const builtinDoc: BuiltinDoc;
+export default builtinDoc;
+//# sourceMappingURL=tanh.d.ts.map

package/dist/generated/builtins/tanh.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tanh.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/tanh.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,UA4LjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/tanh.js

@@ -0,0 +1,193 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "tanh",
+    "category": "math/trigonometry",
+    "keywords": [
+        "tanh",
+        "hyperbolic tangent",
+        "trigonometry",
+        "gpu",
+        "elementwise"
+    ],
+    "summary": "Hyperbolic tangent of scalars, vectors, matrices, complex numbers, or character arrays with MATLAB broadcasting and GPU acceleration.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Prefers provider unary_tanh hooks; falls back to the host path when a provider is unavailable or cannot service the operand type."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::trigonometry::tanh::tests",
+        "integration": "builtins::math::trigonometry::tanh::tests::tanh_gpu_provider_roundtrip"
+    },
+    "description": "`y = tanh(x)` evaluates the hyperbolic tangent of each element in `x`, preserving MATLAB's column-major layout and broadcasting rules across scalars, arrays, and tensors.",
+    "behaviors": [
+        "Operates on scalars, vectors, matrices, and N-D tensors with MATLAB-compatible implicit expansion.",
+        "Logical and integer inputs are promoted to double precision before evaluation so downstream arithmetic keeps MATLAB's numeric semantics.",
+        "Complex values follow the analytic extension `tanh(a + bi) = sinh(a + bi) / cosh(a + bi)`, propagating `NaN`/`Inf` components component-wise.",
+        "Character arrays are interpreted through their Unicode code points and return dense double arrays that mirror MATLAB's behavior.",
+        "Inputs that already live on the GPU stay resident when the provider implements `unary_tanh`; otherwise RunMat gathers to the host, computes, and reapplies residency hints for later operations.",
+        "Empty inputs and singleton dimensions are preserved without introducing extraneous allocations.",
+        "String and string-array arguments raise descriptive errors to match MATLAB's numeric-only contract for the hyperbolic family."
+    ],
+    "examples": [
+        {
+            "description": "Hyperbolic tangent of a real scalar",
+            "input": "y = tanh(1)",
+            "output": "y = 0.7616"
+        },
+        {
+            "description": "Applying `tanh` to a symmetric vector",
+            "input": "x = linspace(-2, 2, 5);\ny = tanh(x)",
+            "output": "y = [-0.9640  -0.7616         0   0.7616   0.9640]"
+        },
+        {
+            "description": "Evaluating `tanh` on a matrix in GPU memory",
+            "input": "G = gpuArray([0    0.5; 1.0  1.5]);\nresult_gpu = tanh(G);\nresult = gather(result_gpu)",
+            "output": "result =\n         0    0.4621\n    0.7616    0.9051"
+        },
+        {
+            "description": "Computing `tanh` for complex angles",
+            "input": "z = 0.5 + 1.0i;\nw = tanh(z)",
+            "output": "w = 1.0428 + 0.8069i"
+        },
+        {
+            "description": "Converting character codes via `tanh`",
+            "input": "c = tanh('ABC')",
+            "output": "c = [1.0000  1.0000  1.0000]"
+        },
+        {
+            "description": "Preserving empty array shapes",
+            "input": "E = zeros(0, 3);\nout = tanh(E)",
+            "output": "out = zeros(0, 3)"
+        },
+        {
+            "description": "Stabilising activation functions",
+            "input": "inputs = [-3 -1 0 1 3];\nactivations = tanh(inputs / 2)",
+            "output": "activations = [-0.9051  -0.4621         0   0.4621   0.9051]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I reach for `tanh`?",
+            "answer": "Use `tanh` for hyperbolic tangent evaluations—common in signal processing, numerical solvers, and neural-network activations thanks to its bounded output."
+        },
+        {
+            "question": "Does `tanh` support complex numbers?",
+            "answer": "Yes. RunMat mirrors MATLAB by evaluating `tanh(z) = sinh(z) / cosh(z)` for complex `z`, producing correct real and imaginary parts while propagating `NaN`/`Inf` values."
+        },
+        {
+            "question": "How does the GPU fallback work?",
+            "answer": "If the provider lacks `unary_tanh`, RunMat gathers the tensor to host memory, computes the result, and reapplies residency choices so downstream GPU consumers still see device-backed tensors when appropriate."
+        },
+        {
+            "question": "Can `tanh` appear in fused GPU kernels?",
+            "answer": "Absolutely. The fusion planner emits WGSL kernels that inline `tanh`, and providers can supply custom fused pipelines for even higher performance."
+        },
+        {
+            "question": "How does `tanh` treat logical arrays?",
+            "answer": "Logical arrays are promoted to `0.0` or `1.0` doubles before evaluation, matching MATLAB's behavior for the hyperbolic family."
+        },
+        {
+            "question": "What happens with empty or singleton dimensions?",
+            "answer": "Shapes are preserved. Empty inputs return empty outputs, and singleton dimensions remain intact so downstream broadcasting behaves as expected."
+        },
+        {
+            "question": "Do I need to worry about numerical overflow?",
+            "answer": "`tanh` saturates towards ±1 for large-magnitude real inputs, providing stable results. Complex poles can still yield infinities, mirroring MATLAB."
+        },
+        {
+            "question": "Can I differentiate `tanh` in RunMat?",
+            "answer": "Yes. The autograd infrastructure recognises `tanh` as a primitive and records it on the reverse-mode tape for native gradients once acceleration is enabled."
+        }
+    ],
+    "links": [
+        {
+            "label": "sinh",
+            "url": "./sinh"
+        },
+        {
+            "label": "cosh",
+            "url": "./cosh"
+        },
+        {
+            "label": "atanh",
+            "url": "./atanh"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "acos",
+            "url": "./acos"
+        },
+        {
+            "label": "acosh",
+            "url": "./acosh"
+        },
+        {
+            "label": "asin",
+            "url": "./asin"
+        },
+        {
+            "label": "asinh",
+            "url": "./asinh"
+        },
+        {
+            "label": "atan",
+            "url": "./atan"
+        },
+        {
+            "label": "atan2",
+            "url": "./atan2"
+        },
+        {
+            "label": "cos",
+            "url": "./cos"
+        },
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "tan",
+            "url": "./tan"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/trigonometry/tanh.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/trigonometry/tanh.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. The fusion planner keeps tensors on the GPU whenever the active provider exposes the necessary kernels (such as `unary_tanh`). Manual `gpuArray` / `gather` calls remain supported for MATLAB compatibility or when you need to pin residency before interacting with external code.",
+    "gpu_behavior": [
+        "With RunMat Accelerate active, tensors remain on the device and execute through the provider's `unary_tanh` hook (or a fused elementwise kernel) without leaving GPU memory.",
+        "If the provider declines the operation—for example, when it lacks the hook for the active precision—RunMat transparently gathers to the host, computes the result, and reapplies the requested residency rules.",
+        "Fusion planning keeps neighbouring elementwise operators grouped, reducing host↔device transfers even when an intermediate fallback occurs."
+    ],
+    "key": "tanh",
+    "slug": "tanh",
+    "categoryPath": [
+        "math",
+        "trigonometry"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=tanh.js.map

package/dist/generated/builtins/tanh.js.map

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

package/dist/generated/builtins/tcpclient.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinDoc } from "../../builtins.js";
+declare const builtinDoc: BuiltinDoc;
+export default builtinDoc;
+//# sourceMappingURL=tcpclient.d.ts.map

package/dist/generated/builtins/tcpclient.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tcpclient.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/tcpclient.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,UA6IjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/tcpclient.js

@@ -0,0 +1,146 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "tcpclient",
+    "category": "io/net",
+    "keywords": [
+        "tcpclient",
+        "tcp",
+        "socket",
+        "networking",
+        "client"
+    ],
+    "summary": "Open a TCP client socket that connects to MATLAB-compatible servers.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/tcpclient.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "All networking executes on the host CPU. GPU-resident scalars are gathered automatically before connecting."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::io::net::tcpclient::tests",
+        "integration": "builtins::io::net::tcpclient::tests::tcpclient_connects_to_loopback_server"
+    },
+    "description": "`tcpclient(host, port)` opens a TCP/IP connection to a remote server and returns a MATLAB-compatible struct that mirrors the `tcpclient` object. The struct tracks connection metadata (remote address and port, byte order, timeouts, and callback configuration) and carries an opaque identifier that other RunMat networking builtins use to operate on the live socket.",
+    "behaviors": [
+        "`tcpclient(host, port)` resolves the hostname (IPv4, IPv6, or DNS) and connects using the default 10 second `ConnectTimeout`. Ports must lie in the range `0–65535`.",
+        "Name-value pairs mirror MATLAB defaults: `Timeout` (non-negative seconds, determines read/write timeouts), `ConnectTimeout` (non-negative seconds, controls how long connection establishment waits), `ByteOrder` (`\"little-endian\"` or `\"big-endian\"`), `InputBufferSize`, `OutputBufferSize`, `UserData`, and `Name`. Unknown options raise `RunMat:tcpclient:InvalidNameValue`.",
+        "Successful calls return a struct whose fields match MATLAB’s `tcpclient` object, including callback placeholders (`BytesAvailableFcn`, `BytesAvailableFcnMode`, `BytesAvailableFcnCount`), connection metadata (`Address`, `Port`, `ServerAddress`, `ServerPort`, `LocalAddress`, `LocalPort`), and configuration (`Timeout`, `ConnectTimeout`, buffer sizes, `ByteOrder`). Hidden fields `__tcpclient_id` and `__tcpserver_id` retain the live socket handle for companion networking builtins.",
+        "Read and write timeouts are enforced using the `Timeout` value. Passing `inf` keeps operations blocking. The returned struct reports the configured timeout verbatim.",
+        "Connection failures raise `RunMat:tcpclient:ConnectionFailed` with the OS error message. Invalid addresses, ports, or name-value arguments raise the corresponding MATLAB-style diagnostics."
+    ],
+    "examples": [
+        {
+            "description": "Connecting to a loopback server for local testing",
+            "input": "client = tcpclient(\"127.0.0.1\", 55000);\ndisp(client.Address)\ndisp(client.Port)",
+            "output": "127.0.0.1\n55000"
+        },
+        {
+            "description": "Customizing tcpclient timeouts and byte order",
+            "input": "client = tcpclient(\"localhost\", 60000, \"Timeout\", 5, \"ConnectTimeout\", 2, \"ByteOrder\", \"big-endian\");\ndisp(client.Timeout)\ndisp(client.ConnectTimeout)\ndisp(client.ByteOrder)",
+            "output": "5\n2\nbig-endian"
+        },
+        {
+            "description": "Storing session metadata in `UserData`",
+            "input": "meta = struct(\"session\", \"demo\", \"started\", \"2024-01-01T00:00:00Z\");\nclient = tcpclient(\"example.com\", 80, \"UserData\", meta);\ndisp(client.UserData.session)",
+            "output": "demo"
+        },
+        {
+            "description": "Detecting connection failures with a shorter connect timeout",
+            "input": "try\n    client = tcpclient(\"192.0.2.20\", 65530, \"ConnectTimeout\", 0.2);\ncatch err\n    disp(err.identifier)\nend",
+            "output": "RunMat:tcpclient:ConnectionFailed"
+        },
+        {
+            "description": "Keeping a streaming connection open with infinite timeouts",
+            "input": "client = tcpclient(\"data.example.com\", 50000, \"Timeout\", inf, \"ConnectTimeout\", inf);\ndisp(client.Timeout)\ndisp(client.ConnectTimeout)",
+            "output": "Inf\nInf"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Which byte orders are supported?",
+            "answer": "`\"little-endian\"` (default) and `\"big-endian\"`. Any other string raises `RunMat:tcpclient:InvalidNameValue`."
+        },
+        {
+            "question": "Can I pass `inf` for `Timeout` or `ConnectTimeout`?",
+            "answer": "Yes. `Timeout = inf` keeps I/O blocking, and `ConnectTimeout = inf` waits indefinitely for a connection."
+        },
+        {
+            "question": "How do I close the client?",
+            "answer": "A companion builtin will release the socket. Until then, tests can use internal helpers to drop clients when finished."
+        },
+        {
+            "question": "Where do buffer sizes apply?",
+            "answer": "`InputBufferSize` and `OutputBufferSize` store the desired limits for future buffered I/O builtins. The current implementation records the values for compatibility."
+        },
+        {
+            "question": "Does the builtin support IPv6?",
+            "answer": "Yes. Pass an IPv6 literal (for example `\"::1\"`) or a hostname that resolves to IPv6. The returned struct reports the chosen address family."
+        },
+        {
+            "question": "What happens when the server rejects the connection?",
+            "answer": "`tcpclient` raises `RunMat:tcpclient:ConnectionFailed` with the OS error (such as “connection refused”)."
+        }
+    ],
+    "links": [
+        {
+            "label": "tcpserver",
+            "url": "./tcpserver"
+        },
+        {
+            "label": "accept",
+            "url": "./accept"
+        },
+        {
+            "label": "fread",
+            "url": "./fread"
+        },
+        {
+            "label": "fwrite",
+            "url": "./fwrite"
+        },
+        {
+            "label": "close",
+            "url": "./close"
+        },
+        {
+            "label": "read",
+            "url": "./read"
+        },
+        {
+            "label": "readline",
+            "url": "./readline"
+        },
+        {
+            "label": "write",
+            "url": "./write"
+        }
+    ],
+    "source": {
+        "label": "crates/runmat-runtime/src/builtins/io/net/tcpclient.rs",
+        "url": "crates/runmat-runtime/src/builtins/io/net/tcpclient.rs"
+    },
+    "gpu_residency": "No. RunMat automatically gathers GPU scalars before opening sockets. The returned struct—and all networking operations—run on the CPU, so `gpuArray` offers no benefit for `tcpclient`.",
+    "gpu_behavior": [
+        "Networking always happens on the host CPU. If `host`, `port`, or name-value arguments reside on the GPU, RunMat gathers them automatically before the socket is created. The returned struct is CPU-resident, and no acceleration-provider hooks are required."
+    ],
+    "key": "tcpclient",
+    "slug": "tcpclient",
+    "categoryPath": [
+        "io",
+        "net"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=tcpclient.js.map

package/dist/generated/builtins/tcpclient.js.map

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

package/dist/generated/builtins/tcpserver.d.ts

@@ -0,0 +1,4 @@
+import type { BuiltinDoc } from "../../builtins.js";
+declare const builtinDoc: BuiltinDoc;
+export default builtinDoc;
+//# sourceMappingURL=tcpserver.d.ts.map

package/dist/generated/builtins/tcpserver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tcpserver.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/tcpserver.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,UA4KjB,CAAC;AAEF,eAAe,UAAU,CAAC"}