runmat 0.6.1 → 0.6.2-dev.0

package/dist/generated/builtins/cospi.js

@@ -13,11 +13,14 @@ const builtinDoc = {
     ],
     "summary": "Compute cos(X*pi) accurately with exact integer and half-integer results.",
     "gpu_support": {
-        "elementwise": false,
+        "elementwise": true,
         "reduction": false,
-        "precisions": [],
-        "broadcasting": "none",
-        "notes": "gpuArray inputs are gathered to the host so RunMat can preserve exact results at integer and half-integer multiples of pi."
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "elementwise",
+        "notes": "GPU inputs gather to the exact host reference path and the floating result is restored to the owning provider."
     },
     "fusion": {
         "elementwise": false,
@@ -31,14 +34,17 @@ const builtinDoc = {
         "unit": "builtins::math::trigonometry::cospi::tests",
         "integration": null
     },
-    "description": "`cospi(X)` computes `cos(X*pi)` without first materializing the approximate floating-point value `X*pi`. Odd half-integers return exactly zero and integers return exactly `+1` or `-1`.",
+    "description": "`cospi(X)` computes `cos(X*pi)` without first materializing the approximate floating-point product. MATLAB documents single and double real or complex arrays; RunMat mode additionally admits typed integers, logicals, and characters through explicit compatibility gates.",
     "behaviors": [
         "Operates element-wise on scalars, vectors, matrices, and N-D tensors.",
-        "Integer and logical inputs are promoted to double precision before evaluation.",
+        "Single real and complex inputs preserve single output; double inputs preserve double output.",
+        "Typed integers are a RunMat-only extension. All eight real integer classes produce double, with exact `+1` or `-1` computed directly from native parity even above `flintmax`.",
+        "Logical and character inputs are separately gated RunMat-only extensions and produce double output.",
         "Returns exactly 0 for odd half-integer inputs and exactly ±1 for integer inputs.",
         "Complex inputs use the analytic extension of `cos(pi*z)` while preserving exact real-axis sine/cosine factors when possible.",
         "Output shape matches the input shape; non-finite real inputs produce `NaN`.",
-        "String inputs are unsupported and raise a builtin-scoped error."
+        "String inputs are unsupported and raise a builtin-scoped error.",
+        "Table, timetable, tall, and distributed container inputs remain general RunMat container/runtime gaps rather than integer-storage gaps."
     ],
     "examples": [
         {
@@ -59,10 +65,14 @@ const builtinDoc = {
         },
         {
             "question": "Does `cospi` support gpuArray inputs?",
-            "answer": "Yes. RunMat currently gathers gpuArray inputs and evaluates the exact host implementation; no GPU kernel is launched yet."
+            "answer": "Yes. RunMat gathers gpuArray inputs, evaluates the exact host implementation, and restores the result to the owning provider."
         }
     ],
     "links": [
+        {
+            "label": "MATLAB cospi documentation",
+            "url": "https://www.mathworks.com/help/matlab/ref/double.cospi.html"
+        },
         {
             "label": "sinpi",
             "url": "./sinpi"

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

@@ -1 +1 @@
-{"version":3,"file":"cospi.js","sourceRoot":"","sources":["../../../src/generated/builtins/cospi.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,OAAO;QACP,QAAQ;QACR,IAAI;QACJ,cAAc;QACd,aAAa;QACb,KAAK;KACN;IACD,SAAS,EAAE,2EAA2E;IACtF,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,4HAA4H;KACtI;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;QACrB,OAAO,EAAE,2IAA2I;KACrJ;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,4CAA4C;QACpD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,0LAA0L;IACzM,WAAW,EAAE;QACX,uEAAuE;QACvE,gFAAgF;QAChF,kFAAkF;QAClF,8HAA8H;QAC9H,6EAA6E;QAC7E,iEAAiE;KAClE;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2BAA2B;YAC1C,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,kBAAkB;SAC7B;QACD;YACE,aAAa,EAAE,sDAAsD;YACrE,OAAO,EAAE,gBAAgB;YACzB,QAAQ,EAAE,OAAO;SAClB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,oLAAoL;SAC/L;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,2HAA2H;SACtI;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,cAAc;KACf;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"cospi.js","sourceRoot":"","sources":["../../../src/generated/builtins/cospi.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,OAAO;QACP,QAAQ;QACR,IAAI;QACJ,cAAc;QACd,aAAa;QACb,KAAK;KACN;IACD,SAAS,EAAE,2EAA2E;IACtF,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,aAAa;QAC7B,OAAO,EAAE,gHAAgH;KAC1H;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;QACrB,OAAO,EAAE,2IAA2I;KACrJ;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,4CAA4C;QACpD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,+QAA+Q;IAC9R,WAAW,EAAE;QACX,uEAAuE;QACvE,8FAA8F;QAC9F,gLAAgL;QAChL,qGAAqG;QACrG,kFAAkF;QAClF,8HAA8H;QAC9H,6EAA6E;QAC7E,iEAAiE;QACjE,yIAAyI;KAC1I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2BAA2B;YAC1C,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,kBAAkB;SAC7B;QACD;YACE,aAAa,EAAE,sDAAsD;YACrE,OAAO,EAAE,gBAAgB;YACzB,QAAQ,EAAE,OAAO;SAClB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,oLAAoL;SAC/L;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,+HAA+H;SAC1I;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,4BAA4B;YACrC,KAAK,EAAE,6DAA6D;SACrE;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,cAAc;KACf;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/createArray.js

@@ -0,0 +1,94 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "createArray",
+    "category": "array/creation",
+    "keywords": [
+        "createArray",
+        "FillValue",
+        "Like",
+        "constant",
+        "array"
+    ],
+    "summary": "Create an array of a specified class and value.",
+    "description": "`createArray` accepts dimensions first, followed by an optional class name and `Like` or `FillValue` name-value arguments. Integer dimensions are structural and exact. Integer FillValue and Like forms preserve authoritative class, complexity, and resident storage. The result is complex when either Like or FillValue is complex.",
+    "behaviors": [
+        "`createArray` returns scalar double zero.",
+        "`createArray(n)` creates an n-by-n array and `createArray(m,n,...)` creates the requested shape.",
+        "Negative dimensions are treated as zero.",
+        "A trailing class name selects the output class.",
+        "FillValue selects the repeated scalar value and preserves its class unless classname or Like requests assignment conversion. Without Like, a GPU-resident FillValue contributes residency and owning provider but does not override an explicit classname.",
+        "Like preserves numeric class and GPU residency; classname and Like cannot be combined.",
+        "If either Like or FillValue is complex, the output is complex. A real single Like therefore produces complex single for a complex FillValue, while a real double Like produces complex double."
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "none",
+        "notes": "Like and GPU FillValue forms use the source handle's owning provider for fill and fallback upload paths; native real and paired-complex integer storage remains exact and the output remains on that owner/device."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "uniform"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::creation::fill::tests"
+    },
+    "examples": [
+        {
+            "description": "Integer array",
+            "input": "A = createArray(2,3,'uint64',FillValue=uint64(7));",
+            "output": "2-by-3 uint64 array of sevens"
+        },
+        {
+            "description": "Prototype",
+            "input": "A = createArray(2,3,Like=uint16(1),FillValue=8);",
+            "output": "2-by-3 uint16 array"
+        },
+        {
+            "description": "Complex FillValue with a real prototype",
+            "input": "A = createArray(2,Like=single(0),FillValue=1+2i);",
+            "output": "2-by-2 complex single array"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How is createArray different from fill?",
+            "answer": "createArray constructs arrays; fill creates 2-D Patch graphics."
+        }
+    ],
+    "links": [
+        {
+            "label": "fill",
+            "url": "./fill"
+        },
+        {
+            "label": "zeros",
+            "url": "./zeros"
+        },
+        {
+            "label": "ones",
+            "url": "./ones"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/creation/fill.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/creation/fill.rs"
+    },
+    "key": "createarray",
+    "slug": "createarray",
+    "aliases": [],
+    "categoryPath": [
+        "array",
+        "creation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=createArray.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"createArray.js","sourceRoot":"","sources":["../../../src/generated/builtins/createArray.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,aAAa;IACtB,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,aAAa;QACb,WAAW;QACX,MAAM;QACN,UAAU;QACV,OAAO;KACR;IACD,SAAS,EAAE,iDAAiD;IAC5D,aAAa,EAAE,0UAA0U;IACzV,WAAW,EAAE;QACX,2CAA2C;QAC3C,kGAAkG;QAClG,0CAA0C;QAC1C,iDAAiD;QACjD,4PAA4P;QAC5P,wFAAwF;QACxF,gMAAgM;KACjM;IACD,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,oNAAoN;KAC9N;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,SAAS;KACvB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,wCAAwC;KACjD;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,eAAe;YAC9B,OAAO,EAAE,oDAAoD;YAC7D,QAAQ,EAAE,+BAA+B;SAC1C;QACD;YACE,aAAa,EAAE,WAAW;YAC1B,OAAO,EAAE,kDAAkD;YAC3D,QAAQ,EAAE,qBAAqB;SAChC;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,mDAAmD;YAC5D,QAAQ,EAAE,6BAA6B;SACxC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,iEAAiE;SAC5E;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6DAA6D;QACtE,KAAK,EAAE,0GAA0G;KAClH;IACD,KAAK,EAAE,aAAa;IACpB,MAAM,EAAE,aAAa;IACrB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/cross.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "Providers may implement the `cross` hook to keep real-valued inputs on the device. Complex outputs currently fall back to the host path."
+        "notes": "Same-owner, same-device real floating inputs may use a provider `cross` hook when its result preserves the required f32/f64 class and belongs to the invoked provider/device. Other resident inputs gather through their owners; eligible real or complex floating results are restored when the owner preserves class and complexity."
     },
     "fusion": {
         "elementwise": false,
@@ -33,14 +33,15 @@ const builtinDoc = {
         "integration": "builtins::math::linalg::ops::cross::tests::cross_gpu_roundtrip",
         "gpu": "builtins::math::linalg::ops::cross::tests::cross_wgpu_matches_cpu"
     },
-    "description": "`cross(A, B)` computes vector cross products for matching 3-element vectors. For matrices and higher-rank arrays, it uses the first dimension of length 3 unless an explicit dimension is provided, following MATLAB semantics.",
+    "description": "`cross(A, B)` computes vector cross products for matching 3-element vectors. MATLAB documents single and double data operands; RunMat mode additionally admits logical and all eight real or complex integer classes through explicit compatibility gates. Output is single when either data operand is single and double otherwise.",
     "behaviors": [
         "Inputs `A` and `B` must be the same size.",
         "With no dimension argument, `cross` uses the first dimension whose extent is exactly `3`.",
         "`cross(A, B, dim)` requires `dim` to be a valid array dimension and `size(A, dim) == 3`.",
         "The output has the same shape as the inputs because each input 3-vector produces one output 3-vector.",
-        "Logical and integer inputs are promoted to double precision before evaluation.",
-        "Real `gpuArray` inputs remain GPU-resident when the active provider implements the `cross` hook; otherwise RunMat gathers, evaluates on the host, and re-uploads the real result."
+        "Typed-integer and logical data operands are RunMat-only extensions, independently gated for A and B, and cross a floating evaluation boundary. Output is single when either data operand is single and double otherwise; arithmetic has floating rounding/overflow behavior rather than integer saturation.",
+        "An ordinary positive integer-valued double `dim` is documented. Because the public cross reference does not list typed or logical classes for `dim`, exact all-eight-class typed-integer dimensions and logical dimensions are conservatively classified as separately gated RunMat extensions; resident typed dimensions gather through their owner for exact validation.",
+        "A native provider hook is used only for same-owner, same-device real floating handles whose result has the required class. Other supported resident values gather independently and eligible real or complex floating results return to the first owner."
     ],
     "examples": [
         {
@@ -79,14 +80,18 @@ const builtinDoc = {
         },
         {
             "question": "Can I use complex inputs?",
-            "answer": "Yes. Complex host inputs use the standard bilinear cross-product formula without conjugation."
+            "answer": "Yes for documented single/double complex inputs. RunMat mode also accepts typed complex integers under the corresponding operand gate, converts both components to double, and applies the standard bilinear formula without conjugation."
         },
         {
             "question": "Does the result stay on the GPU?",
-            "answer": "For real-valued gpuArray inputs, yes when the provider implements `cross`. Complex results currently remain on the host because GPU complex tensor support is not yet wired through this builtin."
+            "answer": "Same-owner, same-device real floating inputs remain resident when a provider's `cross` hook returns the required class. Other resident inputs gather independently, and eligible real or complex floating results return to the first owner. Typed complex integers work on the host, but the current provider ABI cannot encode typed complex-integer resident buffers."
         }
     ],
     "links": [
+        {
+            "label": "MATLAB cross documentation",
+            "url": "https://www.mathworks.com/help/matlab/ref/cross.html"
+        },
         {
             "label": "dot",
             "url": "./dot"
@@ -112,7 +117,7 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/math/linalg/ops/cross.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/ops/cross.rs"
     },
-    "gpu_residency": "You usually do not need to call `gpuArray` explicitly for `cross`. RunMat keeps real-valued tensors on the GPU whenever the active provider supports the operation, and otherwise falls back to a gather -> host compute -> re-upload path automatically.",
+    "gpu_residency": "You usually do not need to call `gpuArray` explicitly for `cross`. RunMat uses a class-preserving native hook for eligible same-owner real inputs and otherwise follows a gather -> host compute -> class-preserving re-upload path for supported real and complex floating values.",
     "gpu_behavior": [
         "The WGPU provider computes real-valued `cross` products by gathering the three vector components into temporary device tensors, applying multiply/subtract kernels on-device, and scattering the results back into the output tensor. Providers that do not implement `cross` fall back to the host reference path."
     ],

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

@@ -1 +1 @@
-{"version":3,"file":"cross.js","sourceRoot":"","sources":["../../../src/generated/builtins/cross.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,iBAAiB;IAC7B,UAAU,EAAE;QACV,OAAO;QACP,eAAe;QACf,gBAAgB;QAChB,WAAW;QACX,KAAK;KACN;IACD,SAAS,EAAE,qDAAqD;IAChE,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,0IAA0I;KACpJ;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,2CAA2C;QACnD,aAAa,EAAE,gEAAgE;QAC/E,KAAK,EAAE,mEAAmE;KAC3E;IACD,aAAa,EAAE,iOAAiO;IAChP,WAAW,EAAE;QACX,2CAA2C;QAC3C,2FAA2F;QAC3F,0FAA0F;QAC1F,uGAAuG;QACvG,gFAAgF;QAChF,mLAAmL;KACpL;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,6CAA6C;YACtD,QAAQ,EAAE,yBAAyB;SACpC;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE,6BAA6B;SACxC;QACD;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,8DAA8D;YACvE,QAAQ,EAAE,6CAA6C;SACxD;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,0FAA0F;YACnG,QAAQ,EAAE,8BAA8B;SACzC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,wIAAwI;SACnJ;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,0FAA0F;SACrG;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,kGAAkG;SAC7G;QACD;YACE,UAAU,EAAE,2BAA2B;YACvC,QAAQ,EAAE,+FAA+F;SAC1G;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,mMAAmM;SAC9M;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,eAAe,EAAE,2PAA2P;IAC5Q,cAAc,EAAE;QACd,qTAAqT;KACtT;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;QACR,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"cross.js","sourceRoot":"","sources":["../../../src/generated/builtins/cross.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,iBAAiB;IAC7B,UAAU,EAAE;QACV,OAAO;QACP,eAAe;QACf,gBAAgB;QAChB,WAAW;QACX,KAAK;KACN;IACD,SAAS,EAAE,qDAAqD;IAChE,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,wUAAwU;KAClV;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,2CAA2C;QACnD,aAAa,EAAE,gEAAgE;QAC/E,KAAK,EAAE,mEAAmE;KAC3E;IACD,aAAa,EAAE,sUAAsU;IACrV,WAAW,EAAE;QACX,2CAA2C;QAC3C,2FAA2F;QAC3F,0FAA0F;QAC1F,uGAAuG;QACvG,6SAA6S;QAC7S,4WAA4W;QAC5W,0PAA0P;KAC3P;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,6CAA6C;YACtD,QAAQ,EAAE,yBAAyB;SACpC;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE,6BAA6B;SACxC;QACD;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,8DAA8D;YACvE,QAAQ,EAAE,6CAA6C;SACxD;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,0FAA0F;YACnG,QAAQ,EAAE,8BAA8B;SACzC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,wIAAwI;SACnJ;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,0FAA0F;SACrG;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,kGAAkG;SAC7G;QACD;YACE,UAAU,EAAE,2BAA2B;YACvC,QAAQ,EAAE,2OAA2O;SACtP;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,0WAA0W;SACrX;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,4BAA4B;YACrC,KAAK,EAAE,sDAAsD;SAC9D;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,eAAe,EAAE,qRAAqR;IACtS,cAAc,EAAE;QACd,qTAAqT;KACtT;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;QACR,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/csvread.js

@@ -17,7 +17,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Performs host-side file I/O and parsing. Acceleration providers are not involved, and results remain on the CPU."
+        "notes": "Performs host-side file I/O and parsing, and results remain on the CPU. Public host controls do not involve an acceleration provider; with the `csvread-resident-control-inputs` extension enabled, resident controls are gathered through their owning provider before parsing."
     },
     "fusion": {
         "elementwise": false,
@@ -30,15 +30,15 @@ const builtinDoc = {
         "unit": "builtins::io::tabular::csvread::tests",
         "integration": "builtins::io::tabular::csvread::tests::csvread_basic_csv_roundtrip"
     },
-    "description": "`csvread(filename)` reads numeric data from comma-separated text files and returns a dense double matrix. Legacy row/column offset handling (including zero-based forms) follows MATLAB and RunMat compatibility behavior.",
+    "description": "`csvread(filename)` reads real or complex numeric data from comma-separated text files and returns a dense double matrix. Row and column controls are zero-based.",
     "behaviors": [
         "Accepts character vectors or string scalars for the file name. String arrays must contain exactly one element.",
         "`csvread(filename, row, col)` starts reading at the zero-based row `row` and column `col`, skipping any data before that offset.",
-        "`csvread(filename, row, col, range)` reads only the rectangle described by `range`. Numeric ranges must contain four elements `[r1 c1 r2 c2]` (zero-based, inclusive). Excel-style ranges use the familiar `\"B2:D6\"` A1 notation, which RunMat converts to zero-based indices internally.",
+        "`csvread(filename, row, col, range)` reads only the rectangle described by `range`. The public forms are a four-element numeric range `[r1 c1 r2 c2]` or an A1 range such as `\"B2..D6\"`. RunMat's colon-separated A1 range and two-element numeric range are independent compatibility-gated extensions.",
         "Empty fields (two consecutive commas or a trailing comma) are interpreted as `0`. Tokens such as `NaN`, `Inf`, and `-Inf` are accepted (case-insensitive).",
         "Any other nonnumeric token raises an error that identifies the offending row and column.",
         "File input is read as byte-oriented CSV text before numeric parsing, so non-UTF-8 bytes in skipped header rows or skipped label columns do not cause an I/O decoding failure.",
-        "Results are dense double-precision tensors using column-major layout. An empty file produces a `0×0` tensor.",
+        "Real input produces a dense double tensor; any complex token (`a+bi`, `a+bj`, or a pure-imaginary form) produces a complex-double tensor without discarding an all-zero imaginary component. An empty file produces a `0×0` tensor.",
         "Paths can contain `~` to reference the home directory; RunMat expands the token before opening the file."
     ],
     "examples": [
@@ -89,11 +89,11 @@ const builtinDoc = {
         },
         {
             "question": "How are Excel-style ranges interpreted?",
-            "answer": "Excel ranges such as `\"B2:D5\"` use the familiar 1-based row numbering and column letters. The builtin converts them internally to zero-based indices and includes both endpoints."
+            "answer": "The public A1 form uses two dots, for example `\"B2..D5\"`, with 1-based row numbers and column letters. RunMat also accepts colon syntax such as `\"B2:D5\"` only when the `csvread-colon-range` extension is enabled. Both forms include their endpoints."
         },
         {
             "question": "Can I read files with quoted numeric fields?",
-            "answer": "Quoted numeric fields are not supported. Remove quotes before calling `csvread`, or switch to `readmatrix`, which has full CSV parsing support."
+            "answer": "Yes. A field wrapped in double quotes is parsed as a numeric token; general quoted-field CSV escaping is outside `csvread`'s narrow numeric format."
         },
         {
             "question": "What happens to empty cells?",
@@ -150,9 +150,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/io/tabular/csvread.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/tabular/csvread.rs"
     },
-    "gpu_residency": "`csvread` always returns a host-resident tensor because it performs file I/O and parsing on the CPU. If you need the data on the GPU, wrap the call with `gpuArray(csvread(...))` or switch to `readmatrix` with the `'Like'` option so that RunMat can place the result directly on the desired device.",
+    "gpu_residency": "`csvread` always returns a host-resident tensor because it performs file I/O and parsing on the CPU. Resident filename, offset, and range controls are accepted only when the `csvread-resident-control-inputs` RunMat extension is enabled.",
     "gpu_behavior": [
-        "`csvread` performs all work on the host CPU. Arguments are gathered from the GPU when necessary, and the resulting tensor is returned in host memory. To keep data on the GPU, call `gpuArray` on the output or switch to `readmatrix` with the `'Like'` option. No provider hooks are required."
+        "`csvread` performs file I/O and parsing on the host CPU. Public host controls require no provider. With the `csvread-resident-control-inputs` extension enabled, resident controls are gathered through their owning provider; the resulting tensor still returns in host memory."
     ],
     "key": "csvread",
     "slug": "csvread",

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

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

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

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

package/dist/generated/builtins/csvwrite.js

@@ -18,7 +18,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Runs entirely on the CPU. gpuArray inputs are gathered before serialisation."
+        "notes": "Runs entirely on the CPU. Direct resident input is a compatibility-gated RunMat extension and is gathered through the handle's owning provider."
     },
     "fusion": {
         "elementwise": false,
@@ -41,11 +41,12 @@ const builtinDoc = {
     },
     "description": "`csvwrite(filename, M)` writes numeric matrices to comma-separated text files. Legacy row/column offset arguments follow MATLAB and RunMat compatibility semantics.",
     "behaviors": [
-        "Only real numeric or logical inputs are accepted. Logical values are converted to `0` and `1` before writing. Complex and textual inputs raise descriptive errors.",
+        "Real or complex single/double data, all eight real integer classes, and logical matrices are accepted. Integer values serialize directly from authoritative storage; logical values serialize as `0` and `1`.",
         "`csvwrite(filename, M, row, col)` starts writing at zero-based row `row` and column `col`, leaving earlier rows blank and earlier columns empty within each row. Offsets must be non-negative integers.",
         "Matrices must be 2-D (trailing singleton dimensions are ignored). Column-major ordering is respected when serialising to text.",
         "Numbers are emitted using MATLAB-compatible short `g` formatting (`%.5g`). `NaN`, `Inf`, and `-Inf` tokens are written verbatim.",
-        "Existing files are overwritten. `csvwrite` does not support appending; switch to `writematrix` with `'WriteMode','append'` when the behaviour is required.",
+        "Each row ends with LF (`\\n`) on every platform. Existing files are overwritten; use `writematrix` with `'WriteMode','append'` when append behavior is required.",
+        "The documented form has no output. RunMat can return a bytes-written output only when the `csvwrite-bytes-written-output` extension is enabled.",
         "Paths that begin with `~` expand to the user's home directory before writing."
     ],
     "examples": [
@@ -66,8 +67,8 @@ const builtinDoc = {
             "input": "mask = [true false true; false true false];\ncsvwrite(\"mask.csv\", mask)"
         },
         {
-            "description": "Writing GPU-resident data without manual gather",
-            "input": "G = gpuArray(single([0.1 0.2 0.3]));\nbytes = csvwrite(\"gpu_values.csv\", G)",
+            "description": "Writing resident data and returning a byte count",
+            "input": "% Requires both csvwrite-resident-input and csvwrite-bytes-written-output.\nG = gpuArray(single([0.1 0.2 0.3]));\nbytes = csvwrite(\"gpu_values.csv\", G)",
             "output": "bytes = 12"
         },
         {
@@ -94,7 +95,7 @@ const builtinDoc = {
         },
         {
             "question": "What line ending does `csvwrite` use?",
-            "answer": "The builtin uses the platform default (`\\r\\n` on Windows, `\\n` elsewhere). Most CSV consumers handle either convention transparently."
+            "answer": "The builtin always writes LF (`\\n`), including on Windows."
         }
     ],
     "links": [
@@ -135,9 +136,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/io/tabular/csvwrite.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/tabular/csvwrite.rs"
     },
-    "gpu_residency": "No additional steps are necessary. `csvwrite` treats GPU arrays as residency sinks: data is gathered back to host memory prior to writing. This matches MATLAB's behaviour, where file I/O always operates on host-resident values.",
+    "gpu_residency": "With the `csvwrite-resident-input` extension enabled, resident data is gathered through the handle's owning provider before host file I/O. Strict compatibility mode rejects the extension before provider access or file mutation.",
     "gpu_behavior": [
-        "`csvwrite` always executes on the host CPU. When the matrix resides on the GPU, RunMat gathers the data through the active acceleration provider before serialisation. No provider hooks are required, and the return value reports the number of bytes written after the gather completes."
+        "`csvwrite` always executes on the host CPU. With the resident-input extension enabled, RunMat gathers through the handle owner before serialisation. A bytes-written return value is a separately gated extension."
     ],
     "key": "csvwrite",
     "slug": "csvwrite",

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

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

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

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

package/dist/generated/builtins/ctranspose.js

@@ -35,9 +35,10 @@ const builtinDoc = {
     },
     "description": "`B = ctranspose(A)` (or `A'`) swaps the first two dimensions of `A` and conjugates complex values. Real-valued inputs therefore behave like simple transpose, with MATLAB/RunMat Hermitian semantics for complex data.",
     "behaviors": [
-        "Works for scalars, vectors, matrices, and N-D arrays; only the first two axes are swapped.",
+        "Works for scalars, vectors, and matrices. N-D arrays with a nonsingleton dimension above two are rejected; use `permute` for N-D reordering.",
         "Real numeric, logical, and character data are not changed by conjugation.",
-        "Complex values receive element-wise conjugation after the transpose (`(a + bi)' = a - bi`).",
+        "Complex single and double values receive element-wise conjugation after the transpose (`(a + bi)' = a - bi`), and remain complex even when every imaginary component is zero. Complex integer storage is rejected.",
+        "Dense real integer input preserves all eight integer classes. Integer-valued sparse storage is available only through the `ctranspose-integer-sparse` RunMat extension.",
         "Character arrays and cell arrays preserve their types; `ctranspose` simply rearranges entries.",
         "String scalars are passed through unchanged; string arrays transpose like MATLAB.",
         "Empty arrays and singleton dimensions follow MATLAB's column-major semantics."
@@ -84,7 +85,7 @@ const builtinDoc = {
         },
         {
             "question": "What about higher-dimensional arrays?",
-            "answer": "Only the first two axes are swapped; trailing dimensions stay in-place, matching MATLAB."
+            "answer": "Use `permute` for higher-dimensional arrays. `ctranspose` accepts vectors and matrices, including explicit trailing singleton dimensions, and rejects nonsingleton dimensions above two."
         },
         {
             "question": "Does the result share storage with the input?",
@@ -100,11 +101,11 @@ const builtinDoc = {
         },
         {
             "question": "Can I rely on `ctranspose` inside linear-algebra routines (e.g., Hermitian products)?",
-            "answer": "Yes. The builtin mirrors MATLAB semantics precisely and is safe to use inside idioms like `A' * A`."
+            "answer": "Yes for the supported numeric, logical, character, string, cell, scalar-struct, sparse, and resident array forms described above. On those inputs it preserves the conjugate-transpose semantics required by idioms such as `A' * A`."
         },
         {
             "question": "What error do I get for unsupported types?",
-            "answer": "Non-numeric objects (e.g., structs) raise `ctranspose: unsupported input type ...`, matching MATLAB's strict type checks."
+            "answer": "Supported scalar structs are unchanged by transpose. Unsupported value kinds raise `ctranspose: unsupported input type ...`; external objects can provide their own `ctranspose` method."
         }
     ],
     "links": [

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

@@ -1 +1 @@
-{"version":3,"file":"ctranspose.js","sourceRoot":"","sources":["../../../src/generated/builtins/ctranspose.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"ctranspose.js","sourceRoot":"","sources":["../../../src/generated/builtins/ctranspose.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,iBAAiB;IAC7B,UAAU,EAAE;QACV,YAAY;QACZ,qBAAqB;QACrB,WAAW;QACX,KAAK;QACL,kBAAkB;KACnB;IACD,SAAS,EAAE,kDAAkD;IAC7D,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,sJAAsJ;KAChK;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,gDAAgD;QACxD,aAAa,EAAE,0EAA0E;QACzF,KAAK,EAAE,6EAA6E;KACrF;IACD,aAAa,EAAE,wNAAwN;IACvO,WAAW,EAAE;QACX,8IAA8I;QAC9I,2EAA2E;QAC3E,oNAAoN;QACpN,yKAAyK;QACzK,gGAAgG;QAChG,mFAAmF;QACnF,+EAA+E;KAChF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,gDAAgD;YACzD,QAAQ,EAAE,6CAA6C;SACxD;QACD;YACE,aAAa,EAAE,iEAAiE;YAChF,OAAO,EAAE,wCAAwC;YACjD,QAAQ,EAAE,+CAA+C;SAC1D;QACD;YACE,aAAa,EAAE,2DAA2D;YAC1E,OAAO,EAAE,2DAA2D;YACpE,QAAQ,EAAE,aAAa;SACxB;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,qCAAqC;YAC9C,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,uDAAuD;YACtE,OAAO,EAAE,qDAAqD;YAC9D,QAAQ,EAAE,oCAAoC;SAC/C;QACD;YACE,aAAa,EAAE,8DAA8D;YAC7E,OAAO,EAAE,yEAAyE;SACnF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,wJAAwJ;SACnK;QACD;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,+FAA+F;SAC1G;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,0LAA0L;SACrM;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,6GAA6G;SACxH;QACD;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+OAA+O;SAC1P;QACD;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,kHAAkH;SAC7H;QACD;YACE,UAAU,EAAE,uFAAuF;YACnG,QAAQ,EAAE,uOAAuO;SAClP;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,0LAA0L;SACrM;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,oEAAoE;QAC7E,KAAK,EAAE,iHAAiH;KACzH;IACD,eAAe,EAAE,yRAAyR;IAC1S,cAAc,EAAE;QACd,8KAA8K;QAC9K,2KAA2K;QAC3K,8QAA8Q;KAC/Q;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;QACR,KAAK;KACN;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,UAyHjB,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,UA0HjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/cumtrapz.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "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."
+        "notes": "Documented single- and double-precision real or complex resident samples use the owning provider's `cumtrapz_dim` hook when its contract is satisfied. RunMat-only integer, logical, same-size-X, mixed-provider, or rejected-provider cases use validated host fallback and return to the first resident owner when its precision permits."
     },
     "fusion": {
         "elementwise": false,
@@ -34,9 +34,10 @@ const builtinDoc = {
     "description": "`cumtrapz(Y)` computes cumulative trapezoidal integrals of sampled data in `Y`. The output matches `Y` in size, with zero at the first element of the integration dimension and running integral values thereafter.",
     "behaviors": [
         "`cumtrapz(Y)` assumes unit spacing between adjacent samples.",
-        "`cumtrapz(X, Y)` accepts a scalar spacing, a vector of coordinates whose length matches the working dimension, or an array `X` with the same size as `Y`.",
+        "`cumtrapz(X, Y)` accepts documented single- or double-precision scalar spacing or a coordinate vector whose length matches the working dimension. A same-size coordinate tensor is an explicitly gated RunMat extension.",
         "`cumtrapz(..., dim)` selects the working dimension explicitly. Dimensions larger than `ndims(Y)` behave like singleton axes, so the result stays zero along those slices.",
-        "Logical inputs are promoted to double precision before integration. Complex-valued `Y` inputs are integrated component-wise and preserve their complex output type.",
+        "Documented `Y` classes are single and double, real or complex, and output preserves single versus double. Typed-integer and logical `Y`, typed-integer or logical `X`, and typed-integer `dim` are separate RunMat-only extensions.",
+        "Typed-integer `Y` and `X` cross the binary64 integration boundary only when every authoritative integer value is exactly representable; otherwise RunMat reports an error instead of silently rounding.",
         "When the selected dimension has length 0 or 1, the output is zero along that dimension because there are no intervals to accumulate."
     ],
     "examples": [
@@ -72,7 +73,7 @@ const builtinDoc = {
         },
         {
             "question": "What forms of `X` are accepted?",
-            "answer": "A scalar spacing, a vector of coordinates matching the integration dimension, or an array with the same size as `Y`."
+            "answer": "The compatibility surface is a single- or double-precision scalar spacing or coordinate vector matching the integration dimension. RunMat mode additionally admits same-size coordinate tensors behind the `cumtrapz-tensor-spacing` extension gate."
         },
         {
             "question": "Does cumtrapz support complex inputs?",
@@ -80,7 +81,7 @@ const builtinDoc = {
         },
         {
             "question": "Does cumtrapz keep gpuArray residency?",
-            "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."
+            "answer": "Yes for documented floating real or complex samples when the owning provider accepts and returns the required shape, storage, precision, device, and ownership contract. Other admitted RunMat forms fall back through host computation and are restored to the first resident owner when possible."
         }
     ],
     "links": [
@@ -109,10 +110,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 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_residency": "Resident floating input dispatch is resolved from the input handle's owner, not the ambient active provider. Native results are validated for shape, storage, precision, device, and owner; invalid native results are freed before host fallback. Fallback returns to the first resident owner when provider precision permits.",
     "gpu_behavior": [
-        "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."
+        "Floating real and complex-interleaved resident `Y` can use provider-backed cumulative trapezoidal integration with real unit, scalar, coordinate-vector, or gated same-size coordinate-tensor spacing.",
+        "Mixed-provider spacing does not cross-dispatch. Integer or logical resident values, missing hooks, provider errors, and contract-invalid results use the exactness-checked host fallback path."
     ],
     "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,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"}
+{"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,6UAA6U;KACvV;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,0NAA0N;QAC1N,2KAA2K;QAC3K,qOAAqO;QACrO,yMAAyM;QACzM,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,sPAAsP;SACjQ;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,uGAAuG;SAClH;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,qSAAqS;SAChT;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,kUAAkU;IACnV,cAAc,EAAE;QACd,wMAAwM;QACxM,gMAAgM;KACjM;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.map

@@ -1 +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"}
+{"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,UAuGjB,CAAC;AAEF,eAAe,UAAU,CAAC"}