runmat 0.6.1 → 0.6.2-dev.0

package/dist/generated/builtins/mustBeNonmissing.js

@@ -15,7 +15,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Validators run on host values and metadata; they throw on validation failure."
+        "notes": "Validation uses coherent resident metadata when the result is type- or shape-decidable; content-dependent checks download exact typed values through the owning provider without changing source residency."
     },
     "fusion": {
         "elementwise": false,
@@ -25,15 +25,18 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "crates/runmat-runtime/src/builtins/common/validation.rs table-style pass/fail tests",
-        "integration": "Representative callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs; not every validator has a dedicated VM case."
+        "unit": "builtins::common::validation::tests",
+        "integration": "Durable callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs"
     },
-    "description": "`mustBeNonmissing` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented.",
+    "description": "`mustBeNonmissing` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented. Integer inputs are validated or rejected from their exact class and values. Resident metadata is validated before any provider access, automatic residency remains transparent, and unsupported explicit gpuArray forms are compatibility-gated before download.",
     "behaviors": [
         "Callable validator forms enforce exact supported arity, throw on validation failure, and suppress automatic output on success.",
         "Arguments-block validation uses the same shared runtime predicates for validators that RunMat can encode statically.",
         "Numeric validators check every element without materializing a cloned numeric array, including sparse stored values and implicit sparse zeros where relevant.",
-        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them."
+        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them.",
+        "All eight integer classes are classified from authoritative storage; exact ordering, range, membership, sign, zero, finiteness, and missingness checks never reconstruct wide values from binary64.",
+        "Resident validation verifies owner, physical storage, precision, logical/integer class, and wrapper provenance before using metadata or downloading exact content.",
+        "Automatic residency remains transparent; explicit gpuArray input is accepted only for documented forms or a declared RunMat-only extension."
     ],
     "examples": [
         {
@@ -54,6 +57,10 @@ const builtinDoc = {
             "url": "../language/arguments"
         }
     ],
+    "gpu_residency": "Metadata-decidable validators avoid download. Content-dependent validators use a non-destructive exact-owner download and leave the source handle, class, payload, and provenance unchanged.",
+    "gpu_behavior": [
+        "Validation does not use the generic message-based gather retry path. Integrity and compatibility failures are terminal; admitted content checks download typed storage deliberately through the exact owning provider."
+    ],
     "key": "mustbenonmissing",
     "slug": "mustbenonmissing",
     "aliases": [],

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

@@ -1 +1 @@
-{"version":3,"file":"mustBeNonmissing.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNonmissing.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,kBAAkB;IAC3B,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,kBAAkB;QAClB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,gEAAgE;IAC3E,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+EAA+E;KACzF;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,qFAAqF;QAC7F,aAAa,EAAE,2IAA2I;KAC3J;IACD,aAAa,EAAE,+ZAA+Z;IAC9a,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,qBAAqB;YAC9B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,KAAK,EAAE,kBAAkB;IACzB,MAAM,EAAE,kBAAkB;IAC1B,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"mustBeNonmissing.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNonmissing.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,kBAAkB;IAC3B,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,kBAAkB;QAClB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,gEAAgE;IAC3E,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6MAA6M;KACvN;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,qCAAqC;QAC7C,aAAa,EAAE,sFAAsF;KACtG;IACD,aAAa,EAAE,gqBAAgqB;IAC/qB,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;QAC7I,qMAAqM;QACrM,oKAAoK;QACpK,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,qBAAqB;YAC9B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,eAAe,EAAE,8LAA8L;IAC/M,cAAc,EAAE;QACd,wNAAwN;KACzN;IACD,KAAK,EAAE,kBAAkB;IACzB,MAAM,EAAE,kBAAkB;IAC1B,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/mustBeNonnegative.js

@@ -15,7 +15,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Validators run on host values and metadata; they throw on validation failure."
+        "notes": "Validation uses coherent resident metadata when the result is type- or shape-decidable; content-dependent checks download exact typed values through the owning provider without changing source residency."
     },
     "fusion": {
         "elementwise": false,
@@ -25,15 +25,18 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "crates/runmat-runtime/src/builtins/common/validation.rs table-style pass/fail tests",
-        "integration": "Representative callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs; not every validator has a dedicated VM case."
+        "unit": "builtins::common::validation::tests",
+        "integration": "Durable callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs"
     },
-    "description": "`mustBeNonnegative` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented.",
+    "description": "`mustBeNonnegative` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented. Integer inputs are validated or rejected from their exact class and values. Resident metadata is validated before any provider access, automatic residency remains transparent, and unsupported explicit gpuArray forms are compatibility-gated before download.",
     "behaviors": [
         "Callable validator forms enforce exact supported arity, throw on validation failure, and suppress automatic output on success.",
         "Arguments-block validation uses the same shared runtime predicates for validators that RunMat can encode statically.",
         "Numeric validators check every element without materializing a cloned numeric array, including sparse stored values and implicit sparse zeros where relevant.",
-        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them."
+        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them.",
+        "All eight integer classes are classified from authoritative storage; exact ordering, range, membership, sign, zero, finiteness, and missingness checks never reconstruct wide values from binary64.",
+        "Resident validation verifies owner, physical storage, precision, logical/integer class, and wrapper provenance before using metadata or downloading exact content.",
+        "Automatic residency remains transparent; explicit gpuArray input is accepted only for documented forms or a declared RunMat-only extension."
     ],
     "examples": [
         {
@@ -54,6 +57,10 @@ const builtinDoc = {
             "url": "../language/arguments"
         }
     ],
+    "gpu_residency": "Metadata-decidable validators avoid download. Content-dependent validators use a non-destructive exact-owner download and leave the source handle, class, payload, and provenance unchanged.",
+    "gpu_behavior": [
+        "Validation does not use the generic message-based gather retry path. Integrity and compatibility failures are terminal; admitted content checks download typed storage deliberately through the exact owning provider."
+    ],
     "key": "mustbenonnegative",
     "slug": "mustbenonnegative",
     "aliases": [],

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

@@ -1 +1 @@
-{"version":3,"file":"mustBeNonnegative.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNonnegative.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,mBAAmB;IAC5B,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,mBAAmB;QACnB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,+CAA+C;IAC1D,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+EAA+E;KACzF;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,qFAAqF;QAC7F,aAAa,EAAE,2IAA2I;KAC3J;IACD,aAAa,EAAE,gaAAga;IAC/a,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,sBAAsB;YAC/B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,KAAK,EAAE,mBAAmB;IAC1B,MAAM,EAAE,mBAAmB;IAC3B,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"mustBeNonnegative.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNonnegative.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,mBAAmB;IAC5B,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,mBAAmB;QACnB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,+CAA+C;IAC1D,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6MAA6M;KACvN;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,qCAAqC;QAC7C,aAAa,EAAE,sFAAsF;KACtG;IACD,aAAa,EAAE,iqBAAiqB;IAChrB,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;QAC7I,qMAAqM;QACrM,oKAAoK;QACpK,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,sBAAsB;YAC/B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,eAAe,EAAE,8LAA8L;IAC/M,cAAc,EAAE;QACd,wNAAwN;KACzN;IACD,KAAK,EAAE,mBAAmB;IAC1B,MAAM,EAAE,mBAAmB;IAC3B,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/mustBeNonpositive.js

@@ -15,7 +15,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Validators run on host values and metadata; they throw on validation failure."
+        "notes": "Validation uses coherent resident metadata when the result is type- or shape-decidable; content-dependent checks download exact typed values through the owning provider without changing source residency."
     },
     "fusion": {
         "elementwise": false,
@@ -25,15 +25,18 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "crates/runmat-runtime/src/builtins/common/validation.rs table-style pass/fail tests",
-        "integration": "Representative callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs; not every validator has a dedicated VM case."
+        "unit": "builtins::common::validation::tests",
+        "integration": "Durable callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs"
     },
-    "description": "`mustBeNonpositive` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented.",
+    "description": "`mustBeNonpositive` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented. Integer inputs are validated or rejected from their exact class and values. Resident metadata is validated before any provider access, automatic residency remains transparent, and unsupported explicit gpuArray forms are compatibility-gated before download.",
     "behaviors": [
         "Callable validator forms enforce exact supported arity, throw on validation failure, and suppress automatic output on success.",
         "Arguments-block validation uses the same shared runtime predicates for validators that RunMat can encode statically.",
         "Numeric validators check every element without materializing a cloned numeric array, including sparse stored values and implicit sparse zeros where relevant.",
-        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them."
+        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them.",
+        "All eight integer classes are classified from authoritative storage; exact ordering, range, membership, sign, zero, finiteness, and missingness checks never reconstruct wide values from binary64.",
+        "Resident validation verifies owner, physical storage, precision, logical/integer class, and wrapper provenance before using metadata or downloading exact content.",
+        "Automatic residency remains transparent; explicit gpuArray input is accepted only for documented forms or a declared RunMat-only extension."
     ],
     "examples": [
         {
@@ -54,6 +57,10 @@ const builtinDoc = {
             "url": "../language/arguments"
         }
     ],
+    "gpu_residency": "Metadata-decidable validators avoid download. Content-dependent validators use a non-destructive exact-owner download and leave the source handle, class, payload, and provenance unchanged.",
+    "gpu_behavior": [
+        "Validation does not use the generic message-based gather retry path. Integrity and compatibility failures are terminal; admitted content checks download typed storage deliberately through the exact owning provider."
+    ],
     "key": "mustbenonpositive",
     "slug": "mustbenonpositive",
     "aliases": [],

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

@@ -1 +1 @@
-{"version":3,"file":"mustBeNonpositive.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNonpositive.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,mBAAmB;IAC5B,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,mBAAmB;QACnB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,+CAA+C;IAC1D,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+EAA+E;KACzF;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,qFAAqF;QAC7F,aAAa,EAAE,2IAA2I;KAC3J;IACD,aAAa,EAAE,gaAAga;IAC/a,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,sBAAsB;YAC/B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,KAAK,EAAE,mBAAmB;IAC1B,MAAM,EAAE,mBAAmB;IAC3B,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"mustBeNonpositive.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNonpositive.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,mBAAmB;IAC5B,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,mBAAmB;QACnB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,+CAA+C;IAC1D,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6MAA6M;KACvN;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,qCAAqC;QAC7C,aAAa,EAAE,sFAAsF;KACtG;IACD,aAAa,EAAE,iqBAAiqB;IAChrB,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;QAC7I,qMAAqM;QACrM,oKAAoK;QACpK,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,sBAAsB;YAC/B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,eAAe,EAAE,8LAA8L;IAC/M,cAAc,EAAE;QACd,wNAAwN;KACzN;IACD,KAAK,EAAE,mBAAmB;IAC1B,MAAM,EAAE,mBAAmB;IAC3B,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/mustBeNonsparse.js

@@ -15,7 +15,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Validators run on host values and metadata; they throw on validation failure."
+        "notes": "Validation uses coherent resident metadata when the result is type- or shape-decidable; content-dependent checks download exact typed values through the owning provider without changing source residency."
     },
     "fusion": {
         "elementwise": false,
@@ -25,15 +25,18 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "crates/runmat-runtime/src/builtins/common/validation.rs table-style pass/fail tests",
-        "integration": "Representative callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs; not every validator has a dedicated VM case."
+        "unit": "builtins::common::validation::tests",
+        "integration": "Durable callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs"
     },
-    "description": "`mustBeNonsparse` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented.",
+    "description": "`mustBeNonsparse` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented. Integer inputs are validated or rejected from their exact class and values. Resident metadata is validated before any provider access, automatic residency remains transparent, and unsupported explicit gpuArray forms are compatibility-gated before download.",
     "behaviors": [
         "Callable validator forms enforce exact supported arity, throw on validation failure, and suppress automatic output on success.",
         "Arguments-block validation uses the same shared runtime predicates for validators that RunMat can encode statically.",
         "Numeric validators check every element without materializing a cloned numeric array, including sparse stored values and implicit sparse zeros where relevant.",
-        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them."
+        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them.",
+        "All eight integer classes are classified from authoritative storage; exact ordering, range, membership, sign, zero, finiteness, and missingness checks never reconstruct wide values from binary64.",
+        "Resident validation verifies owner, physical storage, precision, logical/integer class, and wrapper provenance before using metadata or downloading exact content.",
+        "Automatic residency remains transparent; explicit gpuArray input is accepted only for documented forms or a declared RunMat-only extension."
     ],
     "examples": [
         {
@@ -54,6 +57,10 @@ const builtinDoc = {
             "url": "../language/arguments"
         }
     ],
+    "gpu_residency": "Metadata-decidable validators avoid download. Content-dependent validators use a non-destructive exact-owner download and leave the source handle, class, payload, and provenance unchanged.",
+    "gpu_behavior": [
+        "Validation does not use the generic message-based gather retry path. Integrity and compatibility failures are terminal; admitted content checks download typed storage deliberately through the exact owning provider."
+    ],
     "key": "mustbenonsparse",
     "slug": "mustbenonsparse",
     "aliases": [],

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

@@ -1 +1 @@
-{"version":3,"file":"mustBeNonsparse.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNonsparse.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,iBAAiB;IAC1B,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,iBAAiB;QACjB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,sCAAsC;IACjD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+EAA+E;KACzF;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,qFAAqF;QAC7F,aAAa,EAAE,2IAA2I;KAC3J;IACD,aAAa,EAAE,8ZAA8Z;IAC7a,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,oBAAoB;YAC7B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,KAAK,EAAE,iBAAiB;IACxB,MAAM,EAAE,iBAAiB;IACzB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"mustBeNonsparse.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNonsparse.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,iBAAiB;IAC1B,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,iBAAiB;QACjB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,sCAAsC;IACjD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6MAA6M;KACvN;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,qCAAqC;QAC7C,aAAa,EAAE,sFAAsF;KACtG;IACD,aAAa,EAAE,+pBAA+pB;IAC9qB,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;QAC7I,qMAAqM;QACrM,oKAAoK;QACpK,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,oBAAoB;YAC7B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,eAAe,EAAE,8LAA8L;IAC/M,cAAc,EAAE;QACd,wNAAwN;KACzN;IACD,KAAK,EAAE,iBAAiB;IACxB,MAAM,EAAE,iBAAiB;IACzB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/mustBeNonzero.js

@@ -15,7 +15,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Validators run on host values and metadata; they throw on validation failure."
+        "notes": "Validation uses coherent resident metadata when the result is type- or shape-decidable; content-dependent checks download exact typed values through the owning provider without changing source residency."
     },
     "fusion": {
         "elementwise": false,
@@ -25,15 +25,19 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "crates/runmat-runtime/src/builtins/common/validation.rs table-style pass/fail tests",
-        "integration": "Representative callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs; not every validator has a dedicated VM case."
+        "unit": "builtins::common::validation::tests",
+        "integration": "Durable callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs",
+        "gpu": "builtins::common::validation::tests::wgpu_resident_integer_validators_preserve_exact_source_and_provenance"
     },
-    "description": "`mustBeNonzero` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented.",
+    "description": "`mustBeNonzero` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented. Integer inputs are validated or rejected from their exact class and values. Resident metadata is validated before any provider access, automatic residency remains transparent, and unsupported explicit gpuArray forms are compatibility-gated before download.",
     "behaviors": [
         "Callable validator forms enforce exact supported arity, throw on validation failure, and suppress automatic output on success.",
         "Arguments-block validation uses the same shared runtime predicates for validators that RunMat can encode statically.",
         "Numeric validators check every element without materializing a cloned numeric array, including sparse stored values and implicit sparse zeros where relevant.",
-        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them."
+        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them.",
+        "All eight integer classes are classified from authoritative storage; exact ordering, range, membership, sign, zero, finiteness, and missingness checks never reconstruct wide values from binary64.",
+        "Resident validation verifies owner, physical storage, precision, logical/integer class, and wrapper provenance before using metadata or downloading exact content.",
+        "Automatic residency remains transparent; explicit gpuArray input is accepted only for documented forms or a declared RunMat-only extension."
     ],
     "examples": [
         {
@@ -54,6 +58,10 @@ const builtinDoc = {
             "url": "../language/arguments"
         }
     ],
+    "gpu_residency": "Metadata-decidable validators avoid download. Content-dependent validators use a non-destructive exact-owner download and leave the source handle, class, payload, and provenance unchanged.",
+    "gpu_behavior": [
+        "Validation does not use the generic message-based gather retry path. Integrity and compatibility failures are terminal; admitted content checks download typed storage deliberately through the exact owning provider."
+    ],
     "key": "mustbenonzero",
     "slug": "mustbenonzero",
     "aliases": [],

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

@@ -1 +1 @@
-{"version":3,"file":"mustBeNonzero.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNonzero.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,eAAe;IACxB,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,eAAe;QACf,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,2CAA2C;IACtD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+EAA+E;KACzF;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,qFAAqF;QAC7F,aAAa,EAAE,2IAA2I;KAC3J;IACD,aAAa,EAAE,4ZAA4Z;IAC3a,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,kBAAkB;YAC3B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,eAAe;IACvB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"mustBeNonzero.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNonzero.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,eAAe;IACxB,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,eAAe;QACf,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,2CAA2C;IACtD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6MAA6M;KACvN;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,qCAAqC;QAC7C,aAAa,EAAE,sFAAsF;QACrG,KAAK,EAAE,4GAA4G;KACpH;IACD,aAAa,EAAE,6pBAA6pB;IAC5qB,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;QAC7I,qMAAqM;QACrM,oKAAoK;QACpK,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,kBAAkB;YAC3B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,eAAe,EAAE,8LAA8L;IAC/M,cAAc,EAAE;QACd,wNAAwN;KACzN;IACD,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,eAAe;IACvB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/mustBeNonzeroLengthText.js

@@ -15,7 +15,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Validators run on host values and metadata; they throw on validation failure."
+        "notes": "Validation uses coherent resident metadata when the result is type- or shape-decidable; content-dependent checks download exact typed values through the owning provider without changing source residency."
     },
     "fusion": {
         "elementwise": false,
@@ -25,15 +25,18 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "crates/runmat-runtime/src/builtins/common/validation.rs table-style pass/fail tests",
-        "integration": "Representative callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs; not every validator has a dedicated VM case."
+        "unit": "builtins::common::validation::tests",
+        "integration": "Durable callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs"
     },
-    "description": "`mustBeNonzeroLengthText` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented.",
+    "description": "`mustBeNonzeroLengthText` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented. Integer inputs are validated or rejected from their exact class and values. Resident metadata is validated before any provider access, automatic residency remains transparent, and unsupported explicit gpuArray forms are compatibility-gated before download.",
     "behaviors": [
         "Callable validator forms enforce exact supported arity, throw on validation failure, and suppress automatic output on success.",
         "Arguments-block validation uses the same shared runtime predicates for validators that RunMat can encode statically.",
         "Numeric validators check every element without materializing a cloned numeric array, including sparse stored values and implicit sparse zeros where relevant.",
-        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them."
+        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them.",
+        "All eight integer classes are classified from authoritative storage; exact ordering, range, membership, sign, zero, finiteness, and missingness checks never reconstruct wide values from binary64.",
+        "Resident validation verifies owner, physical storage, precision, logical/integer class, and wrapper provenance before using metadata or downloading exact content.",
+        "Automatic residency remains transparent; explicit gpuArray input is accepted only for documented forms or a declared RunMat-only extension."
     ],
     "examples": [
         {
@@ -54,6 +57,10 @@ const builtinDoc = {
             "url": "../language/arguments"
         }
     ],
+    "gpu_residency": "Metadata-decidable validators avoid download. Content-dependent validators use a non-destructive exact-owner download and leave the source handle, class, payload, and provenance unchanged.",
+    "gpu_behavior": [
+        "Validation does not use the generic message-based gather retry path. Integrity and compatibility failures are terminal; admitted content checks download typed storage deliberately through the exact owning provider."
+    ],
     "key": "mustbenonzerolengthtext",
     "slug": "mustbenonzerolengthtext",
     "aliases": [],

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

@@ -1 +1 @@
-{"version":3,"file":"mustBeNonzeroLengthText.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNonzeroLengthText.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,yBAAyB;IAClC,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,yBAAyB;QACzB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,yCAAyC;IACpD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+EAA+E;KACzF;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,qFAAqF;QAC7F,aAAa,EAAE,2IAA2I;KAC3J;IACD,aAAa,EAAE,saAAsa;IACrb,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,KAAK,EAAE,yBAAyB;IAChC,MAAM,EAAE,yBAAyB;IACjC,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"mustBeNonzeroLengthText.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNonzeroLengthText.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,yBAAyB;IAClC,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,yBAAyB;QACzB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,yCAAyC;IACpD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6MAA6M;KACvN;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,qCAAqC;QAC7C,aAAa,EAAE,sFAAsF;KACtG;IACD,aAAa,EAAE,uqBAAuqB;IACtrB,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;QAC7I,qMAAqM;QACrM,oKAAoK;QACpK,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,eAAe,EAAE,8LAA8L;IAC/M,cAAc,EAAE;QACd,wNAAwN;KACzN;IACD,KAAK,EAAE,yBAAyB;IAChC,MAAM,EAAE,yBAAyB;IACjC,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/mustBeNumeric.js

@@ -15,7 +15,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Validators run on host values and metadata; they throw on validation failure."
+        "notes": "Validation uses coherent resident metadata when the result is type- or shape-decidable; content-dependent checks download exact typed values through the owning provider without changing source residency."
     },
     "fusion": {
         "elementwise": false,
@@ -25,15 +25,18 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "crates/runmat-runtime/src/builtins/common/validation.rs table-style pass/fail tests",
-        "integration": "Representative callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs; not every validator has a dedicated VM case."
+        "unit": "builtins::common::validation::tests",
+        "integration": "Durable callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs"
     },
-    "description": "`mustBeNumeric` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented.",
+    "description": "`mustBeNumeric` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented. Integer inputs are validated or rejected from their exact class and values. Resident metadata is validated before any provider access, automatic residency remains transparent, and unsupported explicit gpuArray forms are compatibility-gated before download.",
     "behaviors": [
         "Callable validator forms enforce exact supported arity, throw on validation failure, and suppress automatic output on success.",
         "Arguments-block validation uses the same shared runtime predicates for validators that RunMat can encode statically.",
         "Numeric validators check every element without materializing a cloned numeric array, including sparse stored values and implicit sparse zeros where relevant.",
-        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them."
+        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them.",
+        "All eight integer classes are classified from authoritative storage; exact ordering, range, membership, sign, zero, finiteness, and missingness checks never reconstruct wide values from binary64.",
+        "Resident validation verifies owner, physical storage, precision, logical/integer class, and wrapper provenance before using metadata or downloading exact content.",
+        "Automatic residency remains transparent; explicit gpuArray input is accepted only for documented forms or a declared RunMat-only extension."
     ],
     "examples": [
         {
@@ -54,6 +57,10 @@ const builtinDoc = {
             "url": "../language/arguments"
         }
     ],
+    "gpu_residency": "Metadata-decidable validators avoid download. Content-dependent validators use a non-destructive exact-owner download and leave the source handle, class, payload, and provenance unchanged.",
+    "gpu_behavior": [
+        "Validation does not use the generic message-based gather retry path. Integrity and compatibility failures are terminal; admitted content checks download typed storage deliberately through the exact owning provider."
+    ],
     "key": "mustbenumeric",
     "slug": "mustbenumeric",
     "aliases": [],

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

@@ -1 +1 @@
-{"version":3,"file":"mustBeNumeric.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNumeric.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,eAAe;IACxB,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,eAAe;QACf,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,mCAAmC;IAC9C,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+EAA+E;KACzF;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,qFAAqF;QAC7F,aAAa,EAAE,2IAA2I;KAC3J;IACD,aAAa,EAAE,4ZAA4Z;IAC3a,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,kBAAkB;YAC3B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,eAAe;IACvB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"mustBeNumeric.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNumeric.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,eAAe;IACxB,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,eAAe;QACf,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,mCAAmC;IAC9C,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6MAA6M;KACvN;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,qCAAqC;QAC7C,aAAa,EAAE,sFAAsF;KACtG;IACD,aAAa,EAAE,6pBAA6pB;IAC5qB,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;QAC7I,qMAAqM;QACrM,oKAAoK;QACpK,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,kBAAkB;YAC3B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,eAAe,EAAE,8LAA8L;IAC/M,cAAc,EAAE;QACd,wNAAwN;KACzN;IACD,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,eAAe;IACvB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/mustBeNumericOrLogical.js

@@ -15,7 +15,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Validators run on host values and metadata; they throw on validation failure."
+        "notes": "Validation uses coherent resident metadata when the result is type- or shape-decidable; content-dependent checks download exact typed values through the owning provider without changing source residency."
     },
     "fusion": {
         "elementwise": false,
@@ -25,15 +25,18 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "crates/runmat-runtime/src/builtins/common/validation.rs table-style pass/fail tests",
-        "integration": "Representative callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs; not every validator has a dedicated VM case."
+        "unit": "builtins::common::validation::tests",
+        "integration": "Durable callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs"
     },
-    "description": "`mustBeNumericOrLogical` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented.",
+    "description": "`mustBeNumericOrLogical` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented. Integer inputs are validated or rejected from their exact class and values. Resident metadata is validated before any provider access, automatic residency remains transparent, and unsupported explicit gpuArray forms are compatibility-gated before download.",
     "behaviors": [
         "Callable validator forms enforce exact supported arity, throw on validation failure, and suppress automatic output on success.",
         "Arguments-block validation uses the same shared runtime predicates for validators that RunMat can encode statically.",
         "Numeric validators check every element without materializing a cloned numeric array, including sparse stored values and implicit sparse zeros where relevant.",
-        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them."
+        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them.",
+        "All eight integer classes are classified from authoritative storage; exact ordering, range, membership, sign, zero, finiteness, and missingness checks never reconstruct wide values from binary64.",
+        "Resident validation verifies owner, physical storage, precision, logical/integer class, and wrapper provenance before using metadata or downloading exact content.",
+        "Automatic residency remains transparent; explicit gpuArray input is accepted only for documented forms or a declared RunMat-only extension."
     ],
     "examples": [
         {
@@ -54,6 +57,10 @@ const builtinDoc = {
             "url": "../language/arguments"
         }
     ],
+    "gpu_residency": "Metadata-decidable validators avoid download. Content-dependent validators use a non-destructive exact-owner download and leave the source handle, class, payload, and provenance unchanged.",
+    "gpu_behavior": [
+        "Validation does not use the generic message-based gather retry path. Integrity and compatibility failures are terminal; admitted content checks download typed storage deliberately through the exact owning provider."
+    ],
     "key": "mustbenumericorlogical",
     "slug": "mustbenumericorlogical",
     "aliases": [],

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

@@ -1 +1 @@
-{"version":3,"file":"mustBeNumericOrLogical.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNumericOrLogical.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,wBAAwB;IACjC,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,wBAAwB;QACxB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,8CAA8C;IACzD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+EAA+E;KACzF;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,qFAAqF;QAC7F,aAAa,EAAE,2IAA2I;KAC3J;IACD,aAAa,EAAE,qaAAqa;IACpb,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,2BAA2B;YACpC,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,KAAK,EAAE,wBAAwB;IAC/B,MAAM,EAAE,wBAAwB;IAChC,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"mustBeNumericOrLogical.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeNumericOrLogical.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,wBAAwB;IACjC,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,wBAAwB;QACxB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,8CAA8C;IACzD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6MAA6M;KACvN;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,qCAAqC;QAC7C,aAAa,EAAE,sFAAsF;KACtG;IACD,aAAa,EAAE,sqBAAsqB;IACrrB,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;QAC7I,qMAAqM;QACrM,oKAAoK;QACpK,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,2BAA2B;YACpC,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,eAAe,EAAE,8LAA8L;IAC/M,cAAc,EAAE;QACd,wNAAwN;KACzN;IACD,KAAK,EAAE,wBAAwB;IAC/B,MAAM,EAAE,wBAAwB;IAChC,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/mustBePositive.js

@@ -15,7 +15,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Validators run on host values and metadata; they throw on validation failure."
+        "notes": "Validation uses coherent resident metadata when the result is type- or shape-decidable; content-dependent checks download exact typed values through the owning provider without changing source residency."
     },
     "fusion": {
         "elementwise": false,
@@ -25,15 +25,19 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "crates/runmat-runtime/src/builtins/common/validation.rs table-style pass/fail tests",
-        "integration": "Representative callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs; not every validator has a dedicated VM case."
+        "unit": "builtins::common::validation::tests",
+        "integration": "Durable callable and arguments-block coverage in crates/runmat-vm/tests/functions.rs",
+        "gpu": "builtins::common::validation::tests::wgpu_resident_integer_validators_preserve_exact_source_and_provenance"
     },
-    "description": "`mustBePositive` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented.",
+    "description": "`mustBePositive` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented. Integer inputs are validated or rejected from their exact class and values. Resident metadata is validated before any provider access, automatic residency remains transparent, and unsupported explicit gpuArray forms are compatibility-gated before download.",
     "behaviors": [
         "Callable validator forms enforce exact supported arity, throw on validation failure, and suppress automatic output on success.",
         "Arguments-block validation uses the same shared runtime predicates for validators that RunMat can encode statically.",
         "Numeric validators check every element without materializing a cloned numeric array, including sparse stored values and implicit sparse zeros where relevant.",
-        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them."
+        "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them.",
+        "All eight integer classes are classified from authoritative storage; exact ordering, range, membership, sign, zero, finiteness, and missingness checks never reconstruct wide values from binary64.",
+        "Resident validation verifies owner, physical storage, precision, logical/integer class, and wrapper provenance before using metadata or downloading exact content.",
+        "Automatic residency remains transparent; explicit gpuArray input is accepted only for documented forms or a declared RunMat-only extension."
     ],
     "examples": [
         {
@@ -54,6 +58,10 @@ const builtinDoc = {
             "url": "../language/arguments"
         }
     ],
+    "gpu_residency": "Metadata-decidable validators avoid download. Content-dependent validators use a non-destructive exact-owner download and leave the source handle, class, payload, and provenance unchanged.",
+    "gpu_behavior": [
+        "Validation does not use the generic message-based gather retry path. Integrity and compatibility failures are terminal; admitted content checks download typed storage deliberately through the exact owning provider."
+    ],
     "key": "mustbepositive",
     "slug": "mustbepositive",
     "aliases": [],

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

@@ -1 +1 @@
-{"version":3,"file":"mustBePositive.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBePositive.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,gBAAgB;IACzB,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,gBAAgB;QAChB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,4CAA4C;IACvD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+EAA+E;KACzF;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,qFAAqF;QAC7F,aAAa,EAAE,2IAA2I;KAC3J;IACD,aAAa,EAAE,6ZAA6Z;IAC5a,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,mBAAmB;YAC5B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,KAAK,EAAE,gBAAgB;IACvB,MAAM,EAAE,gBAAgB;IACxB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"mustBePositive.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBePositive.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,gBAAgB;IACzB,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,gBAAgB;QAChB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,4CAA4C;IACvD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6MAA6M;KACvN;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,qCAAqC;QAC7C,aAAa,EAAE,sFAAsF;QACrG,KAAK,EAAE,4GAA4G;KACpH;IACD,aAAa,EAAE,8pBAA8pB;IAC7qB,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;QAC7I,qMAAqM;QACrM,oKAAoK;QACpK,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,mBAAmB;YAC5B,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,eAAe,EAAE,8LAA8L;IAC/M,cAAc,EAAE;QACd,wNAAwN;KACzN;IACD,KAAK,EAAE,gBAAgB;IACvB,MAAM,EAAE,gBAAgB;IACxB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/mustBeReal.js

@@ -31,6 +31,8 @@ const builtinDoc = {
     "description": "`mustBeReal` is available as a callable MATLAB argument validator. It returns no user-facing value when validation passes and throws a structured RunMat error when validation fails. Validators with literal/static payloads are also encoded in MATLAB `arguments` blocks; dynamic validator payload expressions should call the validator directly until runtime-evaluated arguments-block payloads are implemented.",
     "behaviors": [
         "Callable validator forms enforce exact supported arity, throw on validation failure, and suppress automatic output on success.",
+        "All eight integer classes are real by construction and pass from authoritative class/storage metadata without floating conversion; empty values pass, and complex floating or paired-integer values are checked from their imaginary components.",
+        "Resident real integer arrays pass without payload access, while resident complex floating arrays gather through their exact owner only when their imaginary values must be inspected.",
         "Arguments-block validation uses the same shared runtime predicates for validators that RunMat can encode statically.",
         "Numeric validators check every element without materializing a cloned numeric array, including sparse stored values and implicit sparse zeros where relevant.",
         "Text validators accept string scalars/arrays, character row vectors, and compatible cell arrays of text where MATLAB commonly permits them."

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

@@ -1 +1 @@
-{"version":3,"file":"mustBeReal.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeReal.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,YAAY;QACZ,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,+CAA+C;IAC1D,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+EAA+E;KACzF;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,qFAAqF;QAC7F,aAAa,EAAE,2IAA2I;KAC3J;IACD,aAAa,EAAE,yZAAyZ;IACxa,WAAW,EAAE;QACX,gIAAgI;QAChI,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,eAAe;YACxB,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"mustBeReal.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeReal.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,YAAY;QACZ,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,+CAA+C;IAC1D,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+EAA+E;KACzF;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,qFAAqF;QAC7F,aAAa,EAAE,2IAA2I;KAC3J;IACD,aAAa,EAAE,yZAAyZ;IACxa,WAAW,EAAE;QACX,gIAAgI;QAChI,kPAAkP;QAClP,uLAAuL;QACvL,sHAAsH;QACtH,+JAA+J;QAC/J,6IAA6I;KAC9I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,eAAe;YACxB,QAAQ,EAAE,6EAA6E;SACxF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,+JAA+J;SAC1K;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,oBAAoB;YAC7B,KAAK,EAAE,uBAAuB;SAC/B;KACF;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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