runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/cummax.js

@@ -0,0 +1,182 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "cummax",
+    "category": "math/reduction",
+    "keywords": [
+        "cummax",
+        "cumulative maximum",
+        "running maximum",
+        "reverse",
+        "omitnan",
+        "indices",
+        "gpu"
+    ],
+    "summary": "Running maximum and index tracking for scalars, vectors, matrices, or N-D tensors.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Uses provider cummax_scan when available; otherwise gathers to host and computes MATLAB-compatible results."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::reduction::cummax::tests",
+        "integration": "builtins::math::reduction::cummax::tests::cummax_gpu_provider_roundtrip"
+    },
+    "description": "`cummax(X)` computes the cumulative maximum of the elements in `X` along a chosen dimension. It also tracks where each running maximum occurs, mirroring MATLAB's two-output behaviour.",
+    "behaviors": [
+        "By default the running maximum follows the first non-singleton dimension. Use `cummax(X, dim)` to choose a dimension explicitly; if `dim > ndims(X)`, the input is returned unchanged and the indices are ones.",
+        "`[Y, I] = cummax(X, ...)` returns both the running maxima (`Y`) and the indices of where those maxima were observed (`I`). Indices are one-based and match MATLAB exactly.",
+        "Add `\"reverse\"` (or `\"forward\"`) to control the scan direction. Reverse mode walks from the end of the chosen dimension back to the beginning.",
+        "`\"omitnan\"` skips `NaN` values when choosing the running maximum, returning `NaN` only when every value seen so far is `NaN`. `\"includenan\"` (default) propagates `NaN` once one is encountered.",
+        "Synonyms such as `\"omitmissing\"` / `\"includemissing\"` are accepted for MATLAB compatibility.",
+        "Real and complex inputs are supported. Complex numbers are ordered using MATLAB's magnitude-and-angle rules."
+    ],
+    "examples": [
+        {
+            "description": "Tracking column-wise running maxima",
+            "input": "A = [4 2 7; 3 5 1];\n[Y, I] = cummax(A);\ndisp(Y);\ndisp(I)",
+            "output": "Y =\n     4     2     7\n     4     5     7\nI =\n     1     1     1\n     1     2     1"
+        },
+        {
+            "description": "Requesting running maxima across rows",
+            "input": "A = [4 2 7; 3 5 1];\n[Y, I] = cummax(A, 2);\ndisp(Y);\ndisp(I)",
+            "output": "Y =\n     4     4     7\n     3     5     5\nI =\n     1     1     3\n     1     2     2"
+        },
+        {
+            "description": "Getting cumulative maxima in reverse order",
+            "input": "v = [8 3 6 2];\n[Y, I] = cummax(v, \"reverse\")",
+            "output": "Y = [8 6 6 2]\nI = [1 3 3 4]"
+        },
+        {
+            "description": "Ignoring NaN values in running maxima",
+            "input": "v = [NaN 5 NaN 3];\n[Y, I] = cummax(v, \"omitnan\")",
+            "output": "Y = [NaN 5 5 5]\nI = [NaN 2 2 2]"
+        },
+        {
+            "description": "Capturing running maxima and indices on the GPU",
+            "input": "G = gpuArray([3 1 4 1 5]);\n[Y, I] = cummax(G);\nhostY = gather(Y)\nhostI = gather(I)",
+            "output": "hostY = [3 3 4 4 5];\nhostI = [1 1 3 3 5]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `cummax` always return indices?",
+            "answer": "Yes. The builtin produces MATLAB-compatible indices internally. When a call requests two outputs (`[Y, I] = cummax(...)`), `I` is surfaced directly. For single-output calls the indices remain available to the runtime for later retrieval."
+        },
+        {
+            "question": "How are complex numbers ordered?",
+            "answer": "Complex maxima follow MATLAB's rules: values compare by magnitude, and ties break by phase angle. `\"omitnan\"` treats elements with `NaN` real or imaginary parts as missing."
+        },
+        {
+            "question": "What happens when all elements seen so far are `NaN` with `\"omitnan\"`?",
+            "answer": "The running maximum stays `NaN` and the corresponding index is `NaN` until a finite value is encountered. Once a finite value appears, subsequent `NaN`s leave the maximum and index unchanged."
+        },
+        {
+            "question": "Does the `\"reverse\"` option change the reported indices?",
+            "answer": "Indices are still reported using 1-based positions along the chosen dimension. `\"reverse\"` simply walks the dimension from end to start before writing the outputs."
+        },
+        {
+            "question": "What if the requested dimension exceeds `ndims(X)`?",
+            "answer": "The input is returned unchanged. Every index is `1`, matching MATLAB's treatment of singleton trailing dimensions."
+        }
+    ],
+    "links": [
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "cummin",
+            "url": "./cummin"
+        },
+        {
+            "label": "cumsum",
+            "url": "./cumsum"
+        },
+        {
+            "label": "cumprod",
+            "url": "./cumprod"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "all",
+            "url": "./all"
+        },
+        {
+            "label": "any",
+            "url": "./any"
+        },
+        {
+            "label": "diff",
+            "url": "./diff"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "median",
+            "url": "./median"
+        },
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "nnz",
+            "url": "./nnz"
+        },
+        {
+            "label": "prod",
+            "url": "./prod"
+        },
+        {
+            "label": "std",
+            "url": "./std"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "var",
+            "url": "./var"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/reduction/cummax.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/cummax.rs"
+    },
+    "gpu_residency": "Manual `gpuArray` calls are optional. The planner keeps tensors on the GPU when profitable, and the cummax builtin preserves residency whenever the provider implements `cummax_scan`. If the hook is unavailable, RunMat gathers to the host transparently and still returns MATLAB-compatible maxima and indices. You can still use `gpuArray` to match MATLAB scripts or force residency ahead of a tight GPU loop.",
+    "gpu_behavior": [
+        "When the input already resides on the GPU, RunMat calls the acceleration provider's `cummax_scan` hook. Providers that implement this hook return GPU handles for both the running maxima and their indices. If the hook is missing—or if it rejects the requested options (such as `\"omitnan\"` or `\"reverse\"`)—RunMat gathers the data to the host, computes the MATLAB-compatible result, and returns dense tensors on the CPU. Residency metadata is cleared so downstream kernels can re-promote values when profitable."
+    ],
+    "key": "cummax",
+    "slug": "cummax",
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=cummax.js.map

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

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

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

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

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

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

