runmat 0.6.1 → 0.6.2-dev.0

package/dist/generated/builtins/exprnd.js

@@ -17,10 +17,11 @@ const builtinDoc = {
         "elementwise": false,
         "reduction": false,
         "precisions": [
-            "f64"
+            "single",
+            "double"
         ],
         "broadcasting": "none",
-        "notes": "Uses the provider random_exponential hook (Philox CSPRNG + inverse-transform sampling) when an F64-precision provider is active. F32 providers and providers without the hook fall back to host generation."
+        "notes": "The scalar-double provider hook is used only when its returned handle passes ownership, shape, storage, class, and physical-precision validation before RNG state advances. Array means, native single, and resident means use host fallback; restoration requires the exact source owner to physically support the output precision."
     },
     "fusion": {
         "elementwise": false,
@@ -35,12 +36,15 @@ const builtinDoc = {
     },
     "description": "`exprnd(mu, ...)` draws exponential random samples using mean parameter `mu`. It supports MATLAB-compatible scalar expansion and explicit output-size signatures.",
     "behaviors": [
-        "`exprnd(mu)` returns a scalar double drawn from `Exp(mu)`.",
+        "`exprnd(mu)` returns one sample per element of `mu` and preserves the shape and single/double precision of `mu`.",
         "`exprnd(mu, n)` returns an `n × n` matrix of samples.",
         "`exprnd(mu, m, n)` returns an `m × n` matrix of samples.",
         "`exprnd(mu, sz)` accepts a size vector and returns an array with shape `sz`.",
-        "`mu` must be a positive scalar; `exprnd` errors if `mu <= 0`.",
-        "All outputs are double precision regardless of input type."
+        "A scalar `mu` expands to an explicitly requested output shape; a nonscalar `mu` requires that shape to match exactly.",
+        "Zero or negative size extents produce an empty array, and trailing singleton dimensions beyond dimension two are ignored.",
+        "`mu` must contain finite positive values; logical and complex means reject.",
+        "MATLAB documents `mu` and size controls as single or double. RunMat can additionally accept typed-integer means and sizes only when RunMat extensions are enabled.",
+        "Resident fallback returns output only to the exact mean input owner and only when that owner physically supports the required precision; otherwise the correctly typed output remains on the host. Native array-mean/single provider hooks and independent CPU/GPU random streams remain provider-ABI work."
     ],
     "examples": [
         {

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

@@ -1 +1 @@
-{"version":3,"file":"exprnd.js","sourceRoot":"","sources":["../../../src/generated/builtins/exprnd.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,cAAc;IAC1B,UAAU,EAAE;QACV,QAAQ;QACR,aAAa;QACb,QAAQ;QACR,cAAc;QACd,YAAY;QACZ,UAAU;QACV,SAAS;KACV;IACD,SAAS,EAAE,uGAAuG;IAClH,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,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,MAAM;KACpB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,wCAAwC;QAChD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,mKAAmK;IAClL,WAAW,EAAE;QACX,4DAA4D;QAC5D,uDAAuD;QACvD,0DAA0D;QAC1D,8EAA8E;QAC9E,+DAA+D;QAC/D,4DAA4D;KAC7D;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2BAA2B;YAC1C,OAAO,EAAE,wBAAwB;SAClC;QACD;YACE,aAAa,EAAE,4DAA4D;YAC3E,OAAO,EAAE,0DAA0D;SACpE;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,kKAAkK;SAC5K;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,+BAA+B;SACzC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,mLAAmL;SAC9L;QACD;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,gJAAgJ;SAC3J;QACD;YACE,UAAU,EAAE,0BAA0B;YACtC,QAAQ,EAAE,oJAAoJ;SAC/J;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,6LAA6L;SACxM;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,4FAA4F;SACvG;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,iEAAiE;SAC5E;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6DAA6D;QACtE,KAAK,EAAE,0GAA0G;KAClH;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"exprnd.js","sourceRoot":"","sources":["../../../src/generated/builtins/exprnd.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,cAAc;IAC1B,UAAU,EAAE;QACV,QAAQ;QACR,aAAa;QACb,QAAQ;QACR,cAAc;QACd,YAAY;QACZ,UAAU;QACV,SAAS;KACV;IACD,SAAS,EAAE,uGAAuG;IAClH,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,QAAQ;YACR,QAAQ;SACT;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uUAAuU;KACjV;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,MAAM;KACpB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,wCAAwC;QAChD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,mKAAmK;IAClL,WAAW,EAAE;QACX,kHAAkH;QAClH,uDAAuD;QACvD,0DAA0D;QAC1D,8EAA8E;QAC9E,uHAAuH;QACvH,2HAA2H;QAC3H,6EAA6E;QAC7E,oKAAoK;QACpK,6SAA6S;KAC9S;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2BAA2B;YAC1C,OAAO,EAAE,wBAAwB;SAClC;QACD;YACE,aAAa,EAAE,4DAA4D;YAC3E,OAAO,EAAE,0DAA0D;SACpE;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,kKAAkK;SAC5K;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,+BAA+B;SACzC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,mLAAmL;SAC9L;QACD;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,gJAAgJ;SAC3J;QACD;YACE,UAAU,EAAE,0BAA0B;YACtC,QAAQ,EAAE,oJAAoJ;SAC/J;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,6LAA6L;SACxM;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,4FAA4F;SACvG;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,iEAAiE;SAC5E;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6DAA6D;QACtE,KAAK,EAAE,0GAA0G;KAClH;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/extractAfter.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "No GPU kernel is registered for this compatibility builtin; GPU-resident inputs are gathered to host memory before evaluation."
+        "notes": "No GPU kernel is registered. Documented text and numeric position inputs are host values; gathering a resident numeric position is an independently gated RunMat extension."
     },
     "fusion": {
         "elementwise": false,
@@ -30,7 +30,7 @@ const builtinDoc = {
         "unit": "builtins::strings::transform::compat::tests",
         "integration": null
     },
-    "description": "s = extractAfter(text, boundary) - Extract text after a position or boundary.",
+    "description": "`extractAfter(text, boundary)` returns the text after the first matching text/pattern boundary or after a one-based numeric position. The output preserves the text input datatype and shape.",
     "signatures": [
         {
             "label": "s = extractAfter(text, boundary)",
@@ -43,11 +43,11 @@ const builtinDoc = {
                     "description": "Input text."
                 },
                 {
-                    "name": "arg",
+                    "name": "boundary",
                     "ty": "Any",
-                    "arity": "Variadic",
+                    "arity": "Required",
                     "default": null,
-                    "description": "Additional arguments."
+                    "description": "Text/pattern boundary or positive numeric position, supplied as a scalar or an array the same size as the text input."
                 }
             ],
             "outputs": [
@@ -62,8 +62,11 @@ const builtinDoc = {
         }
     ],
     "behaviors": [
-        "Extract text after a position or boundary.",
-        "Missing text or pattern boundaries are reported as errors."
+        "Numeric positions are one-based structural controls. Scalar positions expand to every text element; nonscalar positions must have exactly the same shape as the text input.",
+        "All eight built-in integer classes are read from native storage without floating-point conversion. Single and double positions must be finite positive integer values.",
+        "String arrays, character vectors, and cell arrays of character vectors preserve their input datatype and shape. Row-wise character matrices and broader cell containers are explicit RunMat extensions.",
+        "Missing text propagates. A text or pattern boundary that cannot be found is reported as an error by the current RunMat implementation.",
+        "Integer, logical, complex, and resident numeric values are not accepted as text. Resident numeric positions require the RunMat extension mode and are gathered before host evaluation."
     ],
     "examples": [
         "extractAfter(\"alpha.beta\", \".\") returns \"beta\"."

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

@@ -1 +1 @@
-{"version":3,"file":"extractAfter.js","sourceRoot":"","sources":["../../../src/generated/builtins/extractAfter.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,cAAc;IACvB,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,cAAc;QACd,SAAS;QACT,WAAW;QACX,QAAQ;QACR,eAAe;KAChB;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,gIAAgI;KAC1I;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,IAAI;QAClB,WAAW,EAAE,gBAAgB;QAC7B,OAAO,EAAE,kFAAkF;KAC5F;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,6CAA6C;QACrD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,+EAA+E;IAC9F,YAAY,EAAE;QACZ;YACE,OAAO,EAAE,kCAAkC;YAC3C,QAAQ,EAAE;gBACR;oBACE,MAAM,EAAE,MAAM;oBACd,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,aAAa;iBAC7B;gBACD;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,uBAAuB;iBACvC;aACF;YACD,SAAS,EAAE;gBACT;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,eAAe;iBAC/B;aACF;SACF;KACF;IACD,WAAW,EAAE;QACX,4CAA4C;QAC5C,4DAA4D;KAC7D;IACD,UAAU,EAAE;QACV,uDAAuD;KACxD;IACD,MAAM,EAAE,EAAE;IACV,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,kEAAkE;QAC3E,KAAK,EAAE,+GAA+G;KACvH;IACD,KAAK,EAAE,cAAc;IACrB,MAAM,EAAE,cAAc;IACtB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;QACT,WAAW;KACZ;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"extractAfter.js","sourceRoot":"","sources":["../../../src/generated/builtins/extractAfter.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,cAAc;IACvB,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,cAAc;QACd,SAAS;QACT,WAAW;QACX,QAAQ;QACR,eAAe;KAChB;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,6KAA6K;KACvL;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,IAAI;QAClB,WAAW,EAAE,gBAAgB;QAC7B,OAAO,EAAE,kFAAkF;KAC5F;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,6CAA6C;QACrD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,+LAA+L;IAC9M,YAAY,EAAE;QACZ;YACE,OAAO,EAAE,kCAAkC;YAC3C,QAAQ,EAAE;gBACR;oBACE,MAAM,EAAE,MAAM;oBACd,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,aAAa;iBAC7B;gBACD;oBACE,MAAM,EAAE,UAAU;oBAClB,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,uHAAuH;iBACvI;aACF;YACD,SAAS,EAAE;gBACT;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,eAAe;iBAC/B;aACF;SACF;KACF;IACD,WAAW,EAAE;QACX,6KAA6K;QAC7K,wKAAwK;QACxK,yMAAyM;QACzM,wIAAwI;QACxI,wLAAwL;KACzL;IACD,UAAU,EAAE;QACV,uDAAuD;KACxD;IACD,MAAM,EAAE,EAAE;IACV,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,kEAAkE;QAC3E,KAAK,EAAE,+GAA+G;KACvH;IACD,KAAK,EAAE,cAAc;IACrB,MAAM,EAAE,cAAc;IACtB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;QACT,WAAW;KACZ;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/extractBefore.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "No GPU kernel is registered for this compatibility builtin; GPU-resident inputs are gathered to host memory before evaluation."
+        "notes": "No GPU kernel is registered. Documented text and numeric position inputs are host values; gathering a resident numeric position is an independently gated RunMat extension."
     },
     "fusion": {
         "elementwise": false,
@@ -30,7 +30,7 @@ const builtinDoc = {
         "unit": "builtins::strings::transform::compat::tests",
         "integration": null
     },
-    "description": "s = extractBefore(text, boundary) - Extract text before a position or boundary.",
+    "description": "`extractBefore(text, boundary)` returns the text before the first matching text/pattern boundary or before a one-based numeric position. The output preserves the text input datatype and shape.",
     "signatures": [
         {
             "label": "s = extractBefore(text, boundary)",
@@ -43,11 +43,11 @@ const builtinDoc = {
                     "description": "Input text."
                 },
                 {
-                    "name": "arg",
+                    "name": "boundary",
                     "ty": "Any",
-                    "arity": "Variadic",
+                    "arity": "Required",
                     "default": null,
-                    "description": "Additional arguments."
+                    "description": "Text/pattern boundary or positive numeric position, supplied as a scalar or an array the same size as the text input."
                 }
             ],
             "outputs": [
@@ -62,8 +62,11 @@ const builtinDoc = {
         }
     ],
     "behaviors": [
-        "Extract text before a position or boundary.",
-        "Missing text or pattern boundaries are reported as errors."
+        "Numeric positions are one-based structural controls. Scalar positions expand to every text element; nonscalar positions must have exactly the same shape as the text input.",
+        "All eight built-in integer classes are read from native storage without floating-point conversion. Single and double positions must be finite positive integer values.",
+        "String arrays, character vectors, and cell arrays of character vectors preserve their input datatype and shape. Row-wise character matrices and broader cell containers are explicit RunMat extensions.",
+        "Missing text propagates. A text or pattern boundary that cannot be found is reported as an error by the current RunMat implementation.",
+        "Integer, logical, complex, and resident numeric values are not accepted as text. Resident numeric positions require the RunMat extension mode and are gathered before host evaluation."
     ],
     "examples": [
         "extractBefore(\"alpha.beta\", \".\") returns \"alpha\"."

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

@@ -1 +1 @@
-{"version":3,"file":"extractBefore.js","sourceRoot":"","sources":["../../../src/generated/builtins/extractBefore.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,eAAe;IACxB,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,eAAe;QACf,SAAS;QACT,WAAW;QACX,QAAQ;QACR,eAAe;KAChB;IACD,SAAS,EAAE,6CAA6C;IACxD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,gIAAgI;KAC1I;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,IAAI;QAClB,WAAW,EAAE,gBAAgB;QAC7B,OAAO,EAAE,kFAAkF;KAC5F;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,6CAA6C;QACrD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,iFAAiF;IAChG,YAAY,EAAE;QACZ;YACE,OAAO,EAAE,mCAAmC;YAC5C,QAAQ,EAAE;gBACR;oBACE,MAAM,EAAE,MAAM;oBACd,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,aAAa;iBAC7B;gBACD;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,uBAAuB;iBACvC;aACF;YACD,SAAS,EAAE;gBACT;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,eAAe;iBAC/B;aACF;SACF;KACF;IACD,WAAW,EAAE;QACX,6CAA6C;QAC7C,4DAA4D;KAC7D;IACD,UAAU,EAAE;QACV,yDAAyD;KAC1D;IACD,MAAM,EAAE,EAAE;IACV,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,kEAAkE;QAC3E,KAAK,EAAE,+GAA+G;KACvH;IACD,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,eAAe;IACvB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;QACT,WAAW;KACZ;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"extractBefore.js","sourceRoot":"","sources":["../../../src/generated/builtins/extractBefore.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,eAAe;IACxB,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,eAAe;QACf,SAAS;QACT,WAAW;QACX,QAAQ;QACR,eAAe;KAChB;IACD,SAAS,EAAE,6CAA6C;IACxD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6KAA6K;KACvL;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,IAAI;QAClB,WAAW,EAAE,gBAAgB;QAC7B,OAAO,EAAE,kFAAkF;KAC5F;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,6CAA6C;QACrD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,kMAAkM;IACjN,YAAY,EAAE;QACZ;YACE,OAAO,EAAE,mCAAmC;YAC5C,QAAQ,EAAE;gBACR;oBACE,MAAM,EAAE,MAAM;oBACd,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,aAAa;iBAC7B;gBACD;oBACE,MAAM,EAAE,UAAU;oBAClB,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,uHAAuH;iBACvI;aACF;YACD,SAAS,EAAE;gBACT;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,eAAe;iBAC/B;aACF;SACF;KACF;IACD,WAAW,EAAE;QACX,6KAA6K;QAC7K,wKAAwK;QACxK,yMAAyM;QACzM,wIAAwI;QACxI,wLAAwL;KACzL;IACD,UAAU,EAAE;QACV,yDAAyD;KAC1D;IACD,MAAM,EAAE,EAAE;IACV,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,kEAAkE;QAC3E,KAAK,EAAE,+GAA+G;KACvH;IACD,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,eAAe;IACvB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;QACT,WAAW;KACZ;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/extractBetween.js

@@ -16,8 +16,8 @@ const builtinDoc = {
         "elementwise": false,
         "reduction": false,
         "precisions": [],
-        "broadcasting": "matlab",
-        "notes": "Runs on the CPU. GPU-resident inputs are gathered before processing, results stay on the host, and the builtin is registered as an Accelerate sink."
+        "broadcasting": "scalar-or-same-size",
+        "notes": "Runs on the CPU. Documented positions are host values; resident position gathering and broader implicit broadcasting are independently gated RunMat extensions."
     },
     "fusion": {
         "elementwise": false,
@@ -30,15 +30,16 @@ const builtinDoc = {
         "unit": "builtins::strings::transform::extractbetween::tests",
         "integration": "builtins::strings::transform::extractbetween::tests::extractBetween_cell_array_preserves_types"
     },
-    "description": "`extractBetween(text, start, stop)` returns text between two boundary markers. Marker types, broadcasting rules, and `'Boundaries'` option semantics follow MATLAB behavior.",
+    "description": "`extractBetween(text, start, stop)` returns text between two boundary markers. Numeric positions accept single, double, and all eight integer classes as one-based structural controls.",
     "behaviors": [
-        "Accepts **string scalars**, **string arrays**, **character arrays** (interpreted row-by-row), and **cell arrays** that contain string scalars or character vectors. Cell outputs preserve the element type (string vs. char) of each cell.",
+        "Documented text input is a string array, character vector, or cell array of character vectors. String input returns string output; character-vector and cellstr input return cell arrays of character vectors.",
         "Boundary inputs can be text or numeric positions. Both boundaries in a call must use the same kind of input; mixing text and numeric markers raises a size/type error.",
-        "Scalar text markers follow MATLAB implicit expansion, applying to every element of the text input. Character-array and cell inputs must exactly match the text shape.",
+        "Scalar boundaries apply to every text element. Nonscalar boundaries must have exactly the same shape as the text input in strict compatibility mode; broader implicit broadcasting is a RunMat extension.",
         "The `'Boundaries'` name-value pair controls inclusivity. Text markers default to **exclusive** extraction, while numeric positions default to **inclusive** behaviour. Values are case-insensitive and must be `'exclusive'` or `'inclusive'`.",
         "Missing string scalars propagate: if the text, start marker, or end marker is `<missing>`, the result is also `<missing>`.",
         "When the start or end boundary cannot be located, `extractBetween` returns an empty string (or an appropriately padded empty row for character arrays).",
-        "Numeric positions use 1-based indexing. Inputs are validated as positive integers, clamped to string length, and honour inclusivity rules exactly as MATLAB does."
+        "Numeric positions use 1-based indexing and are read directly from native single, double, or integer storage. Inputs must be positive integers; stop positions beyond the text length are clamped by the current implementation.",
+        "Row-wise character matrices, cells containing string scalars, and resident numeric positions are separately declared RunMat extensions. Integer, logical, and complex text inputs reject before provider access."
     ],
     "examples": [
         {
@@ -62,12 +63,12 @@ const builtinDoc = {
             "output": "stems = 2×2 string\n    \"accel\"    \"gc\"\n    \"plot\"     \"cli\""
         },
         {
-            "description": "Work with character arrays while preserving row padding",
+            "description": "Extracting text row by row from a character matrix",
             "input": "chars = char(\"Device<GPU>\", \"Planner<Fusion>\");\ntokens = extractBetween(chars, \"<\", \">\")",
             "output": "tokens =\n\n  2×6 char array\n\n    \"GPU   \"\n    \"Fusion\""
         },
         {
-            "description": "Preserve element types in cell arrays",
+            "description": "Extracting text from mixed cell contents",
             "input": "C = {'<missing>', 'A[B]C'; \"Planner <Fusion>\", \"Device<GPU>\"};\nout = extractBetween(C, \"<\", \">\")",
             "output": "out =\n  2×2 cell array\n    {'<missing>'}    {'B'}\n    {\"Fusion\"}       {\"GPU\"}"
         },
@@ -80,7 +81,7 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "Which argument types does `extractBetween` accept?",
-            "answer": "The first argument can be a string scalar, string array, character array, or cell array of character vectors / string scalars. Boundary arguments can be text (string, character array, or cell) or numeric positions supplied as scalars, vectors, or arrays."
+            "answer": "The documented first argument is a string array, character vector, or cell array of character vectors. Boundaries can be text or numeric positions. Numeric positions accept single, double, int8, int16, int32, int64, uint8, uint16, uint32, and uint64. RunMat extension mode additionally admits row-wise character matrices and broader text cells."
         },
         {
             "question": "Can the start and end arguments mix text and numeric positions?",
@@ -88,7 +89,7 @@ const builtinDoc = {
         },
         {
             "question": "What happens when a boundary is not found?",
-            "answer": "`extractBetween` returns the empty string (`\"\"`). Character-array outputs contain space padded rows of the appropriate length."
+            "answer": "The current RunMat implementation returns empty extracted text. String inputs produce empty strings; documented non-string inputs produce character vectors inside cell output."
         },
         {
             "question": "How does `'Boundaries','inclusive'` behave with numeric positions?",
@@ -96,11 +97,11 @@ const builtinDoc = {
         },
         {
             "question": "Does `extractBetween` support implicit expansion?",
-            "answer": "Yes. Scalar boundaries expand against array inputs following MATLAB implicit expansion rules. Cell and character array inputs must retain their original shape; attempting to expand them produces a size mismatch error."
+            "answer": "Documented compatibility permits scalar boundaries or boundaries exactly the same size as the text input. Broader broadcast-compatible shapes require RunMat extension mode."
         },
         {
             "question": "Are GPU inputs supported?",
-            "answer": "Yes. Inputs stored on a GPU are gathered automatically. The function executes on the CPU, returns host-side results, and fusion planning treats the builtin as a residency sink."
+            "answer": "There is no provider kernel. Resident numeric positions require RunMat extension mode, are gathered, and produce host text output. Numeric resident values are never accepted as the text argument."
         }
     ],
     "links": [
@@ -166,7 +167,7 @@ const builtinDoc = {
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/transform/extractbetween.rs"
     },
     "gpu_behavior": [
-        "Text manipulation executes on the CPU. When any argument resides on the GPU, RunMat gathers the values to host memory, performs extraction, and leaves the results on the host. No Accelerate provider hooks are required, and the builtin is registered as an Accelerate sink so fusion plans never attempt to keep data on the device for this operation."
+        "Text manipulation executes on the CPU. RunMat extension mode can gather resident numeric position controls and leaves results on the host. No Accelerate provider hooks are registered, and numeric resident text is rejected before provider access."
     ],
     "key": "extractbetween",
     "slug": "extractbetween",

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

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

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

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

package/dist/generated/builtins/extractFileText.js

@@ -17,7 +17,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "`extractFileText` performs host file IO and text parsing; it does not use provider kernels."
+        "notes": "`extractFileText` performs host file IO and text parsing. It has no provider kernel; resident Pages controls are available only through an explicit RunMat extension."
     },
     "fusion": {
         "elementwise": false,
@@ -32,12 +32,14 @@ const builtinDoc = {
     },
     "description": "`extractFileText(filename)` reads text from a host file and returns a string scalar. This slice supports plain text files with encodings, HTML files through RunMat's `extractHTMLText` parser, and DOCX files by extracting `word/document.xml` text.",
     "behaviors": [
-        "`filename` may be a string scalar, character vector, scalar string array, or 1-by-1 cell containing a text filename.",
+        "Documented `filename`/URL input is a string scalar, character vector, or 1-by-1 cell containing a character vector. A string-valued or nested filename cell is a RunMat extension.",
         "Plain text files are decoded as UTF-8 by default. The `Encoding` name-value option accepts labels supported by `encoding_rs`, such as `UTF-8`, `windows-1252`, and `ISO-8859-1`.",
         "HTML files with extensions `.html`, `.htm`, and `.xhtml` are decoded as text and passed to `extractHTMLText`.",
         "For HTML files, `ExtractionMethod` accepts `\"tree\"`, `\"article\"`, or `\"all-text\"` and follows the existing `extractHTMLText` compatibility behavior.",
         "DOCX files are read as zip archives and text is extracted from `word/document.xml`, preserving paragraph breaks and basic tabs/line breaks.",
-        "PDF extraction, website/URL fetching, password-protected documents, PDF page selection, legacy binary DOC, and full Microsoft Word layout fidelity remain tracked by the broader Text Analytics compatibility issue.",
+        "The documented `Pages` option is a nonempty vector of positive values in single, double, or any of the eight integer classes. RunMat parses these controls exactly from native storage, but PDF extraction itself remains unsupported.",
+        "PDF extraction, website/URL fetching, password-protected documents, legacy binary DOC, and full Microsoft Word layout fidelity remain tracked by the broader Text Analytics compatibility issue.",
+        "Integer, logical, complex, and resident numeric filename values reject before file IO or provider access. Resident Pages controls require RunMat extension mode.",
         "Unknown file extensions are treated as plain text files."
     ],
     "examples": [
@@ -92,9 +94,9 @@ const builtinDoc = {
             "output": "`str` is a string scalar."
         },
         "points": [
-            "`Encoding` applies to plain text and HTML decoding in RunMat.",
+            "MATLAB documents `Encoding` for plain text. RunMat currently also applies it while decoding HTML input.",
             "`ExtractionMethod` is supported for HTML files only.",
-            "`Password` and `Pages` are recognized as PDF-only options but remain unsupported until PDF extraction is implemented."
+            "`Password` and `Pages` are recognized as PDF-only options. Pages values are validated exactly, but extraction remains unsupported until PDF support is implemented."
         ]
     },
     "source": {

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

@@ -1 +1 @@
-{"version":3,"file":"extractFileText.js","sourceRoot":"","sources":["../../../src/generated/builtins/extractFileText.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,iBAAiB;IAC1B,UAAU,EAAE,wBAAwB;IACpC,UAAU,EAAE;QACV,iBAAiB;QACjB,gBAAgB;QAChB,MAAM;QACN,MAAM;QACN,MAAM;QACN,YAAY;KACb;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,6FAA6F;KACvG;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,qDAAqD;QAC7D,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,wPAAwP;IACvQ,WAAW,EAAE;QACX,sHAAsH;QACtH,kLAAkL;QAClL,+GAA+G;QAC/G,4JAA4J;QAC5J,6IAA6I;QAC7I,sNAAsN;QACtN,0DAA0D;KAC3D;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,iBAAiB;YAChC,OAAO,EAAE,sCAAsC;YAC/C,QAAQ,EAAE,gDAAgD;SAC3D;QACD;YACE,aAAa,EAAE,gBAAgB;YAC/B,OAAO,EAAE,0EAA0E;YACnF,QAAQ,EAAE,2DAA2D;SACtE;QACD;YACE,aAAa,EAAE,gBAAgB;YAC/B,OAAO,EAAE,wCAAwC;YACjD,QAAQ,EAAE,gEAAgE;SAC3E;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,6HAA6H;SACxI;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,uFAAuF;SAClG;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,gDAAgD;SAC3D;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,iBAAiB;YAC1B,KAAK,EAAE,mBAAmB;SAC3B;QACD;YACE,OAAO,EAAE,mBAAmB;YAC5B,KAAK,EAAE,qBAAqB;SAC7B;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,iBAAiB;YAChC,OAAO,EAAE,yJAAyJ;YAClK,QAAQ,EAAE,2BAA2B;SACtC;QACD,QAAQ,EAAE;YACR,+DAA+D;YAC/D,sDAAsD;YACtD,uHAAuH;SACxH;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,0EAA0E;QACnF,KAAK,EAAE,uHAAuH;KAC/H;IACD,eAAe,EAAE,sFAAsF;IACvG,KAAK,EAAE,iBAAiB;IACxB,MAAM,EAAE,iBAAiB;IACzB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;QACT,gBAAgB;KACjB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"extractFileText.js","sourceRoot":"","sources":["../../../src/generated/builtins/extractFileText.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,iBAAiB;IAC1B,UAAU,EAAE,wBAAwB;IACpC,UAAU,EAAE;QACV,iBAAiB;QACjB,gBAAgB;QAChB,MAAM;QACN,MAAM;QACN,MAAM;QACN,YAAY;KACb;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,uKAAuK;KACjL;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,qDAAqD;QAC7D,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,wPAAwP;IACvQ,WAAW,EAAE;QACX,oLAAoL;QACpL,kLAAkL;QAClL,+GAA+G;QAC/G,4JAA4J;QAC5J,6IAA6I;QAC7I,wOAAwO;QACxO,kMAAkM;QAClM,kKAAkK;QAClK,0DAA0D;KAC3D;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,iBAAiB;YAChC,OAAO,EAAE,sCAAsC;YAC/C,QAAQ,EAAE,gDAAgD;SAC3D;QACD;YACE,aAAa,EAAE,gBAAgB;YAC/B,OAAO,EAAE,0EAA0E;YACnF,QAAQ,EAAE,2DAA2D;SACtE;QACD;YACE,aAAa,EAAE,gBAAgB;YAC/B,OAAO,EAAE,wCAAwC;YACjD,QAAQ,EAAE,gEAAgE;SAC3E;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,6HAA6H;SACxI;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,uFAAuF;SAClG;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,gDAAgD;SAC3D;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,iBAAiB;YAC1B,KAAK,EAAE,mBAAmB;SAC3B;QACD;YACE,OAAO,EAAE,mBAAmB;YAC5B,KAAK,EAAE,qBAAqB;SAC7B;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,iBAAiB;YAChC,OAAO,EAAE,yJAAyJ;YAClK,QAAQ,EAAE,2BAA2B;SACtC;QACD,QAAQ,EAAE;YACR,yGAAyG;YACzG,sDAAsD;YACtD,qKAAqK;SACtK;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,0EAA0E;QACnF,KAAK,EAAE,uHAAuH;KAC/H;IACD,eAAe,EAAE,sFAAsF;IACvG,KAAK,EAAE,iBAAiB;IACxB,MAAM,EAAE,iBAAiB;IACzB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;QACT,gBAAgB;KACjB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/extractHTMLText.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "`extractHTMLText` parses host-resident text and does not use provider kernels."
+        "notes": "`extractHTMLText` parses host text and htmlTree objects and does not use provider kernels. Numeric resident handles reject before provider access."
     },
     "fusion": {
         "elementwise": false,
@@ -31,14 +31,15 @@ const builtinDoc = {
     },
     "description": "`extractHTMLText` extracts visible text from HTML code or from an `htmlTree` object. It supports the documented `ExtractionMethod` option values `\"tree\"`, `\"article\"`, and `\"all-text\"`.",
     "behaviors": [
-        "`extractHTMLText(code)` accepts string scalars, character vectors, string arrays, multi-row character arrays, and cell arrays of character vectors.",
-        "`extractHTMLText(tree)` accepts scalar RunMat `htmlTree` objects created by `htmlTree`.",
+        "Documented `extractHTMLText(code)` input is a string array, character vector, or cell array of character vectors. Row-wise character matrices and cells containing string scalars are RunMat extensions.",
+        "`extractHTMLText(tree)` accepts RunMat `htmlTree` objects and homogeneous arrays of those objects.",
         "`extractHTMLText(___, 'ExtractionMethod', method)` accepts `tree`, `article`, or `all-text`.",
-        "String arrays, multi-row character arrays, and cell arrays return string arrays with the input shape.",
+        "String arrays, cell arrays, htmlTree arrays, and extension-mode character matrices return string arrays with the input shape.",
         "Script, style, noscript, template, and head content is excluded from extracted text.",
         "Common HTML entities and numeric character references are decoded.",
         "`tree` and `article` currently use the same paragraph/block extraction heuristic. RunMat does not yet implement MathWorks' exact article scoring algorithm.",
-        "`all-text` extracts normalized body text outside skipped elements. Whitespace is normalized for MATLAB-friendly string output."
+        "`all-text` extracts normalized body text outside skipped elements. Whitespace is normalized for MATLAB-friendly string output.",
+        "The builtin has no integer role: all eight integer classes, logical and complex values, and resident numeric handles reject without numeric-to-text conversion or provider access."
     ],
     "examples": [
         {
@@ -64,7 +65,7 @@ const builtinDoc = {
         },
         {
             "question": "Does `extractHTMLText` support arrays?",
-            "answer": "Yes. Text arrays and cells produce string arrays with the same shape. Cells containing `htmlTree` objects are also supported."
+            "answer": "Yes. Documented string arrays, cell arrays of character vectors, and htmlTree arrays produce string arrays with the same shape. Row-wise character matrices and broader or mixed cells require RunMat extension mode."
         },
         {
             "question": "Does `extractHTMLText` execute on the GPU?",

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

@@ -1 +1 @@
-{"version":3,"file":"extractHTMLText.js","sourceRoot":"","sources":["../../../src/generated/builtins/extractHTMLText.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,iBAAiB;IAC1B,UAAU,EAAE,wBAAwB;IACpC,UAAU,EAAE;QACV,iBAAiB;QACjB,MAAM;QACN,gBAAgB;QAChB,OAAO;QACP,UAAU;KACX;IACD,SAAS,EAAE,0DAA0D;IACrE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,gFAAgF;KAC1F;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,gDAAgD;QACxD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,iMAAiM;IAChN,WAAW,EAAE;QACX,qJAAqJ;QACrJ,yFAAyF;QACzF,8FAA8F;QAC9F,uGAAuG;QACvG,sFAAsF;QACtF,oEAAoE;QACpE,6JAA6J;QAC7J,gIAAgI;KACjI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wBAAwB;YACvC,OAAO,EAAE,sHAAsH;YAC/H,QAAQ,EAAE,mDAAmD;SAC9D;QACD;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,uKAAuK;YAChL,QAAQ,EAAE,wBAAwB;SACnC;QACD;YACE,aAAa,EAAE,uBAAuB;YACtC,OAAO,EAAE,4GAA4G;YACrH,QAAQ,EAAE,kCAAkC;SAC7C;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iEAAiE;YAC7E,QAAQ,EAAE,kKAAkK;SAC7K;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,+HAA+H;SAC1I;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,2FAA2F;SACtG;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,aAAa;YACtB,KAAK,EAAE,eAAe;SACvB;QACD;YACE,OAAO,EAAE,cAAc;YACvB,KAAK,EAAE,gBAAgB;SACxB;QACD;YACE,OAAO,EAAE,kBAAkB;YAC3B,KAAK,EAAE,oBAAoB;SAC5B;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;KACF;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,iBAAiB;YAChC,OAAO,EAAE,kHAAkH;YAC3H,QAAQ,EAAE,2CAA2C;SACtD;QACD,QAAQ,EAAE;YACR,gEAAgE;YAChE,qEAAqE;SACtE;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,qEAAqE;QAC9E,KAAK,EAAE,kHAAkH;KAC1H;IACD,eAAe,EAAE,yEAAyE;IAC1F,KAAK,EAAE,iBAAiB;IACxB,MAAM,EAAE,iBAAiB;IACzB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;QACT,gBAAgB;KACjB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"extractHTMLText.js","sourceRoot":"","sources":["../../../src/generated/builtins/extractHTMLText.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,iBAAiB;IAC1B,UAAU,EAAE,wBAAwB;IACpC,UAAU,EAAE;QACV,iBAAiB;QACjB,MAAM;QACN,gBAAgB;QAChB,OAAO;QACP,UAAU;KACX;IACD,SAAS,EAAE,0DAA0D;IACrE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,oJAAoJ;KAC9J;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,gDAAgD;QACxD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,iMAAiM;IAChN,WAAW,EAAE;QACX,0MAA0M;QAC1M,oGAAoG;QACpG,8FAA8F;QAC9F,+HAA+H;QAC/H,sFAAsF;QACtF,oEAAoE;QACpE,6JAA6J;QAC7J,gIAAgI;QAChI,oLAAoL;KACrL;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wBAAwB;YACvC,OAAO,EAAE,sHAAsH;YAC/H,QAAQ,EAAE,mDAAmD;SAC9D;QACD;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,uKAAuK;YAChL,QAAQ,EAAE,wBAAwB;SACnC;QACD;YACE,aAAa,EAAE,uBAAuB;YACtC,OAAO,EAAE,4GAA4G;YACrH,QAAQ,EAAE,kCAAkC;SAC7C;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iEAAiE;YAC7E,QAAQ,EAAE,kKAAkK;SAC7K;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,uNAAuN;SAClO;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,2FAA2F;SACtG;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,aAAa;YACtB,KAAK,EAAE,eAAe;SACvB;QACD;YACE,OAAO,EAAE,cAAc;YACvB,KAAK,EAAE,gBAAgB;SACxB;QACD;YACE,OAAO,EAAE,kBAAkB;YAC3B,KAAK,EAAE,oBAAoB;SAC5B;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;KACF;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,iBAAiB;YAChC,OAAO,EAAE,kHAAkH;YAC3H,QAAQ,EAAE,2CAA2C;SACtD;QACD,QAAQ,EAAE;YACR,gEAAgE;YAChE,qEAAqE;SACtE;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,qEAAqE;QAC9E,KAAK,EAAE,kHAAkH;KAC1H;IACD,eAAe,EAAE,yEAAyE;IAC1F,KAAK,EAAE,iBAAiB;IACxB,MAAM,EAAE,iBAAiB;IACzB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;QACT,gBAAgB;KACjB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/eye.js

@@ -11,7 +11,7 @@ const builtinDoc = {
         "like",
         "logical"
     ],
-    "summary": "Create identity matrices and N-D identity tensors in MATLAB and RunMat.",
+    "summary": "Create identity matrices with an exact requested class, sparsity, and residency.",
     "gpu_support": {
         "elementwise": false,
         "reduction": false,
@@ -20,7 +20,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "Uses provider identity allocation hooks when available; otherwise materialises the identity tensor on the host and uploads it."
+        "notes": "For a resident `'like'` prototype, RunMat uses that handle's owning provider. Real floating identities use the provider hook when it preserves the prototype representation; logical, complex, and integer identities use typed host upload when necessary."
     },
     "fusion": {
         "elementwise": false,
@@ -33,15 +33,16 @@ const builtinDoc = {
         "unit": "builtins::array::creation::eye::tests",
         "integration": "builtins::array::creation::eye::tests::eye_gpu_like_alloc"
     },
-    "description": "`eye` creates identity matrices (and higher-dimensional identity tensors) with ones on the leading diagonal and zeros elsewhere. Scalar, vector, matrix, and N-D sizing forms, including `'logical'` and `'like'` options, follow MATLAB semantics.",
+    "description": "`eye` creates a two-dimensional identity matrix with ones on the leading diagonal and zeros elsewhere. MATLAB-compatible mode supports scalar dimensions, two scalar dimensions, a row size vector with at most two elements, a documented typename, and the `'like'` form. RunMat's older implicit-prototype, column-size-vector, and N-D forms remain available only when RunMat extensions are enabled.",
     "behaviors": [
         "`eye()` returns the scalar `1`.",
         "`eye(n)` returns an `n × n` double-precision identity matrix.",
-        "`eye(m, n, ...)` returns an `m × n × ...` tensor whose first two dimensions form an identity slice that is replicated across all trailing dimensions.",
-        "`eye(sz)` accepts a size vector (row or column) and returns an array with `size(I) == sz`.",
-        "`eye(A)` matches the size of `A`. Logical, complex, and GPU prototypes preserve their logical/complex/device traits; other inputs default to double precision for MATLAB parity.",
-        "`eye(___, 'logical')` returns a logical identity tensor instead of double precision.",
-        "`eye(___, 'like', prototype)` matches the numeric flavour and device residency of `prototype`, including GPU handles."
+        "`eye(m, n)` returns an `m × n` identity matrix. Negative finite integer dimensions are treated as zero; noninteger, nonfinite, or platform-unrepresentable dimensions are rejected before allocation.",
+        "`eye(sz)` accepts a row size vector with no more than two elements. A one-element vector requests a square matrix.",
+        "`eye(___, typename)` supports `double`, `single`, `logical`, and all eight signed and unsigned integer class names.",
+        "`eye(___, 'like', prototype)` uses `prototype` for class, complexity, sparsity, and applicable device residency, but never for output shape. With no dimensions, the result is 1 × 1.",
+        "Dense integer identities and real or logical sparse identities retain exact storage. Complex sparse prototypes remain a representation gap because RunMat's sparse value type does not yet carry complex values.",
+        "`eye(A)`, column size vectors, and more than two dimensions are explicit RunMat extensions rather than MATLAB-compatible syntax."
     ],
     "examples": [
         {
@@ -55,9 +56,9 @@ const builtinDoc = {
             "output": "J =\n     1     0     0     0\n     0     1     0     0"
         },
         {
-            "description": "Replicating an identity matrix across pages",
-            "input": "K = eye(2, 3, 2)   % Two 2x3 identity slices stacked along the third dimension",
-            "output": "K(:, :, 1) =\n     1     0     0\n     0     1     0\n\nK(:, :, 2) =\n     1     0     0\n     0     1     0"
+            "description": "Creating an exact unsigned integer identity matrix",
+            "input": "K = eye(2, 3, 'uint64')",
+            "output": "K =\n  2x3 uint64 matrix\n     1     0     0\n     0     1     0"
         },
         {
             "description": "Creating a logical identity mask",
@@ -84,7 +85,7 @@ const builtinDoc = {
         },
         {
             "question": "Can `eye` generate higher-dimensional identity tensors?",
-            "answer": "Yes. Extra dimensions replicate the identity slice. For example, `eye(2, 3, 4)` creates four `2 × 3` identity matrices stacked along the third dimension."
+            "answer": "Only as a RunMat extension. MATLAB-compatible mode accepts at most two dimensions; extension mode retains the older replicated-slice N-D behavior."
         },
         {
             "question": "What happens if I request zero-sized dimensions?",
@@ -92,15 +93,15 @@ const builtinDoc = {
         },
         {
             "question": "Is single precision supported?",
-            "answer": "Not yet. Requesting `'single'` currently reports an error. Use `'like'` with a single-precision prototype once single-precision support lands."
+            "answer": "Yes. Use `eye(..., 'single')` or a single-precision `'like'` prototype."
         },
         {
             "question": "Does `eye(A)` match the class of `A`?",
-            "answer": "For logical, complex, and GPU prototypes, yes—`eye(A)` behaves like `eye(size(A), 'like', A)`. Other numeric inputs produce double precision to mirror MATLAB's default."
+            "answer": "The implicit `eye(A)` form is a RunMat extension. Portable code should provide dimensions and write `eye(size(A), 'like', A)`; `'like'` controls representation and does not infer shape."
         },
         {
             "question": "How efficient is the GPU path?",
-            "answer": "Providers with dedicated identity allocation avoid host involvement entirely. Providers without the hook fall back to a single host upload, which is still efficient for typical sizes."
+            "answer": "RunMat routes a resident prototype through its owning provider and validates the returned owner, device, shape, storage, class metadata, and precision. Exact typed upload is used when a provider identity hook cannot represent the requested logical, complex, or integer result."
         }
     ],
     "links": [
@@ -181,9 +182,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/array/creation/eye.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/creation/eye.rs"
     },
-    "gpu_residency": "You usually do **not** need to call `gpuArray` yourself in RunMat. The fusion planner keeps data on the GPU whenever it determines that downstream work will benefit from staying on the device. The `eye` builtin respects that residency: if the planner or user requests GPU output (via `'like'`), it will either construct the identity tensor directly on the device (when the provider implements `eye`) or generate it on the host and upload it as a single transfer.",
+    "gpu_residency": "You usually do **not** need to call `gpuArray` yourself in RunMat. The fusion planner keeps data on the GPU whenever downstream work benefits from staying on the device. With a resident `'like'` prototype, `eye` routes construction through that handle's owning provider and preserves supported representation metadata.",
     "gpu_behavior": [
-        "When the result should live on a GPU (either because the prototype is a GPU tensor or the `'like'` argument references one), RunMat first asks the active acceleration provider for an identity buffer via the `eye` / `eye_like` hooks. The WGPU backend implements these hooks directly; simpler providers may return `Err`, in which case the runtime materialises the identity tensor on the host, performs a single upload, and returns a `GpuTensorHandle`. Because the allocation happens in one step, the auto-offload planner can keep subsequent fused expressions resident on the device without extra gathers."
+        "For a resident `'like'` prototype, RunMat first resolves the handle's owning provider. A compatible real floating result can use the provider `eye` hook; exact integer, logical, or complex construction can use one typed host upload. RunMat validates the new handle before returning it and otherwise gathers the prototype and produces a host result instead of silently returning the wrong device or class."
     ],
     "key": "eye",
     "slug": "eye",

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

@@ -1 +1 @@
-{"version":3,"file":"eye.js","sourceRoot":"","sources":["../../../src/generated/builtins/eye.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,KAAK;QACL,UAAU;QACV,QAAQ;QACR,KAAK;QACL,MAAM;QACN,SAAS;KACV;IACD,SAAS,EAAE,yEAAyE;IACpF,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,gIAAgI;KAC1I;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,uCAAuC;QAC/C,aAAa,EAAE,2DAA2D;KAC3E;IACD,aAAa,EAAE,qPAAqP;IACpQ,WAAW,EAAE;QACX,iCAAiC;QACjC,+DAA+D;QAC/D,uJAAuJ;QACvJ,4FAA4F;QAC5F,kLAAkL;QAClL,sFAAsF;QACtF,uHAAuH;KACxH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,YAAY;YACrB,QAAQ,EAAE,iEAAiE;SAC5E;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,eAAe;YACxB,QAAQ,EAAE,yDAAyD;SACpE;QACD;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,gFAAgF;YACzF,QAAQ,EAAE,8GAA8G;SACzH;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,0BAA0B;YACnC,QAAQ,EAAE,gHAAgH;SAC3H;QACD;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,qFAAqF;SAC/F;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,gLAAgL;SAC3L;QACD;YACE,UAAU,EAAE,8CAA8C;YAC1D,QAAQ,EAAE,oGAAoG;SAC/G;QACD;YACE,UAAU,EAAE,oFAAoF;YAChG,QAAQ,EAAE,0HAA0H;SACrI;QACD;YACE,UAAU,EAAE,yDAAyD;YACrE,QAAQ,EAAE,2JAA2J;SACtK;QACD;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,+FAA+F;SAC1G;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,gJAAgJ;SAC3J;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,0KAA0K;SACrL;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,yLAAyL;SACpM;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,4DAA4D;QACrE,KAAK,EAAE,yGAAyG;KACjH;IACD,eAAe,EAAE,gdAAgd;IACje,cAAc,EAAE;QACd,4lBAA4lB;KAC7lB;IACD,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,KAAK;IACb,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"eye.js","sourceRoot":"","sources":["../../../src/generated/builtins/eye.ts"],"names":[],"mappings":"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"}