runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/gpuDevice.js

@@ -0,0 +1,127 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "gpuDevice",
+    "category": "acceleration/gpu",
+    "keywords": [
+        "gpuDevice",
+        "gpu",
+        "device info",
+        "accelerate",
+        "provider"
+    ],
+    "summary": "Query metadata about the active GPU provider and return it as a MATLAB struct.",
+    "references": [
+        "https://www.mathworks.com/help/parallel-computing/gpudevice.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Pure query builtin; it never enqueues GPU kernels. Providers that omit metadata simply leave the corresponding struct fields absent."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::acceleration::gpu::gpudevice::tests::gpu_device_returns_struct",
+        "integration": "tests::gpu::gpu_device_returns_struct",
+        "wgpu": "builtins::acceleration::gpu::gpudevice::tests::gpu_device_wgpu_reports_metadata"
+    },
+    "description": "`info = gpuDevice()` queries the active accelerator provider and returns a MATLAB struct that describes the GPU (or GPU-like backend) that RunMat is currently using. The struct mirrors MathWorks MATLAB's `gpuDevice` metadata, exposing identifiers, vendor information, memory hints, and precision support so you can adapt algorithms at runtime.\n\nThe returned struct contains a subset of these fields (providers may omit ones they cannot populate):\n\n- `device_id` — zero-based identifier reported by the provider. - `index` — MATLAB-style one-based index derived from `device_id`. - `name` — human-readable adapter name. - `vendor` — provider-reported vendor or implementation name. - `backend` — backend identifier such as `inprocess` or `Vulkan` (optional). - `memory_bytes` — total device memory in bytes when known (optional). - `precision` — string describing the scalar precision used for kernels (`\"double\"` or `\"single\"`). - `supports_double` — logical flag that is `true` when double precision kernels are available.\n\nThe builtin raises `gpuDevice: no acceleration provider registered` when no provider is active.",
+    "behaviors": [
+        "Requires an acceleration provider that implements RunMat Accelerate's `AccelProvider` trait.",
+        "Returns a struct so you can access fields with dot notation: `gpuDevice().name`.",
+        "Does not mutate GPU state or enqueue kernels—it is safe to call frequently.",
+        "Accepts a scalar device index; `gpuDevice(1)` returns the active provider, while any other index raises the MATLAB-style error `gpuDevice: GPU device with index N not available`.",
+        "Requests to reset the provider using `gpuDevice('reset')` or `gpuDevice([])` currently raise `gpuDevice: reset is not supported by the active provider`.",
+        "Hooks into `gpuInfo` so the string-form summary stays in sync with the struct fields."
+    ],
+    "examples": [
+        {
+            "description": "Inspecting the active GPU provider",
+            "input": "info = gpuDevice();\ndisp(info.name)",
+            "output": "InProcess"
+        },
+        {
+            "description": "Displaying vendor and backend metadata",
+            "input": "info = gpuDevice();\nfprintf(\"Vendor: %s (backend: %s)\\n\", info.vendor, info.backend)",
+            "output": "Vendor: RunMat (backend: inprocess)"
+        },
+        {
+            "description": "Checking whether double precision is supported",
+            "input": "info = gpuDevice();\nif info.supports_double\n    disp(\"Double precision kernels are available.\");\nelse\n    disp(\"Provider only exposes single precision.\");\nend"
+        },
+        {
+            "description": "Formatting a user-facing status message",
+            "input": "summary = gpuInfo();\ndisp(\"Active GPU summary:\");\ndisp(summary)",
+            "output": "Active GPU summary:\nGPU[device_id=0, index=1, name='InProcess', vendor='RunMat', backend='inprocess', precision='double', supports_double=true]"
+        },
+        {
+            "description": "Handling missing providers gracefully",
+            "input": "try\n    info = gpuDevice();\ncatch ex\n    warning(\"GPU unavailable: %s\", ex.message);\nend"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Do I need to call `gpuDevice` before using other GPU builtins?",
+            "answer": "No. RunMat initialises the active provider during startup. `gpuDevice` is purely informational and can be called at any time to inspect the current provider."
+        },
+        {
+            "question": "Why are some fields missing from the struct?",
+            "answer": "Providers only fill metadata they can reliably supply. For example, the in-process test provider does not report `memory_bytes`. Real GPU backends typically populate additional fields."
+        },
+        {
+            "question": "What happens if there is no GPU provider?",
+            "answer": "RunMat raises `gpuDevice: no acceleration provider registered`. You can catch this error and fall back to CPU code, as shown in the examples above."
+        },
+        {
+            "question": "Does `gpuDevice` support selecting or resetting devices?",
+            "answer": "RunMat currently exposes a single provider. `gpuDevice(1)` returns that provider, matching MATLAB's first-device semantics, while any other index raises `gpuDevice: GPU device with index N not available`. Reset requests (`gpuDevice('reset')` or `gpuDevice([])`) are not implemented yet and return `gpuDevice: reset is not supported by the active provider`."
+        },
+        {
+            "question": "How can I get a quick string summary instead of a struct?",
+            "answer": "Use `gpuInfo()`. It internally calls `gpuDevice` and formats the struct fields into a concise status string that is convenient for logging or display."
+        }
+    ],
+    "links": [
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "gpuInfo",
+            "url": "./gpuinfo"
+        },
+        {
+            "label": "arrayfun",
+            "url": "./arrayfun"
+        },
+        {
+            "label": "pagefun",
+            "url": "./pagefun"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/acceleration/gpu/gpudevice.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/acceleration/gpu/gpudevice.rs"
+    },
+    "gpu_residency": "`gpuDevice` purely reports metadata and does not change residency. Arrays remain on the GPU or CPU exactly as they were prior to the call. Use `gpuArray`, `gather`, and the planner-controlled automatic residency features to move data as needed.",
+    "key": "gpudevice",
+    "slug": "gpudevice",
+    "categoryPath": [
+        "acceleration",
+        "gpu"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=gpuDevice.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gpuDevice.js","sourceRoot":"","sources":["../../../src/generated/builtins/gpuDevice.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,WAAW;IACpB,UAAU,EAAE,kBAAkB;IAC9B,UAAU,EAAE;QACV,WAAW;QACX,KAAK;QACL,aAAa;QACb,YAAY;QACZ,UAAU;KACX;IACD,SAAS,EAAE,gFAAgF;IAC3F,YAAY,EAAE;QACZ,kEAAkE;KACnE;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,sIAAsI;KAChJ;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,0EAA0E;QAClF,aAAa,EAAE,uCAAuC;QACtD,MAAM,EAAE,iFAAiF;KAC1F;IACD,aAAa,EAAE,4mCAA4mC;IAC3nC,WAAW,EAAE;QACX,8FAA8F;QAC9F,kFAAkF;QAClF,6EAA6E;QAC7E,oLAAoL;QACpL,0JAA0J;QAC1J,uFAAuF;KACxF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,sCAAsC;YAC/C,QAAQ,EAAE,WAAW;SACtB;QACD;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,0FAA0F;YACnG,QAAQ,EAAE,qCAAqC;SAChD;QACD;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,yKAAyK;SACnL;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,qEAAqE;YAC9E,QAAQ,EAAE,kJAAkJ;SAC7J;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,gGAAgG;SAC1G;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,gEAAgE;YAC5E,QAAQ,EAAE,+JAA+J;SAC1K;QACD;YACE,UAAU,EAAE,8CAA8C;YAC1D,QAAQ,EAAE,0LAA0L;SACrM;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,qJAAqJ;SAChK;QACD;YACE,UAAU,EAAE,0DAA0D;YACtE,QAAQ,EAAE,sWAAsW;SACjX;QACD;YACE,UAAU,EAAE,2DAA2D;YACvE,QAAQ,EAAE,wJAAwJ;SACnK;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,oEAAoE;QAC7E,KAAK,EAAE,iHAAiH;KACzH;IACD,eAAe,EAAE,sPAAsP;IACvQ,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,WAAW;IACnB,cAAc,EAAE;QACd,cAAc;QACd,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/gpuInfo.js

@@ -0,0 +1,126 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "gpuInfo",
+    "category": "acceleration/gpu",
+    "keywords": [
+        "gpuInfo",
+        "gpu",
+        "device info",
+        "accelerate",
+        "summary"
+    ],
+    "summary": "Return a formatted status string that describes the active GPU provider.",
+    "references": [
+        "https://www.mathworks.com/help/parallel-computing/gpudevice.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Pure query builtin that formats provider metadata. When no provider is registered it returns `GPU[no provider]`."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::acceleration::gpu::gpuinfo::tests::gpu_info_with_provider_formats_summary",
+        "fallback": "builtins::acceleration::gpu::gpuinfo::tests::gpu_info_placeholder_matches_expectation",
+        "wgpu": "builtins::acceleration::gpu::gpuinfo::tests::gpuInfo_wgpu_provider_reports_backend"
+    },
+    "description": "`gpuInfo()` returns a concise, human-readable string that summarises the active GPU acceleration provider. It is a convenience wrapper around [`gpuDevice`](./gpudevice), intended for logging or displaying status information in the REPL and notebooks.",
+    "behaviors": [
+        "Queries the same device metadata as `gpuDevice()` and formats the fields into `GPU[key=value, ...]`.",
+        "Includes identifiers (`device_id`, `index`), descriptive strings (`name`, `vendor`, `backend`) and capability hints (`precision`, `supports_double`, `memory_bytes` when available).",
+        "Escapes string values using MATLAB-style single quote doubling so they are display-friendly.",
+        "When no acceleration provider is registered, returns the placeholder string `GPU[no provider]` instead of throwing an error, making it safe to call unconditionally.",
+        "Propagates unexpected errors (for example, if a provider fails while reporting metadata) so they can be diagnosed."
+    ],
+    "examples": [
+        {
+            "description": "Displaying GPU status in the REPL",
+            "input": "disp(gpuInfo())",
+            "output": "GPU[device_id=0, index=1, name='InProcess', vendor='RunMat', backend='inprocess', precision='double', supports_double=true]"
+        },
+        {
+            "description": "Emitting a log line before a computation",
+            "input": "fprintf(\"Running on %s\\n\", gpuInfo())",
+            "output": "Running on GPU[device_id=0, index=1, name='InProcess', vendor='RunMat', backend='inprocess', precision='double', supports_double=true]"
+        },
+        {
+            "description": "Checking for double precision support quickly",
+            "input": "summary = gpuInfo();\nif contains(summary, \"supports_double=true\")\n    disp(\"Double precision kernels available.\");\nelse\n    disp(\"Falling back to single precision.\");\nend"
+        },
+        {
+            "description": "Handling missing providers gracefully",
+            "input": "% Safe even when acceleration is disabled\nstatus = gpuInfo();\nif status == \"GPU[no provider]\"\n    warning(\"GPU acceleration is currently disabled.\");\nend"
+        },
+        {
+            "description": "Combining `gpuInfo` with `gpuDevice` for structured data",
+            "input": "info = gpuDevice();\nsummary = gpuInfo();\nif isfield(info, 'memory_bytes')\n    fprintf(\"%s (memory: %.2f GB)\\n\", summary, info.memory_bytes / 1e9);\nelse\n    fprintf(\"%s (memory: unknown)\\n\", summary);\nend",
+            "output": "GPU[device_id=0, index=1, name='InProcess', vendor='RunMat', backend='inprocess', precision='double', supports_double=true] (memory: 15.99 GB)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `gpuInfo` change GPU state?",
+            "answer": "No. It only reads metadata and formats it into a string."
+        },
+        {
+            "question": "Will `gpuInfo` throw an error when no provider is registered?",
+            "answer": "No. It returns `GPU[no provider]` so caller code can branch without exception handling."
+        },
+        {
+            "question": "How is `gpuInfo` different from `gpuDevice`?",
+            "answer": "`gpuDevice` returns a struct that you can inspect programmatically. `gpuInfo` formats the same information into a single string that is convenient for logging and display."
+        },
+        {
+            "question": "Does the output order of fields stay stable?",
+            "answer": "Yes. Fields are emitted in the same order as the `gpuDevice` struct: identifiers, descriptive strings, optional metadata, precision, and capability flags."
+        },
+        {
+            "question": "Are strings escaped in MATLAB style?",
+            "answer": "Yes. Single quotes are doubled (e.g., `Ada'GPU` becomes `Ada''GPU`) so the summary can be pasted back into MATLAB code without breaking literal syntax."
+        }
+    ],
+    "links": [
+        {
+            "label": "gpuDevice",
+            "url": "./gpudevice"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "arrayfun",
+            "url": "./arrayfun"
+        },
+        {
+            "label": "pagefun",
+            "url": "./pagefun"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/acceleration/gpu/gpuinfo.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/acceleration/gpu/gpuinfo.rs"
+    },
+    "gpu_residency": "`gpuInfo` is a pure metadata query and never changes residency. Arrays stay wherever they already live (GPU or CPU). Use `gpuArray`, `gather`, or RunMat Accelerate's auto-offload heuristics to move data between devices as needed.",
+    "key": "gpuinfo",
+    "slug": "gpuinfo",
+    "categoryPath": [
+        "acceleration",
+        "gpu"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=gpuInfo.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gpuInfo.js","sourceRoot":"","sources":["../../../src/generated/builtins/gpuInfo.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,kBAAkB;IAC9B,UAAU,EAAE;QACV,SAAS;QACT,KAAK;QACL,aAAa;QACb,YAAY;QACZ,SAAS;KACV;IACD,SAAS,EAAE,0EAA0E;IACrF,YAAY,EAAE;QACZ,kEAAkE;KACnE;IACD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,kHAAkH;KAC5H;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,qFAAqF;QAC7F,UAAU,EAAE,uFAAuF;QACnG,MAAM,EAAE,oFAAoF;KAC7F;IACD,aAAa,EAAE,4PAA4P;IAC3Q,WAAW,EAAE;QACX,sGAAsG;QACtG,sLAAsL;QACtL,8FAA8F;QAC9F,sKAAsK;QACtK,oHAAoH;KACrH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,iBAAiB;YAC1B,QAAQ,EAAE,6HAA6H;SACxI;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,0CAA0C;YACnD,QAAQ,EAAE,wIAAwI;SACnJ;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,uLAAuL;SACjM;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,mKAAmK;SAC7K;QACD;YACE,aAAa,EAAE,0DAA0D;YACzE,OAAO,EAAE,yNAAyN;YAClO,QAAQ,EAAE,gJAAgJ;SAC3J;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,0DAA0D;SACrE;QACD;YACE,UAAU,EAAE,+DAA+D;YAC3E,QAAQ,EAAE,yFAAyF;SACpG;QACD;YACE,UAAU,EAAE,8CAA8C;YAC1D,QAAQ,EAAE,6KAA6K;SACxL;QACD;YACE,UAAU,EAAE,8CAA8C;YAC1D,QAAQ,EAAE,4JAA4J;SACvK;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,yJAAyJ;SACpK;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,kEAAkE;QAC3E,KAAK,EAAE,+GAA+G;KACvH;IACD,eAAe,EAAE,uOAAuO;IACxP,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,cAAc,EAAE;QACd,cAAc;QACd,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/grid.js

@@ -0,0 +1,60 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "grid",
+    "category": "plotting",
+    "keywords": [
+        "grid",
+        "grid on",
+        "grid off",
+        "chart grid lines",
+        "matlab grid"
+    ],
+    "summary": "Toggle grid lines for charts, subplots, and MATLAB `grid on` / `grid off` workflows.",
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::cmds"
+    },
+    "description": "`grid` controls the visibility of axes grid lines on the active subplot or axes selection. It supports the familiar MATLAB command-style forms `grid on`, `grid off`, and bare `grid` toggling, while returning the resulting boolean state in RunMat.",
+    "behaviors": [
+        "`grid on` enables grid lines on the current axes.",
+        "`grid off` disables grid lines on the current axes.",
+        "Calling `grid` with no argument toggles the current state.",
+        "Grid visibility is subplot-local and does not spill into other axes automatically."
+    ],
+    "examples": [
+        {
+            "description": "Enable grid lines on a simple line chart",
+            "input": "plot(1:5, [1 4 2 5 3]);\ngrid on;"
+        },
+        {
+            "description": "Toggle grid lines in one subplot only",
+            "input": "subplot(1, 2, 1);\nplot(1:5, 1:5);\ngrid off;\nsubplot(1, 2, 2);\nplot(1:5, [5 4 3 2 1]);\ngrid on;"
+        }
+    ],
+    "links": [
+        {
+            "label": "axis",
+            "url": "./axis"
+        },
+        {
+            "label": "box",
+            "url": "./box"
+        },
+        {
+            "label": "subplot",
+            "url": "./subplot"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/cmds.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/cmds.rs"
+    },
+    "key": "grid",
+    "slug": "grid",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=grid.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"grid.js","sourceRoot":"","sources":["../../../src/generated/builtins/grid.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,MAAM;QACN,SAAS;QACT,UAAU;QACV,kBAAkB;QAClB,aAAa;KACd;IACD,SAAS,EAAE,sFAAsF;IACjG,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,0BAA0B;KACnC;IACD,aAAa,EAAE,wPAAwP;IACvQ,WAAW,EAAE;QACX,mDAAmD;QACnD,qDAAqD;QACrD,4DAA4D;QAC5D,oFAAoF;KACrF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,mCAAmC;SAC7C;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,qGAAqG;SAC/G;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

@@ -0,0 +1,153 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "gt",
+    "category": "logical/rel",
+    "keywords": [
+        "gt",
+        ">",
+        "greater than",
+        "logical comparison",
+        "gpuArray greater-than"
+    ],
+    "summary": "Element-wise greater-than comparison for scalars, arrays, strings, and gpuArray inputs.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Uses provider elem_gt 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::gt::tests",
+        "integration": "builtins::logical::rel::gt::tests::gt_gpu_provider_roundtrip",
+        "gpu": "builtins::logical::rel::gt::tests::gt_wgpu_matches_host"
+    },
+    "description": "`gt(A, B)` (or the infix `A > B`) performs an element-wise greater-than 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' > 60`).",
+        "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": "Determine Whether One Scalar Exceeds Another",
+            "input": "flag = gt(42, 17)",
+            "output": "flag =\n     1"
+        },
+        {
+            "description": "Filter Matrix Elements Greater Than a Threshold",
+            "input": "M = [1 2 3; 4 5 6];\nmask = gt(M, 3)",
+            "output": "mask =\n  2×3 logical array\n     0     0     0\n     1     1     1"
+        },
+        {
+            "description": "Apply Greater-Than With Implicit Expansion",
+            "input": "v = [1 3 5 7];\nmask = gt(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'];\nisAfterB = gt(letters, 66)",
+            "output": "isAfterB =\n  1×3 logical array\n     0     0     1"
+        },
+        {
+            "description": "Compare String Arrays Lexicographically",
+            "input": "names = [\"alice\" \"charlie\" \"bob\"];\nlater = gt(names, \"bob\")",
+            "output": "later =\n  1×3 logical array\n     0     1     0"
+        },
+        {
+            "description": "Run `gt` Directly On `gpuArray` Inputs",
+            "input": "G1 = gpuArray([1 4 7]);\nG2 = gpuArray([0 5 6]);\ndeviceResult = gt(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 `gt` 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 `gt`?",
+            "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_gt`, 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 `gt` 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": "eq",
+            "url": "./eq"
+        },
+        {
+            "label": "ne",
+            "url": "./ne"
+        },
+        {
+            "label": "ge",
+            "url": "./ge"
+        },
+        {
+            "label": "isequal",
+            "url": "./isequal"
+        },
+        {
+            "label": "le",
+            "url": "./le"
+        },
+        {
+            "label": "lt",
+            "url": "./lt"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/logical/rel/gt.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/logical/rel/gt.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_gt` 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": "gt",
+    "slug": "gt",
+    "categoryPath": [
+        "logical",
+        "rel"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=gt.js.map

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

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

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

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

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

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

package/dist/generated/builtins/hist.js

@@ -0,0 +1,84 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "hist",
+    "category": "plotting",
+    "keywords": [
+        "hist",
+        "legacy histogram",
+        "bin centers",
+        "distribution plot",
+        "matlab hist",
+        "hist vs histogram"
+    ],
+    "summary": "Create legacy center-based histograms for quick distribution plots and MATLAB `hist` workflows.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`hist` supports GPU-aware histogram computation where applicable, but it remains the legacy center-based histogram workflow rather than the object-based `histogram` API."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::hist::tests"
+    },
+    "description": "`hist` is the legacy histogram builtin that uses MATLAB `hist` semantics. The most important distinction from `histogram` is that when you pass a vector as the second argument, `hist` interprets that vector as bin centers rather than bin edges. In RunMat, `hist` remains useful for center-based legacy workflows, while `histogram` is the newer object-style histogram API with bin-edge semantics and handle-based property workflows.",
+    "behaviors": [
+        "`hist(data)` uses a default number of bins based on the input size, following MATLAB-style legacy behavior.",
+        "`hist(data, v)` interprets `v` as bin centers, not bin edges. This is the key semantic difference from `histogram`.",
+        "`hist` is a plotting-style histogram command, while `histogram` returns a first-class histogram object handle.",
+        "Normalization and bin-control workflows are supported, but the builtin should still be documented and used as the legacy center-based histogram path rather than as an alias of `histogram`.",
+        "GPU-aware computation is used where supported, but semantics stay aligned with legacy MATLAB `hist` behavior."
+    ],
+    "examples": [
+        {
+            "description": "Create a default legacy histogram",
+            "input": "data = randn(1, 1000);\nhist(data);"
+        },
+        {
+            "description": "Pass explicit bin centers",
+            "input": "data = randn(1, 500);\ncenters = -3:0.5:3;\nhist(data, centers);",
+            "output": "% Here the second argument is interpreted as bin centers, not edges"
+        },
+        {
+            "description": "Compare legacy hist semantics with modern histogram intent",
+            "input": "data = randn(1, 300);\nhist(data, -2:0.5:2);",
+            "output": "% Use histogram(...) instead when you want bin-edge semantics and an object handle"
+        }
+    ],
+    "links": [
+        {
+            "label": "histogram",
+            "url": "./histogram"
+        },
+        {
+            "label": "bar",
+            "url": "./bar"
+        },
+        {
+            "label": "pie",
+            "url": "./pie"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/hist.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/hist.rs"
+    },
+    "key": "hist",
+    "slug": "hist",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=hist.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hist.js","sourceRoot":"","sources":["../../../src/generated/builtins/hist.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,MAAM;QACN,kBAAkB;QAClB,aAAa;QACb,mBAAmB;QACnB,aAAa;QACb,mBAAmB;KACpB;IACD,SAAS,EAAE,iGAAiG;IAC5G,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,QAAQ;YACR,QAAQ;SACT;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,2KAA2K;KACrL;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,ibAAib;IAChc,WAAW,EAAE;QACX,6GAA6G;QAC7G,qHAAqH;QACrH,gHAAgH;QAChH,8LAA8L;QAC9L,+GAA+G;KAChH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,qCAAqC;SAC/C;QACD;YACE,aAAa,EAAE,2BAA2B;YAC1C,OAAO,EAAE,kEAAkE;YAC3E,QAAQ,EAAE,qEAAqE;SAChF;QACD;YACE,aAAa,EAAE,4DAA4D;YAC3E,OAAO,EAAE,8CAA8C;YACvD,QAAQ,EAAE,oFAAoF;SAC/F;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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