runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/whos.js

@@ -0,0 +1,171 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "whos",
+    "category": "introspection",
+    "keywords": [
+        "whos",
+        "workspace variables",
+        "memory usage",
+        "struct array",
+        "introspection"
+    ],
+    "summary": "List variables in the workspace or MAT-files with MATLAB-compatible metadata.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/whos.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs entirely on the host. GPU arrays stay on the device; RunMat inspects residency metadata and provider precision to compute bytes without gathering the data."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::introspection::whos::tests",
+        "integration": null
+    },
+    "description": "`whos` reports a MATLAB-style table describing each variable in the current workspace (or in a MAT-file when you pass `-file`). The result is a struct array with the traditional `name`, `size`, `bytes`, `class`, `global`, `sparse`, `complex`, `nesting`, and `persistent` fields.",
+    "behaviors": [
+        "`whos` with no arguments lists every variable in the active workspace, using MATLAB's default alphabetical ordering.",
+        "`whos pattern1 pattern2 ...` accepts character vectors or string scalars containing wildcard expressions (`*`, `?`, `[abc]`). Any variable whose name matches at least one pattern is reported.",
+        "`whos('-regexp', expr1, expr2, ...)` keeps variables whose names match any of the supplied regular expressions.",
+        "`whos global` lists only the variables that are marked as global within the active workspace.",
+        "`whos('-file', filename, ...)` inspects a MAT-file without loading it. You can combine `-file` with explicit names or `-regexp` selectors, mirroring MATLAB.",
+        "The returned struct array uses string scalars for textual fields (`name`, `class`, `nesting`) and MATLAB-style numeric row vectors for the `size` field.",
+        "`bytes` reports the amount of memory consumed by the value using RunMat's host representation. GPU arrays stay on the device; RunMat estimates bytes from the device-resident shape and provider precision."
+    ],
+    "examples": [
+        {
+            "description": "List All Workspace Variables",
+            "input": "a = 42;\nb = rand(3, 2);\ninfo = whos;\n{info.name}",
+            "output": "    {\"a\"}    {\"b\"}"
+        },
+        {
+            "description": "Filter Variables With Wildcards",
+            "input": "alpha = 1;\nbeta = 2;\nresults = whos(\"a*\");\n{results.name}",
+            "output": "    {\"alpha\"}"
+        },
+        {
+            "description": "Use Regular Expressions To Match Names",
+            "input": "x1 = rand;\nx2 = rand;\nmatches = whos('-regexp', '^x\\\\d$');\ncellstr({matches.name})",
+            "output": "    {'x1'}\n    {'x2'}"
+        },
+        {
+            "description": "Inspect Variables Stored In A MAT-File",
+            "input": "save('snapshot.mat', 'alpha', 'beta')\nfile_info = whos('-file', 'snapshot.mat');\n{file_info.name}",
+            "output": "    {\"alpha\"}    {\"beta\"}"
+        },
+        {
+            "description": "Check GPU Arrays Without Gathering",
+            "input": "G = gpuArray(rand(1024));\nmeta = whos('G');\nmeta.bytes    % estimated bytes on device",
+            "output": "meta.bytes\nans =\n    8.3886e+06"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What fields does `whos` return?",
+            "answer": "Each entry exposes `name`, `size`, `bytes`, `class`, `global`, `sparse`, `complex`, `nesting`, and `persistent`, matching MATLAB semantics."
+        },
+        {
+            "question": "Does `whos` mutate the workspace?",
+            "answer": "No. It is a pure query that never creates, deletes, or modifies variables."
+        },
+        {
+            "question": "Are bytes identical to MATLAB?",
+            "answer": "RunMat reports the size of its own representations. Numeric and logical arrays match MATLAB's byte counts; other types (such as structs or objects) may differ slightly because RunMat records their data differently."
+        },
+        {
+            "question": "How are global variables handled?",
+            "answer": "Variables declared with `global` are marked with `global = true`. Use `whos global` to list only globals."
+        },
+        {
+            "question": "Can I combine wildcard filters and `-regexp`?",
+            "answer": "Yes. `whos('data*', '-regexp', '^(cfg|state)')` reports the union of both selections."
+        },
+        {
+            "question": "What happens when no variables match?",
+            "answer": "A `0×1` struct array is returned, just like MATLAB, so idioms such as `isempty(whos('foo'))` work."
+        },
+        {
+            "question": "Does `whos('-file', ...)` read the entire MAT-file?",
+            "answer": "It parses only enough metadata to reconstruct variable values. Large arrays are streamed once; no workspace variables are modified."
+        },
+        {
+            "question": "How are persistent variables reported?",
+            "answer": "RunMat currently marks all entries as `persistent = false` in the base workspace. Future releases will surface persistent metadata from function scopes."
+        },
+        {
+            "question": "Will GPU arrays be gathered?",
+            "answer": "No. `whos` inspects device handles and leaves residency untouched."
+        }
+    ],
+    "links": [
+        {
+            "label": "who",
+            "url": "./who"
+        },
+        {
+            "label": "class",
+            "url": "./class"
+        },
+        {
+            "label": "size",
+            "url": "./size"
+        },
+        {
+            "label": "load",
+            "url": "./load"
+        },
+        {
+            "label": "save",
+            "url": "./save"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "isa",
+            "url": "./isa"
+        },
+        {
+            "label": "ischar",
+            "url": "./ischar"
+        },
+        {
+            "label": "isstring",
+            "url": "./isstring"
+        },
+        {
+            "label": "which",
+            "url": "./which"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/introspection/whos.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/introspection/whos.rs"
+    },
+    "gpu_residency": "You do not need to move data to or from the GPU to call `whos`. The builtin gathers scalar arguments if they happen to live on the device, but the workspace variables themselves remain where they are. Use `gather` separately if you need host copies of the data for further processing.",
+    "gpu_behavior": [
+        "`whos` is an introspection builtin that runs entirely on the CPU. When a variable is a `gpuArray`, RunMat leaves it on the device and derives metadata (element count, precision, and total bytes) from the handle and active provider. No kernels are launched and no device buffers are gathered. Auto-offload heuristics remain untouched."
+    ],
+    "key": "whos",
+    "slug": "whos",
+    "categoryPath": [
+        "introspection"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=whos.js.map

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

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

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

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

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

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

package/dist/generated/builtins/write.js

@@ -0,0 +1,130 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "write",
+    "category": "io/net",
+    "keywords": [
+        "write",
+        "tcpclient",
+        "networking",
+        "socket",
+        "binary data",
+        "text"
+    ],
+    "summary": "Write numeric or text data to a remote host through a MATLAB-compatible tcpclient struct.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/tcpclient.write.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "All TCP writes execute on the host CPU. GPU-resident arguments are gathered automatically before socket I/O."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::io::net::write::tests"
+    },
+    "description": "`write(t, data)` transmits binary or textual data over the TCP/IP client returned by `tcpclient` (or `accept`). The builtin mirrors MATLAB’s `write` behaviour so existing socket code continues working without modification. It honours the client’s configured `Timeout`, applies the `ByteOrder` property when encoding multi-byte values, and accepts the optional `datatype` argument used throughout MATLAB’s I/O APIs.",
+    "behaviors": [
+        "`write(t, data)` converts `data` to unsigned 8-bit integers (the MATLAB default) and sends the bytes to the peer. The return value is the number of elements written when the caller requests an output argument.",
+        "`write(t, data, datatype)` encodes the payload using the supplied MATLAB datatype token. Supported values mirror MATLAB: `\"uint8\"` (default), `\"int8\"`, `\"uint16\"`, `\"int16\"`, `\"uint32\"`, `\"int32\"`, `\"uint64\"`, `\"int64\"`, `\"single\"`, `\"double\"`, `\"char\"`, and `\"string\"`. Numeric conversions saturate to the destination range just like MATLAB cast operations. `\"char\"` treats values as single-byte character codes and `\"string\"` encodes UTF-8 text.",
+        "The client’s `ByteOrder` property controls how multi-byte numeric values are serialised. `\"little-endian\"` is the default, while `\"big-endian\"` matches the traditional network byte order.",
+        "When the socket cannot send the entire payload before the timeout expires, `write` raises `RunMat:write:Timeout`. If the peer closes the connection before or during the transfer the builtin raises `RunMat:write:ConnectionClosed` and marks the client as disconnected.",
+        "Inputs that originate on the GPU are gathered back to the host automatically before any bytes are written."
+    ],
+    "examples": [
+        {
+            "description": "Sending an array of bytes to an echo service",
+            "input": "client = tcpclient(\"127.0.0.1\", 50000);\ncount = write(client, uint8(1:4))",
+            "output": "count =\n     4"
+        },
+        {
+            "description": "Writing doubles with explicit byte order",
+            "input": "client = tcpclient(\"localhost\", 50001, \"ByteOrder\", \"big-endian\");\nvalues = [1.5 2.5 3.5];\nwrite(client, values, \"double\")"
+        },
+        {
+            "description": "Transmitting ASCII text",
+            "input": "client = tcpclient(\"127.0.0.1\", 50002);\nwrite(client, \"RunMat TCP\", \"char\")"
+        },
+        {
+            "description": "Sending UTF-8 encoded strings",
+            "input": "client = tcpclient(\"127.0.0.1\", 50003);\nwrite(client, \"Διακριτό\", \"string\")"
+        },
+        {
+            "description": "Handling connection closures",
+            "input": "client = tcpclient(\"example.com\", 12345, \"Timeout\", 0.25);\ntry\n    write(client, uint8([1 2 3 4]));\ncatch err\n    disp(err.identifier)\nend",
+            "output": "RunMat:write:ConnectionClosed"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How many output values does `write` return?",
+            "answer": "When the caller requests an output, the builtin returns the number of elements written (after datatype conversion). This mirrors the behaviour of MATLAB’s numeric I/O routines. If no output is requested, the value is discarded."
+        },
+        {
+            "question": "Does `write` support complex numbers?",
+            "answer": "No. The input must be real. Pass separate real and imaginary parts or convert to a byte representation manually."
+        },
+        {
+            "question": "How are values rounded when converting to integer datatypes?",
+            "answer": "Floating-point inputs are rounded to the nearest integer and then saturated to the target range, matching MATLAB casts (for example `uint8(255.7)` becomes `256 → 255`, `int8(-128.2)` becomes `-128`)."
+        },
+        {
+            "question": "What happens to GPU-resident tensors?",
+            "answer": "They are gathered automatically before the write. Networking is a CPU-only subsystem, so the resulting data is sent from host memory and any temporary handles are released after the transfer."
+        },
+        {
+            "question": "Can I stream large payloads?",
+            "answer": "Yes. `write` loops until the entire payload has been sent or an error occurs. Large payloads honour the client’s timeout and byte-order settings."
+        }
+    ],
+    "links": [
+        {
+            "label": "tcpclient",
+            "url": "./tcpclient"
+        },
+        {
+            "label": "accept",
+            "url": "./accept"
+        },
+        {
+            "label": "read",
+            "url": "./read"
+        },
+        {
+            "label": "readline",
+            "url": "./readline"
+        },
+        {
+            "label": "close",
+            "url": "./close"
+        },
+        {
+            "label": "tcpserver",
+            "url": "./tcpserver"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/io/net/write.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/net/write.rs"
+    },
+    "gpu_behavior": [
+        "Networking occurs on the host CPU. If `data` or the tcpclient struct resides on the GPU, RunMat gathers the values to host memory before converting them to bytes. Acceleration providers are not involved and the resulting payload remains on the CPU. Providers that support residency tracking automatically mark any gathered tensors as released."
+    ],
+    "key": "write",
+    "slug": "write",
+    "categoryPath": [
+        "io",
+        "net"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=write.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"write.js","sourceRoot":"","sources":["../../../src/generated/builtins/write.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,QAAQ;IACpB,UAAU,EAAE;QACV,OAAO;QACP,WAAW;QACX,YAAY;QACZ,QAAQ;QACR,aAAa;QACb,MAAM;KACP;IACD,SAAS,EAAE,2FAA2F;IACtG,YAAY,EAAE;QACZ,gEAAgE;KACjE;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,8GAA8G;KACxH;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,iCAAiC;KAC1C;IACD,aAAa,EAAE,gaAAga;IAC/a,WAAW,EAAE;QACX,mNAAmN;QACnN,6dAA6d;QAC7d,iMAAiM;QACjM,4QAA4Q;QAC5Q,4GAA4G;KAC7G;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,8EAA8E;YACvF,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,sIAAsI;SAChJ;QACD;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,oFAAoF;SAC9F;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,oFAAoF;SAC9F;QACD;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,qJAAqJ;YAC9J,QAAQ,EAAE,+BAA+B;SAC1C;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,qOAAqO;SAChP;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,kHAAkH;SAC7H;QACD;YACE,UAAU,EAAE,8DAA8D;YAC1E,QAAQ,EAAE,yMAAyM;SACpN;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,iMAAiM;SAC5M;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,mJAAmJ;SAC9J;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,sDAAsD;QAC/D,KAAK,EAAE,mGAAmG;KAC3G;IACD,cAAc,EAAE;QACd,yVAAyV;KAC1V;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,cAAc,EAAE;QACd,IAAI;QACJ,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/writematrix.js

@@ -0,0 +1,161 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "writematrix",
+    "category": "io/tabular",
+    "keywords": [
+        "writematrix",
+        "csv",
+        "delimited text",
+        "write",
+        "append",
+        "quote strings",
+        "decimal separator"
+    ],
+    "summary": "Write numeric or string matrices to delimited text files with MATLAB-compatible defaults.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/writematrix.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs entirely on the CPU. gpuArray inputs are gathered automatically before serialisation."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::io::tabular::writematrix::tests",
+        "integration": [
+            "builtins::io::tabular::writematrix::tests::writematrix_writes_space_delimited_txt",
+            "builtins::io::tabular::writematrix::tests::writematrix_defaults_to_comma_for_csv",
+            "builtins::io::tabular::writematrix::tests::writematrix_honours_write_mode_append",
+            "builtins::io::tabular::writematrix::tests::writematrix_quotes_strings_by_default",
+            "builtins::io::tabular::writematrix::tests::writematrix_accepts_gpu_tensor_inputs"
+        ]
+    },
+    "description": "`writematrix(A, filename)` serialises numeric or string matrices to a text file using MATLAB-compatible defaults. Column-major ordering is preserved, delimiters adjust to the filename extension, and optional name/value pairs customise quoting, decimal separators, line endings, and write mode. The builtin mirrors MATLAB behaviour for the supported options, raising descriptive errors for unsupported combinations like spreadsheet output.",
+    "behaviors": [
+        "Accepts real numeric, logical, or string arrays with up to two dimensions (trailing singleton dimensions are ignored). Heterogeneous data requires `writecell` instead.",
+        "Default delimiters follow MATLAB: comma for `.csv`, tab for `.tsv`, whitespace for `.txt` and `.dat`, and comma for other extensions. Specify `'Delimiter', value` to override.",
+        "`'WriteMode'` supports `'overwrite'` (default) and `'append'`. Overwrite truncates existing files; append writes new rows to the end without inserting extra delimiters.",
+        "`'QuoteStrings'` controls whether text fields are wrapped in double quotes. When enabled (the default) embedded quotes are doubled (`\"Alice\"` becomes `\"\"Alice\"\"`).",
+        "`'DecimalSeparator'` swaps the decimal point for locales that require `','` or other characters. Thousands separators are not inserted automatically, matching MATLAB.",
+        "`'LineEnding'` supports `'auto'` (normalized `\\n` for cross-platform portability), `'unix'`, `'pc'`/`'windows'`, and `'mac'`.",
+        "`'FileType'` accepts `'delimitedtext'` or `'text'`. Spreadsheet output (`'spreadsheet'`) is not yet available and triggers a descriptive error consistent with MATLAB's messaging.",
+        "Unsupported options are ignored for forward compatibility. Errors indicate which argument was invalid when the value cannot be interpreted."
+    ],
+    "examples": [
+        {
+            "description": "Save a numeric matrix to a CSV file",
+            "input": "A = [1 2 3; 4 5 6];\nwritematrix(A, \"results.csv\")"
+        },
+        {
+            "description": "Export data with a custom semicolon delimiter",
+            "input": "A = [1 2 3; 4 5 6];\nwritematrix(A, \"results.dat\", 'Delimiter', ';')"
+        },
+        {
+            "description": "Append additional rows to an existing report",
+            "input": "writematrix([7 8 9], \"report.txt\");\nwritematrix([10 11 12], \"report.txt\", 'WriteMode', 'append')"
+        },
+        {
+            "description": "Write string data with quoting disabled",
+            "input": "names = [\"Alice\" \"Bob\" \"Charlie\"];\nwritematrix(names, \"names.csv\", 'QuoteStrings', false)"
+        },
+        {
+            "description": "Use a European decimal separator and explicit line ending",
+            "input": "vals = [12.34; 56.78];\nwritematrix(vals, \"eu.csv\", 'DecimalSeparator', ',', 'LineEnding', 'unix')"
+        },
+        {
+            "description": "Write GPU-resident data transparently",
+            "input": "G = gpuArray(rand(2, 3));\nwritematrix(G, \"gpu_output.csv\")",
+            "output": "% Data is gathered from the GPU automatically and written to disk as CSV."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Which data types does `writematrix` support?",
+            "answer": "Real numeric, logical, and string arrays up to two dimensions. For heterogenous content (mixed numbers and text) use `writecell` or `writetable`."
+        },
+        {
+            "question": "How are empty matrices handled?",
+            "answer": "Zero-row or zero-column inputs produce either an empty file or blank line endings per MATLAB's behaviour. The file is still created or truncated according to `'WriteMode'`."
+        },
+        {
+            "question": "Can I write OTA spreadsheet formats like `.xlsx`?",
+            "answer": "Not yet. Passing `'FileType','spreadsheet'` raises a descriptive error. Use MATLAB's table-based workflows or export delimited text instead."
+        },
+        {
+            "question": "How are embedded quotes in text fields escaped?",
+            "answer": "When `'QuoteStrings'` is `true`, embedded double quotes are doubled (`\"She said \"\"hi\"\"\"`), conforming to RFC 4180 and MATLAB's implementation. With quoting disabled, the characters are written verbatim."
+        },
+        {
+            "question": "What happens if I choose `','` as both delimiter and decimal separator?",
+            "answer": "RunMat mirrors MATLAB by honouring your request without modification, even though the output may be ambiguous. Choose a different delimiter when writing locale-specific decimals."
+        },
+        {
+            "question": "Does `writematrix` change the working directory?",
+            "answer": "No. Relative paths are resolved against the current MATLAB working directory, and only the target file is touched."
+        },
+        {
+            "question": "How do I include header rows or variable names?",
+            "answer": "`writematrix` focuses on numeric/string matrices. For labelled data use `writetable` (planned) or prepend header lines manually with `fprintf` before calling `writematrix` in `'append'` mode."
+        }
+    ],
+    "links": [
+        {
+            "label": "readmatrix",
+            "url": "./readmatrix"
+        },
+        {
+            "label": "fprintf",
+            "url": "./fprintf"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "csvread",
+            "url": "./csvread"
+        },
+        {
+            "label": "csvwrite",
+            "url": "./csvwrite"
+        },
+        {
+            "label": "dlmread",
+            "url": "./dlmread"
+        },
+        {
+            "label": "dlmwrite",
+            "url": "./dlmwrite"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/io/tabular/writematrix.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/tabular/writematrix.rs"
+    },
+    "gpu_residency": "No additional steps are required. `writematrix` treats GPU arrays as residency sinks: the data is gathered before formatting, ensuring the file on disk reflects host memory. This mirrors MATLAB, where `writematrix` operates on numeric values regardless of their original residency.",
+    "gpu_behavior": [
+        "`writematrix` always executes on the host. When the input matrix resides on a GPU, RunMat gathers the array via the active acceleration provider before formatting. No provider-specific hooks or GPU kernels are required, and the result of the write remains a host-side side effect (file on disk). If no provider is registered, the builtin emits the same gather error reported by other residency sinks."
+    ],
+    "key": "writematrix",
+    "slug": "writematrix",
+    "categoryPath": [
+        "io",
+        "tabular"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=writematrix.js.map

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

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

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

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

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

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