runmat 0.3.6 → 0.4.0

package/dist/generated/builtins/asin.js

@@ -0,0 +1,185 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "asin",
+    "category": "math/trigonometry",
+    "keywords": [
+        "asin",
+        "inverse sine",
+        "arcsin",
+        "trigonometry",
+        "gpu"
+    ],
+    "summary": "Element-wise inverse sine with full MATLAB-compatible complex promotion and GPU fallbacks.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Uses the provider's unary_asin hook when all elements stay within [-1, 1]; gathers to host otherwise."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::trigonometry::asin::tests",
+        "integration": "builtins::math::trigonometry::asin::tests::asin_gpu_provider_roundtrip"
+    },
+    "description": "`Y = asin(X)` computes the inverse sine (in radians) of every element of `X`. Results follow MATLAB semantics for real, logical, character, and complex inputs. Real values outside the `[-1, 1]` interval transparently promote to complex outputs so that the mathematical definition remains exact.",
+    "behaviors": [
+        "Accepts scalars, vectors, matrices, and N-D tensors and applies the operation element-wise with MATLAB broadcasting rules.",
+        "Logical inputs convert to doubles (`true → 1.0`, `false → 0.0`) before the inverse sine is taken.",
+        "Character arrays are interpreted as their numeric code points and return dense double or complex tensors, depending on the result.",
+        "Real inputs with magnitude greater than `1` produce complex results identical to MATLAB (`asin(1.2) → 1.5708 - 0.6224i`).",
+        "Complex inputs follow MATLAB's principal branch definitions using `asin(z) = -i log(iz + sqrt(1 - z^2))`.",
+        "NaNs and infinities propagate according to IEEE arithmetic and match MATLAB's edge cases."
+    ],
+    "examples": [
+        {
+            "description": "Inverse sine of a scalar angle",
+            "input": "y = asin(0.5)",
+            "output": "y = 0.5236"
+        },
+        {
+            "description": "Inverse sine of values greater than one (complex output)",
+            "input": "z = asin(1.2)",
+            "output": "z = 1.5708 - 0.6224i"
+        },
+        {
+            "description": "Compute arcsine of every element in a matrix",
+            "input": "A = [0 -0.5 0.75; 1 0.25 -0.8];\nY = asin(A)",
+            "output": "Y =\n    0          -0.5236    0.8481\n    1.5708      0.2527   -0.9273"
+        },
+        {
+            "description": "Handling logical input with automatic double promotion",
+            "input": "mask = logical([0 1 1 0]);\nangles = asin(mask)",
+            "output": "angles = [0 1.5708 1.5708 0]"
+        },
+        {
+            "description": "Computing `asin` on a GPU array and keeping the result on device",
+            "input": "G = gpuArray(linspace(-1, 1, 5));\nresult_gpu = asin(G);\nresult = gather(result_gpu)",
+            "output": "result = [-1.5708 -0.5236 0 0.5236 1.5708]"
+        },
+        {
+            "description": "Evaluating inverse sine of complex numbers",
+            "input": "vals = [1+2i, -0.5+0.75i];\nw = asin(vals)",
+            "output": "w =\n   0.4271 + 1.5286i\n  -0.3983 + 0.7433i"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why does `asin` sometimes return complex numbers?",
+            "answer": "MATLAB (and RunMat) define inverse sine on the complex plane. Real inputs with magnitude greater than `1` lie outside the real domain, so the correct answer is complex. RunMat matches MATLAB's principal branch, yielding identical results."
+        },
+        {
+            "question": "Does `asin` support GPU execution?",
+            "answer": "Yes. When a provider implements `unary_asin` and exposes reduction hooks for bounds checking, the runtime executes `asin` entirely on the device. If complex promotion is required, RunMat gathers to the host to stay mathematically correct."
+        },
+        {
+            "question": "How does `asin` treat logical or integer inputs?",
+            "answer": "Logical arrays convert to doubles (`0` or `1`). Integers convert to double precision before evaluation, mirroring MATLAB and avoiding overflow. The final result is double or complex depending on the data."
+        },
+        {
+            "question": "What happens with NaN or Inf values?",
+            "answer": "NaNs propagate through the computation. Inputs of `±Inf` produce complex infinities consistent with MATLAB's handling of special values."
+        },
+        {
+            "question": "Can I keep the result on the GPU if it becomes complex?",
+            "answer": "Complex results are currently returned on the host because GPU tensor handles represent real data. The runtime gathers automatically and returns `Value::Complex`/`Value::ComplexTensor`, guaranteeing correct MATLAB semantics."
+        },
+        {
+            "question": "Why does `asin` of a character array return numeric arrays?",
+            "answer": "Character arrays are interpreted as their Unicode code points, converted to doubles, and then the inverse sine is applied. Any element outside `[-1, 1]` may promote the whole array to complex— matching MATLAB behaviour."
+        },
+        {
+            "question": "Does `asin` fuse with surrounding element-wise operations?",
+            "answer": "Yes. The fusion planner can emit fused WGSL kernels that include `asin` as long as the provider supports the generated code path. When fused, `asin` participates in GPU auto-offload decisions like other unary operations."
+        },
+        {
+            "question": "Are there precision differences between CPU and GPU paths?",
+            "answer": "Both CPU and GPU implementations operate in the provider's precision (`f32` or `f64`). Results match within normal floating-point error tolerances. For values near the domain boundary `±1`, minor rounding differences may appear but stay within MATLAB compatibility requirements."
+        }
+    ],
+    "links": [
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "acos",
+            "url": "./acos"
+        },
+        {
+            "label": "atan",
+            "url": "./atan"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "acosh",
+            "url": "./acosh"
+        },
+        {
+            "label": "asinh",
+            "url": "./asinh"
+        },
+        {
+            "label": "atan2",
+            "url": "./atan2"
+        },
+        {
+            "label": "atanh",
+            "url": "./atanh"
+        },
+        {
+            "label": "cos",
+            "url": "./cos"
+        },
+        {
+            "label": "cosh",
+            "url": "./cosh"
+        },
+        {
+            "label": "sinh",
+            "url": "./sinh"
+        },
+        {
+            "label": "tan",
+            "url": "./tan"
+        },
+        {
+            "label": "tanh",
+            "url": "./tanh"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/trigonometry/asin.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/trigonometry/asin.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. The fusion planner keeps tensors on the GPU whenever the active provider exposes the `unary_asin` hook and the inputs remain within `[-1, 1]`. When complex promotion is required, RunMat gathers the data and returns the correct complex result automatically. Manual `gpuArray` / `gather` calls remain available for workflows that need explicit residency control.",
+    "gpu_behavior": [
+        "RunMat Accelerate keeps tensors on the GPU when:\n\n1. A provider is registered and implements `unary_asin`, `reduce_min`, and `reduce_max`. 2. The runtime can prove that every element lies within the real domain `[-1, 1]`.\n\nIf any of those hooks are missing, or if the bounds check cannot run (for example, because the provider does not support the min/max reductions for the current tensor layout), RunMat falls back to the host implementation automatically so the results remain correct.\n\nWhen either condition fails—most notably when the input requires complex promotion—the runtime gathers the data to the host, computes the MATLAB-compatible result, and returns a host-resident (or complex) value. This mirrors MATLAB's behaviour without forcing users to manually call `gpuArray` or `gather`."
+    ],
+    "key": "asin",
+    "slug": "asin",
+    "categoryPath": [
+        "math",
+        "trigonometry"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=asin.js.map

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

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

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

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

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

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

package/dist/generated/builtins/asinh.js

@@ -0,0 +1,187 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "asinh",
+    "category": "math/trigonometry",
+    "keywords": [
+        "asinh",
+        "inverse hyperbolic sine",
+        "arcsinh",
+        "trigonometry",
+        "gpu"
+    ],
+    "summary": "Element-wise inverse hyperbolic sine with MATLAB-compatible complex promotion and GPU fallbacks.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Uses the provider's unary_asinh hook when available; gathers to host otherwise."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::trigonometry::asinh::tests",
+        "integration": "builtins::math::trigonometry::asinh::tests::asinh_gpu_provider_roundtrip"
+    },
+    "description": "`Y = asinh(X)` evaluates the inverse hyperbolic sine of every element in `X`. Results match MATLAB semantics for real, logical, character, and complex inputs, including branch cut handling for complex numbers.",
+    "behaviors": [
+        "Accepts scalars, vectors, matrices, and N-D tensors and applies the operation element-wise using MATLAB's broadcasting rules.",
+        "Logical inputs are promoted to doubles (`true → 1.0`, `false → 0.0`) before the inverse hyperbolic sine is applied.",
+        "Character arrays are interpreted as numeric code points and return dense double arrays with the same shape.",
+        "Real inputs produce real outputs for all finite values. Complex inputs follow MATLAB's principal branch definition `asinh(z) = log(z + sqrt(z^2 + 1))`.",
+        "NaNs and infinities propagate according to IEEE arithmetic and match MATLAB's special-case tables."
+    ],
+    "examples": [
+        {
+            "description": "Inverse hyperbolic sine of a scalar",
+            "input": "y = asinh(0.5)",
+            "output": "y = 0.4812"
+        },
+        {
+            "description": "Applying `asinh` to every element of a vector",
+            "input": "x = linspace(-2, 2, 5);\ny = asinh(x)",
+            "output": "y = [-1.4436 -0.8814 0 0.8814 1.4436]"
+        },
+        {
+            "description": "Evaluating `asinh` on a matrix",
+            "input": "A = [0 -0.5 1.0; 1.5 -2.0 3.0];\nB = asinh(A)",
+            "output": "B =\n         0   -0.4812    0.8814\n    1.1948   -1.4436    1.8184"
+        },
+        {
+            "description": "Computing `asinh` on GPU data",
+            "input": "G = gpuArray([0.25 0.5; 0.75 1.0]);\nresult_gpu = asinh(G);\nresult = gather(result_gpu)",
+            "output": "result = [0.2475 0.4812; 0.6931 0.8814]"
+        },
+        {
+            "description": "Handling complex arguments with `asinh`",
+            "input": "z = [1 + 2i, -0.5 + 0.75i];\nw = asinh(z)",
+            "output": "w =\n   1.4694 + 1.0634i\n  -0.6063 + 0.6822i"
+        },
+        {
+            "description": "Using `asinh` inside fused GPU expressions",
+            "input": "G = gpuArray(rand(1024, 1));\nY = sinh(G) + asinh(G)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `asinh` ever return complex numbers for real inputs?",
+            "answer": "No. Real arguments always produce real results. Complex outputs arise only when the inputs themselves are complex."
+        },
+        {
+            "question": "How are logical or integer inputs handled?",
+            "answer": "They are promoted to double precision before evaluation, mirroring MATLAB's behavior. The result is returned as a dense double tensor (or complex tensor for complex inputs)."
+        },
+        {
+            "question": "What happens if the GPU provider lacks `unary_asinh`?",
+            "answer": "RunMat gathers the data to the host, evaluates `asinh` on the CPU, and keeps the result on the host unless a downstream operation requests GPU residency."
+        },
+        {
+            "question": "Is there a precision difference between CPU and GPU outputs?",
+            "answer": "Both paths operate in the provider's precision (`f32` or `f64`). Small rounding differences may appear near very large magnitudes, but the results stay within MATLAB's tolerance specs."
+        },
+        {
+            "question": "Can `asinh` participate in fusion?",
+            "answer": "Yes. Element-wise fusion templates include `asinh`, allowing the fusion planner to inline it alongside other unary operations when generating WGSL kernels."
+        },
+        {
+            "question": "How are character arrays processed?",
+            "answer": "They are interpreted as their Unicode code points, converted to doubles, and then passed through `asinh`, producing a numeric array that matches MATLAB's output."
+        },
+        {
+            "question": "What happens with NaN or Inf values?",
+            "answer": "NaNs propagate unchanged. Positive and negative infinities map to infinities with the same sign, matching MATLAB's special-case rules."
+        },
+        {
+            "question": "Can I keep complex results on the GPU?",
+            "answer": "Currently GPU tensor handles represent real data. When complex values arise, RunMat returns host-resident `Value::Complex` or `Value::ComplexTensor` results to remain MATLAB-compatible."
+        },
+        {
+            "question": "Does `asinh` support automatic differentiation plans?",
+            "answer": "Yes. The fusion and acceleration metadata mark `asinh` as an element-wise operation, so future autodiff infrastructure can reuse the same kernel hooks."
+        }
+    ],
+    "links": [
+        {
+            "label": "sinh",
+            "url": "./sinh"
+        },
+        {
+            "label": "tanh",
+            "url": "./tanh"
+        },
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "acos",
+            "url": "./acos"
+        },
+        {
+            "label": "acosh",
+            "url": "./acosh"
+        },
+        {
+            "label": "asin",
+            "url": "./asin"
+        },
+        {
+            "label": "atan",
+            "url": "./atan"
+        },
+        {
+            "label": "atan2",
+            "url": "./atan2"
+        },
+        {
+            "label": "atanh",
+            "url": "./atanh"
+        },
+        {
+            "label": "cos",
+            "url": "./cos"
+        },
+        {
+            "label": "cosh",
+            "url": "./cosh"
+        },
+        {
+            "label": "tan",
+            "url": "./tan"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/trigonometry/asinh.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/trigonometry/asinh.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. The fusion planner keeps tensors on the GPU whenever the active provider exposes the necessary hooks (`unary_asinh`) and the runtime can keep the data in real form. When the GPU path is incomplete, RunMat gathers to the host automatically and still returns MATLAB-compatible results. Manual `gpuArray` / `gather` remains available for workflows that require explicit residency control.",
+    "gpu_behavior": [
+        "RunMat Accelerate keeps tensors on the GPU when:\n\n1. A provider is registered and implements the `unary_asinh` hook. 2. The inputs do not require complex promotion that the provider cannot represent.\n\nIf either condition is not met, RunMat gathers the data to the host, evaluates `asinh` with the CPU reference implementation, and returns the correct MATLAB result. This guarantees correctness without forcing users to manually call `gpuArray` or `gather`."
+    ],
+    "key": "asinh",
+    "slug": "asinh",
+    "categoryPath": [
+        "math",
+        "trigonometry"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=asinh.js.map

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

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

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

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

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

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

package/dist/generated/builtins/assert.js

@@ -0,0 +1,150 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "assert",
+    "category": "diagnostics",
+    "keywords": [
+        "assert",
+        "diagnostics",
+        "validation",
+        "error",
+        "gpu"
+    ],
+    "summary": "Throw a MATLAB-style error when a logical or numeric condition evaluates to false.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Conditions are evaluated on the host. GPU tensors are gathered before the logical test, and fall back to the default CPU implementation."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::diagnostics::assert::tests",
+        "integration": "builtins::diagnostics::assert::tests::assert_gpu_tensor_passes"
+    },
+    "description": "`assert(cond, ...)` aborts execution with a MATLAB-compatible error when `cond` is false or contains any zero/NaN elements. When the condition is true (or an empty array), execution continues with no output. RunMat mirrors MATLAB’s identifier normalisation, message formatting, and argument validation rules.",
+    "behaviors": [
+        "The first argument must be logical or numeric (real or complex). Scalars must evaluate to true; arrays must contain only nonzero, non-NaN elements (complex values fail when both real and imaginary parts are zero or contain NaNs). Empty inputs pass automatically.",
+        "`assert(cond)` raises `RunMat:assertion:failed` with message `Assertion failed.` when `cond` is false.",
+        "`assert(cond, msg, args...)` formats `msg` with `sprintf`-compatible conversions using any additional arguments.",
+        "`assert(cond, id, msg, args...)` uses a custom message identifier (normalised to `RunMat:*` when missing a namespace) and the formatted message text.",
+        "Arguments are validated strictly: identifiers and message templates must be string scalars or character vectors, and malformed format strings raise `RunMat:assertion:invalidInput`.",
+        "Conditions supplied as gpuArray values are gathered to host memory prior to evaluation so that MATLAB semantics continue to apply."
+    ],
+    "examples": [
+        {
+            "description": "Checking that all elements are nonzero",
+            "input": "A = [1 2 3];\nassert(all(A))"
+        },
+        {
+            "description": "Verifying array bounds during development",
+            "input": "signal = 1:20;\nidx = 12;\nassert(idx >= 1 && idx <= numel(signal), ...\n       \"Index %d is outside [1, %d].\", idx, numel(signal))"
+        },
+        {
+            "description": "Attaching a custom identifier for tooling",
+            "input": "M = magic(3);\nassert(det(M) ~= 0, \"runmat:demo:singularMatrix\", ...\n       \"Matrix must be nonsingular (determinant is zero).\")"
+        },
+        {
+            "description": "Guarding GPU computations without manual gathering",
+            "input": "G = gpuArray(rand(1024, 1));\nassert(all(G > 0), \"All entries must be positive.\")"
+        },
+        {
+            "description": "Converting NaN checks into assertion failures",
+            "input": "samples = [1.0 2.5 3.7 4.2];\navg = mean(samples);\nassert(~isnan(avg), \"Average must be finite.\")"
+        },
+        {
+            "description": "Ensuring structure fields exist before use",
+            "input": "cfg = struct(\"timeout\", 30, \"rate\", 60);\nassert(isfield(cfg, \"rate\"), ...\n       \"runmat:config:missingField\", ...\n       \"Configuration missing required field '%s'.\", \"rate\")"
+        },
+        {
+            "description": "Detecting invalid enumeration values early",
+            "input": "mode = \"linear\";\nvalid = [\"nearest\", \"linear\", \"spline\"];\nassert(any(mode == valid), ...\n       \"Invalid interpolation mode '%s'.\", mode)"
+        },
+        {
+            "description": "Validating dimensions before expensive work",
+            "input": "A = rand(3, 4);\nB = rand(4, 5);\nassert(size(A, 2) == size(B, 1), ...\n       \"runmat:demo:dimensionMismatch\", ...\n       \"Inner dimensions must agree (size(A,2)=%d, size(B,1)=%d).\", ...\n       size(A, 2), size(B, 1))"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What types can I pass as the condition?",
+            "answer": "Logical scalars/arrays and numeric scalars/arrays are accepted. Character arrays, strings, cells, structs, and complex values raise `RunMat:assertion:invalidCondition`."
+        },
+        {
+            "question": "How are NaN values treated?",
+            "answer": "Any `NaN` element causes the assertion to fail, matching MATLAB’s requirement that all elements are non-NaN and nonzero."
+        },
+        {
+            "question": "Do empty arrays pass the assertion?",
+            "answer": "Yes. Empty logical or numeric arrays are treated as true."
+        },
+        {
+            "question": "Can I omit the namespace in the message identifier?",
+            "answer": "Yes. RunMat prefixes unqualified identifiers with `RunMat:` to match MATLAB behaviour."
+        },
+        {
+            "question": "What happens if my format string is malformed?",
+            "answer": "The builtin raises `RunMat:assertion:invalidInput` describing the formatting issue."
+        },
+        {
+            "question": "Does `assert` run on the GPU?",
+            "answer": "No. GPU tensors are gathered automatically and evaluated on the CPU to preserve MATLAB semantics."
+        },
+        {
+            "question": "Can I use strings for messages and identifiers?",
+            "answer": "Yes. Both character vectors and string scalars are accepted for identifiers and message templates."
+        },
+        {
+            "question": "What value does `assert` return when the condition is true?",
+            "answer": "Like MATLAB, `assert` has no meaningful return value. RunMat returns `0.0` internally to satisfy the runtime but nothing is produced in MATLAB code."
+        },
+        {
+            "question": "How do I disable assertions in production code?",
+            "answer": "Wrap the condition in an `if` statement controlled by your own flag; MATLAB (and RunMat) always evaluates `assert`."
+        },
+        {
+            "question": "How do I distinguish assertion failures from other errors?",
+            "answer": "Provide a custom identifier (for example `runmat:module:assertFailed`) and catch it in a `try`/`catch` block."
+        }
+    ],
+    "links": [
+        {
+            "label": "error",
+            "url": "./error"
+        },
+        {
+            "label": "warning",
+            "url": "./warning"
+        },
+        {
+            "label": "isnan",
+            "url": "./isnan"
+        },
+        {
+            "label": "sprintf",
+            "url": "./sprintf"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/diagnostics/assert.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/diagnostics/assert.rs"
+    },
+    "gpu_behavior": [
+        "`assert` is a control-flow builtin. RunMat gathers GPU-resident tensors (including logical gpuArrays) to host memory before evaluating the condition. No GPU kernels are launched, and the acceleration provider metadata is marked as a gather-immediately operation so execution always follows the MATLAB-compatible CPU path. Residency metadata is preserved so subsequent statements observe the same values they would have seen without the assertion."
+    ],
+    "key": "assert",
+    "slug": "assert",
+    "categoryPath": [
+        "diagnostics"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=assert.js.map

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

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

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

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

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

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