runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/gather.js

@@ -0,0 +1,162 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "gather",
+    "category": "acceleration/gpu",
+    "keywords": [
+        "gather",
+        "gpuArray",
+        "download",
+        "host copy",
+        "accelerate",
+        "residency"
+    ],
+    "summary": "Transfer gpuArray data back to host memory, recursively handling cells, structs, and objects.",
+    "references": [
+        "https://www.mathworks.com/help/parallel-computing/gather.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Executes on the CPU; gpuArray inputs are downloaded through the provider's `download` hook and residency metadata is cleared so planners know the value now lives on the host."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::acceleration::gpu::gather::tests",
+        "integration": "builtins::acceleration::gpu::gather::tests::gather_downloads_gpu_tensor",
+        "wgpu": "builtins::acceleration::gpu::gather::tests::gather_wgpu_provider_roundtrip"
+    },
+    "description": "`gather(X)` copies data that resides on the GPU or in another distributed storage back into host memory. In RunMat, this means turning `gpuArray` handles into dense MATLAB values while leaving input values that are already on the CPU unchanged.",
+    "behaviors": [
+        "Accepts any MATLAB value. Non-GPU inputs (numbers, logicals, structs, strings, etc.) pass through untouched, so `gather` is safe to call unconditionally at API boundaries.",
+        "Downloads gpuArray tensors via the active acceleration provider, producing dense double-precision matrices. Logical gpuArray inputs return logical arrays with MATLAB-compatible 0/1 encoding.",
+        "Recursively descends into cells, structs, and objects, gathering every nested gpuArray handle. This mirrors MATLAB's behaviour when you gather composite data structures.",
+        "Clears residency metadata so the auto-offload planner treats the gathered value as host-resident.",
+        "Supports multiple inputs: in a single-output context it returns a `1×N` cell array preserving the original order; in a multi-output assignment the number of inputs and outputs must match, mirroring MATLAB's requirement.",
+        "Raises `gather: no acceleration provider registered` when you attempt to download gpuArray data without an active provider, and propagates provider-specific download errors verbatim."
+    ],
+    "examples": [
+        {
+            "description": "Converting a gpuArray back to host memory",
+            "input": "G = gpuArray([1 2 3; 4 5 6]);\nH = gather(G)",
+            "output": "H =\n     1     2     3\n     4     5     6"
+        },
+        {
+            "description": "Gathering data that is already on the CPU",
+            "input": "x = [10 20 30];\ny = gather(x)",
+            "output": "y =\n    10    20    30"
+        },
+        {
+            "description": "Preserving logical values when gathering",
+            "input": "mask = gpuArray(logical([1 0 1 0]));\nhostMask = gather(mask)",
+            "output": "hostMask =\n  1×4 logical array\n   1   0   1   0"
+        },
+        {
+            "description": "Gathering gpuArray values stored inside a cell array",
+            "input": "C = {gpuArray([1 2]), 42};\nhostC = gather(C)",
+            "output": "hostC =\n  1×2 cell array\n    {[1 2]}    {[42]}"
+        },
+        {
+            "description": "Gathering struct fields that live on the GPU",
+            "input": "S.data = gpuArray(magic(3));\nS.label = \"gpu result\";\nS_host = gather(S)",
+            "output": "S_host =\n  struct with fields:\n     data: [3×3 double]\n    label: \"gpu result\""
+        },
+        {
+            "description": "Gathering multiple gpuArrays into one cell result",
+            "input": "A = gpuArray(eye(3));\nB = gpuArray(ones(3));\ncellOut = gather(A, B)",
+            "output": "cellOut =\n  1×2 cell array\n    {[3×3 double]}    {[3×3 double]}"
+        },
+        {
+            "description": "Gathering results at the end of a GPU pipeline",
+            "input": "A = gpuArray(rand(1024, 1));\nB = sin(A) .* 5;\nresult = gather(B)",
+            "output": "result(1:3) =\n    4.1377\n    2.4884\n    0.1003"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `gather` modify the original gpuArray?",
+            "answer": "No. `gather` returns a host-side copy. The original gpuArray value remains valid and continues to reside on the GPU until it goes out of scope."
+        },
+        {
+            "question": "What happens if the input does not live on the GPU?",
+            "answer": "Nothing changes—the value is returned as-is. This makes `gather` safe to sprinkle into code paths that may or may not run on the GPU."
+        },
+        {
+            "question": "How are logical gpuArray values represented after gathering?",
+            "answer": "Logical handles are tagged during `gpuArray` creation. `gather` reads that metadata and produces a MATLAB logical array with the same shape, ensuring comparisons like `isa(result, 'logical')` behave as expected."
+        },
+        {
+            "question": "Does `gather` recurse into cells, structs, and objects?",
+            "answer": "Yes. Every nested gpuArray handle inside a cell array, struct field, or object property is downloaded and replaced with host data."
+        },
+        {
+            "question": "What happens when I pass multiple inputs but capture a single output?",
+            "answer": "RunMat follows MATLAB: it gathers each input and returns a `1×N` cell array so you can unpack values later. In multi-output assignments you must request the same number of outputs as inputs."
+        },
+        {
+            "question": "What if no acceleration provider is registered?",
+            "answer": "RunMat raises `gather: no acceleration provider registered` when you attempt to gather a gpuArray without an active provider. Register a provider (for example, via `runmat-accelerate`) before calling `gather`."
+        },
+        {
+            "question": "Does `gather` free GPU memory automatically?",
+            "answer": "No. The gpuArray remains on the device. Free the handle explicitly (by clearing the variable) if you no longer need it."
+        }
+    ],
+    "links": [
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gpuDevice",
+            "url": "./gpudevice"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "arrayfun",
+            "url": "./arrayfun"
+        },
+        {
+            "label": "gpuInfo",
+            "url": "./gpuinfo"
+        },
+        {
+            "label": "pagefun",
+            "url": "./pagefun"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/acceleration/gpu/gather.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/acceleration/gpu/gather.rs"
+    },
+    "gpu_residency": "RunMat's auto-offload planner keeps tensors on the GPU until a builtin marked as a sink (such as `gather`, plotting functions, or I/O) requests host access. You usually call `gather` at API boundaries, for example to log results or hand them to CPU-only libraries. If the upstream computation never leaves the GPU, you can omit `gather` and keep chaining gpu-aware builtins.",
+    "gpu_behavior": [
+        "`gather` itself runs on the CPU. When the input contains gpuArray handles, the builtin calls the provider's `download` hook to retrieve a `HostTensorOwned` view, converts the result into MATLAB data, and clears residency via `runmat_accelerate_api::clear_residency`. If the provider does not implement `download`, the builtin surfaces the provider error so you know the backend must be extended. When the input is already on the host, no provider work is required."
+    ],
+    "key": "gather",
+    "slug": "gather",
+    "categoryPath": [
+        "acceleration",
+        "gpu"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=gather.js.map

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

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

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

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

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

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

package/dist/generated/builtins/ge.js

@@ -0,0 +1,153 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "ge",
+    "category": "logical/rel",
+    "keywords": [
+        "ge",
+        ">=",
+        "greater than or equal",
+        "logical comparison",
+        "gpuArray ge"
+    ],
+    "summary": "Element-wise greater-than-or-equal comparison for scalars, arrays, strings, and gpuArray inputs.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Uses provider elem_ge kernels when available; otherwise inputs gather back to host memory transparently."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::logical::rel::ge::tests",
+        "integration": "builtins::logical::rel::ge::tests::ge_gpu_provider_roundtrip",
+        "gpu": "builtins::logical::rel::ge::tests::ge_wgpu_matches_host"
+    },
+    "description": "`ge(A, B)` (or the infix `A >= B`) performs an element-wise greater-than-or-equal comparison. The result is a logical scalar when the broadcasted shape contains one element, or a logical array otherwise.",
+    "behaviors": [
+        "Numeric, logical, and character inputs compare element-wise using MATLAB's implicit expansion rules.",
+        "Character arrays compare by Unicode code point; mixing them with numeric arrays behaves like comparing numeric codes (`'A' >= 65`).",
+        "String scalars and string arrays compare lexically; implicit expansion works across string dimensions.",
+        "Complex inputs are not supported, matching MATLAB's behaviour.",
+        "Mixed numeric/string inputs raise MATLAB-compatible type errors."
+    ],
+    "examples": [
+        {
+            "description": "Test Whether One Scalar Is Greater Than or Equal To Another",
+            "input": "flag = ge(42, 42)",
+            "output": "flag =\n     1"
+        },
+        {
+            "description": "Keep Matrix Elements Above or Equal To A Threshold",
+            "input": "M = [1 2 3; 4 5 6];\nmask = ge(M, 3)",
+            "output": "mask =\n  2×3 logical array\n     0     0     1\n     1     1     1"
+        },
+        {
+            "description": "Apply Greater-Equal With Implicit Expansion",
+            "input": "v = [1 3 5 7];\nmask = ge(v, [2 6])",
+            "output": "mask =\n  1×4 logical array\n     0     0     1     1"
+        },
+        {
+            "description": "Compare Character Data To Numeric Codes",
+            "input": "letters = ['A' 'B' 'C'];\nisAfterOrB = ge(letters, 66)",
+            "output": "isAfterOrB =\n  1×3 logical array\n     0     1     1"
+        },
+        {
+            "description": "Compare String Arrays Lexicographically With Equality Support",
+            "input": "names = [\"alice\" \"charlie\" \"bob\"];\nlaterOrSame = ge(names, \"bob\")",
+            "output": "laterOrSame =\n  1×3 logical array\n     0     1     1"
+        },
+        {
+            "description": "Run `ge` Directly On `gpuArray` Inputs",
+            "input": "G1 = gpuArray([1 4 6]);\nG2 = gpuArray([1 5 6]);\ndeviceResult = ge(G1, G2);\nhostResult = gather(deviceResult)",
+            "output": "deviceResult =\n  1×3 gpuArray logical array\n     1     0     1\nhostResult =\n  1×3 logical array\n     1     0     1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `ge` return logical values?",
+            "answer": "Yes. Scalars return `true` or `false`. Arrays return logical arrays, and `gpuArray` inputs return `gpuArray` logical outputs."
+        },
+        {
+            "question": "How are NaN values treated?",
+            "answer": "Any comparison involving `NaN` returns `false`, matching MATLAB behaviour."
+        },
+        {
+            "question": "Can I compare complex numbers with `ge`?",
+            "answer": "No. MATLAB does not define relational ordering for complex numbers, so RunMat raises a MATLAB-compatible error when complex inputs are supplied."
+        },
+        {
+            "question": "How are strings compared?",
+            "answer": "String scalars and arrays compare lexicographically using Unicode code points, with full support for implicit expansion against scalar strings."
+        },
+        {
+            "question": "Are character vectors treated as numbers or text?",
+            "answer": "Character arrays participate as numeric code points when compared to numeric inputs, and they are converted to strings when compared against string scalars or arrays."
+        },
+        {
+            "question": "Do I need to gather results manually after a GPU comparison?",
+            "answer": "No. When both inputs are `gpuArray` values and the provider supports `elem_ge`, the result stays on the GPU. Otherwise, RunMat gathers inputs transparently and returns a host logical array."
+        },
+        {
+            "question": "Does implicit expansion apply to string arrays?",
+            "answer": "Yes. String arrays support MATLAB-style implicit expansion, so you can compare against scalar strings without manual replication."
+        },
+        {
+            "question": "Can I fuse `ge` inside GPU expressions?",
+            "answer": "Yes. The builtin registers element-wise fusion metadata so the planner can fuse comparisons with surrounding GPU-friendly operations."
+        }
+    ],
+    "links": [
+        {
+            "label": "gt",
+            "url": "./gt"
+        },
+        {
+            "label": "eq",
+            "url": "./eq"
+        },
+        {
+            "label": "ne",
+            "url": "./ne"
+        },
+        {
+            "label": "isequal",
+            "url": "./isequal"
+        },
+        {
+            "label": "le",
+            "url": "./le"
+        },
+        {
+            "label": "lt",
+            "url": "./lt"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/logical/rel/ge.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/rel/ge.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. RunMat's native auto-offload planner keeps intermediate results on the GPU when fused expressions benefit from device execution. Explicit `gpuArray` and `gather` calls remain available for compatibility with MATLAB code that manages residency manually.",
+    "gpu_behavior": [
+        "When both operands are `gpuArray` values and the active acceleration provider implements the `elem_ge` hook, RunMat executes the comparison entirely on the device and returns a `gpuArray` logical result. If the provider does not expose this hook, the runtime gathers the inputs to host memory automatically and performs the CPU comparison instead of failing."
+    ],
+    "key": "ge",
+    "slug": "ge",
+    "categoryPath": [
+        "logical",
+        "rel"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=ge.js.map

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

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

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

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

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

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

package/dist/generated/builtins/genpath.js

@@ -0,0 +1,203 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "genpath",
+    "category": "io/repl_fs",
+    "keywords": [
+        "genpath",
+        "recursive path",
+        "search path",
+        "addpath"
+    ],
+    "summary": "Generate a MATLAB-style search path string for a folder tree.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/genpath.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs entirely on the CPU. gpuArray text inputs are gathered automatically before processing."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::io::repl_fs::genpath::tests",
+        "integration": "builtins::io::repl_fs::genpath::tests::genpath_excludes_specified_directories"
+    },
+    "description": "`genpath` walks a folder tree and returns a character vector that lists the folder and every subfolder in depth-first order. Each entry is separated by the platform `pathsep` character (`:` on Linux/macOS, `;` on Windows), making the result a drop-in argument for `addpath`, `rmpath`, and other path-editing utilities.",
+    "behaviors": [
+        "`genpath()` with no inputs uses the current working directory (`pwd`) as the root folder. `genpath(folder)` accepts either an absolute or relative path.",
+        "MATLAB-reserved directories named `private` or `resources`, as well as class folders (`@MyClass`) and namespace folders (`+pkg`), are skipped automatically along with all of their descendants. The root folder is still included even if it matches one of these reserved names.",
+        "All returned entries are absolute, canonicalised paths beginning with the root directory, followed by each descendant directory in lexical order. The walking order matches MATLAB's depth-first behaviour.",
+        "Duplicate directories are removed automatically. Symlinked folders that resolve to the same physical location only appear once in the output.",
+        "`genpath(folder, excludes)` omits any folder listed in `excludes` together with its descendants. The `excludes` argument is a character vector of absolute or relative paths separated by `pathsep`. Relative entries are resolved against the supplied root folder before canonicalisation.",
+        "If a folder in the tree cannot be read (for example due to permissions), RunMat silently skips that branch while keeping the rest of the result intact.",
+        "If the requested root folder does not exist, RunMat raises `genpath: folder '<name>' not found`, matching MATLAB error semantics."
+    ],
+    "examples": [
+        {
+            "description": "Generate a recursive path for the current working folder",
+            "input": "p = genpath();\naddpath(p);   % Add the current folder and all subfolders to the MATLAB path"
+        },
+        {
+            "description": "Build a search path for a project toolbox",
+            "input": "toolboxRoot = \"toolbox/signal\";\ntoolboxPath = genpath(toolboxRoot);\naddpath(toolboxPath, \"-end\")"
+        },
+        {
+            "description": "Exclude build output directories from the generated path",
+            "input": "root = \"projects/solver\";\nexcludes = strjoin([\n    fullfile(root, \"build\"),\n    fullfile(root, \"dist\")\n], pathsep);\np = genpath(root, excludes)"
+        },
+        {
+            "description": "Skip a private utilities folder while including the rest of the tree",
+            "input": "root = \"analysis\";\np = genpath(root, fullfile(root, \"private\"))"
+        },
+        {
+            "description": "Automatically skip MATLAB-reserved folders",
+            "input": "root = \"toolbox\";\nmkdir(root, \"private\");\nmkdir(root, \"+package\");\np = genpath(root)",
+            "output": "% `p` only includes `toolbox` and subfolders that are not named `private` or\n% `resources`, and that do not begin with `@` or `+`."
+        },
+        {
+            "description": "Combine `genpath` with `savepath` for persistent tooling setup",
+            "input": "p = genpath(\"third_party/toolchain\");\naddpath(p);\nsavepath()"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `genpath` include package (`+pkg`) and class (`@Class`) folders?",
+            "answer": "No. These directories are excluded automatically, along with folders named `private` or `resources`. Use the `excludes` argument for additional rules."
+        },
+        {
+            "question": "How do I exclude multiple folders?",
+            "answer": "Build a character vector or string using `pathsep` (for example, `strjoin({path1, path2}, pathsep)`) and pass it as the second argument. Relative entries are interpreted relative to the root folder."
+        },
+        {
+            "question": "Why are some folders missing from the result?",
+            "answer": "RunMat only omits folders that you explicitly exclude or that cannot be read due to filesystem permissions."
+        },
+        {
+            "question": "What happens if the root folder does not exist?",
+            "answer": "`genpath` raises `genpath: folder '<name>' not found`, matching MATLAB. Create the folder first or adjust the argument."
+        },
+        {
+            "question": "Can I call `genpath` on a GPU array?",
+            "answer": "Yes—the input is gathered to the CPU before processing, and the result is returned as a standard character vector."
+        },
+        {
+            "question": "Is the result always absolute paths?",
+            "answer": "Yes. RunMat resolves the root and all discovered folders to their absolute, canonical locations to avoid duplicates."
+        },
+        {
+            "question": "Will symbolic links be traversed?",
+            "answer": "Yes, but the target directory only appears once in the output. Directory cycles are prevented by tracking canonical paths."
+        },
+        {
+            "question": "Can I feed `genpath` output directly into `addpath` or `rmpath`?",
+            "answer": "Absolutely. The output string is `pathsep`-delimited specifically for that purpose."
+        }
+    ],
+    "links": [
+        {
+            "label": "addpath",
+            "url": "./addpath"
+        },
+        {
+            "label": "rmpath",
+            "url": "./rmpath"
+        },
+        {
+            "label": "path",
+            "url": "./path"
+        },
+        {
+            "label": "which",
+            "url": "./which"
+        },
+        {
+            "label": "cd",
+            "url": "./cd"
+        },
+        {
+            "label": "copyfile",
+            "url": "./copyfile"
+        },
+        {
+            "label": "delete",
+            "url": "./delete"
+        },
+        {
+            "label": "dir",
+            "url": "./dir"
+        },
+        {
+            "label": "exist",
+            "url": "./exist"
+        },
+        {
+            "label": "fullfile",
+            "url": "./fullfile"
+        },
+        {
+            "label": "getenv",
+            "url": "./getenv"
+        },
+        {
+            "label": "ls",
+            "url": "./ls"
+        },
+        {
+            "label": "mkdir",
+            "url": "./mkdir"
+        },
+        {
+            "label": "movefile",
+            "url": "./movefile"
+        },
+        {
+            "label": "pwd",
+            "url": "./pwd"
+        },
+        {
+            "label": "rmdir",
+            "url": "./rmdir"
+        },
+        {
+            "label": "savepath",
+            "url": "./savepath"
+        },
+        {
+            "label": "setenv",
+            "url": "./setenv"
+        },
+        {
+            "label": "tempdir",
+            "url": "./tempdir"
+        },
+        {
+            "label": "tempname",
+            "url": "./tempname"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/io/repl_fs/genpath.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/repl_fs/genpath.rs"
+    },
+    "gpu_residency": "No. `genpath` manipulates host-side strings and filesystem metadata. Supplying `gpuArray` values provides no benefit—RunMat gathers the data automatically.",
+    "gpu_behavior": [
+        "`genpath` operates entirely on the host filesystem. Any string inputs that reside on the GPU are gathered back to the CPU before processing. No acceleration provider hooks are invoked and no device kernels are launched."
+    ],
+    "key": "genpath",
+    "slug": "genpath",
+    "categoryPath": [
+        "io",
+        "repl_fs"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=genpath.js.map

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

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

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

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

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

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

package/dist/generated/builtins/get.js

@@ -0,0 +1,70 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "get",
+    "category": "plotting",
+    "keywords": [
+        "get",
+        "graphics handle",
+        "plot properties",
+        "matlab get",
+        "inspect plotting state"
+    ],
+    "summary": "Inspect figure, axes, and plot-object properties through RunMat’s graphics handles and MATLAB-style `get` workflows.",
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::get::tests"
+    },
+    "description": "`get` reads properties from plotting handles such as figures, axes, titles, legends, and plot objects. In RunMat, it is the public read path for the expanded plotting object system: line handles, image handles, histogram handles, contour handles, and other plotting objects can all be queried through a single MATLAB-style property interface.",
+    "behaviors": [
+        "`get(h)` returns a struct of known properties for the handle `h`.",
+        "`get(h, 'PropertyName')` returns a single property value.",
+        "The supported property set depends on the handle family: figure, axes, text, legend, and child plot objects each expose different fields.",
+        "RunMat uses `get` to surface subplot-local state such as limits, scale modes, legend visibility, and text metadata.",
+        "The handle families covered by `get` now extend across the major plot families rather than just the most recently added plotting builtins."
+    ],
+    "examples": [
+        {
+            "description": "Inspect the full property struct for a line handle",
+            "input": "h = plot(1:5, [1 4 2 5 3]);\nprops = get(h);"
+        },
+        {
+            "description": "Read an axes-local property",
+            "input": "ax = subplot(1, 2, 2);\nsemilogx(logspace(0, 2, 50), logspace(0, 2, 50));\nget(ax, 'XScale')",
+            "output": "ans =\n    'log'"
+        },
+        {
+            "description": "Inspect a legend handle after creation",
+            "input": "plot(1:5, 1:5);\nlg = legend('series');\nget(lg, 'Orientation')"
+        }
+    ],
+    "links": [
+        {
+            "label": "set",
+            "url": "./set"
+        },
+        {
+            "label": "legend",
+            "url": "./legend"
+        },
+        {
+            "label": "subplot",
+            "url": "./subplot"
+        },
+        {
+            "label": "plot",
+            "url": "./plot"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/get.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/get.rs"
+    },
+    "key": "get",
+    "slug": "get",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=get.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"get.js","sourceRoot":"","sources":["../../../src/generated/builtins/get.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,KAAK;QACL,iBAAiB;QACjB,iBAAiB;QACjB,YAAY;QACZ,wBAAwB;KACzB;IACD,SAAS,EAAE,sHAAsH;IACjI,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,gCAAgC;KACzC;IACD,aAAa,EAAE,wVAAwV;IACvW,WAAW,EAAE;QACX,mEAAmE;QACnE,2DAA2D;QAC3D,2IAA2I;QAC3I,qHAAqH;QACrH,4IAA4I;KAC7I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oDAAoD;YACnE,OAAO,EAAE,8CAA8C;SACxD;QACD;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,8FAA8F;YACvG,QAAQ,EAAE,kBAAkB;SAC7B;QACD;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,iEAAiE;SAC3E;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,0DAA0D;QACnE,KAAK,EAAE,uGAAuG;KAC/G;IACD,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,KAAK;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}