runmat 0.6.1 → 0.6.2-dev.0

package/dist/generated/builtins/lhsdesign.js

@@ -33,11 +33,13 @@ const builtinDoc = {
     },
     "description": "`lhsdesign(n,p)` returns an `n`-by-`p` Latin hypercube design with one sample in each stratum of every column.",
     "behaviors": [
-        "`n` and `p` must be positive integer scalars.",
+        "`n` and `p` must be positive integer-valued single or double scalars in MATLAB-compatible mode; native typed-integer dimensions are a RunMat extension and decode exactly.",
         "`\"Smooth\",\"on\"` jitters points uniformly within each stratum. `\"Smooth\",\"off\"` places points at stratum midpoints.",
         "`\"Criterion\"` supports `\"maximin\"`, `\"correlation\"`, and `\"none\"`; the correlation criterion uses midpoint strata, matching MATLAB's discrete correlation-optimized design behavior.",
         "`\"Iterations\",k` generates multiple candidate designs for optimized criteria and keeps the best scored candidate.",
-        "The result uses column-major `n`-by-`p` shape and values in the open interval `(0,1)`."
+        "The result uses column-major `n`-by-`p` shape and values in the open interval `(0,1)`.",
+        "Native typed-integer Iterations and Smooth controls are separately gated RunMat extensions.",
+        "Interactive gpuArray input is a RunMat-only host-fallback extension. Automatic internal residency may gather transparently without changing compatibility admission."
     ],
     "examples": [
         {

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

@@ -1 +1 @@
-{"version":3,"file":"lhsdesign.js","sourceRoot":"","sources":["../../../src/generated/builtins/lhsdesign.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,WAAW;IACpB,UAAU,EAAE,cAAc;IAC1B,UAAU,EAAE;QACV,WAAW;QACX,iBAAiB;QACjB,uBAAuB;QACvB,QAAQ;QACR,YAAY;KACb;IACD,SAAS,EAAE,0CAA0C;IACrD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uFAAuF;KACjG;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,2CAA2C;QACnD,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,gHAAgH;IAC/H,WAAW,EAAE;QACX,+CAA+C;QAC/C,4HAA4H;QAC5H,8LAA8L;QAC9L,qHAAqH;QACrH,wFAAwF;KACzF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wBAAwB;YACvC,OAAO,EAAE,sBAAsB;SAChC;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,+FAA+F;SACzG;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,iGAAiG;SAC5G;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,cAAc;SACtB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,cAAc;SACtB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,gEAAgE;QACzE,KAAK,EAAE,6GAA6G;KACrH;IACD,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,WAAW;IACnB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"lhsdesign.js","sourceRoot":"","sources":["../../../src/generated/builtins/lhsdesign.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,WAAW;IACpB,UAAU,EAAE,cAAc;IAC1B,UAAU,EAAE;QACV,WAAW;QACX,iBAAiB;QACjB,uBAAuB;QACvB,QAAQ;QACR,YAAY;KACb;IACD,SAAS,EAAE,0CAA0C;IACrD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uFAAuF;KACjG;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,2CAA2C;QACnD,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,gHAAgH;IAC/H,WAAW,EAAE;QACX,4KAA4K;QAC5K,4HAA4H;QAC5H,8LAA8L;QAC9L,qHAAqH;QACrH,wFAAwF;QACxF,6FAA6F;QAC7F,sKAAsK;KACvK;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wBAAwB;YACvC,OAAO,EAAE,sBAAsB;SAChC;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,+FAA+F;SACzG;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,iGAAiG;SAC5G;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,cAAc;SACtB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,cAAc;SACtB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,gEAAgE;QACzE,KAAK,EAAE,6GAA6G;KACrH;IACD,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,WAAW;IACnB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/limit.js

@@ -31,7 +31,8 @@ const builtinDoc = {
     },
     "description": "`limit` evaluates scalar symbolic expressions at a finite numeric point. It first performs direct substitution and simplification, then applies repeated L'Hopital reduction for removable `0/0` quotients.",
     "behaviors": [
-        "Supports `limit(expr)`, `limit(expr, point)`, `limit(expr, var)`, `limit(expr, var, point)`, and an optional direction string.",
+        "Supports `limit(expr)`, `limit(expr, point)`, `limit(expr, var)`, `limit(expr, var, point)`, and an optional direction string. MATLAB-compatible calls require a symbolic expression; RunMat mode independently admits scalar numeric expressions.",
+        "All eight integer classes are accepted for a numeric limit point and, in RunMat mode, a numeric expression. Native storage is read directly and values that cannot enter the current binary64 symbolic core exactly are rejected before substitution.",
         "Infers the limit variable when the expression contains exactly one symbolic variable.",
         "Simplifies symbolic arithmetic involving `+`, `-`, `*`, `/`, powers with numeric exponents, and the functions `sin`, `cos`, `tan`, `exp`, `log`, and `sqrt`.",
         "Returns scalar symbolic values, including symbolic constants when the limit simplifies to a finite value.",

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

@@ -1 +1 @@
-{"version":3,"file":"limit.js","sourceRoot":"","sources":["../../../src/generated/builtins/limit.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,OAAO;QACP,UAAU;QACV,UAAU;QACV,UAAU;KACX;IACD,SAAS,EAAE,0EAA0E;IACrF,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,2EAA2E;KACrF;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,iFAAiF;QAChG,kBAAkB,EAAE,yFAAyF;KAC9G;IACD,aAAa,EAAE,6MAA6M;IAC5N,WAAW,EAAE;QACX,gIAAgI;QAChI,uFAAuF;QACvF,8JAA8J;QAC9J,2GAA2G;QAC3G,8FAA8F;KAC/F;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oBAAoB;YACnC,OAAO,EAAE,mCAAmC;SAC7C;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,kDAAkD;SAC5D;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,mDAAmD;SAC7D;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,wDAAwD;YACpE,QAAQ,EAAE,oHAAoH;SAC/H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;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,OAAO;IACd,MAAM,EAAE,OAAO;IACf,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"limit.js","sourceRoot":"","sources":["../../../src/generated/builtins/limit.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,OAAO;QACP,UAAU;QACV,UAAU;QACV,UAAU;KACX;IACD,SAAS,EAAE,0EAA0E;IACrF,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,2EAA2E;KACrF;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,iFAAiF;QAChG,kBAAkB,EAAE,yFAAyF;KAC9G;IACD,aAAa,EAAE,6MAA6M;IAC5N,WAAW,EAAE;QACX,oPAAoP;QACpP,uPAAuP;QACvP,uFAAuF;QACvF,8JAA8J;QAC9J,2GAA2G;QAC3G,8FAA8F;KAC/F;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oBAAoB;YACnC,OAAO,EAAE,mCAAmC;SAC7C;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,kDAAkD;SAC5D;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,mDAAmD;SAC7D;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,wDAAwD;YACpE,QAAQ,EAAE,oHAAoH;SAC/H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;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,OAAO;IACd,MAAM,EAAE,OAAO;IACf,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/linkage.js

@@ -20,7 +20,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "GPU inputs are gathered to host. Hierarchical clustering runs on CPU."
+        "notes": "Interactive gpuArray input is a RunMat-only owning-provider host fallback. Automatic internal residency may gather transparently. Hierarchical clustering runs on CPU and returns a host tree."
     },
     "fusion": {
         "elementwise": false,
@@ -45,7 +45,8 @@ const builtinDoc = {
         "`linkage(X, method, {metric, parameter})` accepts a cell array of `pdist` inputs.",
         "`\"SaveMemory\",\"off\"` is accepted for source compatibility. `\"SaveMemory\",\"on\"` is accepted for observation-matrix input with centroid, median, or ward linkage and Euclidean distance; RunMat uses the same bounded in-memory implementation for both values.",
         "The current exact agglomerative implementation is bounded to 700 observations to avoid unbounded CPU and memory use.",
-        "The first two columns of `Z` contain one-based cluster identifiers. Original observations are numbered `1:m`; newly formed clusters are numbered `m+1`, `m+2`, and so on. The third column contains the linkage distance for each merge."
+        "The first two columns of `Z` contain one-based cluster identifiers. Original observations are numbered `1:m`; newly formed clusters are numbered `m+1`, `m+2`, and so on. The third column contains the linkage distance for each merge.",
+        "Typed-integer observations, condensed distances, and numeric distance parameters are separately gated RunMat extensions and must be exactly representable at the binary64 clustering boundary."
     ],
     "examples": [
         {

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

@@ -1 +1 @@
-{"version":3,"file":"linkage.js","sourceRoot":"","sources":["../../../src/generated/builtins/linkage.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,SAAS;QACT,cAAc;QACd,SAAS;QACT,YAAY;QACZ,YAAY;QACZ,YAAY;QACZ,kBAAkB;KACnB;IACD,SAAS,EAAE,yDAAyD;IACpE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uEAAuE;KACjF;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,qCAAqC;QAC7C,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,6MAA6M;IAC5N,WAAW,EAAE;QACX,+KAA+K;QAC/K,+FAA+F;QAC/F,2CAA2C;QAC3C,6CAA6C;QAC7C,uOAAuO;QACvO,iIAAiI;QACjI,kHAAkH;QAClH,mFAAmF;QACnF,uQAAuQ;QACvQ,sHAAsH;QACtH,0OAA0O;KAC3O;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,0BAA0B;YACzC,OAAO,EAAE,uDAAuD;YAChE,QAAQ,EAAE,oFAAoF;SAC/F;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,kDAAkD;YAC3D,QAAQ,EAAE,4DAA4D;SACvE;QACD;YACE,aAAa,EAAE,oBAAoB;YACnC,OAAO,EAAE,4CAA4C;YACrD,QAAQ,EAAE,0EAA0E;SACrF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,6HAA6H;SACxI;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,gGAAgG;SAC3G;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,cAAc;SACtB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,0DAA0D;QACnE,KAAK,EAAE,uGAAuG;KAC/G;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,IAAI;KACL;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"linkage.js","sourceRoot":"","sources":["../../../src/generated/builtins/linkage.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,SAAS;QACT,cAAc;QACd,SAAS;QACT,YAAY;QACZ,YAAY;QACZ,YAAY;QACZ,kBAAkB;KACnB;IACD,SAAS,EAAE,yDAAyD;IACpE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,gMAAgM;KAC1M;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,qCAAqC;QAC7C,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,6MAA6M;IAC5N,WAAW,EAAE;QACX,+KAA+K;QAC/K,+FAA+F;QAC/F,2CAA2C;QAC3C,6CAA6C;QAC7C,uOAAuO;QACvO,iIAAiI;QACjI,kHAAkH;QAClH,mFAAmF;QACnF,uQAAuQ;QACvQ,sHAAsH;QACtH,0OAA0O;QAC1O,gMAAgM;KACjM;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,0BAA0B;YACzC,OAAO,EAAE,uDAAuD;YAChE,QAAQ,EAAE,oFAAoF;SAC/F;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,kDAAkD;YAC3D,QAAQ,EAAE,4DAA4D;SACvE;QACD;YACE,aAAa,EAAE,oBAAoB;YACnC,OAAO,EAAE,4CAA4C;YACrD,QAAQ,EAAE,0EAA0E;SACrF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,6HAA6H;SACxI;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,gGAAgG;SAC3G;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,cAAc;SACtB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,0DAA0D;QACnE,KAAK,EAAE,uGAAuG;KAC/G;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,IAAI;KACL;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/linprog.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "The solver runs on the host. GPU-resident numeric inputs are gathered before solving."
+        "notes": "The solver runs on the host. Automatically resident numeric inputs gather transparently; explicit gpuArray inputs are a gated RunMat extension."
     },
     "fusion": {
         "elementwise": false,
@@ -34,6 +34,8 @@ const builtinDoc = {
         "`f`, `b`, `beq`, `lb`, and `ub` must be numeric vectors with compatible lengths.",
         "`A` and `Aeq` must be numeric matrices with one column per element of `f`.",
         "`[]` may be passed for omitted optional `Aeq`, `beq`, `lb`, or `ub` arguments.",
+        "Typed-integer values in `f`, `A`, `b`, `Aeq`, `beq`, `lb`, or `ub` are role-specific RunMat extensions. Each value must be exactly representable as double before entering the host solver; otherwise the call errors instead of rounding silently.",
+        "Automatically resident inputs gather transparently for the host solver. Explicit `gpuArray` inputs are a RunMat extension and are rejected while strict compatibility mode disables extensions.",
         "`exitflag` is `1` when an optimum is found, `-2` when no feasible point is found, and `-3` when the objective is unbounded below.",
         "The fourth output is a struct with `iterations`, `algorithm`, `constrviolation`, and `message` fields.",
         "Advanced MATLAB options, algorithms, problem structs, and lambda outputs are intentionally unsupported in this initial implementation."
@@ -72,7 +74,11 @@ const builtinDoc = {
         },
         {
             "question": "Does linprog run on the GPU?",
-            "answer": "No. It gathers GPU-resident inputs and runs the active-set solve on the host."
+            "answer": "No. It gathers automatically resident inputs and runs the active-set solve on the host. Explicit `gpuArray` solver inputs are accepted only when RunMat extensions are enabled."
+        },
+        {
+            "question": "Can linprog accept integer arrays?",
+            "answer": "Only as gated RunMat extensions, independently for each solver role. Every integer value must be exactly representable in binary64; outputs remain double precision."
         }
     ],
     "links": [

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

@@ -1 +1 @@
-{"version":3,"file":"linprog.js","sourceRoot":"","sources":["../../../src/generated/builtins/linprog.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE;QACV,SAAS;QACT,oBAAoB;QACpB,cAAc;QACd,oBAAoB;QACpB,QAAQ;KACT;IACD,SAAS,EAAE,+GAA+G;IAC1H,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uFAAuF;KACjG;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,IAAI;KACpB;IACD,aAAa,EAAE,sPAAsP;IACrQ,WAAW,EAAE;QACX,kFAAkF;QAClF,4EAA4E;QAC5E,gFAAgF;QAChF,mIAAmI;QACnI,wGAAwG;QACxG,wIAAwI;KACzI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,+FAA+F;YACxG,QAAQ,EAAE,yDAAyD;SACpE;QACD;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,2GAA2G;YACpH,QAAQ,EAAE,qCAAqC;SAChD;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,8EAA8E;YACvF,QAAQ,EAAE,yDAAyD;SACpE;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,2HAA2H;YACpI,QAAQ,EAAE,iEAAiE;SAC5E;QACD;YACE,aAAa,EAAE,2BAA2B;YAC1C,OAAO,EAAE,2EAA2E;YACpF,QAAQ,EAAE,oBAAoB;SAC/B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,8DAA8D;YAC1E,QAAQ,EAAE,iFAAiF;SAC5F;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,+EAA+E;SAC1F;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,4DAA4D;QACrE,KAAK,EAAE,yGAAyG;KACjH;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"linprog.js","sourceRoot":"","sources":["../../../src/generated/builtins/linprog.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE;QACV,SAAS;QACT,oBAAoB;QACpB,cAAc;QACd,oBAAoB;QACpB,QAAQ;KACT;IACD,SAAS,EAAE,+GAA+G;IAC1H,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,iJAAiJ;KAC3J;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,uCAAuC;QAC/C,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,sPAAsP;IACrQ,WAAW,EAAE;QACX,kFAAkF;QAClF,4EAA4E;QAC5E,gFAAgF;QAChF,qPAAqP;QACrP,iMAAiM;QACjM,mIAAmI;QACnI,wGAAwG;QACxG,wIAAwI;KACzI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,+FAA+F;YACxG,QAAQ,EAAE,yDAAyD;SACpE;QACD;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,2GAA2G;YACpH,QAAQ,EAAE,qCAAqC;SAChD;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,8EAA8E;YACvF,QAAQ,EAAE,yDAAyD;SACpE;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,2HAA2H;YACpI,QAAQ,EAAE,iEAAiE;SAC5E;QACD;YACE,aAAa,EAAE,2BAA2B;YAC1C,OAAO,EAAE,2EAA2E;YACpF,QAAQ,EAAE,oBAAoB;SAC/B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,8DAA8D;YAC1E,QAAQ,EAAE,iFAAiF;SAC5F;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,iLAAiL;SAC5L;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,sKAAsK;SACjL;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,4DAA4D;QACrE,KAAK,EAAE,yGAAyG;KACjH;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/linsolve.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "Prefers the accel provider's linsolve hook; the current WGPU backend downloads operands to the host, runs the shared solver, then re-uploads the result to preserve GPU residency."
+        "notes": "Prefers the exact owner's `linsolve` hook. WGPU has selected real F32 triangular, transpose, positive-definite, square, and rectangular paths; unsupported cases gather to the shared host solver."
     },
     "fusion": {
         "elementwise": false,
@@ -33,14 +33,15 @@ const builtinDoc = {
         "gpu": "builtins::math::linalg::solve::linsolve::tests::gpu_round_trip_matches_cpu",
         "wgpu": "builtins::math::linalg::solve::linsolve::tests::wgpu_round_trip_matches_cpu"
     },
-    "description": "`X = linsolve(A, B)` solves `A * X = B`. Optional `opts` structural hints (triangular, symmetric, positive-definite, transposed forms) follow MATLAB semantics and can select faster solve paths.",
+    "description": "`X = linsolve(A, B)` solves `A * X = B`. The implemented `opts` surface supports triangular, rectangular, symmetric, positive-definite, and transpose controls, with the extension boundaries described below.",
     "behaviors": [
         "Inputs must behave like 2-D matrices (trailing singleton dimensions are accepted). `size(A, 1)` must match `size(B, 1)` after accounting for `opts.TRANSA`.",
         "When `opts.LT` or `opts.UT` are supplied, `linsolve` performs forward/back substitution instead of a full factorization. Singular pivots trigger the MATLAB error `\"linsolve: matrix is singular to working precision.\"`",
-        "`opts.TRANSA = 'T'` or `'C'` solves `Aᵀ * X = B` (conjugate transpose for complex matrices).",
-        "`opts.POSDEF` and `opts.SYM` are accepted for compatibility; the current implementation still falls back to the SVD-based dense solver when a specialised route is not yet wired in.",
-        "The optional second output `[X, rcond_est] = linsolve(...)` (exposed via the VM multi-output path) returns the estimated reciprocal condition number used to honour `opts.RCOND`.",
-        "Logical and integer inputs are promoted to double precision. Complex inputs are handled in complex arithmetic."
+        "A logical `opts.TRANSA` is supported in compatibility mode (`false` means no transpose and `true` means conjugate transpose). Text values `'N'`, `'T'`, and `'C'` are a RunMat-only extension.",
+        "`opts.POSDEF`, `opts.SYM`, and `opts.RECT` are parsed and forwarded to acceleration providers. On the host, general non-triangular cases currently use the shared SVD-based dense solver rather than specialised structural algorithms.",
+        "For a square system, the optional second output is a reciprocal condition estimate. For a rectangular system, the second output is the estimated rank.",
+        "Logical and integer coefficient inputs are RunMat-only extensions and are promoted to double; integer values must be exactly representable in binary64. Complex floating inputs use complex arithmetic, while typed complex-integer inputs are rejected.",
+        "Typed-integer values for `LT`, `UT`, `RECT`, `SYM`, and `POSDEF`, the `RCOND` option, and two-output calls with explicit `gpuArray` operands are RunMat-only extensions."
     ],
     "examples": [
         {
@@ -64,7 +65,7 @@ const builtinDoc = {
             "output": "x =\n   2.0000 + 0.0000i\n   1.7500 + 0.8750i"
         },
         {
-            "description": "Estimating the reciprocal condition number",
+            "description": "Estimating the reciprocal condition number for a square system",
             "input": "A = [1 1; 1 1+1e-12];\nb = [2; 2+1e-12];\n[x, rcond_est] = linsolve(A, b)",
             "output": "x =\n     1\n     1\n\nrcond_est =\n    4.4409e-12"
         }
@@ -76,15 +77,15 @@ const builtinDoc = {
         },
         {
             "question": "Does `opts.TRANSA` accept lowercase characters?",
-            "answer": "Yes. `opts.TRANSA` is case-insensitive and accepts `'N'`, `'T'`, `'C'`, or their lowercase variants. `'C'` and `'T'` are equivalent for real matrices; `'C'` takes the conjugate transpose for complex matrices (mirroring MATLAB)."
+            "answer": "In RunMat extension mode, text values are case-insensitive and accept `'N'`, `'T'`, or `'C'`. In compatibility mode, use a logical scalar: `false` selects no transpose and `true` selects conjugate transpose."
         },
         {
             "question": "How is `opts.RCOND` used?",
-            "answer": "`opts.RCOND` provides a lower bound on the acceptable reciprocal condition number. If the estimated `rcond` falls below the requested threshold the builtin raises `\"linsolve: matrix is singular to working precision.\"`"
+            "answer": "In RunMat extension mode, `opts.RCOND` provides a non-negative lower bound on the acceptable reciprocal condition estimate. If the estimate falls below it, the builtin raises `\"linsolve: matrix is singular to working precision.\"` Compatibility mode rejects this option."
         },
         {
             "question": "Do `opts.SYM` or `opts.POSDEF` change the algorithm today?",
-            "answer": "They are accepted for MATLAB compatibility. The current implementation still uses the dense SVD solver when no specialised routine is wired in; future work will route positive-definite systems to Cholesky-based kernels."
+            "answer": "They are parsed and forwarded to providers. The host path currently uses the general dense SVD solver for non-triangular systems, so these hints do not select specialised host algorithms. WGPU implements a selected real F32 positive-definite path; support for other cases remains provider-specific."
         },
         {
             "question": "Can I use higher-dimensional arrays?",
@@ -149,9 +150,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/math/linalg/solve/linsolve.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/solve/linsolve.rs"
     },
-    "gpu_residency": "No additional residency management is required. When both operands already reside on the GPU, RunMat executes the provider's `linsolve` hook. The current WGPU backend gathers the data to the host, runs the shared solver, and re-uploads the output automatically, so downstream GPU work keeps its residency. Providers that implement an on-device kernel can execute entirely on the GPU without any MATLAB-level changes.",
+    "gpu_residency": "No additional residency management is required for supported real matrix operands. RunMat selects the exact provider that owns the first resident operand and requires every other resident operand to have that same owner. It validates provider results and preserves explicit or automatic provenance. If the provider declines the solve, or if the operands are complex or scalar, RunMat gathers through the normal host path; that fallback returns a host value rather than automatically re-uploading it.",
     "gpu_behavior": [
-        "When a gpuArray provider is active, RunMat offers the solve to its `linsolve` hook. The current WGPU backend downloads the operands to the host, executes the shared CPU solver, and uploads the result back to the device so downstream kernels retain their residency. If no provider is registered—or a provider declines the hook—RunMat gathers inputs to the host and returns a host tensor."
+        "For eligible real matrix operands, RunMat offers the solve to the exact owner's `linsolve` hook and validates that the returned solution is non-aliased, real, floating, correctly shaped, on the expected device, and owned by that provider. WGPU supports selected real F32 triangular, transpose, positive-definite, square, and rectangular routes. Provider-declined, complex, scalar, or otherwise unsupported cases gather to the shared host solver and return a host result. Explicit-GPU two-output calls are available only in RunMat extension mode."
     ],
     "key": "linsolve",
     "slug": "linsolve",

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

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

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

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

package/dist/generated/builtins/linspace.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "Uses provider `linspace` hooks when available (implemented by the WGPU backend); otherwise falls back to uploading a host-generated sequence to keep residency intact."
+        "notes": "Uses the exact owning provider's `linspace` hook when available; otherwise generates on the host and restores the result to that owner when the provider can represent the output class."
     },
     "fusion": {
         "elementwise": false,
@@ -36,12 +36,13 @@ const builtinDoc = {
     "description": "`linspace(a, b, n)` returns `n` linearly spaced points between `a` and `b`, inclusive. Default point count and row-vector output behavior follow MATLAB semantics.",
     "behaviors": [
         "`linspace(a, b)` is equivalent to `linspace(a, b, 100)`.",
-        "`linspace(a, b, 0)` returns a `1×0` empty double row vector.",
+        "`linspace(a, b, 0)` returns a `1×0` empty row vector whose floating class follows the endpoints.",
         "`linspace(a, b, 1)` returns `b`.",
         "`linspace(a, b, 2)` returns `[a b]`.",
         "Complex end points are supported; the real and imaginary parts are interpolated independently.",
-        "Inputs may be scalars, `1×1` tensors, or GPU scalars (`gpuArray` handles).",
-        "The third argument must be a finite, non-negative integer."
+        "Endpoints may be single- or double-precision scalars, `1×1` tensors, or GPU scalars; integer and logical endpoints are rejected.",
+        "The third argument may be a floating scalar or any of the eight integer classes. Finite floating counts are floored, non-positive counts produce an empty row vector, and infinite or platform-oversized counts raise an error.",
+        "A `NaN` count produces a `1×1` row vector containing `NaN`."
     ],
     "examples": [
         {
@@ -76,11 +77,11 @@ const builtinDoc = {
         },
         {
             "question": "Can I request zero points?",
-            "answer": "Yes. `linspace(a, b, 0)` returns a `1×0` empty row vector."
+            "answer": "Yes. Zero and negative counts return a `1×0` empty row vector."
         },
         {
             "question": "Does the third argument need to be an integer?",
-            "answer": "Yes. Non-integer or negative counts raise an error, just like MATLAB."
+            "answer": "No. RunMat floors a finite floating count, accepts exact scalar counts from every integer class, and maps non-positive counts to an empty result. Infinite and platform-oversized counts raise an error."
         },
         {
             "question": "Does `linspace` support complex inputs?",
@@ -92,11 +93,11 @@ const builtinDoc = {
         },
         {
             "question": "Can I pass GPU scalars?",
-            "answer": "Yes. GPU endpoints are gathered once to compute the sequence. The result stays on the GPU as long as a provider is available and the endpoints are real."
+            "answer": "Yes. RunMat reads each endpoint through its exact owning provider. Real sequences use that provider's `linspace` hook when available; host-generated real or complex results are restored to the owner when it can represent the output class. Endpoints owned by different devices are rejected."
         },
         {
             "question": "What precision is used?",
-            "answer": "RunMat mirrors MATLAB and returns double-precision vectors. Providers may choose to specialise future hooks for other precisions."
+            "answer": "Double endpoints produce double output. If either endpoint is single precision, RunMat produces single output; a provider must support that precision to keep a restored result resident."
         },
         {
             "question": "How does `linspace` differ from the colon operator?",
@@ -124,7 +125,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I use linspace with GPU arrays in RunMat?",
-            "answer": "Yes. Pass GPU scalars to `linspace` and the result will be a GPU-resident array, avoiding unnecessary host-device transfers."
+            "answer": "Yes. Pass compatible GPU scalars from one device. RunMat preserves their owning provider and provenance, using direct generation or one host-generation-and-restore fallback when possible."
         }
     ],
     "links": [
@@ -201,9 +202,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/array/creation/linspace.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/creation/linspace.rs"
     },
-    "gpu_residency": "You usually do **not** need to call `gpuArray` yourself in RunMat. When either endpoint already resides on the GPU, RunMat keeps the generated sequence on the device to preserve residency for downstream operations. When the active provider implements the dedicated `linspace` hook (the WGPU backend does), the sequence is generated directly on-device. If no acceleration provider is registered, or if a provider lacks the hook, the runtime emits the values on the host and uploads them once, preserving correctness with a modest transfer.",
+    "gpu_residency": "You usually do **not** need to call `gpuArray` yourself in RunMat. A resident endpoint selects its exact owning provider; endpoints from different devices are rejected. The runtime prefers that owner's `linspace` hook for real sequences. If direct generation is unavailable, it generates on the host and restores the result to the same owner when the provider supports the required real or complex class and precision; otherwise the correctly typed result remains on the host.",
     "gpu_behavior": [
-        "If either endpoint is already resident on the GPU, RunMat keeps the result on the device whenever the active acceleration provider supports uploading host buffers. Providers may additionally implement the optional `linspace` hook to generate the sequence entirely on device. Until then, RunMat generates the sequence on the host and performs a single upload so downstream kernels can consume the GPU data without extra gathers."
+        "GPU endpoints are downloaded only through their exact owner. For real output, RunMat first offers generation to that owner's `linspace` hook and validates the returned handle's shape, device, owner, precision, and non-aliasing. Otherwise it generates on the host and restores the result to the source owner when representable, preserving explicit or automatic provenance; complex output follows the same gather-and-restore rule."
     ],
     "key": "linspace",
     "slug": "linspace",

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

@@ -1 +1 @@
-{"version":3,"file":"linspace.js","sourceRoot":"","sources":["../../../src/generated/builtins/linspace.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"linspace.js","sourceRoot":"","sources":["../../../src/generated/builtins/linspace.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,UAAU;QACV,OAAO;QACP,QAAQ;QACR,KAAK;QACL,UAAU;KACX;IACD,SAAS,EAAE,4DAA4D;IACvE,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,0LAA0L;KACpM;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,4CAA4C;QACpD,aAAa,EAAE,oEAAoE;QACnF,MAAM,EAAE,uEAAuE;KAChF;IACD,aAAa,EAAE,oKAAoK;IACnL,WAAW,EAAE;QACX,0DAA0D;QAC1D,kGAAkG;QAClG,kCAAkC;QAClC,sCAAsC;QACtC,gGAAgG;QAChG,kIAAkI;QAClI,iOAAiO;QACjO,6DAA6D;KAC9D;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,uBAAuB;YAChC,QAAQ,EAAE,uEAAuE;SAClF;QACD;YACE,aAAa,EAAE,wDAAwD;YACvE,OAAO,EAAE,uBAAuB;YAChC,QAAQ,EAAE,yEAAyE;SACpF;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,8BAA8B;YACvC,QAAQ,EAAE,sFAAsF;SACjG;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,yFAAyF;YAClG,QAAQ,EAAE,uGAAuG;SAClH;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,0EAA0E;SACrF;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,2GAA2G;SACtH;QACD;YACE,UAAU,EAAE,4BAA4B;YACxC,QAAQ,EAAE,gEAAgE;SAC3E;QACD;YACE,UAAU,EAAE,gDAAgD;YAC5D,QAAQ,EAAE,0MAA0M;SACrN;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,+HAA+H;SAC1I;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,+HAA+H;SAC1I;QACD;YACE,UAAU,EAAE,yBAAyB;YACrC,QAAQ,EAAE,mSAAmS;SAC9S;QACD;YACE,UAAU,EAAE,yBAAyB;YACrC,QAAQ,EAAE,2LAA2L;SACtM;QACD;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,6HAA6H;SACxI;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,2FAA2F;SACtG;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,yIAAyI;SACpJ;QACD;YACE,UAAU,EAAE,oDAAoD;YAChE,QAAQ,EAAE,sLAAsL;SACjM;QACD;YACE,UAAU,EAAE,6DAA6D;YACzE,QAAQ,EAAE,gHAAgH;SAC3H;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,wGAAwG;SACnH;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,6LAA6L;SACxM;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,KAAK;YACd,KAAK,EAAE,OAAO;SACf;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,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,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,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,eAAe,EAAE,8dAA8d;IAC/e,cAAc,EAAE;QACd,8aAA8a;KAC/a;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/load.js

@@ -40,7 +40,7 @@ const builtinDoc = {
         "`load(filename, 'A', 'B')` restricts the operation to the listed variable names. String scalars, char vectors, string arrays, or cell arrays of character vectors are accepted.",
         "`load(filename, '-regexp', '^foo', 'bar$')` selects variables whose names match any of the supplied regular expressions.",
         "Repeated names are deduplicated so that the last occurrence wins, mirroring MATLAB's behavior.",
-        "Unsupported data classes trigger descriptive errors. RunMat supports Level-5 double and complex numeric arrays, supported scalar integer classes, single/uint8/uint16 tensors, logical arrays, character arrays, string arrays (stored as cell-of-char data), scalar structs, real sparse matrices, RunMat object envelopes, and cells whose elements are composed of the supported types.",
+        "Unsupported data classes trigger descriptive errors. RunMat supports Level-5 double and single real/complex arrays, all eight native integer scalar and tensor classes, paired complex-integer components, logical arrays, character arrays, string arrays (stored as cell-of-char data), scalar structs, typed real sparse matrices, RunMat object envelopes, and cells whose elements are composed of the supported types. Integer class tags reconstruct authoritative native storage.",
         "Little-endian, big-endian, and compressed (`miCOMPRESSED`) Level-5 MAT-files are supported. MATLAB v7.3 MAT-files are HDF5-backed and currently report an explicit unsupported-version error."
     ],
     "examples": [
@@ -76,7 +76,7 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "Does `load` support ASCII text files?",
-            "answer": "No. RunMat (like MATLAB) restricts the `load` builtin in modern releases to MAT-files. Text and delimited files should be read using `readmatrix`, `readtable`, or other file I/O utilities such as `fileread`."
+            "answer": "RunMat currently reads Level-5 MAT-files only. MATLAB also documents `load(filename,\"-ascii\")` and automatic ASCII loading for non-MAT extensions, so ASCII input remains an explicit general RunMat coverage gap; use `readmatrix`, `readtable`, or other text I/O utilities today."
         },
         {
             "question": "How are structures handled?",

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

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

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

@@ -1 +1 @@
-{"version":3,"file":"loadobj.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/loadobj.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpD,QAAA,MAAM,UAAU,EAAE,UA4FjB,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"loadobj.d.ts","sourceRoot":"","sources":["../../../src/generated/builtins/loadobj.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/loadobj.js

@@ -35,7 +35,8 @@ const builtinDoc = {
         "RunMat recognizes object envelopes written by `save` and restores their payloads recursively.",
         "If the saved class registers `Class.loadobj`, that method receives the restored payload and its return value becomes the loaded variable.",
         "If no registered `loadobj` method exists and the payload is a scalar struct, RunMat reconstructs an object with the saved class name and payload fields as properties.",
-        "Plain non-envelope inputs pass through recursive struct/cell restoration unchanged.",
+        "In RunMat mode, plain non-envelope scalar and cell inputs pass through recursive restoration unchanged; MATLAB-compatible modes reject this undocumented convenience through the `loadobj-plain-payload-passthrough` compatibility gate.",
+        "All eight integer classes nested in object or structure payloads retain their exact values, shape, signedness, and width through recursive restoration and class-specific `loadobj` dispatch.",
         "Recursion is bounded and reports `RunMat:ObjectSerialization:RecursionLimit` for cyclic or excessively nested payloads."
     ],
     "examples": [

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

@@ -1 +1 @@
-{"version":3,"file":"loadobj.js","sourceRoot":"","sources":["../../../src/generated/builtins/loadobj.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,SAAS;QACT,SAAS;QACT,sBAAsB;QACtB,KAAK;QACL,UAAU;KACX;IACD,SAAS,EAAE,6DAA6D;IACxE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,iIAAiI;KAC3I;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,sDAAsD;QAC9D,aAAa,EAAE,4EAA4E;KAC5F;IACD,aAAa,EAAE,4PAA4P;IAC3Q,WAAW,EAAE;QACX,2CAA2C;QAC3C,+FAA+F;QAC/F,2IAA2I;QAC3I,wKAAwK;QACxK,qFAAqF;QACrF,yHAAyH;KAC1H;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,wEAAwE;SAClF;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,0EAA0E;SACpF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,wJAAwJ;SACnK;QACD;YACE,UAAU,EAAE,yDAAyD;YACrE,QAAQ,EAAE,iKAAiK;SAC5K;QACD;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,yMAAyM;SACpN;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,4EAA4E;QACrF,KAAK,EAAE,yHAAyH;KACjI;IACD,eAAe,EAAE,wIAAwI;IACzJ,cAAc,EAAE;QACd,6CAA6C;QAC7C,mEAAmE;KACpE;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,KAAK;QACL,eAAe;KAChB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"loadobj.js","sourceRoot":"","sources":["../../../src/generated/builtins/loadobj.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,SAAS;QACT,SAAS;QACT,sBAAsB;QACtB,KAAK;QACL,UAAU;KACX;IACD,SAAS,EAAE,6DAA6D;IACxE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,iIAAiI;KAC3I;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,sDAAsD;QAC9D,aAAa,EAAE,4EAA4E;KAC5F;IACD,aAAa,EAAE,4PAA4P;IAC3Q,WAAW,EAAE;QACX,2CAA2C;QAC3C,+FAA+F;QAC/F,2IAA2I;QAC3I,wKAAwK;QACxK,0OAA0O;QAC1O,+LAA+L;QAC/L,yHAAyH;KAC1H;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,wEAAwE;SAClF;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,0EAA0E;SACpF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,wJAAwJ;SACnK;QACD;YACE,UAAU,EAAE,yDAAyD;YACrE,QAAQ,EAAE,iKAAiK;SAC5K;QACD;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,yMAAyM;SACpN;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,4EAA4E;QACrF,KAAK,EAAE,yHAAyH;KACjI;IACD,eAAe,EAAE,wIAAwI;IACzJ,cAAc,EAAE;QACd,6CAA6C;QAC7C,mEAAmE;KACpE;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,KAAK;QACL,eAAe;KAChB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/log.js

@@ -19,12 +19,12 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "Falls back to the host implementation when the provider lacks unary_log or when the result requires complex values."
+        "notes": "Uses `reduce_min` plus `unary_log` for resident real data when possible; otherwise computes on the host and restores the result to the exact owner when representable."
     },
     "fusion": {
-        "elementwise": true,
+        "elementwise": false,
         "reduction": false,
-        "max_inputs": 1,
+        "max_inputs": 0,
         "constants": "inline"
     },
     "requires_feature": null,
@@ -33,11 +33,12 @@ const builtinDoc = {
         "integration": "builtins::math::elementwise::log::tests::log_gpu_provider_roundtrip",
         "gpu": "builtins::math::elementwise::log::tests::log_wgpu_matches_cpu_elementwise"
     },
-    "description": "`Y = log(X)` computes the natural logarithm of each element of `X`. Domain promotion to complex values and type handling follow MATLAB semantics.",
+    "description": "`Y = log(X)` computes the natural logarithm of each floating-point element of `X`, including principal-branch complex promotion. Integer, logical, character, and explicit-GPU real-to-complex forms are separately gated RunMat extensions.",
     "behaviors": [
         "`log(X)` applies the operation element-wise with MATLAB broadcasting rules.",
-        "Logical values convert to doubles (`true → 1.0`, `false → 0.0`) before the logarithm is taken.",
-        "Character arrays are interpreted as their numeric code points and return dense double tensors.",
+        "In RunMat extension mode, logical values convert to doubles (`true → 1.0`, `false → 0.0`) before the logarithm is taken; compatibility mode rejects this extension.",
+        "In RunMat extension mode, character arrays are interpreted as their numeric code points and return dense double tensors; compatibility mode rejects this extension.",
+        "Integer input is a RunMat-only extension. All eight integer classes are accepted only when every value is exactly representable in binary64, and the result is double or complex double.",
         "Negative real values produce complex results: `log([-1 1])` returns `[0 + iπ, 0]`.",
         "Complex inputs follow MATLAB's definition: `log(a + bi) = log(|a + bi|) + i·atan2(b, a)`.",
         "`log(0)` returns `-Inf`, matching MATLAB's handling of the logarithm singularity at zero."
@@ -69,7 +70,7 @@ const builtinDoc = {
             "output": "result = [0.0000 0.6931; 1.3863 2.0794]"
         },
         {
-            "description": "Logging character codes from a string",
+            "description": "Logging character codes",
             "input": "C = 'ABC';\nvalues = log(C)",
             "output": "values = [4.1744 4.1897 4.2047]"
         }
@@ -93,7 +94,7 @@ const builtinDoc = {
         },
         {
             "question": "Does the GPU implementation support complex outputs?",
-            "answer": "Providers currently operate on real buffers. When complex results are required, RunMat gathers data to the host to compute the exact result and keeps residency metadata consistent."
+            "answer": "The real provider hook cannot produce complex output. RunMat therefore gathers through the exact owner, computes the complex result on the host, and restores it to that owner when the provider can represent the complex class. Explicit `gpuArray` input requiring this extension is rejected in compatibility mode."
         },
         {
             "question": "Does `log` accept complex inputs directly?",
@@ -210,9 +211,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/math/elementwise/log.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/log.rs"
     },
-    "gpu_residency": "You typically do **not** need to call `gpuArray` yourself. The auto-offload planner tracks residency and keeps tensors on the GPU when profitable. When your expression produces complex results (e.g., negative inputs to `log`), RunMat will gather the data automatically and still return exactly the MATLAB-compatible output. You can force explicit residency with `gpuArray` and `gather` if you want to mirror MathWorks MATLAB workflows.",
+    "gpu_residency": "You typically do **not** need to call `gpuArray` yourself. RunMat resolves the exact provider that owns the input. Real data can remain resident through `reduce_min` and `unary_log`; integer, logical, complex, unsupported-hook, and real-to-complex paths gather through that owner and then restore the correctly typed result when the owner supports its class and precision. Explicit `gpuArray` input that requires real-to-complex promotion is a RunMat-only extension and is rejected in compatibility mode.",
     "gpu_behavior": [
-        "RunMat Accelerate keeps tensors on the GPU when the active provider implements `unary_log` *and* `reduce_min`. The runtime queries the device-side minimum to confirm that all values are non-negative, so positive datasets stay resident and can participate in fused elementwise kernels. When complex outputs are required or the provider cannot supply these hooks, RunMat gathers the tensor to the host, computes the exact MATLAB-compatible result (including complex promotion), updates residency metadata, and returns the host-resident value."
+        "RunMat Accelerate uses the exact owning provider's `reduce_min` to classify resident real data, then validates any `unary_log` output for non-aliasing, shape, device, owner, storage, and precision. When complex output or a fallback is required, it downloads through that owner, computes on the host, and restores the result to the same owner when representable while preserving provenance. `log` is intentionally excluded from fusion until fused execution can represent its complex-domain semantics."
     ],
     "key": "log",
     "slug": "log",

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

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

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

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