package/dist/generated/builtins/cummin.js

@@ -0,0 +1,181 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "cummin",
+    "category": "math/reduction",
+    "keywords": [
+        "cummin",
+        "cumulative minimum",
+        "running minimum",
+        "reverse",
+        "omitnan",
+        "indices",
+        "gpu"
+    ],
+    "summary": "Running minimum and index tracking for scalars, vectors, matrices, or N-D tensors.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Uses provider cummin_scan when available; otherwise gathers to host and computes MATLAB-compatible results."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::reduction::cummin::tests",
+        "integration": "builtins::math::reduction::cummin::tests::cummin_gpu_provider_roundtrip"
+    },
+    "description": "`cummin(X)` computes the cumulative minimum of the elements in `X` along a chosen dimension. It also tracks where each running minimum occurs, mirroring MATLAB's two-output behaviour.",
+    "behaviors": [
+        "By default the running minimum follows the first non-singleton dimension. Use `cummin(X, dim)` to choose a dimension explicitly; if `dim > ndims(X)`, the input is returned unchanged and the indices are ones.",
+        "`[Y, I] = cummin(X, ...)` returns both the running minima (`Y`) and the indices of where those minima were observed (`I`). Indices are one-based and match MATLAB exactly.",
+        "Add `\"reverse\"` (or `\"forward\"`) to control the scan direction. Reverse mode walks from the end of the chosen dimension back to the beginning.",
+        "`\"omitnan\"` skips `NaN` values when choosing the running minimum, returning `NaN` only when every value seen so far is `NaN`. `\"includenan\"` (default) propagates `NaN` once one is encountered.",
+        "Synonyms such as `\"omitmissing\"` / `\"includemissing\"` are accepted for MATLAB compatibility.",
+        "Real and complex inputs are supported. Complex numbers are ordered using MATLAB's magnitude-and-angle rules."
+    ],
+    "examples": [
+        {
+            "description": "Tracking column-wise running minima",
+            "input": "A = [4 2 7; 3 5 1];\n[Y, I] = cummin(A)",
+            "output": "Y =\n     4     2     7\n     3     2     1\nI =\n     1     1     1\n     2     1     2"
+        },
+        {
+            "description": "Requesting running minima across rows",
+            "input": "A = [4 2 7; 3 5 1];\n[Y, I] = cummin(A, 2)",
+            "output": "Y =\n     4     2     2\n     3     3     1\nI =\n     1     2     2\n     1     1     3"
+        },
+        {
+            "description": "Getting cumulative minima in reverse order",
+            "input": "v = [8 3 6 2];\n[Y, I] = cummin(v, \"reverse\")",
+            "output": "Y = [2 2 2 2]\nI = [4 4 4 4]"
+        },
+        {
+            "description": "Ignoring NaN values in running minima",
+            "input": "v = [NaN 5 NaN 3];\n[Y, I] = cummin(v, \"omitnan\")",
+            "output": "Y = [NaN 5 5 3]\nI = [NaN 2 2 4]"
+        },
+        {
+            "description": "Capturing running minima and indices on the GPU",
+            "input": "G = gpuArray([3 1 4 1 5]);\n[Y, I] = cummin(G);\nhostY = gather(Y);\nhostI = gather(I)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `cummin` always return indices?",
+            "answer": "Yes. The builtin produces MATLAB-compatible indices internally. When a call requests two outputs (`[Y, I] = cummin(...)`), `I` is surfaced directly. For single-output calls the indices remain available to the runtime for later retrieval."
+        },
+        {
+            "question": "How are complex numbers ordered?",
+            "answer": "Complex minima follow MATLAB's rules: values compare by magnitude, and ties break by phase angle. `\"omitnan\"` treats elements with `NaN` real or imaginary parts as missing."
+        },
+        {
+            "question": "What happens when all elements seen so far are `NaN` with `\"omitnan\"`?",
+            "answer": "The running minimum stays `NaN` and the corresponding index is `NaN` until a finite value is encountered. Once a finite value appears, subsequent `NaN`s leave the minimum and index unchanged."
+        },
+        {
+            "question": "Does the `\"reverse\"` option change the reported indices?",
+            "answer": "Indices are still reported using 1-based positions along the chosen dimension. `\"reverse\"` simply walks the dimension from end to start before writing the outputs."
+        },
+        {
+            "question": "What if the requested dimension exceeds `ndims(X)`?",
+            "answer": "The input is returned unchanged. Every index is `1`, matching MATLAB's treatment of singleton trailing dimensions."
+        }
+    ],
+    "links": [
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "cumsum",
+            "url": "./cumsum"
+        },
+        {
+            "label": "cumprod",
+            "url": "./cumprod"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "all",
+            "url": "./all"
+        },
+        {
+            "label": "any",
+            "url": "./any"
+        },
+        {
+            "label": "cummax",
+            "url": "./cummax"
+        },
+        {
+            "label": "diff",
+            "url": "./diff"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "median",
+            "url": "./median"
+        },
+        {
+            "label": "nnz",
+            "url": "./nnz"
+        },
+        {
+            "label": "prod",
+            "url": "./prod"
+        },
+        {
+            "label": "std",
+            "url": "./std"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "var",
+            "url": "./var"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/reduction/cummin.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/cummin.rs"
+    },
+    "gpu_residency": "Manual `gpuArray` calls are optional. The planner keeps tensors on the GPU when profitable, and the cummin builtin preserves residency whenever the provider implements `cummin_scan`. If the hook is unavailable, RunMat gathers to the host transparently and still returns MATLAB-compatible minima and indices. You can still use `gpuArray` to match MATLAB scripts or force residency ahead of a tight GPU loop.",
+    "gpu_behavior": [
+        "When the input already resides on the GPU, RunMat calls the acceleration provider's `cummin_scan` hook. Providers that implement this hook return GPU handles for both the running minima and their indices. If the hook is missing—or if it rejects the requested options (such as `\"omitnan\"` or `\"reverse\"`)—RunMat gathers the data to the host, computes the MATLAB-compatible result, and returns dense tensors on the CPU. Residency metadata is cleared so downstream kernels can re-promote values when profitable."
+    ],
+    "key": "cummin",
+    "slug": "cummin",
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=cummin.js.map

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

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

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

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

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

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

