runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/erase.js

@@ -0,0 +1,176 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "erase",
+    "category": "strings/transform",
+    "keywords": [
+        "erase",
+        "remove substring",
+        "delete text",
+        "string manipulation",
+        "character array"
+    ],
+    "summary": "Remove substring occurrences from strings, character arrays, and cell arrays with MATLAB-compatible semantics.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/erase.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Runs on the CPU; RunMat gathers GPU-resident text before removing substrings."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::transform::erase::tests::erase_string_array_shape_mismatch_applies_all_patterns",
+        "integration": "builtins::strings::transform::erase::tests::erase_cell_array_mixed_content"
+    },
+    "description": "`erase(text, pattern)` removes every occurrence of `pattern` from `text`. The builtin accepts string scalars, string arrays, character arrays, and cell arrays of character vectors or string scalars, mirroring MATLAB behaviour. When `pattern` is an array, `erase` removes every occurrence of each pattern entry; the `text` and `pattern` arguments do not need to be the same size.",
+    "behaviors": [
+        "String inputs stay as strings. Missing string scalars (`<missing>`) propagate unchanged.",
+        "String arrays preserve their size and orientation. Each element has every supplied pattern removed.",
+        "Character arrays are processed row by row. Rows shrink as characters are removed and are padded with spaces so the result remains a rectangular char array.",
+        "Cell arrays must contain string scalars or character vectors. The result is a cell array with the same shape whose elements reflect the removed substrings.",
+        "The `pattern` input can be a string scalar, string array, character array, or cell array of character vectors/string scalars. Provide either a scalar pattern or a list; an empty list leaves `text` unchanged.",
+        "Pattern values are treated literally—no regular expressions are used. Use [`replace`](./replace) or the regex builtins for pattern-based removal."
+    ],
+    "examples": [
+        {
+            "description": "Remove a single word from a string scalar",
+            "input": "txt = \"RunMat accelerates MATLAB code\";\nclean = erase(txt, \"accelerates \")",
+            "output": "clean = \"RunMat MATLAB code\""
+        },
+        {
+            "description": "Remove multiple substrings from each element of a string array",
+            "input": "labels = [\"GPU pipeline\"; \"CPU pipeline\"];\nresult = erase(labels, [\"GPU \", \"CPU \"])",
+            "output": "result = 2×1 string\n    \"pipeline\"\n    \"pipeline\""
+        },
+        {
+            "description": "Erase characters from a character array while preserving padding",
+            "input": "chars = char(\"workspace\", \"snapshots\");\ntrimmed = erase(chars, \"s\")",
+            "output": "trimmed =\n\n  2×8 char array\n\n    'workpace'\n    'naphot '"
+        },
+        {
+            "description": "Remove substrings from a cell array of text",
+            "input": "C = {'Kernel Planner', \"GPU Fusion\"};\nout = erase(C, [\"Kernel \", \"GPU \"])",
+            "output": "out = 1×2 cell array\n    {'Planner'}    {\"Fusion\"}"
+        },
+        {
+            "description": "Provide an empty pattern list to leave the text unchanged",
+            "input": "data = [\"alpha\", \"beta\"];\nunchanged = erase(data, string.empty)",
+            "output": "unchanged = 1×2 string\n    \"alpha\"    \"beta\""
+        },
+        {
+            "description": "Remove delimiters before splitting text",
+            "input": "path = \"runmat/bin:runmat/lib\";\nclean = erase(path, \":\")\nparts = split(clean, \"runmat/\")",
+            "output": "clean = \"runmat/binrunmat/lib\"\nparts = 1×3 string\n    \"\"    \"bin\"    \"lib\""
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Can I remove multiple patterns at once?",
+            "answer": "Yes. Supply `pattern` as a string array or cell array. Each pattern is removed in order from every element of the input text."
+        },
+        {
+            "question": "What happens if `pattern` is empty?",
+            "answer": "An empty pattern list leaves the input unchanged. Empty string patterns are ignored because removing empty text would have no effect."
+        },
+        {
+            "question": "Does `erase` modify the original data?",
+            "answer": "No. It returns a new value with substrings removed. The input variables remain unchanged."
+        },
+        {
+            "question": "How are missing string scalars handled?",
+            "answer": "They propagate unchanged. Calling `erase` on `<missing>` returns `<missing>`, matching MATLAB."
+        },
+        {
+            "question": "Can `erase` operate on GPU-resident data?",
+            "answer": "Indirectly. RunMat automatically gathers GPU values to the host, performs the removal, and returns a host result. No explicit `gpuArray` calls are required."
+        },
+        {
+            "question": "How do I remove substrings using patterns or regular expressions?",
+            "answer": "Use `replace` for literal substitution or `regexprep` for regular expressions when you need pattern-based removal rather than literal substring erasure."
+        }
+    ],
+    "links": [
+        {
+            "label": "replace",
+            "url": "./replace"
+        },
+        {
+            "label": "strrep",
+            "url": "./strrep"
+        },
+        {
+            "label": "split",
+            "url": "./split"
+        },
+        {
+            "label": "regexprep",
+            "url": "./regexprep"
+        },
+        {
+            "label": "string",
+            "url": "./string"
+        },
+        {
+            "label": "eraseBetween",
+            "url": "./erasebetween"
+        },
+        {
+            "label": "extractBetween",
+            "url": "./extractbetween"
+        },
+        {
+            "label": "join",
+            "url": "./join"
+        },
+        {
+            "label": "lower",
+            "url": "./lower"
+        },
+        {
+            "label": "pad",
+            "url": "./pad"
+        },
+        {
+            "label": "strcat",
+            "url": "./strcat"
+        },
+        {
+            "label": "strip",
+            "url": "./strip"
+        },
+        {
+            "label": "strtrim",
+            "url": "./strtrim"
+        },
+        {
+            "label": "upper",
+            "url": "./upper"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/transform/erase.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/transform/erase.rs"
+    },
+    "gpu_residency": "No. `erase` automatically gathers GPU inputs and produces host results. You never need to move text to or from the GPU manually for this builtin, and `gpuArray` inputs are handled transparently.",
+    "gpu_behavior": [
+        "`erase` executes on the CPU. When any argument is GPU-resident, RunMat gathers it to host memory before removing substrings. Outputs are returned on the host as well. Providers do not need to implement device kernels for this builtin, and the fusion planner treats it as a sink to avoid keeping text on the GPU."
+    ],
+    "key": "erase",
+    "slug": "erase",
+    "categoryPath": [
+        "strings",
+        "transform"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=erase.js.map

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

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

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

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

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

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

package/dist/generated/builtins/eraseBetween.js

@@ -0,0 +1,174 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "eraseBetween",
+    "category": "strings/transform",
+    "keywords": [
+        "eraseBetween",
+        "delete substring",
+        "boundaries",
+        "inclusive",
+        "exclusive",
+        "string array"
+    ],
+    "summary": "Delete text that lies between boundary markers while matching MATLAB-compatible name-value options.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/string.erasebetween.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "matlab",
+        "notes": "Executes on the CPU. RunMat gathers GPU-resident inputs before deleting text and returns host-side results; the builtin is registered as an Accelerate sink so fusion never keeps the data on device."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 3,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::strings::transform::erasebetween::tests",
+        "integration": "builtins::strings::transform::erasebetween::tests::eraseBetween_numeric_positions_array"
+    },
+    "description": "`eraseBetween(text, start, stop)` removes the portion of `text` that appears between two boundary markers. Boundaries can be substrings or numeric positions. The builtin mirrors MATLAB semantics, including support for string arrays, character arrays, cell arrays, implicit expansion, and the `'Boundaries'` name-value argument that toggles inclusive or exclusive behaviour.",
+    "behaviors": [
+        "Accepts **string scalars**, **string arrays**, **character arrays** (row-by-row), and **cell arrays** containing string scalars or character vectors; the output keeps the same container type.",
+        "Boundary arguments can be text or numeric positions. Both boundaries in a call must use the same representation—mixing text and numeric markers raises a size/type error.",
+        "Text boundaries are **exclusive** by default: the markers are preserved while the enclosed text is deleted. Numeric positions are **inclusive** by default: characters at `startPos` and `endPos` are deleted together with the interior.",
+        "`'Boundaries','inclusive'` removes the markers themselves; `'Boundaries','exclusive'` keeps them. The option is case-insensitive and must be supplied as name-value pairs.",
+        "Missing string scalars propagate (the MATLAB `missing` placeholder in either boundary or text yields `<missing>` in the result). When a boundary cannot be located, `eraseBetween` returns the original element unchanged.",
+        "Numeric positions are validated as positive integers, clamped to the string length, and interpreted using MATLAB’s 1-based indexing rules."
+    ],
+    "examples": [
+        {
+            "description": "Removing text between substrings",
+            "input": "txt = \"The quick brown fox\";\nresult = eraseBetween(txt, \"quick\", \" fox\")",
+            "output": "result = \"The quick fox\""
+        },
+        {
+            "description": "Deleting substrings across a string array",
+            "input": "str = [\"The quick brown fox jumps\"; \"over the lazy dog\"];\nstarts = [\"quick\"; \"the\"];\nends = [\" fox\"; \" dog\"];\ntrimmed = eraseBetween(str, starts, ends)",
+            "output": "trimmed = 2×1 string\n    \"The quick fox jumps\"\n    \"over the dog\""
+        },
+        {
+            "description": "Removing characters between numeric positions",
+            "input": "name = \"Edgar Allen Poe\";\nshort = eraseBetween(name, 6, 11)",
+            "output": "short = \"Edgar Poe\""
+        },
+        {
+            "description": "Using inclusive boundaries to drop the markers",
+            "input": "sentence = \"The quick brown fox jumps over the lazy dog\";\ncollapsed = eraseBetween(sentence, \" brown\", \"lazy\", \"Boundaries\", \"inclusive\")",
+            "output": "collapsed = \"The quick dog\""
+        },
+        {
+            "description": "Operating on character arrays while preserving padding",
+            "input": "chars = char(\"Server<GPU>\", \"Engine<CPU>\");\ntrimmed = eraseBetween(chars, \"<\", \">\", \"Boundaries\", \"inclusive\")",
+            "output": "trimmed =\n\n  2×6 char array\n\n    \"Server\"\n    \"Engine\""
+        },
+        {
+            "description": "Preserving element types in cell arrays",
+            "input": "C = {'alpha<1>', \"beta<2>\";\n     'gamma<3>', \"delta<4>\"};\nclean = eraseBetween(C, \"<\", \">\", \"Boundaries\", \"inclusive\")",
+            "output": "clean =\n  2×2 cell array\n    {'alpha'}    {\"beta\"}\n    {'gamma'}    {\"delta\"}"
+        },
+        {
+            "description": "Handling missing strings safely",
+            "input": "texts = [missing, \"Planner<GPU>\"];\nresult = eraseBetween(texts, \"<\", \">\")",
+            "output": "result = 1×2 string\n    \"<missing>\"    \"Planner\""
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Which argument types does `eraseBetween` accept?",
+            "answer": "The first argument can be a string scalar, string array, character array, or cell array of character vectors / string scalars. Boundary arguments must both be text markers or both be numeric positions."
+        },
+        {
+            "question": "What happens if a boundary is not found?",
+            "answer": "The original text is returned unchanged. Missing string scalars also propagate unchanged."
+        },
+        {
+            "question": "How does `'Boundaries','inclusive'` interact with text markers?",
+            "answer": "Inclusive mode removes the matched start and end markers together with the enclosed text. Exclusive mode keeps the markers and removes only the interior."
+        },
+        {
+            "question": "Can I broadcast scalar boundaries across an array input?",
+            "answer": "Yes. Scalar markers follow MATLAB implicit expansion rules. Character-array and cell-array markers must match the size of the text input."
+        },
+        {
+            "question": "Are GPU inputs supported?",
+            "answer": "GPU values are gathered to host memory before processing. The builtin always returns host-resident outputs and is registered as an Accelerate sink, so fusion planning does not keep text on the GPU."
+        },
+        {
+            "question": "Does `eraseBetween` validate numeric positions?",
+            "answer": "Yes. Positions are parsed as positive integers using MATLAB’s 1-based indexing. Stops are clamped to the string length, and start positions that lie beyond the text leave the element unchanged."
+        }
+    ],
+    "links": [
+        {
+            "label": "extractBetween",
+            "url": "./extractbetween"
+        },
+        {
+            "label": "erase",
+            "url": "./erase"
+        },
+        {
+            "label": "replace",
+            "url": "./replace"
+        },
+        {
+            "label": "split",
+            "url": "./split"
+        },
+        {
+            "label": "join",
+            "url": "./join"
+        },
+        {
+            "label": "lower",
+            "url": "./lower"
+        },
+        {
+            "label": "pad",
+            "url": "./pad"
+        },
+        {
+            "label": "strcat",
+            "url": "./strcat"
+        },
+        {
+            "label": "strip",
+            "url": "./strip"
+        },
+        {
+            "label": "strrep",
+            "url": "./strrep"
+        },
+        {
+            "label": "strtrim",
+            "url": "./strtrim"
+        },
+        {
+            "label": "upper",
+            "url": "./upper"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/strings/transform/erasebetween.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/transform/erasebetween.rs"
+    },
+    "gpu_residency": "No. RunMat automatically gathers device-resident inputs, performs the deletion on the CPU, and returns host outputs. Manual `gpuArray` / `gather` calls are unnecessary; they are honoured only for compatibility with MATLAB when you explicitly need to control residency.",
+    "gpu_behavior": [
+        "The builtin performs all work on the CPU. When any argument is GPU-resident, RunMat gathers the values first, applies the deletions on the host, and returns host-resident outputs. Providers do not need to expose device kernels, and fusion planning treats `eraseBetween` as a residency sink so surrounding expressions will gather automatically."
+    ],
+    "key": "erasebetween",
+    "slug": "erasebetween",
+    "categoryPath": [
+        "strings",
+        "transform"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=eraseBetween.js.map

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

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

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

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

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

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

package/dist/generated/builtins/error.js

@@ -0,0 +1,124 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "error",
+    "category": "diagnostics",
+    "keywords": [
+        "error",
+        "exception",
+        "throw",
+        "diagnostics",
+        "message"
+    ],
+    "summary": "Throw an exception with an identifier and a formatted diagnostic message.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Always executed on the host; GPU tensors are gathered only when they appear in formatted arguments."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::diagnostics::error::tests",
+        "integration": null
+    },
+    "description": "`error` throws an exception immediately, unwinding the current execution frame and transferring control to the nearest `catch` block (or aborting the program if none exists). RunMat mirrors MATLAB's behaviour, including support for message identifiers, formatted messages, `MException` objects, and legacy message structs.",
+    "behaviors": [
+        "`error(message)` throws using the default identifier `RunMat:error`.",
+        "`error(id, message)` uses a custom identifier. Identifiers are normalised to `RunMat:*` when they do not already contain a namespace.",
+        "`error(fmt, arg1, ...)` formats the message with MATLAB's `sprintf` rules before throwing.",
+        "`error(id, fmt, arg1, ...)` combines both a custom identifier and formatted message text.",
+        "`error(MException_obj)` rethrows an existing exception without altering its identifier or message.",
+        "`error(struct('identifier', id, 'message', msg))` honours the legacy structure form.",
+        "Invalid invocations (missing message, extra arguments after an `MException`, malformed structs, etc.) themselves raise `RunMat:error` diagnostics so the caller can correct usage.\n\nThe thrown exception is observed in MATLAB-compatible `try`/`catch` constructs or by the embedding runtime, which converts the string back into an `MException` object."
+    ],
+    "examples": [
+        {
+            "description": "Throwing an error with a simple message",
+            "input": "try\n    error(\"Computation failed.\");\ncatch err\n    fprintf(\"%s -> %s\\n\", err.identifier, err.message);\nend"
+        },
+        {
+            "description": "Throwing an error with a custom identifier",
+            "input": "try\n    error(\"runmat:examples:invalidState\", \"State vector is empty.\");\ncatch err\n    fprintf(\"%s\\n\", err.identifier);\nend"
+        },
+        {
+            "description": "Formatting values inside the error message",
+            "input": "value = 42;\ntry\n    error(\"RunMat:demo:badValue\", \"Value %d is outside [%d, %d].\", value, 0, 10);\ncatch err\n    disp(err.message);\nend"
+        },
+        {
+            "description": "Rethrowing an existing MException",
+            "input": "try\n    try\n        error(\"RunMat:inner:failure\", \"Inner failure.\");\n    catch inner\n        error(inner); % propagate with original identifier/message\n    end\ncatch err\n    fprintf(\"%s\\n\", err.identifier);\nend"
+        },
+        {
+            "description": "Using a legacy message struct",
+            "input": "S.identifier = \"toolbox:demo:badInput\";\nS.message = \"Inputs must be positive integers.\";\ntry\n    error(S);\ncatch err\n    fprintf(\"%s\\n\", err.identifier);\nend"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How do I choose a custom identifier?",
+            "answer": "Use `component:mnemonic` style strings such as `\"RunMat:io:fileNotFound\"` or `\"runmat:tools:badInput\"`. If you omit a namespace (`:`), RunMat prefixes the identifier with `RunMat:` automatically."
+        },
+        {
+            "question": "Can I rethrow an existing `MException`?",
+            "answer": "Yes. Pass the object returned by `catch err` directly to `error(err)` to propagate it unchanged."
+        },
+        {
+            "question": "What happens if I pass extra arguments after an `MException` or struct?",
+            "answer": "RunMat treats that as invalid usage and raises `RunMat:error` explaining that no additional arguments are allowed in those forms."
+        },
+        {
+            "question": "Does `error` run on the GPU?",
+            "answer": "No. The builtin executes on the host. If the message references GPU data, RunMat gathers the values before formatting the diagnostic string."
+        },
+        {
+            "question": "What if I call `error` without arguments?",
+            "answer": "RunMat raises `RunMat:error` indicating that a message is required, matching MATLAB's behaviour."
+        },
+        {
+            "question": "Why was my identifier normalised to `RunMat:...`?",
+            "answer": "MATLAB requires message identifiers to contain at least one namespace separator (`:`). RunMat enforces this rule so diagnostics integrate cleanly with tooling that expects fully-qualified identifiers."
+        },
+        {
+            "question": "Can the message span multiple lines?",
+            "answer": "Yes. Any newline characters in the formatted message are preserved exactly in the thrown exception."
+        },
+        {
+            "question": "Does formatting follow MATLAB rules?",
+            "answer": "Yes. `error` uses the same formatter as `sprintf`, including width/precision specifiers and numeric conversions, and will raise `RunMat:error` if the format string is invalid or under-specified. #"
+        }
+    ],
+    "links": [
+        {
+            "label": "assert",
+            "url": "./assert"
+        },
+        {
+            "label": "warning",
+            "url": "./warning"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/diagnostics/error.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/diagnostics/error.rs"
+    },
+    "gpu_residency": "`error` is a control-flow builtin and never executes on the GPU. When formatting messages that include GPU-resident arrays (for example, via `%g` or `%s` specifiers), RunMat first gathers those values back to host memory so that the final diagnostic message accurately reflects the data the user passed.",
+    "gpu_behavior": [
+        "`error` is a control-flow builtin and never executes on the GPU. When formatting messages that include GPU-resident arrays (for example, via `%g` or `%s` specifiers), RunMat first gathers those values back to host memory so that the final diagnostic message accurately reflects the data the user passed."
+    ],
+    "key": "error",
+    "slug": "error",
+    "categoryPath": [
+        "diagnostics"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=error.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"error.js","sourceRoot":"","sources":["../../../src/generated/builtins/error.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,OAAO;QACP,WAAW;QACX,OAAO;QACP,aAAa;QACb,SAAS;KACV;IACD,SAAS,EAAE,2EAA2E;IACtF,YAAY,EAAE,EAAE;IAChB,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,qGAAqG;KAC/G;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,qCAAqC;QAC7C,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,oUAAoU;IACnV,WAAW,EAAE;QACX,sEAAsE;QACtE,uIAAuI;QACvI,4FAA4F;QAC5F,2FAA2F;QAC3F,oGAAoG;QACpG,sFAAsF;QACtF,+VAA+V;KAChW;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,sHAAsH;SAChI;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,wIAAwI;SAClJ;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,iJAAiJ;SAC3J;QACD;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,mOAAmO;SAC7O;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,4KAA4K;SACtL;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,yMAAyM;SACpN;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,kGAAkG;SAC7G;QACD;YACE,UAAU,EAAE,yEAAyE;YACrF,QAAQ,EAAE,mIAAmI;SAC9I;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,8IAA8I;SACzJ;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,kGAAkG;SAC7G;QACD;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,0MAA0M;SACrN;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,qGAAqG;SAChH;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,sMAAsM;SACjN;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,eAAe,EAAE,iTAAiT;IAClU,cAAc,EAAE;QACd,iTAAiT;KAClT;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,cAAc,EAAE;QACd,aAAa;KACd;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/errorbar.js

@@ -0,0 +1,95 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "errorbar",
+    "category": "plotting",
+    "keywords": [
+        "errorbar",
+        "error bars",
+        "uncertainty plot",
+        "confidence interval plot",
+        "matlab errorbar"
+    ],
+    "summary": "Plot data with symmetric or asymmetric error bars for uncertainty, intervals, and MATLAB `errorbar` workflows.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "single",
+            "double"
+        ],
+        "broadcasting": "none",
+        "notes": "`errorbar` has a dedicated GPU geometry path for supported input combinations and shares the marker path used by other marker-bearing plots."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 6,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::plotting::errorbar::tests",
+        "integration": "runmat-plot/tests/renderer_tests.rs"
+    },
+    "description": "`errorbar` visualizes uncertainty around data points using vertical or both-direction error bars. In RunMat it returns a plot handle, supports MATLAB-style symmetric and asymmetric forms, and participates in the same handle/property and marker-rendering system used by line-like plotting builtins.",
+    "behaviors": [
+        "Vertical-only and both-direction error-bar forms are supported through the runtime and replay/render stack.",
+        "The returned value is an error-bar handle that can be queried or updated through `get` and `set`.",
+        "Cap size, line styling, marker appearance, display names, and related properties use the shared plotting object/property system.",
+        "Error bars remain subplot-local and integrate naturally with legends and axes state.",
+        "GPU-backed geometry is used when plotting-compatible buffers are available for the full input set; otherwise RunMat falls back to host plotting while preserving the same visible result."
+    ],
+    "examples": [
+        {
+            "description": "Plot symmetric vertical error bars",
+            "input": "x = 1:5;\ny = [2 3 2.5 4 3.5];\nerr = [0.2 0.3 0.1 0.4 0.2];\nerrorbar(x, y, err, err);"
+        },
+        {
+            "description": "Plot asymmetric both-direction error bars",
+            "input": "x = 1:4;\ny = [3 4 2 5];\nxn = [0.1 0.2 0.1 0.3];\nxp = [0.2 0.3 0.2 0.4];\nyn = [0.3 0.2 0.4 0.2];\nyp = [0.4 0.3 0.5 0.3];\nerrorbar(x, y, xn, xp, yn, yp);"
+        },
+        {
+            "description": "Style an error-bar object and label it for the legend",
+            "input": "x = 1:5;\ny = [1 2 1.5 3 2.5];\nh = errorbar(x, y, 0.2*ones(size(x)), 0.2*ones(size(x)));\nset(h, 'LineWidth', 2, 'DisplayName', 'measurement');\nlegend;"
+        }
+    ],
+    "links": [
+        {
+            "label": "stem",
+            "url": "./stem"
+        },
+        {
+            "label": "plot",
+            "url": "./plot"
+        },
+        {
+            "label": "legend",
+            "url": "./legend"
+        },
+        {
+            "label": "get",
+            "url": "./get"
+        },
+        {
+            "label": "set",
+            "url": "./set"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/plotting/ops/errorbar.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/errorbar.rs"
+    },
+    "gpu_residency": "`errorbar` preserves GPU residency when the direct error-bar packer path is available for the full input set. Marker rendering stays aligned with the shared marker path.",
+    "gpu_behavior": [
+        "Dedicated GPU geometry generation covers supported vertical and both-direction error-bar workflows.",
+        "Markers continue to use the shared marker path so line/marker styling stays consistent with the rest of the plotting stack."
+    ],
+    "key": "errorbar",
+    "slug": "errorbar",
+    "categoryPath": [
+        "plotting"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=errorbar.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"errorbar.js","sourceRoot":"","sources":["../../../src/generated/builtins/errorbar.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,UAAU;QACV,YAAY;QACZ,kBAAkB;QAClB,0BAA0B;QAC1B,iBAAiB;KAClB;IACD,SAAS,EAAE,gHAAgH;IAC3H,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,8IAA8I;KACxJ;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,qCAAqC;QAC7C,aAAa,EAAE,qCAAqC;KACrD;IACD,aAAa,EAAE,2SAA2S;IAC1T,WAAW,EAAE;QACX,6GAA6G;QAC7G,mGAAmG;QACnG,kIAAkI;QAClI,sFAAsF;QACtF,2LAA2L;KAC5L;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,yFAAyF;SACnG;QACD;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,+JAA+J;SACzK;QACD;YACE,aAAa,EAAE,uDAAuD;YACtE,OAAO,EAAE,2JAA2J;SACrK;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;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,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,eAAe,EAAE,2KAA2K;IAC5L,cAAc,EAAE;QACd,qGAAqG;QACrG,6HAA6H;KAC9H;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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