runmat 0.5.7-dev.2 → 0.5.7-dev.4

package/dist/generated/builtins/cov2corr.js

@@ -0,0 +1,84 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "cov2corr",
+    "category": "stats/summary",
+    "keywords": [
+        "cov2corr",
+        "covariance",
+        "correlation",
+        "standard deviation",
+        "statistics"
+    ],
+    "summary": "Convert a covariance matrix to a correlation matrix.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "RunMat alias for `corrcov`; resident real gpuArray covariance matrices route through the provider `covariance_to_correlation` hook and return resident correlation and sigma gpuArray outputs."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "none"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::stats::summary::covariance_conversion::tests",
+        "integration": "crates/runmat-vm/tests/stats_ml.rs"
+    },
+    "description": "`cov2corr(C)` is a RunMat alias that applies the same covariance-to-correlation conversion as `corrcov(C)`. `[R,sigma] = cov2corr(C)` also returns `sqrt(diag(C))` as an n-by-1 standard-deviation vector.",
+    "behaviors": [
+        "`C` must be a real numeric square matrix stored as double or single precision. Scalar numeric values are accepted as 1-by-1 covariance matrices.",
+        "The diagonal entries of `C` are interpreted as variances and must be nonnegative.",
+        "RunMat validates symmetry within floating-point tolerance before converting.",
+        "RunMat rejects covariance entries whose magnitude exceeds the variance-implied pairwise bound `sqrt(C(i,i)*C(j,j))`.",
+        "Entries involving a zero-variance variable produce `NaN` because the correlation denominator is zero.",
+        "Real gpuArray inputs stay resident when the active provider implements covariance-to-correlation conversion."
+    ],
+    "examples": [
+        {
+            "description": "Convert covariance to correlation",
+            "input": "C = [16 4; 4 25];\nR = cov2corr(C)",
+            "output": "R = [1 0.2; 0.2 1]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Is `cov2corr` different from `corrcov`?",
+            "answer": "No. In RunMat, `cov2corr` is an alias for the same covariance-to-correlation conversion as `corrcov`. It is documented as a RunMat alias rather than an official MathWorks API."
+        }
+    ],
+    "links": [
+        {
+            "label": "corrcov",
+            "url": "./corrcov"
+        },
+        {
+            "label": "cov",
+            "url": "./cov"
+        },
+        {
+            "label": "corrcoef",
+            "url": "./corrcoef"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/stats/summary/covariance_conversion.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/stats/summary/covariance_conversion.rs"
+    },
+    "key": "cov2corr",
+    "slug": "cov2corr",
+    "aliases": [],
+    "categoryPath": [
+        "stats",
+        "summary"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=cov2corr.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cov2corr.js","sourceRoot":"","sources":["../../../src/generated/builtins/cov2corr.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,UAAU;QACV,YAAY;QACZ,aAAa;QACb,oBAAoB;QACpB,YAAY;KACb;IACD,SAAS,EAAE,sDAAsD;IACjE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,gMAAgM;KAC1M;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,MAAM;KACpB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,wDAAwD;QAChE,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,4MAA4M;IAC3N,WAAW,EAAE;QACX,kJAAkJ;QAClJ,mFAAmF;QACnF,8EAA8E;QAC9E,sHAAsH;QACtH,uGAAuG;QACvG,8GAA8G;KAC/G;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,oCAAoC;YAC7C,QAAQ,EAAE,oBAAoB;SAC/B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,iLAAiL;SAC5L;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6EAA6E;QACtF,KAAK,EAAE,0HAA0H;KAClI;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/cputime.js

@@ -0,0 +1,99 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "cputime",
+    "category": "timing",
+    "keywords": [
+        "cputime",
+        "cpu time",
+        "timing",
+        "profiling",
+        "legacy"
+    ],
+    "summary": "Return total CPU time used by the current RunMat process.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Host-side process timing helper. GPU providers are never consulted."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::timing::cputime::tests",
+        "integration": null
+    },
+    "description": "`cputime` returns the total CPU time used by the current RunMat process in seconds. It is intended for legacy MATLAB compatibility; prefer `timeit` or `tic`/`toc` for wall-clock benchmarking.",
+    "behaviors": [
+        "Takes no input arguments.",
+        "Returns a finite, nonnegative scalar double in seconds.",
+        "Native Unix builds use host process CPU accounting via getrusage.",
+        "Native Windows builds use host process CPU accounting via GetProcessTimes.",
+        "WASM/browser builds do not expose process CPU accounting, so RunMat returns monotonic seconds since the WASM runtime first used `cputime`; differences remain useful for compatibility code, but the measurement is wall-clock elapsed time rather than true CPU time.",
+        "GPU providers are never consulted, and the builtin is excluded from fusion plans."
+    ],
+    "examples": [
+        {
+            "description": "Measure CPU Time Used By Code",
+            "input": "tStart = cputime;\nfor k = 1:100000\n    sqrt(k);\nend\ntElapsed = cputime - tStart",
+            "output": "tElapsed = <seconds>"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How is `cputime` different from `tic` and `toc`?",
+            "answer": "`cputime` measures CPU time consumed by the process on native targets. `tic`/`toc` measure wall-clock elapsed time."
+        },
+        {
+            "question": "Why does WASM use a wall-clock fallback?",
+            "answer": "Browsers do not expose process CPU time. RunMat keeps the no-argument scalar API available so MATLAB compatibility code that subtracts two calls still runs."
+        },
+        {
+            "question": "Does `cputime` reset?",
+            "answer": "No. Like MATLAB, native builds return total CPU time since the current process started. On WASM, the wall-clock fallback is measured from the first `cputime` call. To measure a section of code, subtract two readings."
+        }
+    ],
+    "links": [
+        {
+            "label": "tic",
+            "url": "./tic"
+        },
+        {
+            "label": "toc",
+            "url": "./toc"
+        },
+        {
+            "label": "timeit",
+            "url": "./timeit"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/timing/cputime.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/timing/cputime.rs"
+    },
+    "syntax": {
+        "example": {
+            "description": "Syntax",
+            "input": "t = cputime"
+        },
+        "points": [
+            "`cputime` accepts no input arguments.",
+            "`t` is a scalar double value in seconds.",
+            "Use `cputime` differences to measure CPU time spent between two points."
+        ]
+    },
+    "key": "cputime",
+    "slug": "cputime",
+    "aliases": [],
+    "categoryPath": [
+        "timing"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=cputime.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cputime.js","sourceRoot":"","sources":["../../../src/generated/builtins/cputime.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,QAAQ;IACpB,UAAU,EAAE;QACV,SAAS;QACT,UAAU;QACV,QAAQ;QACR,WAAW;QACX,QAAQ;KACT;IACD,SAAS,EAAE,2DAA2D;IACtE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,qEAAqE;KAC/E;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,kCAAkC;QAC1C,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,iMAAiM;IAChN,WAAW,EAAE;QACX,2BAA2B;QAC3B,yDAAyD;QACzD,mEAAmE;QACnE,4EAA4E;QAC5E,wQAAwQ;QACxQ,mFAAmF;KACpF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,qFAAqF;YAC9F,QAAQ,EAAE,sBAAsB;SACjC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,qHAAqH;SAChI;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,8JAA8J;SACzK;QACD;YACE,UAAU,EAAE,uBAAuB;YACnC,QAAQ,EAAE,0NAA0N;SACrO;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,wDAAwD;QACjE,KAAK,EAAE,qGAAqG;KAC7G;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,QAAQ;YACvB,OAAO,EAAE,aAAa;SACvB;QACD,QAAQ,EAAE;YACR,uCAAuC;YACvC,0CAA0C;YAC1C,yEAAyE;SAC1E;KACF;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

@@ -0,0 +1,60 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "crossentropy",
+    "category": "deep_learning",
+    "keywords": [
+        "crossentropy",
+        "deep learning",
+        "loss"
+    ],
+    "summary": "Compute cross-entropy loss for numeric predictions and targets.",
+    "description": "`crossentropy(Y,T)` computes cross-entropy over same-sized host numeric arrays, host `dlarray` compatibility objects, or plain resident real `gpuArray` tensors.",
+    "behaviors": [
+        "Inputs must be finite, non-empty numeric arrays, host-backed `dlarray` objects, or plain real `gpuArray` tensors with the same number of elements.",
+        "Predictions are clipped to a small open interval before taking logarithms; targets must be probabilities in the range [0, 1].",
+        "The third positional argument or `Weights` name-value option may provide scalar, prediction-sized, channel-sized, or observation-sized weights.",
+        "Supported name-value options are `ClassificationMode`, `TargetCategories`, `Reduction`, `NormalizationFactor`, `DataFormat`, `WeightsFormat`, `Weights`, and `Mask`.",
+        "`DataFormat` and `WeightsFormat` validate RunMat's supported deep-learning labels `S`, `C`, `B`, `T`, and `U`; `WeightsFormat` maps weight dimensions to prediction dimensions by label.",
+        "`ClassificationMode` supports single-label/exclusive and multi-label/independent aliases.",
+        "`Reduction` supports `sum` and `none`; unreduced output preserves the prediction shape.",
+        "`NormalizationFactor` supports `all-elements`, `batch-size`, `mask-included`, `none`, and positive numeric scalars.",
+        "`Mask` must be a full-size logical or binary numeric array.",
+        "Plain real `gpuArray` prediction and target tensors use provider-side cross-entropy kernels for same-shape losses. Scalar, prediction-sized, channel-sized, and observation-sized host weights are materialized as temporary provider inputs; full prediction-sized resident real `gpuArray` weights and masks are consumed directly. `Reduction=\"none\"` returns a resident `gpuArray`; scalar reductions reduce on the provider and read back only the scalar result.",
+        "Host `dlarray` inputs return host `dlarray` compatibility outputs; reduced scalar losses and unreduced loss arrays are returned as unformatted `dlarray` objects.",
+        "Datastore/category target expansion, automatic differentiation, GPU-backed `dlarray`, `NormalizationFactor=\"mask-included\"` for GPU inputs, and non-full-size resident GPU weight remapping with `WeightsFormat` remain future work."
+    ],
+    "examples": [
+        {
+            "description": "Compute Loss",
+            "input": "loss = crossentropy([0.8 0.2], [1 0])",
+            "output": "Scalar loss."
+        },
+        {
+            "description": "Use Class Weights",
+            "input": "loss = crossentropy(Y, T, weights, \"DataFormat\", \"CB\")",
+            "output": "Weighted scalar loss normalized by batch size."
+        },
+        {
+            "description": "Unreduced Multi-Label Loss",
+            "input": "losses = crossentropy(Y, T, \"ClassificationMode\", \"multi-label\", \"Reduction\", \"none\")",
+            "output": "Array of per-element losses."
+        }
+    ],
+    "syntax": {
+        "example": {
+            "description": "Supported forms",
+            "input": "loss = crossentropy(Y, T, weights, Name, Value)",
+            "output": "Numeric or `dlarray` loss."
+        }
+    },
+    "gpu_residency": "`crossentropy` preserves residency for plain real `gpuArray` prediction and target tensors through the `runmat-accelerate` `crossentropy_terms` provider hook. Unreduced losses remain resident; scalar reductions use provider reduction and read back only the scalar. Host weights and masks that can be expanded from scalar, prediction-sized, channel-sized, or observation-sized forms are uploaded as temporary provider tensors. Resident GPU weights and masks stay on the provider when they are real and exactly prediction-sized; `WeightsFormat` remapping and `NormalizationFactor=\"mask-included\"` still fall back to the host path.",
+    "key": "crossentropy",
+    "slug": "crossentropy",
+    "aliases": [],
+    "categoryPath": [
+        "deep_learning"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=crossentropy.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"crossentropy.js","sourceRoot":"","sources":["../../../src/generated/builtins/crossentropy.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,cAAc;IACvB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,cAAc;QACd,eAAe;QACf,MAAM;KACP;IACD,SAAS,EAAE,iEAAiE;IAC5E,aAAa,EAAE,kKAAkK;IACjL,WAAW,EAAE;QACX,oJAAoJ;QACpJ,+HAA+H;QAC/H,iJAAiJ;QACjJ,sKAAsK;QACtK,0LAA0L;QAC1L,2FAA2F;QAC3F,yFAAyF;QACzF,qHAAqH;QACrH,6DAA6D;QAC7D,0cAA0c;QAC1c,mKAAmK;QACnK,wOAAwO;KACzO;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,cAAc;YAC7B,OAAO,EAAE,uCAAuC;YAChD,QAAQ,EAAE,cAAc;SACzB;QACD;YACE,aAAa,EAAE,mBAAmB;YAClC,OAAO,EAAE,4DAA4D;YACrE,QAAQ,EAAE,gDAAgD;SAC3D;QACD;YACE,aAAa,EAAE,4BAA4B;YAC3C,OAAO,EAAE,+FAA+F;YACxG,QAAQ,EAAE,8BAA8B;SACzC;KACF;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,iBAAiB;YAChC,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE,4BAA4B;SACvC;KACF;IACD,eAAe,EAAE,wnBAAwnB;IACzoB,KAAK,EAAE,cAAc;IACrB,MAAM,EAAE,cAAc;IACtB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,eAAe;KAChB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/crossvalind.js

@@ -0,0 +1,97 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "crossvalind",
+    "category": "stats/ml",
+    "keywords": [
+        "crossvalind",
+        "cross validation",
+        "kfold",
+        "holdout",
+        "leavemout",
+        "resubstitution",
+        "statistics",
+        "machine learning"
+    ],
+    "summary": "Generate cross-validation indices and logical train/test partitions.",
+    "status": "implemented",
+    "coverage": {
+        "unit": "builtins::stats::ml::crossvalind::tests",
+        "integration": "crates/runmat-vm/tests/stats_ml.rs"
+    },
+    "description": "`crossvalind` provides MATLAB-compatible cross-validation split helpers for older Statistics and Machine Learning workflows. K-fold calls return numeric fold ids, while holdout, leave-M-out, and resubstitution calls return logical training/test masks.",
+    "signatures": [
+        {
+            "label": "indices = crossvalind('KFold', n, k)",
+            "description": "Return a column vector of one-based fold ids for `n` observations distributed across `k` randomized folds."
+        },
+        {
+            "label": "indices = crossvalind('KFold', n, k, 'Classes', group)",
+            "description": "Assign fold ids while balancing observations within each class label."
+        },
+        {
+            "label": "train = crossvalind('HoldOut', n, p)",
+            "description": "Return a logical training mask after randomly holding out fraction `p` or count `p` for testing."
+        },
+        {
+            "label": "[train, test] = crossvalind('HoldOut', n, p)",
+            "description": "Return complementary logical training and test masks."
+        },
+        {
+            "label": "[train, test] = crossvalind('LeaveMOut', n, m)",
+            "description": "Randomly mark `m` observations as test observations and return train/test masks."
+        },
+        {
+            "label": "[train, test] = crossvalind('Resubstitution', n)",
+            "description": "Return all-true training and test masks for resubstitution workflows."
+        }
+    ],
+    "examples": [
+        {
+            "input": "rng(2026);\nidx = crossvalind('HoldOut', 10, 0.3);\nnumel(idx)",
+            "description": "Create a reproducible holdout training mask."
+        },
+        {
+            "input": "rng(1);\nfold = crossvalind('KFold', 12, 3);\ntabulate(fold)",
+            "description": "Assign observations to randomized folds."
+        },
+        {
+            "input": "group = [1;1;1;1;2;2;2;2];\n[train,test] = crossvalind('HoldOut', 8, 0.5, 'Classes', group);",
+            "description": "Preserve class balance when producing a holdout split."
+        }
+    ],
+    "returns": [
+        "`KFold` returns a numeric column vector with one-based fold ids in the range `1:k`.",
+        "`HoldOut`, `LeaveMOut`, and `Resubstitution` return a logical training mask by default.",
+        "Two-output partition calls return `[train, test]` logical column vectors."
+    ],
+    "notes": [
+        "`crossvalind` consumes RunMat's shared RNG stream, so `rng(seed)` controls reproducibility.",
+        "`Classes` accepts numeric, logical, string, string-array, or character-row labels with one label per observation.",
+        "`Min` validates that each class has enough observations for class-balanced splits."
+    ],
+    "errors": [
+        {
+            "identifier": "RunMat:crossvalind:InvalidArgument",
+            "when": "The method, observation count, partition value, options, classes, or output count is invalid."
+        },
+        {
+            "identifier": "RunMat:crossvalind:Internal",
+            "when": "The requested output is too large or cannot be allocated."
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/stats/ml/crossvalind.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/stats/ml/crossvalind.rs"
+    },
+    "gpu_residency": "No. `crossvalind` is a small control-flow/index generation helper. GPU-resident inputs are gathered before partition generation, and outputs are host logical or numeric index arrays.",
+    "key": "crossvalind",
+    "slug": "crossvalind",
+    "aliases": [],
+    "categoryPath": [
+        "stats",
+        "ml"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=crossvalind.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"crossvalind.js","sourceRoot":"","sources":["../../../src/generated/builtins/crossvalind.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,aAAa;IACtB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,aAAa;QACb,kBAAkB;QAClB,OAAO;QACP,SAAS;QACT,WAAW;QACX,gBAAgB;QAChB,YAAY;QACZ,kBAAkB;KACnB;IACD,SAAS,EAAE,sEAAsE;IACjF,QAAQ,EAAE,aAAa;IACvB,UAAU,EAAE;QACV,MAAM,EAAE,yCAAyC;QACjD,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,6PAA6P;IAC5Q,YAAY,EAAE;QACZ;YACE,OAAO,EAAE,sCAAsC;YAC/C,aAAa,EAAE,4GAA4G;SAC5H;QACD;YACE,OAAO,EAAE,wDAAwD;YACjE,aAAa,EAAE,uEAAuE;SACvF;QACD;YACE,OAAO,EAAE,sCAAsC;YAC/C,aAAa,EAAE,kGAAkG;SAClH;QACD;YACE,OAAO,EAAE,8CAA8C;YACvD,aAAa,EAAE,uDAAuD;SACvE;QACD;YACE,OAAO,EAAE,gDAAgD;YACzD,aAAa,EAAE,kFAAkF;SAClG;QACD;YACE,OAAO,EAAE,kDAAkD;YAC3D,aAAa,EAAE,uEAAuE;SACvF;KACF;IACD,UAAU,EAAE;QACV;YACE,OAAO,EAAE,gEAAgE;YACzE,aAAa,EAAE,8CAA8C;SAC9D;QACD;YACE,OAAO,EAAE,8DAA8D;YACvE,aAAa,EAAE,0CAA0C;SAC1D;QACD;YACE,OAAO,EAAE,8FAA8F;YACvG,aAAa,EAAE,wDAAwD;SACxE;KACF;IACD,SAAS,EAAE;QACT,qFAAqF;QACrF,yFAAyF;QACzF,2EAA2E;KAC5E;IACD,OAAO,EAAE;QACP,6FAA6F;QAC7F,mHAAmH;QACnH,oFAAoF;KACrF;IACD,QAAQ,EAAE;QACR;YACE,YAAY,EAAE,oCAAoC;YAClD,MAAM,EAAE,+FAA+F;SACxG;QACD;YACE,YAAY,EAAE,6BAA6B;YAC3C,MAAM,EAAE,2DAA2D;SACpE;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,8DAA8D;QACvE,KAAK,EAAE,2GAA2G;KACnH;IACD,eAAe,EAAE,wLAAwL;IACzM,KAAK,EAAE,aAAa;IACpB,MAAM,EAAE,aAAa;IACrB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,IAAI;KACL;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

@@ -1 +1 @@
-{"version":3,"file":"cumtrapz.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/cumtrapz.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,UAwHjB,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"cumtrapz.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/cumtrapz.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/cumtrapz.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "GPU inputs currently gather to the host for cumulative trapezoidal integration and re-upload real-valued outputs so downstream code can remain device-resident."
+        "notes": "Real, logical, and complex-interleaved GPU sample inputs route through provider `cumtrapz_dim` for unit, scalar, vector, and tensor real spacing. Provider-missing cases fall back to host semantics."
     },
     "fusion": {
         "elementwise": false,
@@ -80,7 +80,7 @@ const builtinDoc = {
         },
         {
             "question": "Does cumtrapz keep gpuArray residency?",
-            "answer": "For real-valued results, yes. RunMat currently gathers GPU inputs to the host, computes the cumulative trapezoidal integral, and re-uploads the result so downstream GPU code can stay resident."
+            "answer": "For real, logical, and complex-valued gpuArray sample inputs, yes. RunMat uses the acceleration provider's `cumtrapz_dim` hook with real unit, scalar, vector, or tensor spacing."
         }
     ],
     "links": [
@@ -109,9 +109,10 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/math/reduction/cumtrapz.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/cumtrapz.rs"
     },
-    "gpu_residency": "Manual `gpuArray` promotion is optional. If sampled data already lives on the GPU, RunMat preserves real-valued cumulative results as gpuArrays by re-uploading the output after the host fallback path.",
+    "gpu_residency": "Manual `gpuArray` promotion is optional. If real, logical, or complex-interleaved sampled data already lives on the GPU, RunMat preserves cumulative outputs as gpuArrays through the provider `cumtrapz_dim` path.",
     "gpu_behavior": [
-        "RunMat does not yet expose a native provider hook for `cumtrapz`. When the input is a gpuArray, the runtime gathers the data to host memory, performs the cumulative trapezoidal integration with MATLAB-compatible dimension and spacing rules, and re-uploads real-valued outputs so downstream GPU work stays resident."
+        "Real, logical, and complex-interleaved gpuArray sample inputs use provider-backed cumulative trapezoidal integration for unit spacing, scalar spacing, coordinate-vector spacing, and same-size coordinate-tensor spacing.",
+        "Spacing inputs must be real-valued. Provider-missing cases use the host fallback path to preserve MATLAB-compatible semantics."
     ],
     "key": "cumtrapz",
     "slug": "cumtrapz",

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

@@ -1 +1 @@
-{"version":3,"file":"cumtrapz.js","sourceRoot":"","sources":["../../../src/generated/builtins/cumtrapz.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,UAAU;QACV,oCAAoC;QACpC,uBAAuB;QACvB,sBAAsB;QACtB,KAAK;KACN;IACD,SAAS,EAAE,kEAAkE;IAC7E,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,iKAAiK;KAC3K;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,4CAA4C;KACrD;IACD,aAAa,EAAE,qNAAqN;IACpO,WAAW,EAAE;QACX,8DAA8D;QAC9D,2JAA2J;QAC3J,2KAA2K;QAC3K,qKAAqK;QACrK,sIAAsI;KACvI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2DAA2D;YAC1E,OAAO,EAAE,gDAAgD;YACzD,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,+BAA+B;YACxC,QAAQ,EAAE,eAAe;SAC1B;QACD;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,yCAAyC;YAClD,QAAQ,EAAE,6CAA6C;SACxD;QACD;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,8DAA8D;YACvE,QAAQ,EAAE,oBAAoB;SAC/B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,4GAA4G;SACvH;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,0FAA0F;SACrG;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,sHAAsH;SACjI;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,uGAAuG;SAClH;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,kMAAkM;SAC7M;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,eAAe,EAAE,0MAA0M;IAC3N,cAAc,EAAE;QACd,4TAA4T;KAC7T;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,WAAW;KACZ;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"cumtrapz.js","sourceRoot":"","sources":["../../../src/generated/builtins/cumtrapz.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,UAAU;QACV,oCAAoC;QACpC,uBAAuB;QACvB,sBAAsB;QACtB,KAAK;KACN;IACD,SAAS,EAAE,kEAAkE;IAC7E,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,uMAAuM;KACjN;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,4CAA4C;KACrD;IACD,aAAa,EAAE,qNAAqN;IACpO,WAAW,EAAE;QACX,8DAA8D;QAC9D,2JAA2J;QAC3J,2KAA2K;QAC3K,qKAAqK;QACrK,sIAAsI;KACvI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2DAA2D;YAC1E,OAAO,EAAE,gDAAgD;YACzD,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,+BAA+B;YACxC,QAAQ,EAAE,eAAe;SAC1B;QACD;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,yCAAyC;YAClD,QAAQ,EAAE,6CAA6C;SACxD;QACD;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,8DAA8D;YACvE,QAAQ,EAAE,oBAAoB;SAC/B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,4GAA4G;SACvH;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,0FAA0F;SACrG;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,sHAAsH;SACjI;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,uGAAuG;SAClH;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,mLAAmL;SAC9L;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,eAAe,EAAE,qNAAqN;IACtO,cAAc,EAAE;QACd,4NAA4N;QAC5N,gIAAgI;KACjI;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,WAAW;KACZ;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/cvpartition.js

@@ -0,0 +1,104 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "cvpartition",
+    "category": "stats/ml",
+    "keywords": [
+        "cvpartition",
+        "cross validation",
+        "kfold",
+        "holdout",
+        "leaveout",
+        "resubstitution",
+        "statistics",
+        "machine learning"
+    ],
+    "summary": "Create cross-validation partition objects.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "logical",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "GPU inputs are gathered to host. Partition construction is metadata-oriented and runs on CPU."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "none"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::stats::ml::cvpartition::tests",
+        "integration": "crates/runmat-vm/tests/stats_ml.rs"
+    },
+    "description": "`cvpartition` creates a `cvpartition` object for K-fold, holdout, leave-one-out, resubstitution, or custom cross-validation masks. Use `training` and `test` to extract logical masks.",
+    "behaviors": [
+        "`cvpartition(n,'KFold',k)` creates `k` deterministic round-robin folds for `n` observations, with `k` in the interval `[2,n)`.",
+        "`cvpartition(stratvar,'KFold',k)` and `cvpartition(stratvar,'Holdout',p)` stratify by default. Use `'Stratify',false` to partition only by observation order.",
+        "`cvpartition(n,'Holdout',p)` accepts a fraction in `(0,1)` or an integer count in `[1,n)`.",
+        "`cvpartition(n,'Leaveout')` creates one test set per observation.",
+        "`cvpartition(n,'Resubstitution')` creates a single partition with all observations in training and none in test.",
+        "`cvpartition('CustomPartition',testSets)` accepts a logical vector or matrix whose columns are test sets, or a positive-integer vector whose values identify test-set numbers.",
+        "Numeric stratification labels containing `NaN` are treated as missing; those rows remain in `NumObservations` but are false in returned training and test masks.",
+        "The returned object exposes `NumObservations`, `NumTestSets`, `TestSize`, `TrainSize`, `Type`, `IsCustom`, `IsGrouped`, and `IsStratified` properties.",
+        "Fold assignment is deterministic for reproducibility; it does not attempt to reproduce MATLAB's RNG-dependent exact fold order."
+    ],
+    "examples": [
+        {
+            "description": "Create K-fold masks",
+            "input": "c = cvpartition(6, 'KFold', 3);\nidxTest = test(c, 1);\nidxTrainAll = training(c, 'all')",
+            "output": "`idxTest` is a 6-by-1 logical vector. `idxTrainAll` is a 6-by-3 logical matrix."
+        },
+        {
+            "description": "Create a stratified holdout partition",
+            "input": "group = [1; 1; 2; 2];\nc = cvpartition(group, 'Holdout', 0.5);\nidx = test(c)",
+            "output": "`idx` selects one observation from each group."
+        },
+        {
+            "description": "Use custom test sets",
+            "input": "c = cvpartition('CustomPartition', logical([1 0; 0 1; 0 0]));\nidx = test(c, 'all')",
+            "output": "`idx` preserves the supplied test-set columns."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does RunMat randomize partitions?",
+            "answer": "No. RunMat uses deterministic fold and holdout assignment so results are reproducible across runs."
+        },
+        {
+            "question": "How do I get masks for all folds?",
+            "answer": "Use `test(c,'all')` or `training(c,'all')`; columns correspond to partition test sets."
+        }
+    ],
+    "links": [
+        {
+            "label": "training",
+            "url": "./training"
+        },
+        {
+            "label": "test",
+            "url": "./test"
+        },
+        {
+            "label": "lasso",
+            "url": "./lasso"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/stats/ml/cvpartition.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/stats/ml/cvpartition.rs"
+    },
+    "key": "cvpartition",
+    "slug": "cvpartition",
+    "aliases": [],
+    "categoryPath": [
+        "stats",
+        "ml"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=cvpartition.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cvpartition.js","sourceRoot":"","sources":["../../../src/generated/builtins/cvpartition.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,aAAa;IACtB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,aAAa;QACb,kBAAkB;QAClB,OAAO;QACP,SAAS;QACT,UAAU;QACV,gBAAgB;QAChB,YAAY;QACZ,kBAAkB;KACnB;IACD,SAAS,EAAE,4CAA4C;IACvD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,SAAS;YACT,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+FAA+F;KACzG;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,MAAM;KACpB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,yCAAyC;QACjD,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,wLAAwL;IACvM,WAAW,EAAE;QACX,gIAAgI;QAChI,+JAA+J;QAC/J,4FAA4F;QAC5F,mEAAmE;QACnE,kHAAkH;QAClH,gLAAgL;QAChL,kKAAkK;QAClK,wJAAwJ;QACxJ,iIAAiI;KAClI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,qBAAqB;YACpC,OAAO,EAAE,0FAA0F;YACnG,QAAQ,EAAE,iFAAiF;SAC5F;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,+EAA+E;YACxF,QAAQ,EAAE,gDAAgD;SAC3D;QACD;YACE,aAAa,EAAE,sBAAsB;YACrC,OAAO,EAAE,qFAAqF;YAC9F,QAAQ,EAAE,gDAAgD;SAC3D;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,oGAAoG;SAC/G;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,wFAAwF;SACnG;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,8DAA8D;QACvE,KAAK,EAAE,2GAA2G;KACnH;IACD,KAAK,EAAE,aAAa;IACpB,MAAM,EAAE,aAAa;IACrB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,IAAI;KACL;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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