package/dist/generated/builtins/cumprod.js

@@ -0,0 +1,181 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "cumprod",
+    "category": "math/reduction",
+    "keywords": [
+        "cumprod",
+        "cumulative product",
+        "running product",
+        "reverse",
+        "omitnan",
+        "gpu"
+    ],
+    "summary": "Cumulative product of scalars, vectors, matrices, or N-D tensors.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Falls back to host multiplication when the active provider lacks prefix-product hooks. The output always matches the input shape."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::reduction::cumprod::tests",
+        "integration": "builtins::math::reduction::cumprod::tests::cumprod_gpu_provider_roundtrip"
+    },
+    "description": "`cumprod(X)` multiplies elements cumulatively along a chosen dimension. The result has the same size as `X`, and each element stores the running product.",
+    "behaviors": [
+        "By default, the running product is taken along the first dimension whose length is greater than `1`.",
+        "`cumprod(X, dim)` lets you choose the dimension explicitly; if `dim > ndims(X)`, the input is returned unchanged.",
+        "Passing `[]` for the dimension argument keeps the default dimension (MATLAB treats it as a placeholder).",
+        "`cumprod(..., \"reverse\")` accumulates from the end toward the beginning; `\"forward\"` (default) works from start to finish.",
+        "`cumprod(..., \"omitnan\")` treats `NaN` values as missing. Empty prefixes yield `1`, the multiplicative identity.",
+        "Synonyms such as `\"omitmissing\"` / `\"includemissing\"` are accepted for MATLAB compatibility.",
+        "The function supports real or complex scalars and dense tensors. Logical inputs are promoted to double precision."
+    ],
+    "examples": [
+        {
+            "description": "Running products down each column (default dimension)",
+            "input": "A = [1 2 3; 4 5 6];\ncolumnProducts = cumprod(A)",
+            "output": "columnProducts =\n     1     2     3\n     4    10    18"
+        },
+        {
+            "description": "Tracking cumulative products across rows",
+            "input": "A = [1 2 3; 4 5 6];\nrowProducts = cumprod(A, 2)",
+            "output": "rowProducts =\n     1     2     6\n     4    20   120"
+        },
+        {
+            "description": "Reversing the accumulation direction",
+            "input": "v = [2 3 4 5];\nreverseProducts = cumprod(v, \"reverse\")",
+            "output": "reverseProducts =\n   120    60    20     5"
+        },
+        {
+            "description": "Ignoring NaN values while multiplying",
+            "input": "v = [2 NaN 4 NaN 3];\nrunning = cumprod(v, \"omitnan\")",
+            "output": "running =\n     2     2     8     8    24"
+        },
+        {
+            "description": "Computing a cumulative product inside a GPU workflow",
+            "input": "G = gpuArray(1 + 0.1*rand(1, 5));\ntotals = cumprod(G);\nhostResult = gather(totals)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `cumprod` change the size of the input?",
+            "answer": "No. The output always equals the input shape."
+        },
+        {
+            "question": "What happens if I request a dimension larger than `ndims(X)`?",
+            "answer": "The input is returned unchanged, matching MATLAB behaviour."
+        },
+        {
+            "question": "How does `\"omitnan\"` treat leading NaN values?",
+            "answer": "They are ignored, so the cumulative product uses the multiplicative identity `1` until a finite value appears."
+        },
+        {
+            "question": "Can I combine `\"reverse\"` and `\"omitnan\"`?",
+            "answer": "Yes. The options can be specified in any order and RunMat mirrors MATLAB’s results."
+        },
+        {
+            "question": "Does the GPU path respect `\"omitnan\"`?",
+            "answer": "Only when the active provider offers a native prefix-product kernel with missing-value support. Otherwise the runtime gathers to the host to preserve MATLAB semantics."
+        }
+    ],
+    "links": [
+        {
+            "label": "prod",
+            "url": "./prod"
+        },
+        {
+            "label": "cumsum",
+            "url": "./cumsum"
+        },
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "all",
+            "url": "./all"
+        },
+        {
+            "label": "any",
+            "url": "./any"
+        },
+        {
+            "label": "cummax",
+            "url": "./cummax"
+        },
+        {
+            "label": "cummin",
+            "url": "./cummin"
+        },
+        {
+            "label": "diff",
+            "url": "./diff"
+        },
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "median",
+            "url": "./median"
+        },
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "nnz",
+            "url": "./nnz"
+        },
+        {
+            "label": "std",
+            "url": "./std"
+        },
+        {
+            "label": "var",
+            "url": "./var"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/reduction/cumprod.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/cumprod.rs"
+    },
+    "gpu_residency": "Manual `gpuArray` calls are optional. RunMat promotes tensors automatically when the planner predicts a benefit, keeping fused expressions resident on the device. Explicit `gpuArray` is still supported for MATLAB compatibility or when you want to guarantee GPU residency before entering a critical loop.",
+    "gpu_behavior": [
+        "When data already lives on the GPU, RunMat asks the active acceleration provider for a device-side prefix-product implementation. The runtime calls the `cumprod_scan` hook with the chosen dimension, direction, and NaN mode. Providers that lack this hook—or that report an error for the requested options—trigger a gather to host memory, perform the cumulative product on the CPU, and return the dense tensor result. Residency metadata is cleared so downstream operations can re-promote the tensor when profitable."
+    ],
+    "key": "cumprod",
+    "slug": "cumprod",
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=cumprod.js.map

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

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

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

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

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

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