runmat 0.6.1 → 0.6.2-dev.1

package/dist/generated/builtins/gammaln.js

@@ -20,7 +20,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "Uses the provider unary_gammaln hook after proving real GPU inputs are nonnegative; falls back to host evaluation when the hook is unavailable."
+        "notes": "Uses unary_gammaln for documented real single or double input after proving the domain. RunMat-only integer and logical extensions gather authoritatively, validate before provider access, and restore floating output to the owning provider."
     },
     "fusion": {
         "elementwise": false,
@@ -38,9 +38,10 @@ const builtinDoc = {
         "`gammaln(A)` applies the log-gamma function element-by-element while preserving the input tensor shape.",
         "Double inputs return double results; single tensors preserve single dtype metadata with single-rounded output values.",
         "`gammaln(0)` returns `Inf`; `gammaln(Inf)` returns `Inf`; `gammaln(NaN)` returns `NaN`.",
-        "Scalar integer, logical, and character inputs are promoted through RunMat's ordinary numeric coercion path for compatibility with existing elementwise builtins.",
+        "Typed integer, logical, and character inputs are separate RunMat-only extensions and are rejected in strict compatibility mode.",
+        "The integer extension admits all eight classes only when every value is exactly representable as binary64; output is double.",
         "Negative, complex, string, and sparse inputs produce stable typed errors.",
-        "Real GPU tensors stay on device when the provider implements `unary_gammaln`; otherwise RunMat gathers the tensor, evaluates on the host, and returns a host value with the computed results."
+        "Real GPU tensors stay with their owning provider. Native output is validated for shape, precision, real storage, and ownership; all fallback results are restored to that owner."
     ],
     "examples": [
         {
@@ -80,7 +81,7 @@ const builtinDoc = {
         },
         {
             "question": "Can `gammaln` run on GPU arrays?",
-            "answer": "Yes for real nonnegative tensors. The WGPU backend evaluates `gammaln` on device; other providers may fall back to host evaluation if they do not expose `unary_gammaln`."
+            "answer": "Yes for real nonnegative single or double tensors. A valid native result stays resident; otherwise RunMat gathers, computes, and uploads the precision-preserving result back to the input's owning provider."
         }
     ],
     "related": [
@@ -111,11 +112,12 @@ const builtinDoc = {
             "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/gammaln.rs"
         }
     ],
-    "gpu_residency": "Yes when the active provider implements `unary_gammaln` for real-valued gpuArray inputs. Providers without that hook trigger a host fallback, so the computed result is returned as a host tensor rather than a resident gpuArray.",
+    "gpu_residency": "Yes for admitted gpuArray inputs. Documented floating inputs use validated native output when possible; host fallback and RunMat-only integer or logical extension paths upload the result back to the original owning provider.",
     "implementation_notes": [
         "CPU evaluation uses a log-Lanczos approximation and the reflection identity for positive inputs below 0.5.",
         "The WGPU backend uses the same log-Lanczos form for f32 and f64 precision.",
-        "RunMat validates the real nonnegative domain before executing provider kernels so negative inputs produce stable domain errors."
+        "RunMat validates the real nonnegative domain before executing provider kernels so negative inputs produce stable domain errors.",
+        "Integer, logical, and character support consists of independently gated RunMat-only extensions. Integer admission uses the shared exact-binary64 predicate before conversion, including for resident storage."
     ],
     "key": "gammaln",
     "slug": "gammaln",

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

@@ -1 +1 @@
-{"version":3,"file":"gammaln.js","sourceRoot":"","sources":["../../../src/generated/builtins/gammaln.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,kBAAkB;IAC9B,UAAU,EAAE;QACV,SAAS;QACT,OAAO;QACP,WAAW;QACX,kBAAkB;QAClB,aAAa;QACb,KAAK;KACN;IACD,SAAS,EAAE,wFAAwF;IACnG,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,iJAAiJ;KAC3J;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,6CAA6C;QACrD,aAAa,EAAE,6EAA6E;KAC7F;IACD,aAAa,EAAE,oJAAoJ;IACnK,WAAW,EAAE;QACX,yGAAyG;QACzG,uHAAuH;QACvH,yFAAyF;QACzF,kKAAkK;QAClK,2EAA2E;QAC3E,+LAA+L;KAChM;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,gBAAgB;YACzB,QAAQ,EAAE,YAAY;SACvB;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,kBAAkB;YAC3B,QAAQ,EAAE,YAAY;SACvB;QACD;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,kCAAkC;YAC3C,QAAQ,EAAE,yBAAyB;SACpC;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,kBAAkB;YAC3B,QAAQ,EAAE,cAAc;SACzB;QACD;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,mEAAmE;YAC5E,QAAQ,EAAE,4BAA4B;SACvC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,2JAA2J;SACtK;QACD;YACE,UAAU,EAAE,oDAAoD;YAChE,QAAQ,EAAE,6HAA6H;SACxI;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,2KAA2K;SACtL;KACF;IACD,SAAS,EAAE;QACT;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;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;YACE,OAAO,EAAE,kEAAkE;YAC3E,KAAK,EAAE,+GAA+G;SACvH;KACF;IACD,eAAe,EAAE,oOAAoO;IACrP,sBAAsB,EAAE;QACtB,4GAA4G;QAC5G,4EAA4E;QAC5E,iIAAiI;KAClI;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,aAAa;KACd;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"gammaln.js","sourceRoot":"","sources":["../../../src/generated/builtins/gammaln.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,kBAAkB;IAC9B,UAAU,EAAE;QACV,SAAS;QACT,OAAO;QACP,WAAW;QACX,kBAAkB;QAClB,aAAa;QACb,KAAK;KACN;IACD,SAAS,EAAE,wFAAwF;IACnG,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,iPAAiP;KAC3P;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,6CAA6C;QACrD,aAAa,EAAE,6EAA6E;KAC7F;IACD,aAAa,EAAE,oJAAoJ;IACnK,WAAW,EAAE;QACX,yGAAyG;QACzG,uHAAuH;QACvH,yFAAyF;QACzF,iIAAiI;QACjI,8HAA8H;QAC9H,2EAA2E;QAC3E,kLAAkL;KACnL;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,gBAAgB;YACzB,QAAQ,EAAE,YAAY;SACvB;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,kBAAkB;YAC3B,QAAQ,EAAE,YAAY;SACvB;QACD;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,kCAAkC;YAC3C,QAAQ,EAAE,yBAAyB;SACpC;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,kBAAkB;YAC3B,QAAQ,EAAE,cAAc;SACzB;QACD;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,mEAAmE;YAC5E,QAAQ,EAAE,4BAA4B;SACvC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,2JAA2J;SACtK;QACD;YACE,UAAU,EAAE,oDAAoD;YAChE,QAAQ,EAAE,6HAA6H;SACxI;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,+MAA+M;SAC1N;KACF;IACD,SAAS,EAAE;QACT;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;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;YACE,OAAO,EAAE,kEAAkE;YAC3E,KAAK,EAAE,+GAA+G;SACvH;KACF;IACD,eAAe,EAAE,kOAAkO;IACnP,sBAAsB,EAAE;QACtB,4GAA4G;QAC5G,4EAA4E;QAC5E,iIAAiI;QACjI,+MAA+M;KAChN;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,aAAa;KACd;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/gamrnd.js

@@ -17,7 +17,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "RunMat currently generates samples on the host RNG path."
+        "notes": "RunMat currently generates samples on the host RNG path and restores documented floating gpuArray output to the input provider."
     },
     "fusion": {
         "elementwise": false,
@@ -35,7 +35,9 @@ const builtinDoc = {
         "`a` and `b` support scalar expansion and matching array shapes.",
         "Without explicit size arguments, the output shape is the scalar-expanded parameter shape.",
         "With explicit size arguments, nonscalar parameters must match the requested shape.",
-        "`a` must be nonnegative and `b` must be positive."
+        "`a` must be nonnegative and `b` must be positive.",
+        "MATLAB-compatible mode accepts documented single and double parameters and size controls. Native typed-integer parameters or dimensions are separately declared RunMat extensions; admitted numerical parameters must be exactly representable at the binary64 sampling boundary.",
+        "Automatic internal residency may gather transparently. Documented explicit floating gpuArray input preserves its provider ownership and output residency."
     ],
     "examples": [
         {

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

@@ -1 +1 @@
-{"version":3,"file":"gamrnd.js","sourceRoot":"","sources":["../../../src/generated/builtins/gamrnd.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,cAAc;IAC1B,UAAU,EAAE;QACV,QAAQ;QACR,OAAO;QACP,QAAQ;QACR,YAAY;KACb;IACD,SAAS,EAAE,4CAA4C;IACvD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,0DAA0D;KACpE;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,qDAAqD;QAC7D,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,oJAAoJ;IACnK,WAAW,EAAE;QACX,iEAAiE;QACjE,2FAA2F;QAC3F,oFAAoF;QACpF,mDAAmD;KACpD;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,qBAAqB;SAC/B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4BAA4B;YACxC,QAAQ,EAAE,yGAAyG;SACpH;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,0EAA0E;QACnF,KAAK,EAAE,uHAAuH;KAC/H;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"gamrnd.js","sourceRoot":"","sources":["../../../src/generated/builtins/gamrnd.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,cAAc;IAC1B,UAAU,EAAE;QACV,QAAQ;QACR,OAAO;QACP,QAAQ;QACR,YAAY;KACb;IACD,SAAS,EAAE,4CAA4C;IACvD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,iIAAiI;KAC3I;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,qDAAqD;QAC7D,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,oJAAoJ;IACnK,WAAW,EAAE;QACX,iEAAiE;QACjE,2FAA2F;QAC3F,oFAAoF;QACpF,mDAAmD;QACnD,mRAAmR;QACnR,2JAA2J;KAC5J;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,qBAAqB;SAC/B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4BAA4B;YACxC,QAAQ,EAAE,yGAAyG;SACpH;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,0EAA0E;QACnF,KAAK,EAAE,uHAAuH;KAC/H;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/gather.js

@@ -20,7 +20,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "Executes on the CPU; gpuArray inputs are downloaded through the provider's `download` hook and residency metadata is cleared so planners know the value now lives on the host."
+        "notes": "Executes on the CPU; gpuArray inputs are copied through the provider's native numeric download contract. The returned value is host-resident while the source gpuArray remains valid with its residency and provenance unchanged."
     },
     "fusion": {
         "elementwise": false,
@@ -37,9 +37,9 @@ const builtinDoc = {
     "description": "`gather(X)` copies GPU-resident data back to host memory. In RunMat, `gpuArray` handles become dense MATLAB values, while CPU-resident inputs pass through unchanged.",
     "behaviors": [
         "Accepts any MATLAB value. Non-GPU inputs (numbers, logicals, structs, strings, etc.) pass through untouched, so `gather` is safe to call unconditionally at API boundaries.",
-        "Downloads gpuArray tensors via the active acceleration provider, producing dense double-precision matrices. Logical gpuArray inputs return logical arrays with MATLAB-compatible 0/1 encoding.",
-        "Recursively descends into cells, structs, and objects, gathering every nested gpuArray handle. This mirrors MATLAB's behaviour when you gather composite data structures.",
-        "Clears residency metadata so the auto-offload planner treats the gathered value as host-resident.",
+        "Downloads gpuArray tensors through their owning acceleration provider and reconstructs native double, single, logical, and integer classes, including supported complex storage, without widening the payload.",
+        "In `runmat` compatibility mode, recursively descends into cells, structs, and objects and gathers every nested gpuArray handle.",
+        "Creates a host copy without clearing or changing the source handle's residency, class, layout, or explicit-device provenance.",
         "Supports multiple inputs: in a single-output context it returns a `1×N` cell array preserving the original order; in a multi-output assignment the number of inputs and outputs must match, mirroring MATLAB's requirement.",
         "Raises `gather: no acceleration provider registered` when you attempt to download gpuArray data without an active provider, and propagates provider-specific download errors verbatim."
     ],
@@ -146,7 +146,7 @@ const builtinDoc = {
     },
     "gpu_residency": "RunMat's auto-offload planner keeps tensors on the GPU until a builtin marked as a sink (such as `gather`, plotting functions, or I/O) requests host access. You usually call `gather` at API boundaries, for example to log results or hand them to CPU-only libraries. If the upstream computation never leaves the GPU, you can omit `gather` and keep chaining gpu-aware builtins.",
     "gpu_behavior": [
-        "`gather` itself runs on the CPU. When the input contains gpuArray handles, the builtin calls the provider's `download` hook to retrieve a `HostTensorOwned` view, converts the result into MATLAB data, and clears residency via `runmat_accelerate_api::clear_residency`. If the provider does not implement `download`, the builtin surfaces the provider error so you know the backend must be extended. When the input is already on the host, no provider work is required."
+        "`gather` itself runs on the CPU. Each gpuArray handle is resolved to its owning provider and downloaded through the native numeric transfer contract, which carries the physical element type, shape, and real or interleaved-complex layout. RunMat reconstructs the corresponding host value and leaves the source gpuArray valid and resident. If the provider cannot download that native representation, the builtin surfaces the provider error; host inputs require no provider work."
     ],
     "key": "gather",
     "slug": "gather",

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

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

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

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

package/dist/generated/builtins/ge.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "Uses provider elem_ge kernels when available; otherwise inputs gather back to host memory transparently."
+        "notes": "Uses provider elem_ge kernels when they preserve the operand domain. Exact integer fallbacks compare authoritative host storage and upload a logical result to the input handle's owning provider."
     },
     "fusion": {
         "elementwise": true,
@@ -35,11 +35,12 @@ const builtinDoc = {
     },
     "description": "`ge(A, B)` (or `A >= B`) compares inputs element-wise for greater-than-or-equal relations. Scalar expansion and output-shape behavior follow MATLAB semantics.",
     "behaviors": [
-        "Numeric, logical, and character inputs compare element-wise using MATLAB's implicit expansion rules.",
+        "Numeric, logical, and character inputs compare element-wise using MATLAB's implicit expansion rules. All eight integer classes are supported without converting authoritative integer values through f64.",
         "Character arrays compare by Unicode code point; mixing them with numeric arrays behaves like comparing numeric codes (`'A' >= 65`).",
         "String scalars and string arrays compare lexically; implicit expansion works across string dimensions.",
-        "Complex inputs are not supported, matching MATLAB's behaviour.",
-        "Mixed numeric/string inputs raise MATLAB-compatible type errors."
+        "Complex inputs compare their real parts; imaginary components do not participate in ordering.",
+        "Mixed numeric/string inputs raise type errors.",
+        "Categorical comparison is implemented through the categorical helper. String/cellstr, table, timetable, and complete right-hand object-overload parity remain pending."
     ],
     "examples": [
         {
@@ -54,8 +55,8 @@ const builtinDoc = {
         },
         {
             "description": "Apply Greater-Equal With Implicit Expansion",
-            "input": "v = [1 3 5 7];\nmask = ge(v, [2 6])",
-            "output": "mask =\n  1×4 logical array\n     0     0     1     1"
+            "input": "v = [1 3 5 7];\nmask = ge(v, 3)",
+            "output": "mask =\n  1×4 logical array\n     0     1     1     1"
         },
         {
             "description": "Compare Character Data To Numeric Codes",
@@ -84,7 +85,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I compare complex numbers with `ge`?",
-            "answer": "No. MATLAB does not define relational ordering for complex numbers, so RunMat raises a MATLAB-compatible error when complex inputs are supplied."
+            "answer": "Yes. Ordering compares the real parts and ignores imaginary components."
         },
         {
             "question": "How are strings compared?",
@@ -96,7 +97,7 @@ const builtinDoc = {
         },
         {
             "question": "Do I need to gather results manually after a GPU comparison?",
-            "answer": "No. When both inputs are `gpuArray` values and the provider supports `elem_ge`, the result stays on the GPU. Otherwise, RunMat gathers inputs transparently and returns a host logical array."
+            "answer": "No. Native comparisons return a resident logical result. Correctness fallbacks gather, compare on authoritative host storage, and upload the logical result to the owning provider."
         },
         {
             "question": "Does implicit expansion apply to string arrays?",
@@ -139,7 +140,7 @@ const builtinDoc = {
     },
     "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. RunMat's native auto-offload planner keeps intermediate results on the GPU when fused expressions benefit from device execution. Explicit `gpuArray` and `gather` calls remain available for compatibility with MATLAB code that manages residency manually.",
     "gpu_behavior": [
-        "When both operands are `gpuArray` values and the active acceleration provider implements the `elem_ge` hook, RunMat executes the comparison entirely on the device and returns a `gpuArray` logical result. If the provider does not expose this hook, the runtime gathers the inputs to host memory automatically and performs the CPU comparison instead of failing."
+        "When resident operands can use the provider's `elem_ge` hook without changing their value domain, RunMat executes on the device. Otherwise it gathers, performs an exact host comparison, and uploads a logical result to the original handle's owning provider."
     ],
     "key": "ge",
     "slug": "ge",

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

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

package/dist/generated/builtins/getenv.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Host-only operation. RunMat gathers GPU-resident arguments before querying the process environment; providers do not implement hooks for this builtin."
+        "notes": "Host-only operation. Resident numeric arguments are invalid environment names and reject before provider access; providers do not implement hooks for this builtin."
     },
     "fusion": {
         "elementwise": false,
@@ -27,17 +27,17 @@ const builtinDoc = {
     "requires_feature": null,
     "tested": {
         "unit": "builtins::io::repl_fs::getenv::tests",
-        "integration": "builtins::io::repl_fs::getenv::tests::getenv_returns_struct_with_all_variables"
+        "integration": "builtins::io::repl_fs::getenv::tests::getenv_no_argument_returns_string_dictionary"
     },
-    "description": "`getenv(name)` returns the value of environment variable `name` visible to the current process. Calling `getenv` with no arguments returns a struct of available variables, consistent with MATLAB semantics.",
+    "description": "`getenv(name)` returns the value of environment variable `name` visible to the current process. Calling `getenv` with no arguments returns a dictionary of string names and values.",
     "behaviors": [
-        "Accepts character vectors (`'PATH'`) or string scalars (`\"PATH\"`). Character vector inputs return character vectors; string inputs return string scalars.",
+        "Accepts character vectors (`'PATH'`) or string scalars (`\"PATH\"`). Both scalar forms return character vectors.",
         "Vectorised calls are supported: pass a string array to receive a string array of values, or a cell array of character vectors to receive a cell array of character vectors.",
-        "When the requested variable is not defined, `getenv` returns an empty character vector or an empty string scalar (depending on the input type). This matches MATLAB’s “variable not found” semantics.",
-        "Calling `getenv` with no arguments returns a scalar struct. Field names are the environment variable names; field values are character vectors containing each variable’s value.",
+        "When a scalar requested variable is not defined, `getenv` returns an empty character vector. Nonscalar string and cell containers retain their documented container type and dimensions.",
+        "Calling `getenv` with no arguments returns a dictionary whose keys and values are strings.",
         "On Windows, environment variable lookups are case-insensitive, mirroring the operating system. On Unix-like systems, lookups are case-sensitive.",
-        "Trailing spaces in character matrix inputs are ignored so that padded rows created with MATLAB’s string manipulation functions remain compatible.",
-        "The builtin rejects non-text inputs (numeric arrays, logicals, GPU tensors, etc.) with a clear MATLAB-style diagnostic."
+        "RunMat mode additionally accepts padded multirow character matrices and cells containing string scalars; both conveniences are independently disabled in MATLAB-compatible modes.",
+        "The builtin rejects non-text inputs, including every integer class and resident numeric handles, before provider access or environment lookup."
     ],
     "examples": [
         {
@@ -62,19 +62,19 @@ const builtinDoc = {
         },
         {
             "description": "Inspect All Environment Variables",
-            "input": "env = getenv();\ndisp(env.USER)",
-            "output": "env =\n  struct with fields:\n    HOME: '/'\n    PATH: '/usr/local/bin:/usr/bin:/bin'\n    USER: 'user'"
+            "input": "env = getenv();\ndisp(env(\"USER\"))",
+            "output": "\"user\""
         },
         {
             "description": "Cache The Environment For Repeated Access",
-            "input": "env = getenv();\nresultsFolder = fullfile(env.HOME, \"results\")",
+            "input": "env = getenv();\nresultsFolder = fullfile(env(\"HOME\"), \"results\")",
             "output": "resultsFolder =\n    \"//results\""
         }
     ],
     "faqs": [
         {
             "question": "What does `getenv` return when the variable is missing?",
-            "answer": "An empty character vector (`''`) for character inputs, or an empty string scalar (`\"\"`) for string inputs. You can test for a missing variable with `isempty(value)` or `value == \"\"`."
+            "answer": "A scalar character-vector or string-scalar query returns an empty character vector (`''`). You can test for a missing variable with `isempty(value)`."
         },
         {
             "question": "Does `getenv` support vectorised inputs?",
@@ -90,15 +90,15 @@ const builtinDoc = {
         },
         {
             "question": "Can I call `getenv` from GPU-accelerated code?",
-            "answer": "Yes. Inputs originating on the GPU are gathered automatically. The builtin still executes on the CPU, and the output lives on the host."
+            "answer": "The environment lookup always executes on the host and accepts textual names. Resident numeric values are not converted into names and reject before provider access."
         },
         {
             "question": "How do I access all environment variables at once?",
-            "answer": "Call `getenv()` with no arguments. The result is a struct whose fields contain character vectors for each environment variable."
+            "answer": "Call `getenv()` with no arguments. The result is a dictionary with string keys and values."
         },
         {
-            "question": "What happens if an environment variable name is not a valid struct field?",
-            "answer": "RunMat preserves the exact name as a struct field. Access it via dynamic field references when the name contains characters that cannot be used in dot notation."
+            "question": "What happens if an environment variable name contains punctuation?",
+            "answer": "The no-argument dictionary preserves the exact string key, so names do not need to be valid structure field identifiers."
         },
         {
             "question": "Are trailing spaces in character inputs significant?",
@@ -191,9 +191,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/io/repl_fs/getenv.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/repl_fs/getenv.rs"
     },
-    "gpu_residency": "No. `getenv` has no GPU implementation and simply queries the host environment. Passing GPU-resident values is supported (RunMat gathers them automatically), but there is no benefit to calling `gpuArray` yourself.",
+    "gpu_residency": "No. `getenv` is a host environment query with textual inputs. Resident numeric values are invalid names and reject before provider access.",
     "gpu_behavior": [
-        "`getenv` always runs on the CPU. If the argument originates from the GPU—for example, a string scalar produced by an accelerated builtin—RunMat gathers it to host memory before reading the environment. No GPU kernels are launched, and acceleration providers do not need to implement hooks for this builtin."
+        "`getenv` always runs on the CPU. No GPU kernels, downloads, or acceleration-provider hooks participate."
     ],
     "key": "getenv",
     "slug": "getenv",

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

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

package/dist/generated/builtins/getfield.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Runs on the host. Values that already reside on the GPU stay resident; no kernels are dispatched."
+        "notes": "Direct field retrieval is metadata-only and preserves resident handles. The independently gated indexed-resident form gathers authoritative storage through the owning provider."
     },
     "fusion": {
         "elementwise": false,
@@ -29,14 +29,14 @@ const builtinDoc = {
         "unit": "builtins::structs::core::getfield::tests",
         "integration": "runmat-vm/tests/functions.rs::member_get_set_and_method_call_skeleton"
     },
-    "description": "`value = getfield(S, field)` returns the contents of `S.field`. Nested field access, struct-array indexing forms, and object property access follow MATLAB semantics.",
+    "description": "`value = getfield(S, field)` returns the contents of `S.field`. Nested field access and structure-array indexing follow MATLAB semantics; RunMat object-family access is a separately gated extension.",
     "behaviors": [
         "Field names must be character vectors or string scalars. Several field names in a row navigate nested structs: `getfield(S, \"outer\", \"inner\")` is equivalent to `S.outer.inner`.",
         "When `S` is a struct array, `getfield(S, \"field\")` examines the first element by default. Provide indices in a cell array to target another element: `getfield(S, {k}, \"field\")` yields `S(k).field`.",
-        "After a field name you may supply an index cell to subscript the field value, e.g. `getfield(S, \"values\", {row, col})`. Each position accepts positive integers or the keyword `end` to reference the last element in that dimension.",
-        "MATLAB-style objects honour property attributes: static or private properties raise errors, while dependent properties invoke `get.<name>` when available.",
-        "Handle objects dereference to their underlying instance automatically. Deleted handles raise the standard MATLAB-style error.",
-        "`MException` values expose the `message`, `identifier`, and `stack` fields for compatibility with MATLAB error handling."
+        "After a field name you may supply an index cell to subscript the field value, e.g. `getfield(S, \"values\", {row, col})`. Numeric indices accept exact positive scalar or vector values from every integer class, and logical vectors select matching elements.",
+        "Direct integer field access and host subarray selection preserve the field's exact class, shape, storage, and magnitude; an index class never determines the output class.",
+        "RunMat mode additionally accepts textual `end` or numeric selectors, object/handle/listener/exception property access, and indexed resident-field gather. Each family is independently disabled in MATLAB-compatible modes.",
+        "Directly retrieved resident fields retain their original handle without provider access. Indexed resident fields use the explicit RunMat-only typed host-gather form and return host data."
     ],
     "examples": [
         {
@@ -60,8 +60,8 @@ const builtinDoc = {
             "output": "firstName = \"Ada\""
         },
         {
-            "description": "Using `end` to reference the last item in a field",
-            "input": "series = struct(\"values\", {1:5});\nlastValue = getfield(series, \"values\", {\"end\"})",
+            "description": "Selecting the last item in a field",
+            "input": "series = struct(\"values\", {1:5});\nlastValue = getfield(series, \"values\", {5})",
             "output": "lastValue = 5"
         },
         {
@@ -78,7 +78,7 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "Does `getfield` work on non-struct values?",
-            "answer": "No. The first argument must be a scalar struct, a struct array (possibly empty), an object instance created with `new_object`, a handle object, or an `MException`. Passing other types raises an error."
+            "answer": "The MATLAB-compatible surface requires a scalar or nonscalar structure. RunMat mode additionally supports selected object, handle, listener, and exception values through an explicit extension gate."
         },
         {
             "question": "How do I access nested struct fields?",
@@ -90,15 +90,15 @@ const builtinDoc = {
         },
         {
             "question": "Can I index the value stored in a field?",
-            "answer": "Yes. You may supply scalars or `end` inside the index cell to reference elements of the field value."
+            "answer": "Yes. Supply numeric or logical values inside an index cell. RunMat mode also provides a separately gated textual `end` convenience."
         },
         {
             "question": "Do dependent properties run their getter methods?",
-            "answer": "Yes. If a property is marked `Dependent` and a `get.propertyName` builtin exists, `getfield` invokes it. Otherwise the backing field `<property>_backing` is inspected."
+            "answer": "In RunMat mode, yes. Object-family access is a RunMat extension; dependent properties invoke `get.<name>` when available, otherwise the backing field `<property>_backing` is inspected."
         },
         {
             "question": "What happens when I query a deleted handle object?",
-            "answer": "RunMat mirrors MATLAB by raising `Invalid or deleted handle object 'ClassName'.`"
+            "answer": "The RunMat object-family extension raises `Invalid or deleted handle object 'ClassName'.`"
         }
     ],
     "links": [
@@ -135,9 +135,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/structs/core/getfield.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/structs/core/getfield.rs"
     },
-    "gpu_residency": "You do not have to move data between CPU and GPU explicitly when calling `getfield`. The builtin works entirely with metadata and returns handles or tensors in whatever memory space they already inhabit.",
+    "gpu_residency": "Direct field access is metadata-only and preserves an existing resident handle. Indexing into a resident field is a separately gated RunMat form that gathers exact typed storage to the host.",
     "gpu_behavior": [
-        "`getfield` is metadata-only. When structs or objects contain GPU tensors, the tensors remain on the device. The builtin manipulates only the host-side metadata and does not dispatch GPU kernels or gather buffers back to the CPU. Results inherit residency from the values being returned."
+        "Direct resident field retrieval performs no provider operation. Indexed resident-field access is not presented as metadata-only: in RunMat mode it routes through the owning provider, downloads authoritative storage, and returns a host result; MATLAB-compatible modes reject it before provider access."
     ],
     "key": "getfield",
     "slug": "getfield",

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

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

package/dist/generated/builtins/gpuArray.js

@@ -22,7 +22,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "Uploads host-resident data through the provider `upload` hook, including complex interleaved tensors, and re-uploading gpuArray inputs when dtype conversion is requested. Supports MATLAB-style size vectors, class strings, and `'like'` prototypes."
+        "notes": "Uploads host-resident data through the provider's native numeric transfer contract, preserving double, single, and all eight integer classes in real or interleaved-complex storage. Dtype conversion uploads a fresh gpuArray while leaving the source handle valid."
     },
     "fusion": {
         "elementwise": false,
@@ -36,16 +36,16 @@ const builtinDoc = {
         "integration": "builtins::acceleration::gpu::gpuarray::tests::gpu_array_transfers_numeric_tensor",
         "conversions": "builtins::acceleration::gpu::gpuarray::tests::gpu_array_casts_to_int32",
         "reshape": "builtins::acceleration::gpu::gpuarray::tests::gpu_array_applies_size_arguments",
-        "wgpu": "builtins::acceleration::gpu::gpuarray::tests::gpu_array_wgpu_roundtrip"
+        "wgpu": "builtins::acceleration::gpu::gpuarray::tests::gpu_array_wgpu_complex_and_integer_roundtrip"
     },
-    "description": "`gpuArray(X)` moves data to the active GPU and returns a `gpuArray` handle for accelerated execution. Type controls, size forms, and `'like'` prototype behavior follow MATLAB semantics.",
+    "description": "`gpuArray(X)` moves data to the active GPU and returns a `gpuArray` handle for accelerated execution. RunMat mode additionally supports explicit dtype, size, and `'like'` construction extensions.",
     "behaviors": [
-        "Accepts numeric tensors, complex tensors, logical arrays, booleans, character vectors, and existing gpuArray handles. Other input types raise descriptive errors so callers can gather or convert first.",
-        "Optional leading size arguments (`gpuArray(data, m, n, ...)` or `gpuArray(data, [m n ...])`) reshape the uploaded value. The element count must match the requested size.",
-        "Class strings such as `'single'`, `'double'`, `'int32'`, `'uint8'`, and `'logical'` convert real data before upload, matching MATLAB casting semantics (round-to-nearest with saturation for integers, `NaN`→0 for integer classes, and errors when converting `NaN` to logical). Complex inputs can be uploaded as double or single precision.",
-        "`'like', prototype` infers the dtype (and logical state) from `prototype`. Explicit class strings override the inference when both are supplied.",
+        "Accepts numeric tensors, complex tensors, logical arrays, booleans, character vectors, and existing gpuArray handles. Double, single, and all eight integer classes retain native real or supported complex storage during transfer.",
+        "In `runmat` compatibility mode, optional leading size arguments reshape the uploaded value while preserving element count.",
+        "In `runmat` compatibility mode, class strings convert real data before upload and complex inputs can select double or single precision.",
+        "In `runmat` compatibility mode, `'like', prototype` infers dtype and logical state from the prototype.",
         "`\"gpuArray\"` strings are accepted as no-ops so call-sites that forward arguments from constructors such as `zeros(..., 'gpuArray')` remain compatible.",
-        "Inputs that are already gpuArray handles pass through by default. When a class change is requested, RunMat gathers the data, performs the conversion, uploads a fresh buffer, and frees the old handle.",
+        "Inputs that are already gpuArray handles pass through by default. When a class change is requested, RunMat gathers the data, performs the conversion, and uploads a fresh buffer without invalidating the original handle.",
         "When no acceleration provider is registered, the builtin raises `gpuArray: no acceleration provider registered`."
     ],
     "examples": [
@@ -115,9 +115,9 @@ const builtinDoc = {
         "label": "crates/runmat-runtime/src/builtins/acceleration/gpu/gpuarray.rs",
         "url": "crates/runmat-runtime/src/builtins/acceleration/gpu/gpuarray.rs"
     },
-    "gpu_residency": "RunMat’s auto-offload planner transparently moves and keeps tensors on the GPU when it predicts a benefit. You typically call `gpuArray` to honour MATLAB scripts that opt-in explicitly, to enforce residency before a long computation, or when you need MATLAB-style dtype conversion alongside the upload. The builtin never forces a host copy once the handle has been created.",
+    "gpu_residency": "RunMat’s auto-offload planner transparently moves and keeps tensors on the GPU when it predicts a benefit. MATLAB-compatible scripts use `gpuArray(X)` for explicit upload; dtype, size, and `'like'` construction forms are RunMat-only extensions.",
     "gpu_behavior": [
-        "`gpuArray` itself runs on the CPU. For host inputs it prepares a `HostTensorView` and forwards it to the provider’s `upload` hook. Complex tensors are uploaded as interleaved real/imaginary buffers and marked with complex storage metadata so `gather` reconstructs a host `ComplexTensor`. For gpuArray inputs that require dtype conversion, the builtin gathers the existing buffer, casts the result on the host, uploads a replacement, and frees the original handle. Providers that do not yet implement `upload` should report an informative error; the builtin surface mirrors MATLAB’s message by prefixing it with `gpuArray:`."
+        "`gpuArray` itself runs on the CPU. Host values enter one provider transfer contract carrying their native element type, shape, and real or interleaved-complex layout. `gather` uses the matching native download contract to reconstruct the same host class without widening single or integer values. A requested dtype conversion creates a new buffer and leaves the source gpuArray valid; providers that cannot represent the requested native transfer return an informative `gpuArray:` error."
     ],
     "key": "gpuarray",
     "slug": "gpuarray",

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

@@ -1 +1 @@
-{"version":3,"file":"gpuArray.js","sourceRoot":"","sources":["../../../src/generated/builtins/gpuArray.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,kBAAkB;IAC9B,UAAU,EAAE;QACV,UAAU;QACV,KAAK;QACL,QAAQ;QACR,QAAQ;QACR,YAAY;QACZ,OAAO;QACP,MAAM;QACN,MAAM;KACP;IACD,SAAS,EAAE,+DAA+D;IAC1E,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,wPAAwP;KAClQ;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,8CAA8C;QACtD,aAAa,EAAE,kFAAkF;QACjG,aAAa,EAAE,wEAAwE;QACvF,SAAS,EAAE,gFAAgF;QAC3F,MAAM,EAAE,wEAAwE;KACjF;IACD,aAAa,EAAE,2LAA2L;IAC1M,WAAW,EAAE;QACX,0MAA0M;QAC1M,2KAA2K;QAC3K,iVAAiV;QACjV,kJAAkJ;QAClJ,0JAA0J;QAC1J,yMAAyM;QACzM,kHAAkH;KACnH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,iDAAiD;YAChE,OAAO,EAAE,6DAA6D;YACtE,QAAQ,EAAE,gFAAgF;SAC3F;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,4FAA4F;YACrG,QAAQ,EAAE,6CAA6C;SACxD;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,uDAAuD;YAChE,QAAQ,EAAE,gDAAgD;SAC3D;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,gJAAgJ;YACzJ,QAAQ,EAAE,0BAA0B;SACrC;QACD;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE,qBAAqB;SAChC;QACD;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,mEAAmE;YAC5E,QAAQ,EAAE,0BAA0B;SACrC;KACF;IACD,MAAM,EAAE,EAAE;IACV,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,iEAAiE;QAC1E,KAAK,EAAE,iEAAiE;KACzE;IACD,eAAe,EAAE,uXAAuX;IACxY,cAAc,EAAE;QACd,inBAAinB;KAClnB;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,cAAc;QACd,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"gpuArray.js","sourceRoot":"","sources":["../../../src/generated/builtins/gpuArray.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,kBAAkB;IAC9B,UAAU,EAAE;QACV,UAAU;QACV,KAAK;QACL,QAAQ;QACR,QAAQ;QACR,YAAY;QACZ,OAAO;QACP,MAAM;QACN,MAAM;KACP;IACD,SAAS,EAAE,+DAA+D;IAC1E,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,uQAAuQ;KACjR;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,8CAA8C;QACtD,aAAa,EAAE,kFAAkF;QACjG,aAAa,EAAE,wEAAwE;QACvF,SAAS,EAAE,gFAAgF;QAC3F,MAAM,EAAE,4FAA4F;KACrG;IACD,aAAa,EAAE,qMAAqM;IACpN,WAAW,EAAE;QACX,sOAAsO;QACtO,4HAA4H;QAC5H,yIAAyI;QACzI,wGAAwG;QACxG,0JAA0J;QAC1J,4NAA4N;QAC5N,kHAAkH;KACnH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,iDAAiD;YAChE,OAAO,EAAE,6DAA6D;YACtE,QAAQ,EAAE,gFAAgF;SAC3F;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,4FAA4F;YACrG,QAAQ,EAAE,6CAA6C;SACxD;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,uDAAuD;YAChE,QAAQ,EAAE,gDAAgD;SAC3D;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,gJAAgJ;YACzJ,QAAQ,EAAE,0BAA0B;SACrC;QACD;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE,qBAAqB;SAChC;QACD;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,mEAAmE;YAC5E,QAAQ,EAAE,0BAA0B;SACrC;KACF;IACD,MAAM,EAAE,EAAE;IACV,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,iEAAiE;QAC1E,KAAK,EAAE,iEAAiE;KACzE;IACD,eAAe,EAAE,sPAAsP;IACvQ,cAAc,EAAE;QACd,yeAAye;KAC1e;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,cAAc;QACd,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/groupcounts.js

@@ -15,15 +15,19 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Grouping runs on the host."
+        "notes": "Grouping runs on the host. Automatic internal residency gathers transparently; explicit interactive gpuArray input is a declared RunMat-only extension."
     },
     "tested": {
-        "unit": "builtins::array::grouping::tests"
+        "unit": "builtins::array::grouping::tests",
+        "integration": "crates/runmat-vm/tests/integer_statistical_semantics.rs"
     },
-    "description": "`B = groupcounts(A)` returns counts for each sorted nonmissing group in array data. For table input, `groupcounts(T,vars)` returns a table with grouping variables, `GroupCount`, and `Percent`.",
+    "description": "`B = groupcounts(A)` returns counts for each sorted group in array data, including the missing group by default. For table input, `groupcounts(T,vars)` returns a table with grouping variables, `GroupCount`, and `Percent`.",
     "behaviors": [
         "Supports array, cell-array-of-grouping-vectors, and table grouping inputs.",
-        "Missing groups are excluded from the count output."
+        "All eight integer classes are documented grouping data and are compared from authoritative storage, including distinct uint64 values above flintmax.",
+        "The one-group form supports numeric edges and positive bin counts together with IncludedEdge, IncludeEmptyGroups, and IncludeMissingGroups. Exact integer edges never cross a floating comparison boundary. Multi-group bin specifications and time bins are not currently supported.",
+        "Native typed-integer bin counts and boolean controls are independently gated RunMat extensions; equivalent double and logical controls remain available in MATLAB-compatible mode.",
+        "Missing groups are included by default. Count and percentage outputs are double, while unbinned grouping outputs preserve their integer class."
     ],
     "examples": [
         {

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

@@ -1 +1 @@
-{"version":3,"file":"groupcounts.js","sourceRoot":"","sources":["../../../src/generated/builtins/groupcounts.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,QAAQ;QACR,OAAO;QACP,OAAO;KACR;IACD,SAAS,EAAE,6CAA6C;IACxD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,4BAA4B;KACtC;IACD,QAAQ,EAAE;QACR,MAAM,EAAE,kCAAkC;KAC3C;IACD,aAAa,EAAE,kMAAkM;IACjN,WAAW,EAAE;QACX,4EAA4E;QAC5E,oDAAoD;KACrD;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,cAAc;YAC7B,OAAO,EAAE,0BAA0B;YACnC,QAAQ,EAAE,YAAY;SACvB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,wDAAwD;QACjE,KAAK,EAAE,qGAAqG;KAC7G;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"}
+{"version":3,"file":"groupcounts.js","sourceRoot":"","sources":["../../../src/generated/builtins/groupcounts.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,QAAQ;QACR,OAAO;QACP,OAAO;KACR;IACD,SAAS,EAAE,6CAA6C;IACxD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,yJAAyJ;KACnK;IACD,QAAQ,EAAE;QACR,MAAM,EAAE,kCAAkC;QAC1C,aAAa,EAAE,yDAAyD;KACzE;IACD,aAAa,EAAE,+NAA+N;IAC9O,WAAW,EAAE;QACX,4EAA4E;QAC5E,sJAAsJ;QACtJ,uRAAuR;QACvR,oLAAoL;QACpL,gJAAgJ;KACjJ;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,cAAc;YAC7B,OAAO,EAAE,0BAA0B;YACnC,QAAQ,EAAE,YAAY;SACvB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,wDAAwD;QACjE,KAAK,EAAE,qGAAqG;KAC7G;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/groupsummary.d.ts

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

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

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