runmat 0.6.1 → 0.6.2-dev.0

package/dist/generated/builtins/colorcube.js

@@ -18,6 +18,8 @@ const builtinDoc = {
     "behaviors": [
         "`colorcube()` returns an m-by-3 RGB matrix.",
         "`colorcube(m)` returns exactly `m` rows, where `m` must be a nonnegative integer.",
+        "`m` can use any of the eight integer classes. It is read exactly as a host structural row count, and the result remains an m-by-3 double matrix.",
+        "Resident scalar controls are rejected without provider dispatch; `colorcube` does not run a numeric GPU kernel.",
         "The result can be passed directly to `colormap`."
     ],
     "examples": [
@@ -34,6 +36,10 @@ const builtinDoc = {
         {
             "question": "What size is `colorcube()`?",
             "answer": "It returns the active colormap length when one exists, otherwise 256 rows by 3 columns."
+        },
+        {
+            "question": "Which integer classes can specify `m`?",
+            "answer": "All eight built-in integer classes are documented: `int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, and `uint64`. The value must be nonnegative and no larger than RunMat's allocation guard."
         }
     ],
     "links": [
@@ -50,6 +56,10 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/plotting/ops/colormap_arrays.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/colormap_arrays.rs"
     },
+    "gpu_residency": "The generated colormap is a host double matrix. A resident `m` control is rejected without gathering.",
+    "gpu_behavior": [
+        "`colorcube` performs host structural allocation and RGB generation only; it does not invoke provider kernels."
+    ],
     "key": "colorcube",
     "slug": "colorcube",
     "aliases": [],

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

@@ -1 +1 @@
-{"version":3,"file":"colorcube.js","sourceRoot":"","sources":["../../../src/generated/builtins/colorcube.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,WAAW;IACpB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,WAAW;QACX,UAAU;QACV,cAAc;QACd,iBAAiB;KAClB;IACD,SAAS,EAAE,uDAAuD;IAClE,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,qCAAqC;KAC9C;IACD,aAAa,EAAE,uMAAuM;IACtN,WAAW,EAAE;QACX,6CAA6C;QAC7C,mFAAmF;QACnF,kDAAkD;KACnD;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4BAA4B;YAC3C,OAAO,EAAE,uDAAuD;SACjE;QACD;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,oBAAoB;SAC9B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,6BAA6B;YACzC,QAAQ,EAAE,yFAAyF;SACpG;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,sEAAsE;QAC/E,KAAK,EAAE,mHAAmH;KAC3H;IACD,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,WAAW;IACnB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"colorcube.js","sourceRoot":"","sources":["../../../src/generated/builtins/colorcube.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,WAAW;IACpB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,WAAW;QACX,UAAU;QACV,cAAc;QACd,iBAAiB;KAClB;IACD,SAAS,EAAE,uDAAuD;IAClE,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,qCAAqC;KAC9C;IACD,aAAa,EAAE,uMAAuM;IACtN,WAAW,EAAE;QACX,6CAA6C;QAC7C,mFAAmF;QACnF,kJAAkJ;QAClJ,iHAAiH;QACjH,kDAAkD;KACnD;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4BAA4B;YAC3C,OAAO,EAAE,uDAAuD;SACjE;QACD;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,oBAAoB;SAC9B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,6BAA6B;YACzC,QAAQ,EAAE,yFAAyF;SACpG;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,8MAA8M;SACzN;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,sEAAsE;QAC/E,KAAK,EAAE,mHAAmH;KAC3H;IACD,eAAe,EAAE,uGAAuG;IACxH,cAAc,EAAE;QACd,+GAA+G;KAChH;IACD,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,WAAW;IACnB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/colormap.js

@@ -10,19 +10,22 @@ const builtinDoc = {
         "surface palette",
         "matlab colormap"
     ],
-    "summary": "Set the active colormap in MATLAB and RunMat plotting.",
+    "summary": "Set or query a plotting colormap.",
     "requires_feature": null,
     "tested": {
         "unit": "builtins::plotting::cmds"
     },
-    "description": "`colormap` sets the active color palette for the current plotting context. It accepts a named palette or an m-by-3 RGB matrix with values in [0, 1], and affects colormap-driven visualizations such as `imagesc`, `surf`, and `contourf`, scoped to the active axes in MATLAB and RunMat.",
+    "description": "`colormap` sets or queries the color palette for the current or explicitly targeted plotting context. Public custom maps accept m-by-3 single or double RGB values in [0,1], or uint8 RGB values in [0,255]. Query output is a normalized host double matrix.",
     "behaviors": [
         "Supported colormap names include `parula`, `colorcube`, `viridis`, `plasma`, `inferno`, `magma`, `turbo`, `jet`, `hot`, `cool`, `spring`, `summer`, `autumn`, `winter`, `gray`, `bone`, `copper`, `pink`, and `lines`.",
         "Named colormaps are also available as RGB array generator functions, so MATLAB forms such as `colormap(jet)`, `colormap(gray(64))`, and `c = turbo(128)` are supported.",
-        "RGB matrix inputs are validated as m-by-3 numeric arrays with finite values in [0, 1] and are preserved in plotting state and scene serialization.",
+        "`cmap = colormap()` and `cmap = colormap(target)` return an m-by-3 normalized host double matrix. Setter forms do not expose an output.",
+        "Public RGB maps are m-by-3 single or double arrays in [0,1], or uint8 arrays in [0,255]. uint8 channels are normalized by division by 255 at the host graphics-state boundary.",
+        "The other seven integer classes are a RunMat extension. They are accepted only when every native integer channel is exactly 0 or 1, and strict compatibility mode rejects the form before conversion.",
+        "Resident RGB maps are rejected without provider access; colormap metadata and query results are host-resident.",
         "Unknown colormap names raise errors rather than silently falling back.",
         "Colormap state composes naturally with `colorbar`, `imagesc`, `surf`, and filled contour plots.",
-        "Colormap changes apply to the current axes context in the plotting state model."
+        "Untargeted changes apply to the current axes. Targeted axes and figure forms update only the selected plotting context."
     ],
     "examples": [
         {
@@ -53,7 +56,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I define a custom colormap?",
-            "answer": "Yes. Pass an m-by-3 RGB matrix with finite values in [0, 1], for example `colormap([0 0 0; 1 0.5 0; 1 1 1])`. RunMat preserves matrix inputs in plotting state and scene serialization."
+            "answer": "Yes. Pass an m-by-3 single or double matrix in [0,1], or a uint8 matrix in [0,255]. RunMat mode also admits other integer classes when every channel is exactly 0 or 1."
         }
     ],
     "links": [

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

@@ -1 +1 @@
-{"version":3,"file":"colormap.js","sourceRoot":"","sources":["../../../src/generated/builtins/colormap.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,UAAU;QACV,eAAe;QACf,iBAAiB;QACjB,iBAAiB;QACjB,iBAAiB;KAClB;IACD,SAAS,EAAE,wDAAwD;IACnE,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,0BAA0B;KACnC;IACD,aAAa,EAAE,4RAA4R;IAC3S,WAAW,EAAE;QACX,wNAAwN;QACxN,yKAAyK;QACzK,oJAAoJ;QACpJ,wEAAwE;QACxE,iGAAiG;QACjG,iFAAiF;KAClF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,+HAA+H;SACzI;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,wMAAwM;SAClN;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,qDAAqD;SAC/D;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,+BAA+B;SACzC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,+BAA+B;YAC3C,QAAQ,EAAE,6PAA6P;SACxQ;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,2VAA2V;SACtW;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,yLAAyL;SACpM;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;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,8BAA8B;YACvC,KAAK,EAAE,6CAA6C;SACrD;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;QACD;YACE,OAAO,EAAE,yBAAyB;YAClC,KAAK,EAAE,6BAA6B;SACrC;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"colormap.js","sourceRoot":"","sources":["../../../src/generated/builtins/colormap.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,UAAU;QACV,eAAe;QACf,iBAAiB;QACjB,iBAAiB;QACjB,iBAAiB;KAClB;IACD,SAAS,EAAE,mCAAmC;IAC9C,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,0BAA0B;KACnC;IACD,aAAa,EAAE,+PAA+P;IAC9Q,WAAW,EAAE;QACX,wNAAwN;QACxN,yKAAyK;QACzK,yIAAyI;QACzI,gLAAgL;QAChL,uMAAuM;QACvM,gHAAgH;QAChH,wEAAwE;QACxE,iGAAiG;QACjG,yHAAyH;KAC1H;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,+HAA+H;SACzI;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,wMAAwM;SAClN;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,qDAAqD;SAC/D;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,+BAA+B;SACzC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,+BAA+B;YAC3C,QAAQ,EAAE,6PAA6P;SACxQ;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,2VAA2V;SACtW;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,yKAAyK;SACpL;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;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,8BAA8B;YACvC,KAAK,EAAE,6CAA6C;SACrD;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;QACD;YACE,OAAO,EAAE,yBAAyB;YAClC,KAAK,EAAE,6BAA6B;SACrC;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/colororder.js

@@ -20,13 +20,16 @@ const builtinDoc = {
     "tested": {
         "unit": "builtins::plotting::colororder::tests"
     },
-    "description": "`colororder` controls the implicit series colors used by line-style plotting commands. RunMat supports querying the current color order, setting figure-wide or axes-specific palettes, RGB triplet matrices, string and cell string color specifications, hex colors, and common MATLAB palette names.",
+    "description": "`colororder` controls the implicit series colors used by line-style plotting commands. Public numeric RGB inputs are single or double matrices in [0,1]. RunMat additionally supports a gated host-only integer RGB extension.",
     "behaviors": [
         "`colororder()` returns the current figure color order as an m-by-3 RGB triplet matrix.",
         "`colororder(colors)` sets the color order for the current figure and applies it to existing axes.",
         "`colororder(ax, colors)` sets the color order for the specified axes without changing the current axes.",
         "`colororder(fig, colors)` sets the color order for every axes in the specified figure.",
-        "Numeric color arrays must be m-by-3 RGB triplet matrices with finite values in [0, 1]. A single RGB triplet vector is accepted as one color.",
+        "Numeric color arrays must be m-by-3 RGB triplet matrices with finite values in [0,1]. Public numeric classes are single and double; a single RGB triplet vector is accepted as one color.",
+        "All eight integer classes are accepted only in RunMat mode and only when every native channel is exactly 0 or 1. Strict compatibility mode rejects integer RGB setters before conversion.",
+        "Integer channels cross an explicit host f32 graphics-state boundary. Query output is always an m-by-3 host double matrix; setter forms expose no output.",
+        "Resident numeric color arrays are rejected without provider access.",
         "String and cell string color arrays accept MATLAB color names, short color tokens, and `#RGB` or `#RRGGBB` hex strings.",
         "Palette names include `default`, `gem`, `gem12`, `glow`, `glow12`, `sail`, `reef`, `meadow`, `dye`, and `earth`.",
         "Changing the color order recolors existing line/scatter/bar-family series cyclically and controls future implicit plot colors."

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

@@ -1 +1 @@
-{"version":3,"file":"colororder.js","sourceRoot":"","sources":["../../../src/generated/builtins/colororder.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,YAAY;QACZ,aAAa;QACb,aAAa;QACb,cAAc;QACd,mBAAmB;KACpB;IACD,SAAS,EAAE,6DAA6D;IACxE,kBAAkB,EAAE,IAAI;IACxB,KAAK,EAAE;QACL,WAAW,EAAE,MAAM;QACnB,QAAQ,EAAE,MAAM;QAChB,OAAO,EAAE,wHAAwH;KAClI;IACD,QAAQ,EAAE;QACR,MAAM,EAAE,uCAAuC;KAChD;IACD,aAAa,EAAE,ySAAyS;IACxT,WAAW,EAAE;QACX,wFAAwF;QACxF,mGAAmG;QACnG,yGAAyG;QACzG,wFAAwF;QACxF,8IAA8I;QAC9I,yHAAyH;QACzH,kHAAkH;QAClH,gIAAgI;KACjI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,mFAAmF;YAC5F,QAAQ,EAAE,4EAA4E;SACvF;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,iEAAiE;SAC3E;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,2GAA2G;SACrH;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,8MAA8M;SACzN;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,qJAAqJ;SAChK;QACD;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,gHAAgH;SAC3H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"colororder.js","sourceRoot":"","sources":["../../../src/generated/builtins/colororder.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,YAAY;QACZ,aAAa;QACb,aAAa;QACb,cAAc;QACd,mBAAmB;KACpB;IACD,SAAS,EAAE,6DAA6D;IACxE,kBAAkB,EAAE,IAAI;IACxB,KAAK,EAAE;QACL,WAAW,EAAE,MAAM;QACnB,QAAQ,EAAE,MAAM;QAChB,OAAO,EAAE,wHAAwH;KAClI;IACD,QAAQ,EAAE;QACR,MAAM,EAAE,uCAAuC;KAChD;IACD,aAAa,EAAE,gOAAgO;IAC/O,WAAW,EAAE;QACX,wFAAwF;QACxF,mGAAmG;QACnG,yGAAyG;QACzG,wFAAwF;QACxF,2LAA2L;QAC3L,2LAA2L;QAC3L,0JAA0J;QAC1J,qEAAqE;QACrE,yHAAyH;QACzH,kHAAkH;QAClH,gIAAgI;KACjI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,mFAAmF;YAC5F,QAAQ,EAAE,4EAA4E;SACvF;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,iEAAiE;SAC3E;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,2GAA2G;SACrH;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,8MAA8M;SACzN;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,qJAAqJ;SAChK;QACD;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,gHAAgH;SAC3H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/combinations.js

@@ -15,15 +15,17 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Combination materialization runs on the host."
+        "notes": "The table result is host-resident. Gathering resident inputs is a gated RunMat extension."
     },
     "tested": {
         "unit": "builtins::array::grouping::tests"
     },
-    "description": "`T = combinations(A,B,...)` returns a table whose rows contain the Cartesian product of the input vector elements.",
+    "description": "`T = combinations(A1,...,An)` returns a host table whose rows contain the Cartesian product of the input elements. Each input is linearized in column-major order.",
     "behaviors": [
-        "Supports numeric, logical, string, character, and cell inputs.",
-        "Supports the `VariableNames` name-value option."
+        "Supports numeric, logical, string, character, and cell inputs. Text such as `VariableNames` is ordinary input data, not an option name.",
+        "All eight integer classes are public inputs. Each corresponding table variable preserves the exact native integer class and values.",
+        "Row, column, matrix, and multidimensional inputs are linearized columnwise; output variables are columns and empty integer inputs retain their class.",
+        "The result is a host table. Resident inputs use a gated RunMat gather extension rather than a public compatibility path."
     ],
     "examples": [
         {

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

@@ -1 +1 @@
-{"version":3,"file":"combinations.js","sourceRoot":"","sources":["../../../src/generated/builtins/combinations.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,cAAc;IACvB,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,cAAc;QACd,WAAW;QACX,OAAO;QACP,eAAe;KAChB;IACD,SAAS,EAAE,8CAA8C;IACzD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+CAA+C;KACzD;IACD,QAAQ,EAAE;QACR,MAAM,EAAE,kCAAkC;KAC3C;IACD,aAAa,EAAE,oHAAoH;IACnI,WAAW,EAAE;QACX,gEAAgE;QAChE,iDAAiD;KAClD;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gBAAgB;YAC/B,OAAO,EAAE,uCAAuC;YAChD,QAAQ,EAAE,eAAe;SAC1B;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,wDAAwD;QACjE,KAAK,EAAE,qGAAqG;KAC7G;IACD,KAAK,EAAE,cAAc;IACrB,MAAM,EAAE,cAAc;IACtB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"combinations.js","sourceRoot":"","sources":["../../../src/generated/builtins/combinations.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,cAAc;IACvB,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,cAAc;QACd,WAAW;QACX,OAAO;QACP,eAAe;KAChB;IACD,SAAS,EAAE,8CAA8C;IACzD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,2FAA2F;KACrG;IACD,QAAQ,EAAE;QACR,MAAM,EAAE,kCAAkC;KAC3C;IACD,aAAa,EAAE,oKAAoK;IACnL,WAAW,EAAE;QACX,yIAAyI;QACzI,qIAAqI;QACrI,uJAAuJ;QACvJ,0HAA0H;KAC3H;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gBAAgB;YAC/B,OAAO,EAAE,uCAAuC;YAChD,QAAQ,EAAE,eAAe;SAC1B;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,wDAAwD;QACjE,KAAK,EAAE,qGAAqG;KAC7G;IACD,KAAK,EAAE,cAAc;IACrB,MAAM,EAAE,cAAc;IACtB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/complex.js

@@ -20,7 +20,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "scalar-only",
-        "notes": "When a provider exposes complex_from_real / complex_from_real_imag, gpuArray inputs stay resident and return complex-interleaved GPU storage. The runtime gathers only when the hook is unavailable or a host-only conversion is required."
+        "notes": "Floating gpuArray inputs stay resident when the owning provider exposes complex construction. Typed-integer resident inputs use exact native transfer for composition and restore paired complex-integer storage to the owning provider."
     },
     "fusion": {
         "elementwise": false,
@@ -36,11 +36,12 @@ const builtinDoc = {
     "behaviors": [
         "With two inputs, `a` and `b` must be real numeric values. Complex inputs raise an error.",
         "Two non-scalar inputs must have the same size. If either input is scalar, it expands across the other input.",
-        "Integer and logical inputs are promoted to double precision before constructing the complex result.",
+        "Integer inputs retain their integer class in exact complex integer storage. In the binary form, the peer must have the same integer class or be a full scalar double, and scalar-double conversion rounds and saturates to the integer class.",
+        "If either floating input is single, the result is complex single; logical-only inputs produce complex double.",
         "String and character inputs are rejected because the constructor accepts numeric inputs only.",
         "Unary `complex(a)` preserves existing complex scalars and complex tensors. Real inputs become complex values with zero imaginary parts.",
         "Empty real tensors preserve their empty shape and return empty complex tensors.",
-        "Real gpuArray inputs remain device-resident when the active provider supports complex construction; two-argument GPU construction preserves MATLAB scalar expansion rules and rejects complex operands."
+        "Real floating gpuArray inputs remain device-resident when the owning provider supports complex construction; typed-integer resident inputs preserve exact paired storage and return to the owning provider after exact fallback composition."
     ],
     "examples": [
         {
@@ -93,7 +94,7 @@ const builtinDoc = {
         },
         {
             "question": "Does `complex` accept logical inputs?",
-            "answer": "Yes. RunMat promotes logical values to doubles (`true` becomes `1`, `false` becomes `0`) before constructing the complex output."
+            "answer": "Yes. Logical values produce complex double output. Integer values are different: all eight integer classes are documented inputs and retain their class in exact complex integer storage."
         },
         {
             "question": "Does `complex` accept strings or character arrays?",
@@ -101,7 +102,7 @@ const builtinDoc = {
         },
         {
             "question": "Can `complex` run on GPU arrays?",
-            "answer": "Yes. Real gpuArray inputs are interleaved on the provider into complex GPU storage. Unary `complex(A)` adds a zero imaginary lane; binary `complex(A,B)` combines real and imaginary operands with scalar expansion. Complex operands are still rejected in the two-argument form, matching MATLAB's real-input requirement."
+            "answer": "Floating real gpuArray inputs use owning-provider complex construction when precision and hooks support it. Typed-integer resident inputs use exact native transfer for fallback composition and restore paired complex-integer output to the same owner."
         }
     ],
     "links": [
@@ -142,10 +143,10 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/math/elementwise/complex.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/complex.rs"
     },
-    "gpu_residency": "`complex` keeps real gpuArray inputs resident when the active provider supports `complex_from_real` and `complex_from_real_imag`. Outputs use complex-interleaved GPU storage so downstream GPU-aware operations can consume them without a host round trip.",
+    "gpu_residency": "`complex` keeps floating real gpuArray inputs resident when the owning provider supports the required precision and complex-construction hook. Typed-integer input uses exact owner-aware fallback and restores paired native storage to that owner.",
     "gpu_behavior": [
-        "Unary `complex(A)` on a real gpuArray writes `[real, 0]` interleaved lanes on the device and marks the handle as complex storage.",
-        "Binary `complex(A, B)` accepts real gpuArray and host real operands, uploading host operands as needed, then uses the provider hook to interleave the output on-device with scalar expansion.",
+        "Unary `complex(A)` on a floating real gpuArray writes `[real, 0]` interleaved lanes when the owning-provider hook is available.",
+        "Binary `complex(A, B)` uses the owning-provider hook only when class and precision rules can be preserved; typed integers use exact native fallback and restore resident output to the selected owner.",
         "If either two-argument operand is already complex, RunMat raises the same real-input error as the host path."
     ],
     "key": "complex",

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

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

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

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

package/dist/generated/builtins/compose.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Formatting runs on the CPU. GPU inputs are gathered to host memory before substitution."
+        "notes": "Formatting runs on the CPU. Resident inputs are a mode-gated RunMat extension and gather through the owning provider before substitution. A string format specification returns a host string array, while a character format specification returns a host cell array of character vectors."
     },
     "fusion": {
         "elementwise": false,
@@ -29,13 +29,15 @@ const builtinDoc = {
         "unit": "builtins::strings::core::compose::tests",
         "integration": "builtins::strings::core::compose::tests::compose_gpu_argument"
     },
-    "description": "`compose(formatSpec, A1, ..., An)` substitutes data into `%` placeholders and returns a string array. It combines `sprintf`-style formatting with string-array expansion behavior matching MATLAB and RunMat.",
+    "description": "`compose(formatSpec, A1, ..., An)` substitutes data into `%` placeholders. A string format specification returns a string array and a character format specification returns a cell array of character vectors. Integer arguments are read from exact native storage, including int64 and uint64 values above `flintmax`.",
     "behaviors": [
-        "`formatSpec` must be text: a string scalar, string array, character vector, character array, or cell array of character vectors.",
+        "`formatSpec` must be a string or character format for substitution. A cell array of character vectors is supported only by unary `compose(formatSpec)`, which converts it to cellstr output.",
         "If `formatSpec` is scalar and any argument array has more than one element, RunMat broadcasts the scalar specification over the array dimensions.",
         "When `formatSpec` is a string or character array with multiple elements, the output has the same shape as the specification. Each element uses the corresponding row or cell during formatting.",
-        "Arguments can be numeric, logical, string, or text-like cell arrays. Non-text arguments are converted using MATLAB-compatible rules (logical values become `1` or `0`, complex numbers use the `a + bi` form).",
-        "When you omit additional arguments, `compose(formatSpec)` simply converts the specification into a string array, preserving the original structure.",
+        "Arguments can be numeric, logical, string, or character data. Cell-array data arguments are rejected because they are outside the documented domain. All eight integer classes are formatted directly from native values, so `%d` and `%i` preserve exact decimal text above `flintmax`.",
+        "Resident arguments are a RunMat-only extension because MATLAB does not document GPU-array support for compose. RunMat mode gathers them through the owning provider before formatting and returns host text in the class selected by formatSpec.",
+        "When you omit additional arguments, string formatSpec returns a string array, while character and cellstr formatSpec return a cell array of character vectors.",
+        "General nonscalar row-wise formatting geometry remains a known gap: scalar expansion and equal-element-count forms are covered, but every higher-dimensional MATLAB format cycling case has not yet been modeled.",
         "Errors are raised if argument shapes are incompatible with the specification or if format specifiers are incomplete."
     ],
     "examples": [
@@ -55,20 +57,15 @@ const builtinDoc = {
             "output": "values = 1×2 string\n    \"max: 3.14\"    \"min: 0.12\""
         },
         {
-            "description": "Formatting Each Row Of A Character Array",
-            "input": "C = ['Row %02d'; 'Row %02d'; 'Row %02d'];\nidx = compose(C, (1:3).')",
-            "output": "idx = 3×1 string\n    \"Row 01\"\n    \"Row 02\"\n    \"Row 03\""
+            "description": "Using A Character Format Vector",
+            "input": "idx = compose('Row %02d', (1:3).')",
+            "output": "idx = 3×1 cell\n    {'Row 01'}\n    {'Row 02'}\n    {'Row 03'}"
         },
         {
             "description": "Combining Real And Imaginary Parts",
             "input": "Z = [1+2i, 3-4i];\ntxt = compose(\"z = %s\", Z)",
             "output": "txt = 1×2 string\n    \"z = 1+2i\"    \"z = 3-4i\""
         },
-        {
-            "description": "Using A Cell Array Of Format Specs",
-            "input": "specs = {'%0.1f volts', '%0.1f amps'};\nreadings = compose(specs, {12.6, 3.4})",
-            "output": "readings = 2×1 string\n    \"12.6 volts\"\n    \"3.4 amps\""
-        },
         {
             "description": "Formatting GPU-Resident Data",
             "input": "G = gpuArray([10 20 30]);\nlabels = compose(\"Value %d\", G)",
@@ -94,7 +91,7 @@ const builtinDoc = {
         },
         {
             "question": "What if I pass GPU arrays?",
-            "answer": "Inputs that reside on the GPU are automatically gathered to host memory before formatting. The resulting string array always lives on the CPU."
+            "answer": "In RunMat mode, resident inputs are gathered before formatting and the text result lives on the host. Compatibility mode rejects this explicitly classified extension."
         },
         {
             "question": "How do I emit literal percent signs?",
@@ -106,7 +103,7 @@ const builtinDoc = {
         },
         {
             "question": "What happens when `formatSpec` is empty?",
-            "answer": "`compose(formatSpec)` returns an empty string array with the same shape as `formatSpec`. When `formatSpec` and arguments have zero elements, the output is `0×0`."
+            "answer": "An empty string formatSpec returns an empty string array. Empty character or cellstr formatSpec returns empty cellstr-compatible output with the corresponding shape."
         }
     ],
     "links": [
@@ -168,7 +165,7 @@ const builtinDoc = {
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/core/compose.rs"
     },
     "gpu_behavior": [
-        "`compose` is a residency sink. When inputs include GPU-resident tensors, RunMat gathers the data back to host memory using the active acceleration provider before performing the formatting logic. All formatted strings live in host memory, so acceleration providers do not need compose-specific kernels."
+        "`compose` is a residency sink. In RunMat mode, resident tensors gather through their owning provider before formatting. All formatted text lives in host memory, so providers do not need compose-specific kernels."
     ],
     "key": "compose",
     "slug": "compose",

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

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

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

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

package/dist/generated/builtins/cond.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "RunMat gathers GPU inputs to the host when a provider does not expose a native cond hook, then re-uploads the scalar result to preserve residency."
+        "notes": "RunMat uses the input handle's owning provider. When its cond hook is unavailable, RunMat gathers to host and re-uploads the scalar through that same provider; upload failures are reported rather than silently changing residency."
     },
     "fusion": {
         "elementwise": false,
@@ -40,7 +40,11 @@ const builtinDoc = {
         "Scalars behave like 1x1 matrices. Non-zero scalars have condition number `1`, while `cond(0) = Inf`.",
         "Empty matrices return `0`, matching MATLAB's convention.",
         "Singular or rank-deficient matrices return `Inf`.",
-        "Complex inputs are handled in full complex arithmetic."
+        "Any NaN or infinite matrix element returns `NaN`, matching the current MATLAB nonfinite-input convention.",
+        "Single-precision host input returns a native single scalar; double input returns double. Resident output retains the owning provider's selected precision, including integer gather-fallback results re-uploaded through that provider.",
+        "Complex inputs are handled in full complex arithmetic.",
+        "The documented matrix domain is single or double. Typed-integer and logical matrices are independent RunMat-only extensions; integer matrices must be exactly representable as binary64 before crossing the floating linear-algebra boundary.",
+        "Typed-integer norm selectors are a separate RunMat-only structural extension. They are decoded exactly and accept only 1 or 2 without entering matrix arithmetic."
     ],
     "examples": [
         {
@@ -93,7 +97,7 @@ const builtinDoc = {
         },
         {
             "question": "Will calling `cond` move my data off the GPU?",
-            "answer": "Only when the active provider lacks a dedicated implementation. In that case RunMat gathers the data, computes the scalar on the host, and uploads it back so subsequent GPU operations still see a device-resident value."
+            "answer": "Only when the owning provider lacks a dedicated implementation. RunMat then gathers, computes on the host, and uploads the scalar through that same provider; an upload failure is reported rather than silently changing residency."
         }
     ],
     "links": [

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

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

package/dist/generated/builtins/confusionmat.js

@@ -18,7 +18,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "GPU inputs are gathered to host. Label matching and count accumulation run on CPU."
+        "notes": "MATLAB does not document full gpuArray support for confusionmat. RunMat mode accepts resident inputs as an explicit extension, gathers them to host, and performs exact label matching and count accumulation on CPU."
     },
     "fusion": {
         "elementwise": false,
@@ -34,11 +34,11 @@ const builtinDoc = {
     "description": "`confusionmat(group,grouphat)` compares true class labels in `group` with predicted labels in `grouphat` and returns a matrix whose rows are true classes and columns are predicted classes.",
     "behaviors": [
         "`group` and `grouphat` must contain the same number of labels.",
-        "Numeric, logical, string, character-row, categorical, and cell-string labels are supported. Text label families can be mixed between string, char, cell-string, and categorical inputs.",
+        "MATLAB-compatible inputs are single, double, logical, string, character-row, categorical, and cell-string labels. In RunMat mode, all eight typed-integer classes are also accepted as an explicit extension, without conversion through floating point. Text label families can be mixed between string, char, cell-string, and categorical inputs.",
         "Without an explicit order, numeric labels are sorted ascending, text labels follow first appearance across `group` then `grouphat`, categorical labels follow category order for observed categories, and logical labels are ordered false then true.",
         "`confusionmat(group,grouphat,'Order',order)` uses the supplied class order, requires every nonmissing label in `group` and `grouphat` to appear in `order`, and includes zero rows or columns for extra order labels that do not appear in the data.",
         "Rows with missing true or predicted labels are omitted. Numeric `NaN`, empty text, and `<missing>` text are treated as missing labels.",
-        "`[C,order] = confusionmat(...)` returns the class labels corresponding to the rows and columns of `C`, preserving the label family of the inferred or explicit order."
+        "`[C,order] = confusionmat(...)` returns the class labels corresponding to the rows and columns of `C`. Typed-integer extension inputs preserve their exact class and values in `order`, including int64 and uint64 values above flintmax."
     ],
     "examples": [
         {

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

@@ -1 +1 @@
-{"version":3,"file":"confusionmat.js","sourceRoot":"","sources":["../../../src/generated/builtins/confusionmat.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,cAAc;IACvB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,cAAc;QACd,kBAAkB;QAClB,gBAAgB;QAChB,YAAY;QACZ,kBAAkB;KACnB;IACD,SAAS,EAAE,kEAAkE;IAC7E,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,oFAAoF;KAC9F;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,0CAA0C;QAClD,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,8LAA8L;IAC7M,WAAW,EAAE;QACX,gEAAgE;QAChE,yLAAyL;QACzL,uPAAuP;QACvP,sPAAsP;QACtP,wIAAwI;QACxI,uKAAuK;KACxK;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,oFAAoF;YAC7F,QAAQ,EAAE,sCAAsC;SACjD;QACD;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,oGAAoG;YAC7G,QAAQ,EAAE,gDAAgD;SAC3D;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,sFAAsF;SACjG;QACD;YACE,UAAU,EAAE,0DAA0D;YACtE,QAAQ,EAAE,uJAAuJ;SAClK;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,KAAK,EAAE,cAAc;IACrB,MAAM,EAAE,cAAc;IACtB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,IAAI;KACL;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"confusionmat.js","sourceRoot":"","sources":["../../../src/generated/builtins/confusionmat.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,cAAc;IACvB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,cAAc;QACd,kBAAkB;QAClB,gBAAgB;QAChB,YAAY;QACZ,kBAAkB;KACnB;IACD,SAAS,EAAE,kEAAkE;IAC7E,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uNAAuN;KACjO;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,0CAA0C;QAClD,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,8LAA8L;IAC7M,WAAW,EAAE;QACX,gEAAgE;QAChE,sVAAsV;QACtV,uPAAuP;QACvP,sPAAsP;QACtP,wIAAwI;QACxI,2OAA2O;KAC5O;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,oFAAoF;YAC7F,QAAQ,EAAE,sCAAsC;SACjD;QACD;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,oGAAoG;YAC7G,QAAQ,EAAE,gDAAgD;SAC3D;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,sFAAsF;SACjG;QACD;YACE,UAAU,EAAE,0DAA0D;YACtE,QAAQ,EAAE,uJAAuJ;SAClK;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,KAAK,EAAE,cAAc;IACrB,MAAM,EAAE,cAAc;IACtB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,IAAI;KACL;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/conj.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "Uses the provider's unary_conj hook for real-valued and complex-interleaved GPU tensors. Complex GPU inputs stay resident when the provider supports the hook; fusion treats conj as a pass-through for real data."
+        "notes": "Uses the owning provider's unary_conj hook for floating real and complex-interleaved GPU tensors. Real integer and logical inputs are exact resident identities. Floating fallback and typed complex-integer conjugation restore class-preserving output to the owning provider."
     },
     "fusion": {
         "elementwise": true,
@@ -34,10 +34,11 @@ const builtinDoc = {
     },
     "description": "`conj(x)` negates the imaginary component of each element in `x`, while real values remain unchanged. The operation is element-wise for scalars and arrays, matching MATLAB behavior.",
     "behaviors": [
-        "Complex scalars and arrays have their imaginary components multiplied by `-1`; when a result has no imaginary part it collapses to a real scalar or tensor just like MATLAB.",
+        "Complex scalars and arrays have their imaginary components multiplied by `-1` and remain complex values, including when the imaginary component is zero.",
+        "For typed complex integers, RunMat conservatively applies saturating imaginary-component negation; public evidence does not directly settle signed-minimum or unsigned-imaginary endpoints, so those cases remain evidence-open.",
         "Purely real numeric inputs (double, single, integer) are returned unchanged.",
-        "Logical arrays are promoted to double precision with `true → 1.0` and `false → 0.0`.",
-        "Character arrays are promoted to double precision containing their Unicode code points; the Conjugate operation does not alter the codes because they are real-valued.",
+        "Logical scalars and arrays are returned unchanged and retain logical class.",
+        "Character arrays are not part of the documented MATLAB input classes. RunMat mode accepts them as an explicit compatibility extension and returns double Unicode code points.",
         "String arrays are not supported and raise an error."
     ],
     "examples": [
@@ -57,12 +58,12 @@ const builtinDoc = {
             "output": "unchanged = [-2.5 0 9.75]"
         },
         {
-            "description": "Use conj on logical masks converted to doubles",
+            "description": "Use conj on a logical mask",
             "input": "mask = logical([0 1 0; 1 1 0]);\nnumeric = conj(mask)",
-            "output": "numeric =\n     0     1     0\n     1     1     0"
+            "output": "numeric retains logical class and the same true/false values."
         },
         {
-            "description": "Convert MATLAB char arrays to numeric codes with conj",
+            "description": "Conjugating character codes",
             "input": "chars = 'RunMat';\ncodes = conj(chars)\noutputClass = class(codes)",
             "output": "codes = [82 117 110 77 97 116];\noutputClass = 'double'"
         },
@@ -74,23 +75,23 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "Does `conj` change purely real inputs?",
-            "answer": "No. Real values (including logical and character data) are returned unchanged, although logical and character inputs become double precision arrays just like in MATLAB."
+            "answer": "No. Real numeric and logical values retain their class and values. Character input is a RunMat-mode extension that returns double code points."
         },
         {
             "question": "How does `conj` handle complex zeros?",
-            "answer": "`conj(0 + 0i)` returns `0`. Imaginary zeros remain zero after negation."
+            "answer": "The value remains complex and its imaginary zero changes sign under negation."
         },
         {
             "question": "Can I call `conj` on string arrays?",
-            "answer": "No. The builtin only accepts numeric, logical, or character inputs. Convert strings with `double(string)` if you need numeric codes."
+            "answer": "No. MATLAB-compatible mode accepts numeric and logical inputs. RunMat mode additionally accepts character input as an explicit extension."
         },
         {
             "question": "Does `conj` allocate a new array?",
-            "answer": "Yes. The builtin materialises a new tensor (or scalar). Fusion may eliminate the allocation when the surrounding expression can be fused safely, especially when the data stays on the GPU."
+            "answer": "Not necessarily. Real host values and resident integer or logical handles use an exact identity path. Floating and complex providers may allocate an output handle, while fusion can eliminate intermediate allocation."
         },
         {
             "question": "What happens on the GPU without `unary_conj`?",
-            "answer": "RunMat gathers the tensor to host memory, applies the CPU semantics (including complex negation), and allows later operations to re-upload data if advantageous."
+            "answer": "RunMat gathers floating data to host memory, applies the CPU semantics, and re-uploads the result through the handle's owning provider so residency is preserved."
         },
         {
             "question": "Is GPU execution numerically identical to CPU?",
@@ -98,7 +99,7 @@ const builtinDoc = {
         },
         {
             "question": "Does `conj` participate in fusion?",
-            "answer": "Yes. The fusion planner can fold `conj` into neighbouring elementwise kernels, letting providers keep tensors on the GPU whenever possible."
+            "answer": "Yes for supported floating real expressions. The fusion planner treats real conjugation as identity; complex and typed-integer cases use their dedicated runtime paths."
         }
     ],
     "links": [
@@ -213,9 +214,9 @@ const builtinDoc = {
     },
     "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. RunMat's fusion planner and Accelerate layer manage residency and offload decisions automatically, keeping tensors on the GPU whenever device execution is beneficial. Explicit `gpuArray` and `gather` remain available for MATLAB compatibility or fine-grained residency control.",
     "gpu_behavior": [
-        "**Hook available:** Real tensors stay on the GPU and are processed in-place (both the in-process provider used for tests and the WGPU provider expose this path).",
+        "**Hook available:** Real tensors stay GPU-resident and are processed by the owning provider (both the in-process provider used for tests and the WGPU provider expose this path).",
         "**Fusion and auto-offload:** Because `conj` is tagged as an elementwise unary builtin, the fusion planner treats it as a pass-through for real-valued kernels. Native auto-offload therefore keeps fused expressions resident on the GPU whenever the surrounding ops are profitable.",
-        "**Hook missing or complex input:** RunMat gathers the data to host memory, applies the CPU semantics (including complex negation and type promotion), and returns the result. The planner may re-upload tensors later if profitable.\n\nComplex tensors are currently materialised on the host because GPU-side complex layouts are still under development. Providers can add native complex kernels later without changing this builtin."
+        "**Hook missing:** RunMat transfers floating or paired complex-integer data exactly through the input handle's owner, applies the host semantics, and restores class-preserving output to that same provider. Providers may implement native floating complex-interleaved conjugation through the unary hook."
     ],
     "key": "conj",
     "slug": "conj",

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

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