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

package/dist/generated/builtins/mustBeGreaterThan.js

@@ -0,0 +1,65 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "mustBeGreaterThan",
+    "category": "argument-validation",
+    "keywords": [
+        "mustBeGreaterThan",
+        "argument validation",
+        "arguments block",
+        "MATLAB compatibility"
+    ],
+    "summary": "Validate that numeric values are greater than a threshold.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Validators run on host values and metadata; they throw on validation failure."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "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."
+    },
+    "description": "`mustBeGreaterThan` 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.",
+        "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."
+    ],
+    "examples": [
+        {
+            "description": "Using the validator as a normal callable guard",
+            "input": "mustBeGreaterThan(A, 0)",
+            "output": "No output when validation passes; an error is thrown when validation fails."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does this validator work in an `arguments` block?",
+            "answer": "Yes for literal/static validator payloads that RunMat can encode at compile time. Dynamic validator payload expressions should use the callable form for now."
+        }
+    ],
+    "links": [
+        {
+            "label": "`arguments` blocks",
+            "url": "../language/arguments"
+        }
+    ],
+    "key": "mustbegreaterthan",
+    "slug": "mustbegreaterthan",
+    "aliases": [],
+    "categoryPath": [
+        "argument-validation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=mustBeGreaterThan.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mustBeGreaterThan.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeGreaterThan.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,4DAA4D;IACvE,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,yBAAyB;YAClC,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"}

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

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

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

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

package/dist/generated/builtins/mustBeGreaterThanOrEqual.js

@@ -0,0 +1,65 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "mustBeGreaterThanOrEqual",
+    "category": "argument-validation",
+    "keywords": [
+        "mustBeGreaterThanOrEqual",
+        "argument validation",
+        "arguments block",
+        "MATLAB compatibility"
+    ],
+    "summary": "Validate that numeric values are greater than or equal to a threshold.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Validators run on host values and metadata; they throw on validation failure."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "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."
+    },
+    "description": "`mustBeGreaterThanOrEqual` 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.",
+        "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."
+    ],
+    "examples": [
+        {
+            "description": "Using the validator as a normal callable guard",
+            "input": "mustBeGreaterThanOrEqual(A, 0)",
+            "output": "No output when validation passes; an error is thrown when validation fails."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does this validator work in an `arguments` block?",
+            "answer": "Yes for literal/static validator payloads that RunMat can encode at compile time. Dynamic validator payload expressions should use the callable form for now."
+        }
+    ],
+    "links": [
+        {
+            "label": "`arguments` blocks",
+            "url": "../language/arguments"
+        }
+    ],
+    "key": "mustbegreaterthanorequal",
+    "slug": "mustbegreaterthanorequal",
+    "aliases": [],
+    "categoryPath": [
+        "argument-validation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=mustBeGreaterThanOrEqual.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mustBeGreaterThanOrEqual.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeGreaterThanOrEqual.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,0BAA0B;IACnC,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,0BAA0B;QAC1B,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,wEAAwE;IACnF,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,uaAAua;IACtb,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,gCAAgC;YACzC,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,0BAA0B;IACjC,MAAM,EAAE,0BAA0B;IAClC,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/mustBeInRange.js

@@ -0,0 +1,66 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "mustBeInRange",
+    "category": "argument-validation",
+    "keywords": [
+        "mustBeInRange",
+        "argument validation",
+        "arguments block",
+        "MATLAB compatibility"
+    ],
+    "summary": "Validate that numeric values fall within lower and upper bounds, including inclusive/exclusive interval options.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Validators run on host values and metadata; they throw on validation failure."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "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."
+    },
+    "description": "`mustBeInRange` 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.",
+        "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.",
+        "`mustBeInRange` supports default inclusive bounds, a single `\"inclusive\"` or `\"exclusive\"` flag, two per-bound `\"inclusive\"`/`\"exclusive\"` flags, and compatibility aliases for excluding one bound."
+    ],
+    "examples": [
+        {
+            "description": "Using the validator as a normal callable guard",
+            "input": "mustBeInRange(A, 0, 1, \"exclusive\")",
+            "output": "No output when validation passes; an error is thrown when validation fails."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does this validator work in an `arguments` block?",
+            "answer": "Yes for literal/static validator payloads that RunMat can encode at compile time. Dynamic validator payload expressions should use the callable form for now."
+        }
+    ],
+    "links": [
+        {
+            "label": "`arguments` blocks",
+            "url": "../language/arguments"
+        }
+    ],
+    "key": "mustbeinrange",
+    "slug": "mustbeinrange",
+    "aliases": [],
+    "categoryPath": [
+        "argument-validation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=mustBeInRange.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mustBeInRange.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeInRange.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,kHAAkH;IAC7H,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;QAC7I,8MAA8M;KAC/M;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,uCAAuC;YAChD,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"}

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

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

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

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

