runmat 0.6.1-dev.1 → 0.6.2-dev.0

package/dist/generated/builtins/array2table.js

@@ -7,7 +7,8 @@ const builtinDoc = {
         "array2table",
         "table",
         "VariableNames",
-        "RowNames"
+        "RowNames",
+        "DimensionNames"
     ],
     "summary": "Convert an array into a table.",
     "gpu_support": {
@@ -28,10 +29,11 @@ const builtinDoc = {
         "unit": "builtins::table::tests",
         "integration": "crates/runmat-vm/tests/tables_timetables.rs"
     },
-    "description": "`array2table(A)` splits two-dimensional arrays into table variables by column.",
+    "description": "`array2table(A)` splits a homogeneous two-dimensional array into table variables by column. Native integer columns preserve the exact class and values of `A`.",
     "behaviors": [
         "Numeric, complex, logical, string, and cell arrays are split column-wise.",
-        "`\"VariableNames\"` and `\"RowNames\"` are supported."
+        "`\"VariableNames\"`, `\"RowNames\"`, and `\"DimensionNames\"` are supported. Current variable names may contain Unicode, spaces, and leading or trailing whitespace; row-name edge whitespace is removed.",
+        "Interactive resident GPU input is a mode-gated RunMat extension. It gathers exact typed storage before table construction and rejects in MATLAB-compatible mode."
     ],
     "examples": [
         {
@@ -51,8 +53,8 @@ const builtinDoc = {
         }
     ],
     "source": {
-        "label": "`crates/runmat-runtime/src/builtins/table/mod.rs`",
-        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/table/mod.rs"
+        "label": "`crates/runmat-runtime/src/builtins/table/builtins/conversions.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/table/builtins/conversions.rs"
     },
     "key": "array2table",
     "slug": "array2table",

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

@@ -1 +1 @@
-{"version":3,"file":"array2table.js","sourceRoot":"","sources":["../../../src/generated/builtins/array2table.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,aAAa;IACtB,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE;QACV,aAAa;QACb,OAAO;QACP,eAAe;QACf,UAAU;KACX;IACD,SAAS,EAAE,gCAAgC;IAC3C,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,mDAAmD;KAC7D;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,wBAAwB;QAChC,aAAa,EAAE,6CAA6C;KAC7D;IACD,aAAa,EAAE,gFAAgF;IAC/F,WAAW,EAAE;QACX,2EAA2E;QAC3E,uDAAuD;KACxD;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wBAAwB;YACvC,OAAO,EAAE,yDAAyD;YAClE,QAAQ,EAAE,eAAe;SAC1B;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,aAAa;YACtB,KAAK,EAAE,eAAe;SACvB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,mDAAmD;QAC5D,KAAK,EAAE,gGAAgG;KACxG;IACD,KAAK,EAAE,aAAa;IACpB,MAAM,EAAE,aAAa;IACrB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"array2table.js","sourceRoot":"","sources":["../../../src/generated/builtins/array2table.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,aAAa;IACtB,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE;QACV,aAAa;QACb,OAAO;QACP,eAAe;QACf,UAAU;QACV,gBAAgB;KACjB;IACD,SAAS,EAAE,gCAAgC;IAC3C,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,mDAAmD;KAC7D;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,wBAAwB;QAChC,aAAa,EAAE,6CAA6C;KAC7D;IACD,aAAa,EAAE,gKAAgK;IAC/K,WAAW,EAAE;QACX,2EAA2E;QAC3E,2MAA2M;QAC3M,kKAAkK;KACnK;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wBAAwB;YACvC,OAAO,EAAE,yDAAyD;YAClE,QAAQ,EAAE,eAAe;SAC1B;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,aAAa;YACtB,KAAK,EAAE,eAAe;SACvB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,oEAAoE;QAC7E,KAAK,EAAE,iHAAiH;KACzH;IACD,KAAK,EAAE,aAAa;IACpB,MAAM,EAAE,aAAa;IACrB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/array2timetable.js

@@ -5,9 +5,13 @@ const builtinDoc = {
     "category": "table",
     "keywords": [
         "array2timetable",
-        "array",
         "timetable",
-        "RowTimes"
+        "RowTimes",
+        "SampleRate",
+        "TimeStep",
+        "StartTime",
+        "VariableNames",
+        "DimensionNames"
     ],
     "summary": "Convert an array into a timetable.",
     "gpu_support": {
@@ -25,18 +29,21 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "builtins::table::tests"
+        "unit": "builtins::table::tests",
+        "integration": "crates/runmat-vm/tests/tables_timetables.rs"
     },
-    "description": "`array2timetable(A, 'RowTimes', times)` splits array columns into timetable variables.",
+    "description": "`array2timetable(X, timingName, timingValue)` splits a homogeneous two-dimensional array into timetable variables by column. Native integer columns preserve the exact class and values of `X`.",
     "behaviors": [
-        "`\"VariableNames\"`, `\"RowNames\"`, and `\"RowTimes\"` are supported.",
-        "If row times are omitted, sequential numeric row times are generated."
+        "Exactly one of `\"RowTimes\"`, `\"SampleRate\"`, or `\"TimeStep\"` is required. Explicit row times must be an M-by-1 datetime or duration vector.",
+        "`\"StartTime\"` applies to `\"SampleRate\"` and `\"TimeStep\"`; a calendar-duration step requires a datetime start. `\"VariableNames\"` and `\"DimensionNames\"` follow current table naming rules, while `\"RowNames\"` is not an `array2timetable` option.",
+        "All eight integer classes are preserved exactly when supplied as `X` and are accepted as positive scalar sample rates.",
+        "Interactive resident GPU arguments are mode-gated RunMat extensions. They gather exact typed storage before timetable construction and reject in MATLAB-compatible mode."
     ],
     "examples": [
         {
-            "description": "Array to timetable",
-            "input": "TT = array2timetable([10;20], 'RowTimes', [1;2])",
-            "output": "TT = timetable object"
+            "description": "Create a timetable at two samples per second",
+            "input": "TT = array2timetable(int16([10;20]), 'SampleRate', 2)",
+            "output": "TT = 2x1 timetable"
         }
     ],
     "links": [
@@ -50,8 +57,8 @@ const builtinDoc = {
         }
     ],
     "source": {
-        "label": "`crates/runmat-runtime/src/builtins/table/mod.rs`",
-        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/table/mod.rs"
+        "label": "`crates/runmat-runtime/src/builtins/table/builtins/timetable.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/table/builtins/timetable.rs"
     },
     "key": "array2timetable",
     "slug": "array2timetable",

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

@@ -1 +1 @@
-{"version":3,"file":"array2timetable.js","sourceRoot":"","sources":["../../../src/generated/builtins/array2timetable.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,iBAAiB;IAC1B,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE;QACV,iBAAiB;QACjB,OAAO;QACP,WAAW;QACX,UAAU;KACX;IACD,SAAS,EAAE,oCAAoC;IAC/C,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uDAAuD;KACjE;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,wBAAwB;KACjC;IACD,aAAa,EAAE,wFAAwF;IACvG,WAAW,EAAE;QACX,wEAAwE;QACxE,uEAAuE;KACxE;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oBAAoB;YACnC,OAAO,EAAE,kDAAkD;YAC3D,QAAQ,EAAE,uBAAuB;SAClC;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,aAAa;YACtB,KAAK,EAAE,eAAe;SACvB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,mDAAmD;QAC5D,KAAK,EAAE,gGAAgG;KACxG;IACD,KAAK,EAAE,iBAAiB;IACxB,MAAM,EAAE,iBAAiB;IACzB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"array2timetable.js","sourceRoot":"","sources":["../../../src/generated/builtins/array2timetable.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,iBAAiB;IAC1B,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE;QACV,iBAAiB;QACjB,WAAW;QACX,UAAU;QACV,YAAY;QACZ,UAAU;QACV,WAAW;QACX,eAAe;QACf,gBAAgB;KACjB;IACD,SAAS,EAAE,oCAAoC;IAC/C,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uDAAuD;KACjE;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,wBAAwB;QAChC,aAAa,EAAE,6CAA6C;KAC7D;IACD,aAAa,EAAE,iMAAiM;IAChN,WAAW,EAAE;QACX,mJAAmJ;QACnJ,8PAA8P;QAC9P,wHAAwH;QACxH,0KAA0K;KAC3K;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,uDAAuD;YAChE,QAAQ,EAAE,oBAAoB;SAC/B;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,aAAa;YACtB,KAAK,EAAE,eAAe;SACvB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,kEAAkE;QAC3E,KAAK,EAAE,+GAA+G;KACvH;IACD,KAAK,EAAE,iBAAiB;IACxB,MAAM,EAAE,iBAAiB;IACzB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/arrayDatastore.js

@@ -7,15 +7,17 @@ const builtinDoc = {
         "arrayDatastore",
         "datastore",
         "array",
-        "table"
+        "ReadSize",
+        "IterationDimension",
+        "OutputType"
     ],
-    "summary": "Create an array datastore descriptor object.",
+    "summary": "Create a datastore for an in-memory array.",
     "gpu_support": {
         "elementwise": false,
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Datastore descriptors are host metadata."
+        "notes": "Interactive resident input is a mode-gated RunMat extension that gathers before host datastore construction."
     },
     "fusion": {
         "elementwise": false,
@@ -28,15 +30,16 @@ const builtinDoc = {
         "unit": "builtins::table::tests",
         "integration": "crates/runmat-vm/tests/tables_timetables.rs"
     },
-    "description": "`arrayDatastore(A)` creates a descriptor object with `Data` and `ReadSize` properties.",
+    "description": "`arrayDatastore(A)` retains an in-memory array together with `ReadSize`, `IterationDimension`, and `OutputType` properties. Integer A remains in its exact native class.",
     "behaviors": [
-        "The constructor preserves the input data and `ReadSize` metadata for code that passes datastore descriptors around.",
-        "Iterator-style operations such as `read`, `hasdata`, and `reset` require the generic datastore dispatch layer and are not provided by this constructor builtin."
+        "`ReadSize` and `IterationDimension` must be positive integer-valued doubles; typed-integer controls reject. `OutputType` is `\"cell\"` or `\"same\"`, and `\"same\"` requires iteration dimension 1.",
+        "Interactive resident input is a mode-gated RunMat extension. It gathers exact typed storage before host object construction and rejects in MATLAB-compatible mode.",
+        "RunMat currently represents this as a value descriptor whose `Data` property exposes the retained payload. Stateful iterator operations such as `read`, `readall`, `preview`, `hasdata`, and `reset` require a datastore handle/dispatch layer and are not yet provided."
     ],
     "examples": [
         {
-            "description": "Create datastore",
-            "input": "ds = arrayDatastore([1;2])",
+            "description": "Retain typed data with explicit read properties",
+            "input": "ds = arrayDatastore(int16([1;2]), 'ReadSize', 2, 'OutputType', 'same')",
             "output": "ds = arrayDatastore object"
         }
     ],
@@ -47,8 +50,8 @@ const builtinDoc = {
         }
     ],
     "source": {
-        "label": "`crates/runmat-runtime/src/builtins/table/mod.rs`",
-        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/table/mod.rs"
+        "label": "`crates/runmat-runtime/src/builtins/table/builtins/constructors.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/table/builtins/constructors.rs"
     },
     "key": "arraydatastore",
     "slug": "arraydatastore",

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

@@ -1 +1 @@
-{"version":3,"file":"arrayDatastore.js","sourceRoot":"","sources":["../../../src/generated/builtins/arrayDatastore.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,gBAAgB;IACzB,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE;QACV,gBAAgB;QAChB,WAAW;QACX,OAAO;QACP,OAAO;KACR;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,0CAA0C;KACpD;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,wBAAwB;QAChC,aAAa,EAAE,6CAA6C;KAC7D;IACD,aAAa,EAAE,wFAAwF;IACvG,WAAW,EAAE;QACX,qHAAqH;QACrH,iKAAiK;KAClK;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,kBAAkB;YACjC,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,4BAA4B;SACvC;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,kBAAkB;YAC3B,KAAK,EAAE,oBAAoB;SAC5B;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,mDAAmD;QAC5D,KAAK,EAAE,gGAAgG;KACxG;IACD,KAAK,EAAE,gBAAgB;IACvB,MAAM,EAAE,gBAAgB;IACxB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,IAAI;QACJ,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"arrayDatastore.js","sourceRoot":"","sources":["../../../src/generated/builtins/arrayDatastore.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,gBAAgB;IACzB,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE;QACV,gBAAgB;QAChB,WAAW;QACX,OAAO;QACP,UAAU;QACV,oBAAoB;QACpB,YAAY;KACb;IACD,SAAS,EAAE,4CAA4C;IACvD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,8GAA8G;KACxH;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,wBAAwB;QAChC,aAAa,EAAE,6CAA6C;KAC7D;IACD,aAAa,EAAE,0KAA0K;IACzL,WAAW,EAAE;QACX,sMAAsM;QACtM,oKAAoK;QACpK,0QAA0Q;KAC3Q;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,iDAAiD;YAChE,OAAO,EAAE,wEAAwE;YACjF,QAAQ,EAAE,4BAA4B;SACvC;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,kBAAkB;YAC3B,KAAK,EAAE,oBAAoB;SAC5B;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,qEAAqE;QAC9E,KAAK,EAAE,kHAAkH;KAC1H;IACD,KAAK,EAAE,gBAAgB;IACvB,MAAM,EAAE,gBAAgB;IACxB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,IAAI;QACJ,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/arrayfun.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "Executes directly on the GPU for supported builtin callbacks (sin, cos, abs, exp, log, sqrt, plus, minus, times, rdivide, ldivide) when all inputs are gpuArray values; falls back to host execution for closures, heterogeneous inputs, or unsupported callbacks. Uniform numeric/logical outputs are re-uploaded to the GPU otherwise; complex/character outputs stay on the host."
+        "notes": "Executes directly on the GPU for supported floating builtin callbacks when all inputs are gpuArray values; otherwise gathers exact typed storage, evaluates on the host, and re-uploads uniform numeric or logical output. All eight resident integer classes retain exact input and output storage through fallback."
     },
     "fusion": {
         "elementwise": false,
@@ -32,14 +32,15 @@ const builtinDoc = {
         "unit": "builtins::acceleration::gpu::arrayfun::tests",
         "integration": "builtins::acceleration::gpu::arrayfun::tests::arrayfun_gpu_roundtrip"
     },
-    "description": "`arrayfun(func, A1, A2, ...)` evaluates `func` for each element (or element-wise tuple) of the supplied arrays. Inputs must share size (with scalar expansion), `'UniformOutput'` controls array-versus-cell output, and `'ErrorHandler'` provides MATLAB/RunMat-compatible fallback behavior.",
+    "description": "`arrayfun(func, A1, A2, ...)` evaluates a scalar callback for each element or element-wise tuple. Ordinary host inputs must have the same size; the documented gpuArray overload accepts compatible sizes. `UniformOutput` controls array-versus-cell collection, and `ErrorHandler` receives the documented identifier, message, and linear index when a callback fails.",
     "behaviors": [
-        "Accepts function handles, builtin names (character vectors or string scalars), and closures.",
-        "Supports additional scalar parameters: `arrayfun(@(x,c) x + c, A, 5)` passes `5` to every call.",
-        "Honors the `'UniformOutput'` and `'ErrorHandler'` name-value pairs for MATLAB-compatible control flow.",
-        "Handles numeric, logical, character, and complex arrays. Unsupported types raise a descriptive error instructing you to use `cellfun` when appropriate.",
+        "The documented callable form is a function handle. Character-vector and string-scalar callable names are a mode-gated RunMat extension.",
+        "Host arrays require equal sizes. Host scalar expansion is a mode-gated RunMat extension; gpuArray input follows the documented compatible-size expansion rule.",
+        "`UniformOutput` accepts logical true/false or double 1/0. Typed-integer controls reject. With uniform output, every callback or error-handler result must be scalar and retain one data type; all eight integer classes, native single, and complex single are collected without widening.",
+        "Host `UniformOutput` and `ErrorHandler` implement the documented single-output control flow. With gpuArray input these options are a mode-gated RunMat extension because the GPU overload exposes scalar uniform outputs only.",
+        "The current implementation handles numeric, logical, character, string, and complex arrays. Standard multiple-output callbacks and cell, struct, and user-object inputs remain general callback/container gaps.",
         "Empty inputs return empty outputs whose shape matches the first array argument.",
-        "When any input is a `gpuArray`, numeric or logical uniform outputs are uploaded back to the GPU so downstream code retains GPU residency. Complex or character uniform outputs remain on the host until providers add the appropriate buffer support. The current implementation computes on the host and therefore inherits the host's floating-point behaviour."
+        "When any input is a gpuArray, supported builtin callbacks may dispatch directly; otherwise authoritative typed inputs gather for callback evaluation and numeric or logical uniform outputs are uploaded back to the provider. Complex or character uniform outputs remain on the host."
     ],
     "examples": [
         {
@@ -48,8 +49,8 @@ const builtinDoc = {
             "output": "B =\n     1     4     9\n    16    25    36"
         },
         {
-            "description": "Passing additional scalar parameters",
-            "input": "A = [1 2 3];\noffset = 10;\nresult = arrayfun(@(x, c) x + c, A, offset)",
+            "description": "Passing equal-sized additional arrays",
+            "input": "A = [1 2 3];\noffset = [10 10 10];\nresult = arrayfun(@(x, c) x + c, A, offset)",
             "output": "result =\n    11    12    13"
         },
         {
@@ -75,7 +76,7 @@ const builtinDoc = {
         },
         {
             "question": "What happens when the callback returns mixed types?",
-            "answer": "Set `'UniformOutput', false` so the builtin returns a cell array. When `'UniformOutput'` is `true` every callback invocation must return a numeric, logical, or complex scalar."
+            "answer": "Set `'UniformOutput', false` so the builtin returns a cell array. When `'UniformOutput'` is true, every callback invocation must return a scalar of the same data type; RunMat rejects heterogeneous results instead of promoting them."
         },
         {
             "question": "Can `arrayfun` handle character inputs?",
@@ -122,7 +123,7 @@ const builtinDoc = {
     },
     "gpu_residency": "No. RunMat's auto-offload logic moves tensors to the GPU when profitable. If you do call `gpuArray`, `arrayfun` keeps the result on the GPU for uniform numeric or logical outputs so later operations can continue without gathering. Non-uniform or complex/character results stay on the host until GPU representations are available.",
     "gpu_behavior": [
-        "When every input is a `gpuArray`, `'UniformOutput'` is `true`, and the callback resolves to one of the supported builtins (`sin`, `cos`, `abs`, `exp`, `log`, `sqrt`, `plus`, `minus`, `times`, `rdivide`, or `ldivide`), RunMat bypasses the host path and dispatches directly to the active provider through the corresponding hooks (`unary_*` or `elem_*`). The builtin acts as a fusion barrier—the fusion planner lowers upstream producers before invoking `arrayfun` because the callback can evaluate arbitrary MATLAB code.\n\nAll other combinations—including closures, callbacks with extra scalar parameters, mixed residency, or `'UniformOutput', false`—gather inputs to the host, execute the callback element-wise, and then upload numeric or logical uniform results back to the GPU so later code continues with device residency. Complex and character uniform outputs remain host-resident until device representations are available. Cell outputs are always host-resident."
+        "When every input is a gpuArray, uniform output is implicit, and the callback resolves to one of the supported builtins (`sin`, `cos`, `abs`, `exp`, `log`, `sqrt`, `plus`, `minus`, `times`, `rdivide`, or `ldivide`), RunMat can dispatch directly through provider hooks. The builtin remains a fusion barrier because arbitrary callback code may execute. Other documented GPU forms use compatible-size typed gather fallback and re-upload uniform numeric or logical results, including exact integer classes. GPU options, host scalar expansion, and text callables are separately mode-gated RunMat extensions; complex, character, and cell outputs remain host-resident."
     ],
     "key": "arrayfun",
     "slug": "arrayfun",

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

@@ -1 +1 @@
-{"version":3,"file":"arrayfun.js","sourceRoot":"","sources":["../../../src/generated/builtins/arrayfun.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,kBAAkB;IAC9B,UAAU,EAAE;QACV,UAAU;QACV,UAAU;QACV,iBAAiB;QACjB,oBAAoB;QACpB,eAAe;KAChB;IACD,SAAS,EAAE,yEAAyE;IACpF,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,sXAAsX;KAChY;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,8CAA8C;QACtD,aAAa,EAAE,sEAAsE;KACtF;IACD,aAAa,EAAE,gSAAgS;IAC/S,WAAW,EAAE;QACX,8FAA8F;QAC9F,iGAAiG;QACjG,wGAAwG;QACxG,yJAAyJ;QACzJ,iFAAiF;QACjF,mWAAmW;KACpW;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE,6CAA6C;SACxD;QACD;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,yEAAyE;YAClF,QAAQ,EAAE,8BAA8B;SACzC;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,gIAAgI;YACzI,QAAQ,EAAE,wDAAwD;SACnE;QACD;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,6IAA6I;YACtJ,QAAQ,EAAE,0DAA0D;SACrE;QACD;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,0EAA0E;YACnF,QAAQ,EAAE,yDAAyD;SACpE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,qPAAqP;SAChQ;QACD;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,iLAAiL;SAC5L;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,qJAAqJ;SAChK;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,8LAA8L;SACzM;QACD;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,2IAA2I;SACtJ;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,mEAAmE;QAC5E,KAAK,EAAE,gHAAgH;KACxH;IACD,eAAe,EAAE,2UAA2U;IAC5V,cAAc,EAAE;QACd,w8BAAw8B;KACz8B;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,cAAc;QACd,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"arrayfun.js","sourceRoot":"","sources":["../../../src/generated/builtins/arrayfun.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,kBAAkB;IAC9B,UAAU,EAAE;QACV,UAAU;QACV,UAAU;QACV,iBAAiB;QACjB,oBAAoB;QACpB,eAAe;KAChB;IACD,SAAS,EAAE,yEAAyE;IACpF,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,uTAAuT;KACjU;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,8CAA8C;QACtD,aAAa,EAAE,sEAAsE;KACtF;IACD,aAAa,EAAE,2WAA2W;IAC1X,WAAW,EAAE;QACX,yIAAyI;QACzI,gKAAgK;QAChK,4RAA4R;QAC5R,gOAAgO;QAChO,iNAAiN;QACjN,iFAAiF;QACjF,yRAAyR;KAC1R;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE,6CAA6C;SACxD;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,iFAAiF;YAC1F,QAAQ,EAAE,8BAA8B;SACzC;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,gIAAgI;YACzI,QAAQ,EAAE,wDAAwD;SACnE;QACD;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,6IAA6I;YACtJ,QAAQ,EAAE,0DAA0D;SACrE;QACD;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,0EAA0E;YACnF,QAAQ,EAAE,yDAAyD;SACpE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,qPAAqP;SAChQ;QACD;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,yOAAyO;SACpP;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,qJAAqJ;SAChK;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,8LAA8L;SACzM;QACD;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,2IAA2I;SACtJ;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,mEAAmE;QAC5E,KAAK,EAAE,gHAAgH;KACxH;IACD,eAAe,EAAE,2UAA2U;IAC5V,cAAc,EAAE;QACd,spBAAspB;KACvpB;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,cAAc;QACd,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/asin.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "Uses the provider's unary_asin hook when all elements stay within [-1, 1]; gathers to host otherwise."
+        "notes": "Uses the provider's unary_asin hook when all elements stay within [-1, 1]. Unsupported floating hooks use an owner-preserving fallback; real resident input that requires complex promotion is available only in RunMat mode and returns to the owning provider."
     },
     "fusion": {
         "elementwise": true,
@@ -35,8 +35,9 @@ const builtinDoc = {
     "description": "`Y = asin(X)` computes the inverse sine (in radians) of each element in `X`. Real values in `[-1, 1]` return real outputs; values outside that interval promote to complex outputs, consistent with MATLAB behavior.",
     "behaviors": [
         "Accepts scalars, vectors, matrices, and N-D tensors and applies the operation element-wise with MATLAB broadcasting rules.",
-        "Logical inputs convert to doubles (`true → 1.0`, `false → 0.0`) before the inverse sine is taken.",
-        "Character arrays are interpreted as their numeric code points and return dense double or complex tensors, depending on the result.",
+        "The documented table and timetable overloads are not yet implemented in RunMat.",
+        "Documented single inputs preserve native single or complex-single storage; double inputs preserve double or complex-double storage.",
+        "Typed-integer, logical, and character inputs are RunMat-only extensions. They enter an explicit double computation boundary and preserve input shape.",
         "Real inputs with magnitude greater than `1` produce complex results identical to MATLAB (`asin(1.2) → 1.5708 - 0.6224i`).",
         "Complex inputs follow MATLAB's principal branch definitions using `asin(z) = -i log(iz + sqrt(1 - z^2))`.",
         "NaNs and infinities propagate according to IEEE arithmetic and match MATLAB's edge cases."
@@ -58,7 +59,7 @@ const builtinDoc = {
             "output": "Y =\n    0          -0.5236    0.8481\n    1.5708      0.2527   -0.9273"
         },
         {
-            "description": "Handling logical input with automatic double promotion",
+            "description": "Computing inverse sine values from logical input",
             "input": "mask = logical([0 1 1 0]);\nangles = asin(mask)",
             "output": "angles = [0 1.5708 1.5708 0]"
         },
@@ -84,7 +85,7 @@ const builtinDoc = {
         },
         {
             "question": "How does `asin` treat logical or integer inputs?",
-            "answer": "Logical arrays convert to doubles (`0` or `1`). Integers convert to double precision before evaluation, mirroring MATLAB and avoiding overflow. The final result is double or complex depending on the data."
+            "answer": "They are outside the documented single/double data domain. RunMat mode retains logical and all-eight-class integer inputs as explicit extensions and converts them to double at the inverse-sine computation boundary."
         },
         {
             "question": "What happens with NaN or Inf values?",
@@ -92,7 +93,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I keep the result on the GPU if it becomes complex?",
-            "answer": "Complex results are currently returned on the host because GPU tensor handles represent real data. The runtime gathers automatically and returns `Value::Complex`/`Value::ComplexTensor`, guaranteeing correct MATLAB semantics."
+            "answer": "The public GPU contract requires potentially complex results to start from explicitly complex input. RunMat mode additionally supports real resident input that needs complex promotion, gathering and re-uploading the complex result to the same provider."
         },
         {
             "question": "Why does `asin` of a character array return numeric arrays?",
@@ -169,9 +170,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/math/trigonometry/asin.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/trigonometry/asin.rs"
     },
-    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. The fusion planner keeps tensors on the GPU whenever the active provider exposes the `unary_asin` hook and the inputs remain within `[-1, 1]`. When complex promotion is required, RunMat gathers the data and returns the correct complex result automatically. Manual `gpuArray` / `gather` calls remain available for workflows that need explicit residency control.",
+    "gpu_residency": "The fusion planner keeps documented floating inputs on the GPU whenever the active provider exposes `unary_asin` and the inputs remain within `[-1, 1]`. Unsupported hooks use owner-preserving fallback. RunMat mode also permits real resident input that requires complex promotion and restores the complex result to the same provider.",
     "gpu_behavior": [
-        "RunMat Accelerate keeps tensors on the GPU when:\n\n1. A provider is registered and implements `unary_asin`, `reduce_min`, and `reduce_max`. 2. The runtime can prove that every element lies within the real domain `[-1, 1]`.\n\nIf any of those hooks are missing, or if the bounds check cannot run (for example, because the provider does not support the min/max reductions for the current tensor layout), RunMat falls back to the host implementation automatically so the results remain correct.\n\nWhen either condition fails—most notably when the input requires complex promotion—the runtime gathers the data to the host, computes the MATLAB-compatible result, and returns a host-resident (or complex) value. This mirrors MATLAB's behaviour without forcing users to manually call `gpuArray` or `gather`."
+        "RunMat Accelerate keeps tensors on the GPU when a provider implements `unary_asin`, `reduce_min`, and `reduce_max` and the reductions prove that every element lies in `[-1, 1]`. Missing floating hooks use an owner-preserving gather fallback. Real resident input that requires complex promotion is rejected in MATLAB-compatible modes and is an explicit RunMat-only extension that restores the complex result to the owning provider."
     ],
     "key": "asin",
     "slug": "asin",

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

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

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

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

package/dist/generated/builtins/asinh.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "Uses the provider's unary_asinh hook when available; gathers to host otherwise."
+        "notes": "Uses the provider's unary_asinh hook when available; unsupported floating hooks and admitted resident integer/logical extensions use owner-preserving fallback."
     },
     "fusion": {
         "elementwise": true,
@@ -35,8 +35,9 @@ const builtinDoc = {
     "description": "`Y = asinh(X)` evaluates the inverse hyperbolic sine of each element in `X`. Real and complex inputs are handled element-wise, with branch behavior matching MATLAB semantics.",
     "behaviors": [
         "Accepts scalars, vectors, matrices, and N-D tensors and applies the operation element-wise using MATLAB's broadcasting rules.",
-        "Logical inputs are promoted to doubles (`true → 1.0`, `false → 0.0`) before the inverse hyperbolic sine is applied.",
-        "Character arrays are interpreted as numeric code points and return dense double arrays with the same shape.",
+        "The documented table and timetable overloads are not yet implemented in RunMat.",
+        "Documented single and complex-single inputs preserve native single storage; double and complex-double inputs preserve double storage.",
+        "Typed-integer, logical, and character inputs are RunMat-only extensions. They enter an explicit double computation boundary and preserve input shape.",
         "Real inputs produce real outputs for all finite values. Complex inputs follow MATLAB's principal branch definition `asinh(z) = log(z + sqrt(z^2 + 1))`.",
         "NaNs and infinities propagate according to IEEE arithmetic and match MATLAB's special-case tables."
     ],
@@ -78,11 +79,11 @@ const builtinDoc = {
         },
         {
             "question": "How are logical or integer inputs handled?",
-            "answer": "They are promoted to double precision before evaluation, mirroring MATLAB's behavior. The result is returned as a dense double tensor (or complex tensor for complex inputs)."
+            "answer": "They are outside the documented single/double data domain. RunMat mode retains logical and all-eight-class integer inputs as explicit extensions and converts them to double at the inverse-hyperbolic-sine computation boundary."
         },
         {
             "question": "What happens if the GPU provider lacks `unary_asinh`?",
-            "answer": "RunMat gathers the data to the host, evaluates `asinh` on the CPU, and keeps the result on the host unless a downstream operation requests GPU residency."
+            "answer": "RunMat gathers the data, evaluates `asinh` on the CPU, and restores the result to the input handle's owning provider."
         },
         {
             "question": "Is there a precision difference between CPU and GPU outputs?",
@@ -94,7 +95,7 @@ const builtinDoc = {
         },
         {
             "question": "How are character arrays processed?",
-            "answer": "They are interpreted as their Unicode code points, converted to doubles, and then passed through `asinh`, producing a numeric array that matches MATLAB's output."
+            "answer": "Character input is outside the documented single/double domain. RunMat mode retains it as an explicit extension, interprets Unicode code points as doubles, and applies `asinh` element-wise."
         },
         {
             "question": "What happens with NaN or Inf values?",
@@ -102,7 +103,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I keep complex results on the GPU?",
-            "answer": "Currently GPU tensor handles represent real data. When complex values arise, RunMat returns host-resident `Value::Complex` or `Value::ComplexTensor` results to remain MATLAB-compatible."
+            "answer": "Complex floating input is supported. When a provider hook is unavailable, RunMat uses an owner-preserving fallback and restores the complex result to the same provider."
         },
         {
             "question": "Does `asinh` support automatic differentiation plans?",
@@ -171,9 +172,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/math/trigonometry/asinh.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/trigonometry/asinh.rs"
     },
-    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. The fusion planner keeps tensors on the GPU whenever the active provider exposes the necessary hooks (`unary_asinh`) and the runtime can keep the data in real form. When the GPU path is incomplete, RunMat gathers to the host automatically and still returns MATLAB-compatible results. Manual `gpuArray` / `gather` remains available for workflows that require explicit residency control.",
+    "gpu_residency": "The fusion planner keeps tensors on the GPU whenever the active provider exposes `unary_asinh`. When the hook is unavailable, RunMat gathers, computes, and restores the result to the input handle's owning provider. Resident integer and logical inputs remain separately gated RunMat-only extensions.",
     "gpu_behavior": [
-        "RunMat Accelerate keeps tensors on the GPU when:\n\n1. A provider is registered and implements the `unary_asinh` hook. 2. The inputs do not require complex promotion that the provider cannot represent.\n\nIf either condition is not met, RunMat gathers the data to the host, evaluates `asinh` with the CPU reference implementation, and returns the correct MATLAB result. This guarantees correctness without forcing users to manually call `gpuArray` or `gather`."
+        "RunMat Accelerate keeps tensors on the GPU when a provider implements `unary_asinh`. Otherwise, it gathers the authoritative value, evaluates the reference implementation, and restores the result to the input handle's owning provider."
     ],
     "key": "asinh",
     "slug": "asinh",

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

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

package/dist/generated/builtins/assert.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Conditions are evaluated on the host. GPU tensors are gathered before the logical test, and fall back to the default CPU implementation."
+        "notes": "The documented gpuArray form executes on the client. Conditions and scalar formatting replacements gather through authoritative typed storage before host evaluation; all eight integer classes remain exact."
     },
     "fusion": {
         "elementwise": false,
@@ -29,14 +29,14 @@ const builtinDoc = {
         "unit": "builtins::diagnostics::assert::tests",
         "integration": "builtins::diagnostics::assert::tests::assert_gpu_tensor_passes"
     },
-    "description": "`assert(cond, ...)` aborts execution when `cond` is false (or contains zero/NaN values) and otherwise returns no output. Error identifier handling, message formatting, and argument validation follow MATLAB and RunMat assert semantics.",
+    "description": "`assert(cond, ...)` throws when a logical or logically convertible condition is false and has no public output. A real numeric condition is true only when it is nonempty and every element is nonzero; NaN cannot convert to logical. Optional text supplies a formatted message and a qualified error identifier.",
     "behaviors": [
-        "The first argument must be logical or numeric (real or complex). Scalars must evaluate to true; arrays must contain only nonzero, non-NaN elements (complex values fail when both real and imaginary parts are zero or contain NaNs). Empty inputs pass automatically.",
+        "The documented condition is logical or convertible to logical. Logical, character, and real numeric conditions pass only when nonempty and every element is nonzero. All eight integer classes are tested directly from authoritative storage. NaN cannot convert to logical, and complex conditions are a mode-gated RunMat extension.",
         "`assert(cond)` raises `RunMat:assertion:failed` with message `Assertion failed.` when `cond` is false.",
-        "`assert(cond, msg, args...)` formats `msg` with `sprintf`-compatible conversions using any additional arguments.",
-        "`assert(cond, id, msg, args...)` uses a custom message identifier (normalised to `RunMat:*` when missing a namespace) and the formatted message text.",
-        "Arguments are validated strictly: identifiers and message templates must be string scalars or character vectors, and malformed format strings raise `RunMat:assertion:invalidInput`.",
-        "Conditions supplied as gpuArray values are gathered to host memory prior to evaluation so that MATLAB semantics continue to apply."
+        "`assert(cond, msg, A...)` formats `msg` with `sprintf`-compatible conversions. Each documented A is a character vector, string scalar, or numeric scalar; integer scalar values remain exact through decimal, unsigned, hexadecimal, and string formatting.",
+        "`assert(cond, errID, msg, A...)` requires colon-separated identifier fields that each begin with a letter and otherwise contain letters, digits, or underscores. Automatic `RunMat:` qualification of an unqualified identifier is a mode-gated RunMat extension.",
+        "Arguments are validated strictly: identifiers and message templates must be string scalars or character vectors, replacement arrays reject, and malformed format strings raise `RunMat:assertion:invalidInput`.",
+        "The public gpuArray form executes on the client. Resident conditions and scalar numeric replacements gather through typed storage; no assertion kernel runs on the GPU."
     ],
     "examples": [
         {
@@ -75,19 +75,19 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "What types can I pass as the condition?",
-            "answer": "Logical scalars/arrays and numeric scalars/arrays are accepted. Character arrays, strings, cells, structs, and complex values raise `RunMat:assertion:invalidCondition`."
+            "answer": "Logical arrays, character arrays, and real numeric arrays are accepted when convertible to a logical condition. Strings, cells, structs, and other unsupported values reject. Complex conditions are available only in RunMat compatibility mode."
         },
         {
             "question": "How are NaN values treated?",
-            "answer": "Any `NaN` element causes the assertion to fail, matching MATLAB’s requirement that all elements are non-NaN and nonzero."
+            "answer": "NaN cannot be converted to logical, so a real condition containing NaN raises the invalid-condition diagnostic rather than an ordinary assertion failure."
         },
         {
             "question": "Do empty arrays pass the assertion?",
-            "answer": "Yes. Empty logical or numeric arrays are treated as true."
+            "answer": "No. A condition is true only when its result is nonempty and all elements are nonzero, so empty logical, character, or real numeric conditions fail the assertion."
         },
         {
             "question": "Can I omit the namespace in the message identifier?",
-            "answer": "Yes. RunMat prefixes unqualified identifiers with `RunMat:` to match MATLAB behaviour."
+            "answer": "Only in RunMat compatibility mode. The documented form requires colon-separated component and mnemonic fields; RunMat mode can prefix an unqualified identifier with `RunMat:`."
         },
         {
             "question": "What happens if my format string is malformed?",
@@ -103,7 +103,7 @@ const builtinDoc = {
         },
         {
             "question": "What value does `assert` return when the condition is true?",
-            "answer": "Like MATLAB, `assert` has no meaningful return value. RunMat returns `0.0` internally to satisfy the runtime but nothing is produced in MATLAB code."
+            "answer": "`assert` has no public output. RunMat uses an internal control-flow sentinel only to complete runtime dispatch."
         },
         {
             "question": "How do I disable assertions in production code?",
@@ -137,7 +137,7 @@ const builtinDoc = {
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/diagnostics/assert.rs"
     },
     "gpu_behavior": [
-        "`assert` is a control-flow builtin. RunMat gathers GPU-resident tensors (including logical gpuArrays) to host memory before evaluating the condition. No GPU kernels are launched, and the acceleration provider metadata is marked as a gather-immediately operation so execution always follows the MATLAB-compatible CPU path. Residency metadata is preserved so subsequent statements observe the same values they would have seen without the assertion."
+        "`assert` is a control-flow builtin. Public documentation accepts gpuArray input but states that execution does not run on the GPU. RunMat therefore gathers resident logical, real numeric, and scalar formatting values through authoritative typed storage before host evaluation; all eight integer classes remain exact, and no provider assertion kernel is launched."
     ],
     "key": "assert",
     "slug": "assert",

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

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

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

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

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

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