runmat 0.6.1 → 0.6.2-dev.0

package/dist/generated/builtins/containers.Map.d.ts.map

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

package/dist/generated/builtins/containers.Map.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Map storage lives on the host. GPU inputs are gathered when constructing maps or fetching values."
+        "notes": "Map storage and outputs are host-resident. Resident constructor, key-query, removal, lookup, selected-values, and assignment inputs are gated RunMat extensions that gather before host Map processing."
     },
     "fusion": {
         "elementwise": false,
@@ -28,15 +28,18 @@ const builtinDoc = {
     "tested": {
         "unit": "builtins::containers::map::containers_map::tests"
     },
-    "description": "`containers.Map` creates dictionary objects that associate unique keys with values. Supported key kinds include character vectors, string scalars, and numeric/logical scalars; values default to `'any'` storage semantics, with method behavior aligned to MATLAB and RunMat.",
+    "description": "`containers.Map` creates host-resident handle objects that associate unique character or real numeric keys with values. Public key types are `char`, `double`, `single`, `int32`, `uint32`, `int64`, and `uint64`; declared value types include `any`, `char`, `logical`, both floating classes, and all eight integer classes.",
     "behaviors": [
-        "Keys must be unique. Constructing a map or assigning a key that already exists overwrites the stored value (matching MATLAB's behaviour).",
-        "The `KeyType`, `ValueType`, and `Count` properties are readable with dot-indexing.",
+        "Constructor keys must be unique and duplicates raise an error. Later assignment to an existing key overwrites the stored value.",
+        "The read-only `KeyType`, `ValueType`, and `Count` properties are readable with dot-indexing; `Count` is a uint64 scalar.",
         "`map(key)` returns the associated value; requesting a missing key raises the MATLAB-compatible error *\"The specified key is not present in this container.\"*",
         "Assignments of the form `map(key) = value` update or insert entries.",
-        "Methods `keys(map)`, `values(map)`, `isKey(map, keySpec)`, and `remove(map, keySpec)` are fully compatible. When `keySpec` is a cell or string array, the result matches MATLAB's shape.",
-        "GPU tensors presented as values are gathered to host memory before insertion. When values or keys arrive on the GPU and need to be expanded element-wise (for example, vector-valued constructor arguments), RunMat downloads them to materialise individual scalars.",
-        "The `'UniformValues'` flag is accepted; when `true`, RunMat validates that every inserted value has the same MATLAB class. Retrieval still returns a cell array, matching MATLAB behaviour when the value type is `'any'`."
+        "RunMat returns `keys(map)` as a sorted row cell and aligns `values(map)` to that order, matching public examples without treating ordering as a formal MATLAB guarantee. `values(map,keySet)` requires a cell key set and preserves its shape.",
+        "`isKey` returns scalar logical for one scalar key and a same-shape logical result for key collections; `remove` mutates the handle and has no public output.",
+        "Integer key identity is exact for int32, uint32, int64, and uint64, including values wider than binary64 can distinguish. Narrow integer key arrays reject rather than alias through double.",
+        "All eight integer value classes preserve native storage through construction, assignment, lookup, and values output. Declared integer ValueType values are scalar and use the runtime's MATLAB integer saturation rules; ValueType any retains nonscalar integer arrays exactly.",
+        "`UniformValues` defaults to true for populated constructors; specifying false permits heterogeneous values and sets ValueType to `any`.",
+        "MATLAB documents thread-based execution but no gpuArray capability for this class. RunMat resident input gathering is therefore compatibility-gated and always produces host Map state and host outputs."
     ],
     "examples": [
         {
@@ -46,7 +49,7 @@ const builtinDoc = {
         },
         {
             "description": "Build a map from paired cell arrays",
-            "input": "keys = {'apple', 'pear', 'banana'};\nvals = {42, [1 2 3], true};\nfruit = containers.Map(keys, vals);\nenergy = fruit('apple')",
+            "input": "keys = {'apple', 'pear', 'banana'};\nvals = {42, [1 2 3], true};\nfruit = containers.Map(keys, vals, 'UniformValues', false);\nenergy = fruit('apple')",
             "output": "energy =\n    42"
         },
         {
@@ -57,7 +60,7 @@ const builtinDoc = {
         {
             "description": "Query keys, values, and membership",
             "input": "allKeys = keys(fruit);\nallVals = values(fruit);\nmask = isKey(fruit, {'apple', 'durian'})",
-            "output": "allKeys =\n  1×4 cell array\n    {'apple'}    {'pear'}    {'banana'}    {'peach'}\n\nallVals =\n  1×4 cell array\n    {[99]}    {[1 2 3]}    {[1]}    {1×1 struct}\n\nmask =\n  1×2 logical array\n     1     0"
+            "output": "allKeys =\n  1×4 cell array\n    {'apple'}    {'banana'}    {'peach'}    {'pear'}\n\nallVals =\n  1×4 cell array\n    {[99]}    {[1]}    {1×1 struct}    {[1 2 3]}\n\nmask =\n  1×2 logical array\n     1     0"
         },
         {
             "description": "Remove keys and inspect the map length",
@@ -68,7 +71,7 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "Which key types are supported?",
-            "answer": "`containers.Map` accepts `'char'`, `'string'`, `'double'`, `'single'`, `'int32'`, `'uint32'`, `'int64'`, `'uint64'`, and `'logical'`. Keys supplied during construction or assignment are coerced to the declared type and must be scalar."
+            "answer": "Public KeyType values are `'char'`, `'double'`, `'single'`, `'int32'`, `'uint32'`, `'int64'`, and `'uint64'`. String-array constructor keys are converted to character-vector keys, so the resulting KeyType is `'char'`; logical and narrow integer KeyType values are not public Map key types."
         },
         {
             "question": "What happens when I provide duplicate keys at construction time?",
@@ -80,7 +83,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I store GPU arrays as map values?",
-            "answer": "Yes. RunMat automatically gathers GPU tensors to host memory before inserting them so it can apply the same validation and coercion rules as MATLAB. This ensures constructors that rely on vector expansion continue to produce predictable host-side values."
+            "answer": "Only as a RunMat extension. MATLAB does not document gpuArray support for containers.Map. With RunMat extensions enabled, resident keys or values gather before processing and the Map stores host values; strict compatibility mode rejects before provider access."
         },
         {
             "question": "How does `length(map)` behave?",
@@ -92,11 +95,7 @@ const builtinDoc = {
         },
         {
             "question": "Does the map preserve insertion order?",
-            "answer": "Yes. `keys(map)` and `values(map)` return entries in the order they were first inserted, matching the behaviour of MATLAB's `containers.Map`."
-        },
-        {
-            "question": "Is the implementation thread-safe?",
-            "answer": "Yes. A global read/write lock guards the backing storage so concurrent reads are allowed while write operations remain exclusive."
+            "answer": "No insertion-order guarantee should be assumed. RunMat returns keys in key order and aligns `values(map)` to that order, matching the ordering shown by MATLAB's public examples."
         },
         {
             "question": "How do I remove every entry?",
@@ -116,7 +115,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I use MATLAB `string` values as `containers.Map` keys?",
-            "answer": "— MATLAB's `containers.Map` only accepts scalar character vectors (or scalar numerics / logicals) as keys, not `string` scalars. Convert first with `char(str)` when you use a `'char'` KeyType, e.g. `m(char(\"apple\")) = 1`. RunMat additionally accepts `'string'` as a `KeyType` alias that stores keys as character vectors internally, so either `m = containers.Map('KeyType','char','ValueType','any')` followed by `m(char(s)) = v` or constructing from cell arrays of char vectors works reliably across both runtimes."
+            "answer": "String arrays are accepted as constructor key sets and converted to character vectors, making the resulting KeyType `'char'`. Key lookup methods also accept a string scalar as a textual key, but `'string'` is not a KeyType value."
         },
         {
             "question": "Is `containers.Map` a handle class?",
@@ -127,6 +126,26 @@ const builtinDoc = {
         {
             "label": "length",
             "url": "./length"
+        },
+        {
+            "label": "MATLAB containers.Map documentation",
+            "url": "https://www.mathworks.com/help/matlab/ref/containers.map.html"
+        },
+        {
+            "label": "MATLAB isKey documentation",
+            "url": "https://www.mathworks.com/help/matlab/ref/containers.map.iskey.html"
+        },
+        {
+            "label": "MATLAB keys documentation",
+            "url": "https://www.mathworks.com/help/matlab/ref/containers.map.keys.html"
+        },
+        {
+            "label": "MATLAB values documentation",
+            "url": "https://www.mathworks.com/help/matlab/ref/containers.map.values.html"
+        },
+        {
+            "label": "MATLAB remove documentation",
+            "url": "https://www.mathworks.com/help/matlab/ref/containers.map.remove.html"
         }
     ],
     "source": {
@@ -134,7 +153,7 @@ const builtinDoc = {
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/containers/map/containers.map.rs"
     },
     "gpu_behavior": [
-        "The data structure itself resides on the CPU. When you construct a map with GPU arrays, RunMat first downloads the inputs so it can perform MATLAB-compatible validation and coercion. Maps never retain device buffers internally, so the GPU provider does not need to implement special hooks for this builtin."
+        "The data structure itself resides on the CPU. RunMat can gather resident inputs only through explicitly gated extensions; Maps never retain device buffers and all method outputs are host-resident."
     ],
     "syntax": {
         "example": {
@@ -144,8 +163,8 @@ const builtinDoc = {
         "points": [
             "`keys` is a cell vector (or string array) of scalar keys. Every element must share the same `KeyType`; mixing classes raises an error.",
             "`values` is a matched cell vector of the values to store, one per key. When `'UniformValues'` is `true`, every value must share the same MATLAB class.",
-            "`ktype` (the `'KeyType'` Name-Value pair) selects the key class. Supported values are `'char'` (default), `'double'`, `'single'`, `'int32'`, `'uint32'`, `'int64'`, `'uint64'`, and `'logical'`. RunMat additionally accepts `'string'`, storing keys as char vectors internally for MATLAB compatibility.",
-            "`vtype` (the `'ValueType'` Name-Value pair) restricts the values. The default `'any'` stores arbitrary MATLAB objects; pass a class name (e.g. `'double'`) to reject mismatched inserts.",
+            "`ktype` selects `'char'`, `'double'`, `'single'`, `'int32'`, `'uint32'`, `'int64'`, or `'uint64'`. Empty typed construction requires both KeyType and ValueType.",
+            "`vtype` selects `'any'`, `'char'`, `'logical'`, `'double'`, `'single'`, or any of the eight integer classes.",
             "Returns `m`, a handle to a `containers.Map` object. Because it is a handle class, assigning `m2 = m` produces two references to the same map."
         ]
     },

package/dist/generated/builtins/containers.Map.js.map

@@ -1 +1 @@
-{"version":3,"file":"containers.Map.js","sourceRoot":"","sources":["../../../src/generated/builtins/containers.Map.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,gBAAgB;IACzB,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,gBAAgB;QAChB,KAAK;QACL,YAAY;QACZ,UAAU;QACV,QAAQ;KACT;IACD,SAAS,EAAE,2DAA2D;IACtE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,mGAAmG;KAC7G;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,kDAAkD;KAC3D;IACD,aAAa,EAAE,iRAAiR;IAChS,WAAW,EAAE;QACX,2IAA2I;QAC3I,oFAAoF;QACpF,gKAAgK;QAChK,sEAAsE;QACtE,0LAA0L;QAC1L,uQAAuQ;QACvQ,4NAA4N;KAC7N;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,wDAAwD;YACjE,QAAQ,EAAE,oDAAoD;SAC/D;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,gIAAgI;YACzI,QAAQ,EAAE,kBAAkB;SAC7B;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,6DAA6D;YACtE,QAAQ,EAAE,+BAA+B;SAC1C;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,4FAA4F;YACrG,QAAQ,EAAE,iNAAiN;SAC5N;QACD;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,iFAAiF;YAC1F,QAAQ,EAAE,wEAAwE;SACnF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,4OAA4O;SACvP;QACD;YACE,UAAU,EAAE,kEAAkE;YAC9E,QAAQ,EAAE,uJAAuJ;SAClK;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,uMAAuM;SAClN;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,gQAAgQ;SAC3Q;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,uJAAuJ;SAClK;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,+HAA+H;SAC1I;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,+IAA+I;SAC1J;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,mIAAmI;SAC9I;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,2KAA2K;SACtL;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,8IAA8I;SACzJ;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,sXAAsX;SACjY;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,qXAAqX;SAChY;QACD;YACE,UAAU,EAAE,4DAA4D;YACxE,QAAQ,EAAE,qgBAAqgB;SAChhB;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,+aAA+a;SAC1b;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,uEAAuE;QAChF,KAAK,EAAE,oHAAoH;KAC5H;IACD,cAAc,EAAE;QACd,oTAAoT;KACrT;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,QAAQ;YACvB,OAAO,EAAE,yKAAyK;SACnL;QACD,QAAQ,EAAE;YACR,wIAAwI;YACxI,wJAAwJ;YACxJ,4SAA4S;YAC5S,0LAA0L;YAC1L,+IAA+I;SAChJ;KACF;IACD,KAAK,EAAE,gBAAgB;IACvB,MAAM,EAAE,gBAAgB;IACxB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,YAAY;QACZ,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"containers.Map.js","sourceRoot":"","sources":["../../../src/generated/builtins/containers.Map.ts"],"names":[],"mappings":"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"}

package/dist/generated/builtins/contains.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "matlab",
-        "notes": "Runs on the CPU; when inputs reside on the GPU RunMat gathers them automatically so behaviour matches MATLAB."
+        "notes": "Runs on the CPU. RunMat has no resident text-array representation; resident numeric values reject as nontext before provider access."
     },
     "fusion": {
         "elementwise": false,
@@ -82,7 +82,7 @@ const builtinDoc = {
         },
         {
             "question": "How do I ignore letter case?",
-            "answer": "Specify `'IgnoreCase', true` (or `'on'`) after the pattern argument. The option is case-insensitive, so `'ignorecase'` also works. The default is `false`, matching MATLAB."
+            "answer": "Specify `'IgnoreCase', true` after the pattern argument. The option name is case-insensitive and the default is `false`. Positional, numeric, and textual flag conveniences are available only in RunMat compatibility mode."
         },
         {
             "question": "What happens with empty patterns?",
@@ -98,7 +98,7 @@ const builtinDoc = {
         },
         {
             "question": "Does `contains` run on the GPU?",
-            "answer": "No. The builtin executes on the CPU. If inputs reside on the GPU (for example, after other accelerated operations), RunMat gathers them automatically so behaviour matches MATLAB."
+            "answer": "No. The builtin executes on the CPU, and RunMat has no GPU-resident text representation. Numeric gpuArray values reject as nontext before provider access."
         },
         {
             "question": "Does `contains` preserve the input shape?",
@@ -131,9 +131,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/strings/search/contains.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/search/contains.rs"
     },
-    "gpu_residency": "You usually do NOT need to call `gpuArray` yourself in RunMat (unlike MATLAB).\n\n`contains` always executes on the host, but RunMat's runtime automatically gathers any GPU-resident inputs before evaluating the text search so behaviour is identical to MATLAB. You can still call `gpuArray` manually for compatibility with legacy MATLAB code; the runtime will gather those inputs just in time when `contains` runs.",
+    "gpu_residency": "`contains` executes on host text values. RunMat currently has no GPU-resident string representation, so a numeric gpuArray is rejected as nontext before any provider download.",
     "gpu_behavior": [
-        "`contains` performs host-side text comparisons. When invoked with data that currently resides on the GPU, RunMat gathers the inputs before executing the search so that results match MATLAB exactly. No provider hooks are required for this builtin."
+        "`contains` performs host-side text comparisons and registers no provider hook. Resident numeric inputs reject before provider access because they are not text values."
     ],
     "key": "contains",
     "slug": "contains",

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

@@ -1 +1 @@
-{"version":3,"file":"contains.js","sourceRoot":"","sources":["../../../src/generated/builtins/contains.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"contains.js","sourceRoot":"","sources":["../../../src/generated/builtins/contains.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,WAAW;QACX,aAAa;QACb,YAAY;QACZ,cAAc;KACf;IACD,SAAS,EAAE,iEAAiE;IAC5E,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,sIAAsI;KAChJ;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,0EAA0E;KAC1F;IACD,aAAa,EAAE,wQAAwQ;IACvR,WAAW,EAAE;QACX,8GAA8G;QAC9G,8HAA8H;QAC9H,+DAA+D;QAC/D,+EAA+E;QAC/E,gHAAgH;QAChH,kIAAkI;KACnI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wCAAwC;YACvD,OAAO,EAAE,sDAAsD;YAC/D,QAAQ,EAAE,oBAAoB;SAC/B;QACD;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,wDAAwD;YACjE,QAAQ,EAAE,oBAAoB;SAC/B;QACD;YACE,aAAa,EAAE,2DAA2D;YAC1E,OAAO,EAAE,wEAAwE;YACjF,QAAQ,EAAE,sCAAsC;SACjD;QACD;YACE,aAAa,EAAE,qDAAqD;YACpE,OAAO,EAAE,4HAA4H;YACrI,QAAQ,EAAE,0CAA0C;SACrD;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,2DAA2D;YACpE,QAAQ,EAAE,sCAAsC;SACjD;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,4CAA4C;YACrD,QAAQ,EAAE,0CAA0C;SACrD;QACD;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,4DAA4D;YACrE,QAAQ,EAAE,kCAAkC;SAC7C;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,+OAA+O;SAC1P;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,8NAA8N;SACzO;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,gJAAgJ;SAC3J;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,wMAAwM;SACnN;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,gMAAgM;SAC3M;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,4JAA4J;SACvK;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,gMAAgM;SAC3M;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,cAAc;SACtB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,eAAe,EAAE,iLAAiL;IAClM,cAAc,EAAE;QACd,wKAAwK;KACzK;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;QACT,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/contour.js

@@ -18,10 +18,18 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [
             "single",
-            "double"
+            "double",
+            "int8",
+            "int16",
+            "int32",
+            "int64",
+            "uint8",
+            "uint16",
+            "uint32",
+            "uint64"
         ],
         "broadcasting": "none",
-        "notes": "`contour` uses the shared contour-generation path and returns a contour handle in the plotting object model."
+        "notes": "Floating gpuArray `Z` can use RunMat's shared WGPU contour path. Integer gpuArray coordinates, heights, levels, and scalar properties gather exactly through the owning provider before the client graphics boundary because the contour shaders consume floating buffers."
     },
     "fusion": {
         "elementwise": false,
@@ -33,18 +41,19 @@ const builtinDoc = {
     "tested": {
         "unit": "builtins::plotting::contour::tests"
     },
-    "description": "`contour` creates contour line plots from scalar fields. It returns a contour handle and supports level-list and level-step forms, sharing contour-generation behavior across MATLAB and RunMat.",
+    "description": "`contour` creates contour line plots from scalar fields using implicit or explicit coordinates, explicit levels, and a supported subset of contour appearance properties. RunMat returns an opaque contour handle; MATLAB's contour-matrix first output and two-output `[M, c]` form remain graphics-representation gaps.",
     "behaviors": [
-        "`contour(Z)` uses implicit axes, while `contour(X, Y, Z)` accepts explicit vector or matrix coordinates.",
-        "The builtin returns a contour handle that works with the plotting property system.",
-        "Levels can be controlled through explicit level lists, level counts, or level-step workflows.",
+        "`contour(Z)` uses implicit axes, while `contour(X, Y, Z)` accepts strictly monotonic coordinate vectors or meshgrid-style matrices and `contour(ax, ...)` selects an existing axes target.",
+        "All eight built-in integer classes are accepted for `X`, `Y`, `Z`, positional level counts/vectors, `LevelList`, `LevelStep`, and `LineWidth`; integer shape, distinctness, meshgrid identity, ordering, count, and scalar constraints are validated from authoritative storage before floating graphics conversion.",
+        "A scalar level argument is a positive requested level count bounded by RunMat's one-million-level materialization guard; a vector is an explicit monotonically increasing level list, and `[k k]` requests one level at `k`.",
         "Contour state is subplot-local and composes naturally with `colormap`, `colorbar`, and surface/composite builtins.",
-        "GPU-aware contour generation is used when the shared plotting path can operate directly on GPU-resident scalar fields."
+        "The public compatibility surface accepts GPU arrays but performs contour plotting on the client. RunMat preserves that behavior for resident integers through exact owning-provider gather and additionally accelerates eligible floating `Z` grids through the shared WGPU plotting context."
     ],
     "options": [
-        "`'LevelList'` / `'Levels'` accepts an explicit, strictly increasing vector of contour values.",
-        "`'LevelStep'` specifies evenly spaced contour levels.",
-        "`'LineColor'` accepts MATLAB color strings, RGB triples, and contour-specific modes such as `'auto'` or `'none'` where supported."
+        "`'LevelList'` accepts an explicit monotonically increasing vector of contour values; RunMat also accepts `'Levels'` as an alias.",
+        "`'LevelStep'` accepts a positive finite scalar spacing, and `'LineWidth'` accepts a positive finite scalar width.",
+        "`'LineColor'` accepts color strings, RGB triples, and `'auto'`, `'flat'`, or `'none'`. Typed-integer RGB triples containing only exact 0/1 channels are a separately gated RunMat extension because the public RGB contract does not explicitly advertise integer classes.",
+        "The broader Contour property surface, including label-generation properties, `EdgeColor`, `FaceColor`, alpha controls, and post-construction typed `XData`/`YData`/`ZData` mutation, remains a general graphics-property coverage gap."
     ],
     "examples": [
         {
@@ -73,7 +82,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I add labels to the contour lines?",
-            "answer": "Use `clabel` after `contour` to annotate the lines with their level values. Pass the contour handle to `clabel` so it knows which plot to label.\n\n```matlab\n[C, h] = contour(X, Y, Z);\nclabel(C, h);\n```"
+            "answer": "MATLAB supports contour labels through `clabel` and contour label properties. RunMat's current contour object does not yet implement that broader label-generation surface."
         },
         {
             "question": "What's the difference between contour and contourf?",

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

@@ -1 +1 @@
-{"version":3,"file":"contour.js","sourceRoot":"","sources":["../../../src/generated/builtins/contour.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,eAAe;QACf,WAAW;QACX,YAAY;QACZ,gBAAgB;QAChB,mBAAmB;KACpB;IACD,SAAS,EAAE,iDAAiD;IAC5D,YAAY,EAAE,qGAAqG;IACnH,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,QAAQ;YACR,QAAQ;SACT;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,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,oCAAoC;KAC7C;IACD,aAAa,EAAE,kMAAkM;IACjN,WAAW,EAAE;QACX,0GAA0G;QAC1G,oFAAoF;QACpF,+FAA+F;QAC/F,oHAAoH;QACpH,wHAAwH;KACzH;IACD,SAAS,EAAE;QACT,+FAA+F;QAC/F,uDAAuD;QACvD,mIAAmI;KACpI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,0FAA0F;SACpG;QACD;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,wGAAwG;SAClH;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,mFAAmF;YAC5F,QAAQ,EAAE,sBAAsB;SACjC;QACD;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,+SAA+S;YACxT,YAAY,EAAE,qGAAqG;SACpH;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,iSAAiS;SAC5S;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,+MAA+M;SAC1N;QACD;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,wTAAwT;SACnU;KACF;IACD,OAAO,EAAE;QACP;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,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,8BAA8B;YACvC,KAAK,EAAE,6CAA6C;SACrD;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;QACD;YACE,OAAO,EAAE,yBAAyB;YAClC,KAAK,EAAE,6BAA6B;SACrC;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,8DAA8D;QACvE,KAAK,EAAE,2GAA2G;KACnH;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"contour.js","sourceRoot":"","sources":["../../../src/generated/builtins/contour.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,eAAe;QACf,WAAW;QACX,YAAY;QACZ,gBAAgB;QAChB,mBAAmB;KACpB;IACD,SAAS,EAAE,iDAAiD;IAC5D,YAAY,EAAE,qGAAqG;IACnH,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,QAAQ;YACR,QAAQ;YACR,MAAM;YACN,OAAO;YACP,OAAO;YACP,OAAO;YACP,OAAO;YACP,QAAQ;YACR,QAAQ;YACR,QAAQ;SACT;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,4QAA4Q;KACtR;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,oCAAoC;KAC7C;IACD,aAAa,EAAE,2TAA2T;IAC1U,WAAW,EAAE;QACX,4LAA4L;QAC5L,sTAAsT;QACtT,8NAA8N;QAC9N,oHAAoH;QACpH,+RAA+R;KAChS;IACD,SAAS,EAAE;QACT,kIAAkI;QAClI,mHAAmH;QACnH,4QAA4Q;QAC5Q,wOAAwO;KACzO;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,0FAA0F;SACpG;QACD;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,wGAAwG;SAClH;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,mFAAmF;YAC5F,QAAQ,EAAE,sBAAsB;SACjC;QACD;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,+SAA+S;YACxT,YAAY,EAAE,qGAAqG;SACpH;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,iSAAiS;SAC5S;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,6KAA6K;SACxL;QACD;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,wTAAwT;SACnU;KACF;IACD,OAAO,EAAE;QACP;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,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,8BAA8B;YACvC,KAAK,EAAE,6CAA6C;SACrD;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;QACD;YACE,OAAO,EAAE,yBAAyB;YAClC,KAAK,EAAE,6BAA6B;SACrC;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,8DAA8D;QACvE,KAAK,EAAE,2GAA2G;KACnH;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/contourf.js

@@ -17,10 +17,18 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [
             "single",
-            "double"
+            "double",
+            "int8",
+            "int16",
+            "int32",
+            "int64",
+            "uint8",
+            "uint16",
+            "uint32",
+            "uint64"
         ],
         "broadcasting": "none",
-        "notes": "`contourf` uses the shared filled-contour pipeline and returns a contour-fill handle."
+        "notes": "Eligible floating `Z` grids can use RunMat's shared WGPU filled-contour path. Integer gpuArray coordinates, heights, levels, and scalar properties gather exactly through their owning provider before the client graphics boundary because the contour shaders consume floating buffers."
     },
     "fusion": {
         "elementwise": false,
@@ -32,13 +40,16 @@ const builtinDoc = {
     "tested": {
         "unit": "builtins::plotting::contourf::tests"
     },
-    "description": "`contourf` creates filled contour plots by coloring regions between contour levels. It returns a contour-fill handle and shares contour-level generation semantics with `contour` in MATLAB and RunMat.",
+    "description": "`contourf` creates filled contour plots by coloring regions between contour levels. RunMat returns an opaque contour-fill handle; MATLAB's contour-matrix first output and two-output `[M, c]` form remain graphics-representation gaps.",
     "behaviors": [
-        "`contourf(Z)` uses implicit axes, while `contourf(X, Y, Z)` accepts explicit coordinates.",
+        "`contourf(Z)` uses implicit axes, `contourf(X, Y, Z)` accepts strictly monotonic coordinate vectors or coordinate matrices that vary along opposite dimensions, and `contourf(ax, ...)` selects an existing axes target.",
+        "All eight built-in integer classes are documented for `X`, `Y`, `Z`, positional level counts/vectors, `LevelList`, and `LevelStep`; RunMat also accepts them for positive `LineWidth` values. Shape, distinctness, coordinate-matrix identity, ordering, count, and scalar constraints are checked from authoritative storage before floating graphics conversion.",
         "The returned value is a contour-fill handle in the plotting object system.",
-        "Level-list, level-count, and related contour workflows mirror the broader contour family semantics.",
+        "A scalar level is a positive bounded requested level count, a vector is an explicit monotonically increasing level list, and `[k k]` requests one level at `k`.",
         "`contourf` works naturally with `colorbar` and `colormap` because filled regions are fundamentally color-mapped scalar ranges.",
-        "Filled contours and optional line overlays are handled through the shared contour stack."
+        "The public compatibility surface accepts GPU arrays but executes on the client. Resident integer inputs therefore gather through their owning provider, while RunMat additionally accelerates eligible floating `Z` grids through its shared WGPU plotting context.",
+        "Typed-integer `LineColor` RGB triplets containing only exact 0/1 channels use the separately gated `contour-integer-line-color` RunMat extension.",
+        "The broader Contour property surface, contour labels, post-construction typed data mutation, and MATLAB contour-matrix/object output forms remain general graphics gaps."
     ],
     "examples": [
         {

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

@@ -1 +1 @@
-{"version":3,"file":"contourf.js","sourceRoot":"","sources":["../../../src/generated/builtins/contourf.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,UAAU;QACV,qBAAqB;QACrB,eAAe;QACf,sBAAsB;QACtB,iBAAiB;KAClB;IACD,SAAS,EAAE,mDAAmD;IAC9D,YAAY,EAAE,kGAAkG;IAChH,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,QAAQ;YACR,QAAQ;SACT;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,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,qCAAqC;KAC9C;IACD,aAAa,EAAE,yMAAyM;IACxN,WAAW,EAAE;QACX,2FAA2F;QAC3F,4EAA4E;QAC5E,qGAAqG;QACrG,gIAAgI;QAChI,0FAA0F;KAC3F;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,sGAAsG;SAChH;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,kIAAkI;SAC5I;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,oFAAoF;YAC7F,QAAQ,EAAE,sBAAsB;SACjC;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,8PAA8P;YACvQ,YAAY,EAAE,kGAAkG;SACjH;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,2TAA2T;SACtU;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,uSAAuS;SAClT;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,gSAAgS;SAC3S;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,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,8BAA8B;YACvC,KAAK,EAAE,6CAA6C;SACrD;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;QACD;YACE,OAAO,EAAE,yBAAyB;YAClC,KAAK,EAAE,6BAA6B;SACrC;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"contourf.js","sourceRoot":"","sources":["../../../src/generated/builtins/contourf.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,UAAU;QACV,qBAAqB;QACrB,eAAe;QACf,sBAAsB;QACtB,iBAAiB;KAClB;IACD,SAAS,EAAE,mDAAmD;IAC9D,YAAY,EAAE,kGAAkG;IAChH,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,QAAQ;YACR,QAAQ;YACR,MAAM;YACN,OAAO;YACP,OAAO;YACP,OAAO;YACP,OAAO;YACP,QAAQ;YACR,QAAQ;YACR,QAAQ;SACT;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,2RAA2R;KACrS;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,qCAAqC;KAC9C;IACD,aAAa,EAAE,0OAA0O;IACzP,WAAW,EAAE;QACX,0NAA0N;QAC1N,oWAAoW;QACpW,4EAA4E;QAC5E,iKAAiK;QACjK,gIAAgI;QAChI,qQAAqQ;QACrQ,mJAAmJ;QACnJ,0KAA0K;KAC3K;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,sGAAsG;SAChH;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,kIAAkI;SAC5I;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,oFAAoF;YAC7F,QAAQ,EAAE,sBAAsB;SACjC;QACD;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,8PAA8P;YACvQ,YAAY,EAAE,kGAAkG;SACjH;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,2TAA2T;SACtU;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,uSAAuS;SAClT;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,gSAAgS;SAC3S;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,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,8BAA8B;YACvC,KAAK,EAAE,6CAA6C;SACrD;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,KAAK,EAAE,uCAAuC;SAC/C;QACD;YACE,OAAO,EAAE,yBAAyB;YAClC,KAAK,EAAE,6BAA6B;SACrC;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/conv.js

@@ -20,7 +20,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "The in-process provider and WGPU backend expose conv1d; other providers fall back to the host implementation when this hook is unavailable."
+        "notes": "Same-owner, same-device real floating inputs may use the provider conv1d hook when its result preserves the required f32/f64 class and belongs to the invoked provider/device. Other resident inputs gather through their owning providers; eligible real or complex floating results are restored only when the owner preserves the selected class. Convolution does not accept typed complex-integer inputs."
     },
     "fusion": {
         "elementwise": false,
@@ -33,14 +33,15 @@ const builtinDoc = {
         "unit": "builtins::math::signal::conv::tests",
         "integration": "builtins::math::signal::conv::tests::conv_gpu_roundtrip_matches_cpu"
     },
-    "description": "`conv(a, b)` computes the one-dimensional linear convolution of vectors `a` and `b`. The default returns full convolution length, while `'same'` and `'valid'` select alternate output shapes following MATLAB semantics.",
+    "description": "`conv(a, b)` computes the one-dimensional linear convolution of vectors `a` and `b`. MATLAB documents all eight integer classes, logical, single, double, and complex inputs; any single input selects single output and every other combination returns double.",
     "behaviors": [
-        "Accepts real or complex scalars, vectors, or tensors that can be flattened column-major into a vector.",
-        "Keeps the orientation of the first input when returning row or column vectors (`'same'` and `'valid'` honour this rule).",
+        "Accepts real or complex row/column vectors from all documented numeric and logical classes. Integer inputs cross an explicit floating boundary and never produce integer output.",
+        "In the compatibility target, full output is a row unless both inputs are columns; `'same'` and `'valid'` retain the orientation of the first input.",
         "Supports the three MATLAB shape modes: `'full'` (default), `'same'`, and `'valid'`.",
-        "Returns empty outputs when either input is empty or when `'valid'` is requested with insufficient overlap.",
+        "Empty inputs normally return empty output. MATLAB's documented `'valid'` exception for an empty second vector returns a zero vector with the first input's length, orientation, class, and complexity.",
         "Logical inputs are promoted to double precision before the convolution.",
-        "GPU inputs are gathered automatically when the active provider lacks a native 1-D convolution kernel."
+        "Explicitly complex input produces complex output even when every resulting imaginary component is zero.",
+        "The public GPU-array surface is supported. A native hook is used only for same-owner, same-device real floating handles whose result has the required class; other supported resident values use class-preserving gather/restore fallback."
     ],
     "examples": [
         {
@@ -86,11 +87,11 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "Does `conv` require row vectors?",
-            "answer": "No. `conv` accepts row vectors, column vectors, scalars, and tensors that can be flattened into a vector. The result preserves the orientation of the first input when that orientation is unambiguous."
+            "answer": "No. `conv` accepts row vectors, column vectors, and scalars. Genuine matrices and higher-dimensional arrays are rejected; use `conv2` or `convn` for those inputs. The result preserves the orientation of the first input when that orientation is unambiguous."
         },
         {
             "question": "What happens when one of the inputs is empty?",
-            "answer": "The result is an empty vector with an orientation derived from the non-empty input (or a `0×1` column vector when both inputs are empty), matching MATLAB's behaviour."
+            "answer": "The result is normally empty. For `conv(u, [], 'valid')`, MATLAB documents a special case: RunMat returns zeros with the same length and orientation as `u`, while preserving the selected floating class and explicit complexity."
         },
         {
             "question": "How is `'same'` computed?",
@@ -102,15 +103,15 @@ const builtinDoc = {
         },
         {
             "question": "Does `conv` support single precision?",
-            "answer": "The host path computes in double precision. Provider implementations choose their native precision: the in-process provider mirrors double results, while the WGPU backend emits either `f32` or `f64` kernels depending on device support. Providers without a `conv1d` hook gather inputs back to the CPU to maintain MATLAB-compatible answers."
+            "answer": "When either numeric input is single, the output is single. Otherwise integer, logical, and double inputs produce double output. Integer multiplication and accumulation therefore have floating overflow/rounding semantics rather than integer saturation."
         },
         {
             "question": "Will the result stay on the GPU?",
-            "answer": "Yes—provided the active provider exposes the `conv1d` hook (the in-process provider and WGPU backend do). Without that hook, RunMat gathers inputs, computes on the host, and returns a CPU tensor with the correct orientation."
+            "answer": "Same-owner, same-device real floating inputs remain resident when a provider's `conv1d` hook returns the required class. Other resident inputs gather through their own providers and eligible floating results return to the first owner. Typed complex integers work on the host, but the current provider ABI cannot encode typed complex-integer resident buffers."
         },
         {
             "question": "Can I convolve matrices or higher-dimensional arrays?",
-            "answer": "`conv` treats inputs as vectors using MATLAB column-major order. For multi-dimensional convolution use the dedicated `conv2` or `convn` builtins (planned)."
+            "answer": "MATLAB requires vectors. RunMat rejects genuine matrix inputs; use `conv2` or `convn` for multidimensional convolution."
         },
         {
             "question": "How do I convolve with an impulse (delta) kernel?",
@@ -126,6 +127,10 @@ const builtinDoc = {
         }
     ],
     "links": [
+        {
+            "label": "MATLAB conv documentation",
+            "url": "https://www.mathworks.com/help/matlab/ref/conv.html"
+        },
         {
             "label": "fft",
             "url": "./fft"

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

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

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

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

package/dist/generated/builtins/conv2.js

@@ -21,7 +21,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "When the active provider lacks a conv2d hook RunMat gathers inputs to the host and executes the CPU path."
+        "notes": "Same-owner, same-device real floating inputs may use the provider conv2d hook when its result preserves the required f32/f64 class and belongs to the invoked provider/device. Other resident inputs gather through their owning providers; eligible real or complex floating results are restored only when the owner preserves the selected class. Convolution does not accept typed complex-integer inputs."
     },
     "fusion": {
         "elementwise": false,
@@ -37,16 +37,17 @@ const builtinDoc = {
             "builtins::math::signal::conv2::tests::conv2_wgpu_fallback_matches_cpu"
         ]
     },
-    "description": "`conv2` performs two-dimensional linear convolution. The default returns full convolution size, while `'same'` and `'valid'` modes select alternate regions; these shape rules match MATLAB and RunMat, including separable `conv2(hcol, hrow, A)` form.",
+    "description": "`conv2` performs two-dimensional linear convolution in direct and separable forms. MATLAB documents all eight integer classes, logical, single, double, and complex inputs; any single numeric input selects single output and every other combination returns double.",
     "behaviors": [
         "`conv2(A, B)` returns the full 2-D convolution of `A` and `B`.",
         "`conv2(A, B, 'same')` slices the central part of the full convolution so the output matches the shape of `A`.",
         "For even-sized kernels with `'same'`, alignment follows MATLAB's top-left convention in each even dimension.",
         "`conv2(A, B, 'valid')` returns only those points where `B` overlaps `A` completely.",
         "`conv2(hcol, hrow, A)` is syntactic sugar for `conv2(hcol(:) * hrow(:)', A)`.",
+        "Direct A/B and separable u/v/A inputs accept every integer class, including mixed classes and complex integer storage. They convert to the selected floating output domain before multiplication and accumulation, so no integer overflow or saturation applies.",
         "Scalars are treated as `1×1` matrices and preserve the orientation of the other input.",
         "Empty inputs follow MATLAB’s rules: `conv2([], X)` and `conv2(X, [])` return empty matrices (or zero-sized slices for `'same'`).",
-        "Logical inputs are promoted to double precision before computation; complex inputs preserve their imaginary part throughout the convolution."
+        "Logical inputs are promoted to double precision before computation; explicit complex inputs remain complex even when the result has zero imaginary components; resident integer inputs gather exactly before conversion."
     ],
     "examples": [
         {
@@ -62,7 +63,7 @@ const builtinDoc = {
         {
             "description": "Extracting the same-sized result to preserve dimensions",
             "input": "edge = conv2([1 2 3; 4 5 6; 7 8 9], [1 0 -1; 1 0 -1; 1 0 -1], 'same')",
-            "output": "edge =\n    -7    -4     7\n   -15    -6    15\n   -13    -4    13"
+            "output": "edge =\n     7     4    -7\n    15     6   -15\n    13     4   -13"
         },
         {
             "description": "Valid convolution for sliding-window statistics",
@@ -98,7 +99,7 @@ const builtinDoc = {
         },
         {
             "question": "Will the result stay on the GPU?",
-            "answer": "If the active provider exposes the `conv2d` hook the result stays device-resident. Otherwise RunMat falls back to the CPU path and returns a host tensor; this fallback is documented so providers can add native kernels without breaking compatibility."
+            "answer": "Same-owner, same-device real floating operands remain resident when a provider's `conv2d` hook returns the required class. Other resident operands gather independently, and eligible real or complex floating results return to the first owner. Typed complex integers work on the host, but the current provider ABI cannot encode typed complex-integer resident buffers."
         },
         {
             "question": "What does `conv2` actually compute?",
@@ -114,6 +115,10 @@ const builtinDoc = {
         }
     ],
     "links": [
+        {
+            "label": "MATLAB conv2 documentation",
+            "url": "https://www.mathworks.com/help/matlab/ref/conv2.html"
+        },
         {
             "label": "conv",
             "url": "./conv"
@@ -148,7 +153,7 @@ const builtinDoc = {
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/signal/conv2.rs"
     },
     "gpu_behavior": [
-        "RunMat Accelerate keeps tensors on the GPU when the active provider implements a `conv2d` hook (the in-process provider uses the host implementation and returns a GPU handle; the WGPU backend will adopt a native kernel). When the hook is unavailable, RunMat gathers GPU inputs to the host, performs the convolution on the CPU, and returns a host tensor. Documentation and the GPU metadata make this fallback explicit so providers can add native implementations without changing this builtin."
+        "RunMat Accelerate invokes `conv2d` only for real floating handles owned by the same provider on the same device, and accepts the result only when its precision matches the single-dominant output rule. Otherwise each handle gathers through its owner, the host reference path computes true convolution, and an eligible real or complex result is restored to the first owner when that provider preserves its class."
     ],
     "syntax": {
         "example": {
@@ -156,14 +161,14 @@ const builtinDoc = {
             "input": "C = conv2(A, B)\nC = conv2(u, v, A)\nC = conv2(___, shape)"
         },
         "points": [
-            "`A` is the 2-D input matrix (real, complex, or logical; logicals are promoted to double).",
+            "`A` is the 2-D input matrix and can use any documented real or complex numeric class or logical; integer and logical inputs are promoted to floating output.",
             "`B` is the 2-D convolution kernel. It is flipped along both axes before the sum-of-products, which is what makes the operation true convolution rather than correlation.",
             "`conv2(u, v, A)` is the separable form: `u` is a column vector applied down the rows of `A` and `v` is a row vector applied across the columns. This is equivalent to `conv2(u(:) * v(:).', A)` but runs as two 1-D passes, which is much faster whenever the effective kernel `u*v'` is rank-1 (box filters, Gaussians, Sobel components).",
             "`shape` selects the output region: `'full'` (default) returns an array of size `size(A) + size(B) - 1`; `'same'` slices the central portion so the output matches `size(A)`; `'valid'` returns only the fully-overlapping region of size `size(A) - size(B) + 1` (empty when `B` is larger than `A` along any dimension)."
         ]
     },
     "validation": {
-        "summary": "`conv2` uses an in-repo implementation for both the direct (`conv2(A, B)`) and separable (`conv2(u, v, A)`) forms. The module-level tests cover `'full'`, `'same'`, and `'valid'` shapes against reference outputs. The GPU path currently defers to the CPU implementation via the in-process provider and returns a GPU handle; a native WGPU `conv2d` kernel is tracked as follow-up.",
+        "summary": "`conv2` uses one formula-aligned implementation for direct (`conv2(A, B)`) and separable (`conv2(u, v, A)`) forms. Tests cover asymmetric kernels, even-kernel `'same'` alignment, all shape modes, single and complex class retention, exact integer gathers, mixed providers, and resident fallback. Providers may supply a class-preserving native real-floating `conv2d` hook.",
         "implementation": {
             "label": "crates/runmat-runtime/src/builtins/math/signal/conv2.rs",
             "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/signal/conv2.rs"