package/dist/generated/builtins/mustBeInteger.js

@@ -0,0 +1,65 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "mustBeInteger",
+    "category": "argument-validation",
+    "keywords": [
+        "mustBeInteger",
+        "argument validation",
+        "arguments block",
+        "MATLAB compatibility"
+    ],
+    "summary": "Validate that numeric values are integer-valued.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Validators run on host values and metadata; they throw on validation failure."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "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."
+    },
+    "description": "`mustBeInteger` 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.",
+        "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."
+    ],
+    "examples": [
+        {
+            "description": "Using the validator as a normal callable guard",
+            "input": "mustBeInteger(A)",
+            "output": "No output when validation passes; an error is thrown when validation fails."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does this validator work in an `arguments` block?",
+            "answer": "Yes for literal/static validator payloads that RunMat can encode at compile time. Dynamic validator payload expressions should use the callable form for now."
+        }
+    ],
+    "links": [
+        {
+            "label": "`arguments` blocks",
+            "url": "../language/arguments"
+        }
+    ],
+    "key": "mustbeinteger",
+    "slug": "mustbeinteger",
+    "aliases": [],
+    "categoryPath": [
+        "argument-validation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=mustBeInteger.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mustBeInteger.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeInteger.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,kDAAkD;IAC7D,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"}

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

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

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

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

package/dist/generated/builtins/mustBeLessThan.js

@@ -0,0 +1,65 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "mustBeLessThan",
+    "category": "argument-validation",
+    "keywords": [
+        "mustBeLessThan",
+        "argument validation",
+        "arguments block",
+        "MATLAB compatibility"
+    ],
+    "summary": "Validate that numeric values are less than a threshold.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Validators run on host values and metadata; they throw on validation failure."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "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."
+    },
+    "description": "`mustBeLessThan` 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.",
+        "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."
+    ],
+    "examples": [
+        {
+            "description": "Using the validator as a normal callable guard",
+            "input": "mustBeLessThan(A, 10)",
+            "output": "No output when validation passes; an error is thrown when validation fails."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does this validator work in an `arguments` block?",
+            "answer": "Yes for literal/static validator payloads that RunMat can encode at compile time. Dynamic validator payload expressions should use the callable form for now."
+        }
+    ],
+    "links": [
+        {
+            "label": "`arguments` blocks",
+            "url": "../language/arguments"
+        }
+    ],
+    "key": "mustbelessthan",
+    "slug": "mustbelessthan",
+    "aliases": [],
+    "categoryPath": [
+        "argument-validation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=mustBeLessThan.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mustBeLessThan.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeLessThan.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,yDAAyD;IACpE,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,uBAAuB;YAChC,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"}

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

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

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

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

package/dist/generated/builtins/mustBeLessThanOrEqual.js

@@ -0,0 +1,65 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "mustBeLessThanOrEqual",
+    "category": "argument-validation",
+    "keywords": [
+        "mustBeLessThanOrEqual",
+        "argument validation",
+        "arguments block",
+        "MATLAB compatibility"
+    ],
+    "summary": "Validate that numeric values are less than or equal to a threshold.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Validators run on host values and metadata; they throw on validation failure."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "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."
+    },
+    "description": "`mustBeLessThanOrEqual` 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.",
+        "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."
+    ],
+    "examples": [
+        {
+            "description": "Using the validator as a normal callable guard",
+            "input": "mustBeLessThanOrEqual(A, 10)",
+            "output": "No output when validation passes; an error is thrown when validation fails."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does this validator work in an `arguments` block?",
+            "answer": "Yes for literal/static validator payloads that RunMat can encode at compile time. Dynamic validator payload expressions should use the callable form for now."
+        }
+    ],
+    "links": [
+        {
+            "label": "`arguments` blocks",
+            "url": "../language/arguments"
+        }
+    ],
+    "key": "mustbelessthanorequal",
+    "slug": "mustbelessthanorequal",
+    "aliases": [],
+    "categoryPath": [
+        "argument-validation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=mustBeLessThanOrEqual.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mustBeLessThanOrEqual.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeLessThanOrEqual.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,uBAAuB;IAChC,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,uBAAuB;QACvB,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,qEAAqE;IAChF,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,oaAAoa;IACnb,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,8BAA8B;YACvC,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,uBAAuB;IAC9B,MAAM,EAAE,uBAAuB;IAC/B,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/mustBeMember.js

@@ -0,0 +1,65 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "mustBeMember",
+    "category": "argument-validation",
+    "keywords": [
+        "mustBeMember",
+        "argument validation",
+        "arguments block",
+        "MATLAB compatibility"
+    ],
+    "summary": "Validate that values are members of a supplied numeric, logical, or text set.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Validators run on host values and metadata; they throw on validation failure."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "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."
+    },
+    "description": "`mustBeMember` 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.",
+        "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."
+    ],
+    "examples": [
+        {
+            "description": "Using the validator as a normal callable guard",
+            "input": "mustBeMember(mode, {\"on\", \"off\"})",
+            "output": "No output when validation passes; an error is thrown when validation fails."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does this validator work in an `arguments` block?",
+            "answer": "Yes for literal/static validator payloads that RunMat can encode at compile time. Dynamic validator payload expressions should use the callable form for now."
+        }
+    ],
+    "links": [
+        {
+            "label": "`arguments` blocks",
+            "url": "../language/arguments"
+        }
+    ],
+    "key": "mustbemember",
+    "slug": "mustbemember",
+    "aliases": [],
+    "categoryPath": [
+        "argument-validation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=mustBeMember.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mustBeMember.js","sourceRoot":"","sources":["../../../src/generated/builtins/mustBeMember.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,cAAc;IACvB,UAAU,EAAE,qBAAqB;IACjC,UAAU,EAAE;QACV,cAAc;QACd,qBAAqB;QACrB,iBAAiB;QACjB,sBAAsB;KACvB;IACD,SAAS,EAAE,+EAA+E;IAC1F,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,2ZAA2Z;IAC1a,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,uCAAuC;YAChD,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,cAAc;IACrB,MAAM,EAAE,cAAc;IACtB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,qBAAqB;KACtB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/mustBeNegative.js

@@ -0,0 +1,65 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "mustBeNegative",
+    "category": "argument-validation",
+    "keywords": [
+        "mustBeNegative",
+        "argument validation",
+        "arguments block",
+        "MATLAB compatibility"
+    ],
+    "summary": "Validate that numeric values are negative.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Validators run on host values and metadata; they throw on validation failure."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "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."
+    },
+    "description": "`mustBeNegative` 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.",
+        "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."
+    ],
+    "examples": [
+        {
+            "description": "Using the validator as a normal callable guard",
+            "input": "mustBeNegative(A)",
+            "output": "No output when validation passes; an error is thrown when validation fails."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does this validator work in an `arguments` block?",
+            "answer": "Yes for literal/static validator payloads that RunMat can encode at compile time. Dynamic validator payload expressions should use the callable form for now."
+        }
+    ],
+    "links": [
+        {
+            "label": "`arguments` blocks",
+            "url": "../language/arguments"
+        }
+    ],
+    "key": "mustbenegative",
+    "slug": "mustbenegative",
+    "aliases": [],
+    "categoryPath": [
+        "argument-validation"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=mustBeNegative.js.map