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

package/dist/generated/builtins/find.js

@@ -9,18 +9,18 @@ const builtinDoc = {
         "indices",
         "row",
         "column",
-        "gpu"
+        "gpu",
+        "integer"
     ],
-    "summary": "Locate nonzero indices and values in MATLAB and RunMat.",
+    "summary": "Locate nonzero indices and values with exact integer and GPU-aware semantics.",
     "gpu_support": {
         "elementwise": false,
         "reduction": false,
         "precisions": [
-            "f32",
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "WGPU provider executes find directly on the device; other providers fall back to the host and re-upload results to preserve residency."
+        "notes": "An f64 provider can execute find natively. Inputs resident in an f32 provider use a gather, host-compute, and re-upload fallback through the input handle's owning provider so double index outputs cannot round above 2^24 while outputs remain resident; resident logical and integer inputs use the same fallback to preserve their output classes and authoritative values."
     },
     "fusion": {
         "elementwise": false,
@@ -30,86 +30,56 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "builtins::array::indexing::find::tests",
-        "integration": "builtins::array::indexing::find::tests::find_gpu_roundtrip"
+        "unit": "builtins::array::indexing::find::tests"
     },
-    "description": "`find(X)` returns indices of nonzero elements in `X`. With one output it returns 1-based linear indices; with multiple outputs it returns row/column subscripts (and optionally values). Count limits and search-direction options follow MATLAB semantics.",
+    "description": "`find(X)` returns the 1-based indices of nonzero elements in column-major order. The documented input classes are single, double, all eight integer classes, logical, and char, including complex numeric arrays. With three outputs, `v` preserves the selected value class and authoritative integer values.",
     "behaviors": [
-        "`find(X)` scans in column-major order and returns a column vector of linear indices.",
-        "`find(X, K)` limits the result to the first `K` matches; `K = 0` yields an empty result.",
-        "`find(X, K, 'first')` (default) scans from the start, while `'last'` scans from the end.",
-        "`find(X, 'last')` is equivalent to `find(X, 1, 'last')` and returns the final nonzero index.",
-        "`[row, col] = find(X)` returns per-element row and column subscripts for 2-D or N-D inputs (higher dimensions are flattened into the column index, matching MATLAB semantics).",
-        "`[row, col, val] = find(X)` also returns the corresponding values; complex inputs preserve their complex values.",
-        "Logical, char, integer, and double inputs are all supported. Empty inputs return empty outputs with MATLAB-compatible shapes."
+        "For one output, a row-vector input produces a row vector of indices; every other nonspecial input produces a column vector.",
+        "`find([])` and `find(0)` use MATLAB's empty-matrix convention and return `[]`; other empty or all-zero row vectors return `1×0`, and other empty results return `0×1`.",
+        "`find(X,K)` requires a positive integer scalar K. Typed K values are converted exactly and zero, negative, fractional, nonfinite, or out-of-platform-range values reject before X is traversed.",
+        "`find(X,K,'first')` scans from the start. `find(X,K,'last')` selects the last K matches but returns them in ascending linear-index order.",
+        "`[row,col,v] = find(X)` returns column vectors. For N-D X, col linearizes the trailing dimensions.",
+        "Integer and complex-integer inputs use authoritative storage for zero testing and preserve exact v values above flintmax. Logical v remains logical and single v remains single.",
+        "Typed-integer sparse storage is a gated RunMat extension because MATLAB sparse value storage is single, double, or logical.",
+        "`find(X,direction)` without K is a gated RunMat convenience extension; the documented MATLAB form is `find(X,K,direction)`."
     ],
     "examples": [
         {
-            "description": "Finding linear indices of nonzero elements",
+            "description": "Find linear indices",
             "input": "A = [0 4 0; 7 0 9];\nk = find(A)",
             "output": "k =\n     2\n     4\n     6"
         },
         {
-            "description": "Limiting the number of matches",
-            "input": "A = [0 3 5 0 8];\nfirst_two = find(A, 2)",
-            "output": "first_two =\n     2\n     3"
+            "description": "Find the final two matches",
+            "input": "A = [1 0 2 3 0];\nk = find(A,2,'last')",
+            "output": "k =\n     3\n     4"
         },
         {
-            "description": "Locating the last nonzero element",
-            "input": "A = [1 0 0 6 0 2];\nlast_index = find(A, 'last')",
-            "output": "last_index =\n     6"
-        },
-        {
-            "description": "Retrieving row and column subscripts",
-            "input": "A = [0 4 0; 7 0 9];\n[rows, cols] = find(A)",
-            "output": "rows =\n     2\n     1\n     2\n\ncols =\n     1\n     2\n     3"
-        },
-        {
-            "description": "Capturing values alongside indices (including complex inputs)",
-            "input": "Z = [0 1+2i; 0 0; 3-4i 0];\n[r, c, v] = find(Z)",
-            "output": "r =\n     1\n     3\n\nc =\n     1\n     1\n\nv =\n   1.0000 + 2.0000i\n   3.0000 - 4.0000i"
+            "description": "Preserve integer values",
+            "input": "A = uint64([0 9007199254740993]);\n[r,c,v] = find(A)",
+            "output": "r = 1\nc = 2\nv = uint64(9007199254740993)"
         }
     ],
     "faqs": [
         {
-            "question": "What elements does `find` consider nonzero?",
-            "answer": "Any element whose real or imaginary component is nonzero. For logical inputs, `true` maps to 1 and is considered nonzero; `false` is ignored."
-        },
-        {
-            "question": "How are higher-dimensional arrays handled when requesting row/column outputs?",
-            "answer": "`find` treats the first dimension as rows and flattens the remaining dimensions into the column index, matching MATLAB's column-major storage."
-        },
-        {
-            "question": "What happens when I request more matches than exist?",
-            "answer": "`find` returns all available nonzero elements—no error is raised. For example, `find(A, 10)` simply returns every nonzero in `A` if it has fewer than 10."
-        },
-        {
-            "question": "Does `find` support char arrays and integers?",
-            "answer": "Yes. Characters are converted to their numeric code points during the test for nonzero values; integers are promoted to double precision for the result vectors."
-        },
-        {
-            "question": "Can I run `find` entirely on the GPU today?",
-            "answer": "Not yet. The runtime gathers GPU inputs, computes on the host, and re-uploads results. Providers can implement the optional `find` hook to make the entire path GPU-native in the future."
-        },
-        {
-            "question": "What shapes do empty results take?",
-            "answer": "When no element matches, the returned arrays are `0×1` column vectors, just like MATLAB."
+            "question": "What counts as nonzero?",
+            "answer": "A real value is nonzero when it is not exact zero. A complex value is nonzero when either component is nonzero. NaN and infinities are nonzero."
         },
         {
-            "question": "How does `find` interact with fusion or auto-offload?",
-            "answer": "`find` is a control-flow style operation, so it does not participate in fusion. Auto-offload still keeps data resident on the GPU where possible by uploading results after the host computation."
+            "question": "Are index outputs integers?",
+            "answer": "No. MATLAB-compatible k, row, and col outputs are double. RunMat rejects an index that cannot be represented exactly as binary64 instead of silently rounding it."
         },
         {
-            "question": "Does `find` preserve complex values in the third output?",
-            "answer": "Yes. When you request the value output, complex inputs return a complex column vector that matches MATLAB's behaviour."
+            "question": "What happens on an f32 GPU provider?",
+            "answer": "RunMat gathers and computes the result on the host so double indices remain exact, then re-uploads the outputs through the input handle's owning provider to preserve gpuArray residency and device ownership. An f64 provider can execute the operation natively."
         },
         {
-            "question": "Can I combine `find` with `gpuArray` explicitly?",
-            "answer": "Absolutely. If you call `find(gpuArray(X))`, the runtime ensures outputs stay on the GPU so later GPU-aware builtins can consume them without additional transfers."
+            "question": "Does the third output preserve integer values?",
+            "answer": "Yes. v preserves all eight integer classes exactly, including int64 and uint64 values above flintmax."
         },
         {
-            "question": "Is there a way to obtain subscripts for every dimension?",
-            "answer": "Use `find` to get linear indices and then call `ind2sub(size(X), ...)` if you need explicit per-dimension subscripts for N-D arrays."
+            "question": "Why can strict compatibility reject find(X,'last')?",
+            "answer": "MATLAB documents direction only after K. Enable RunMat extensions to use the direction-only convenience form, or write `find(X,1,'last')`."
         }
     ],
     "links": [
@@ -134,9 +104,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/array/indexing/find.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/indexing/find.rs"
     },
-    "gpu_residency": "Usually you do **not** need to move data with `gpuArray` manually. If a provider backs `find` directly, the entire operation stays on the GPU. Otherwise, RunMat gathers once, computes on the host, and then uploads results back to the active provider so subsequent kernels remain device-resident. This means GPU pipelines continue seamlessly without additional `gather`/`gpuArray` calls from user code.",
+    "gpu_residency": "F64 real inputs use the owning provider's hook when available. F32, logical, and integer resident inputs take a correctness-first host fallback because index outputs must be exact doubles and v must preserve its input class; fallback outputs are re-uploaded through that same owner so they remain resident on the input device.",
     "gpu_behavior": [
-        "When the input already resides on the GPU (i.e., a `gpuArray`), RunMat gathers it if the active provider does not implement a dedicated `find` kernel, performs the computation on the host, and then uploads the results back to the provider. This preserves residency so downstream fused kernels can continue on the device without an explicit `gather`. Providers may implement a custom hook in the future to run `find` entirely on the GPU; until then, the automatic gather/upload path maintains correctness with a small one-off cost."
+        "Provider execution is limited to cases where the owning provider can produce exact double indices. Other resident integer inputs gather exactly through their owning provider, compute on the host, and restore outputs through that same provider even when another provider is active."
     ],
     "key": "find",
     "slug": "find",

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

@@ -1 +1 @@
-{"version":3,"file":"find.js","sourceRoot":"","sources":["../../../src/generated/builtins/find.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,MAAM;QACN,SAAS;QACT,SAAS;QACT,KAAK;QACL,QAAQ;QACR,KAAK;KACN;IACD,SAAS,EAAE,yDAAyD;IACpE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,wIAAwI;KAClJ;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,wCAAwC;QAChD,aAAa,EAAE,4DAA4D;KAC5E;IACD,aAAa,EAAE,6PAA6P;IAC5Q,WAAW,EAAE;QACX,sFAAsF;QACtF,0FAA0F;QAC1F,0FAA0F;QAC1F,8FAA8F;QAC9F,gLAAgL;QAChL,kHAAkH;QAClH,+HAA+H;KAChI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,kCAAkC;YAC3C,QAAQ,EAAE,6BAA6B;SACxC;QACD;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,0CAA0C;YACnD,QAAQ,EAAE,6BAA6B;SACxC;QACD;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,kDAAkD;YAC3D,QAAQ,EAAE,sBAAsB;SACjC;QACD;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,6CAA6C;YACtD,QAAQ,EAAE,kEAAkE;SAC7E;QACD;YACE,aAAa,EAAE,+DAA+D;YAC9E,OAAO,EAAE,iDAAiD;YAC1D,QAAQ,EAAE,6FAA6F;SACxG;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,+IAA+I;SAC1J;QACD;YACE,UAAU,EAAE,+EAA+E;YAC3F,QAAQ,EAAE,gJAAgJ;SAC3J;QACD;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,2JAA2J;SACtK;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,kKAAkK;SAC7K;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,2LAA2L;SACtM;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,0FAA0F;SACrG;QACD;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,mMAAmM;SAC9M;QACD;YACE,UAAU,EAAE,0DAA0D;YACtE,QAAQ,EAAE,wHAAwH;SACnI;QACD;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,qKAAqK;SAChL;QACD;YACE,UAAU,EAAE,0DAA0D;YACtE,QAAQ,EAAE,sIAAsI;SACjJ;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6DAA6D;QACtE,KAAK,EAAE,0GAA0G;KAClH;IACD,eAAe,EAAE,mZAAmZ;IACpa,cAAc,EAAE;QACd,ohBAAohB;KACrhB;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"find.js","sourceRoot":"","sources":["../../../src/generated/builtins/find.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,MAAM;QACN,SAAS;QACT,SAAS;QACT,KAAK;QACL,QAAQ;QACR,KAAK;QACL,SAAS;KACV;IACD,SAAS,EAAE,+EAA+E;IAC1F,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,iXAAiX;KAC3X;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,wCAAwC;KACjD;IACD,aAAa,EAAE,gTAAgT;IAC/T,WAAW,EAAE;QACX,6HAA6H;QAC7H,wKAAwK;QACxK,iMAAiM;QACjM,2IAA2I;QAC3I,oGAAoG;QACpG,kLAAkL;QAClL,6HAA6H;QAC7H,6HAA6H;KAC9H;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,qBAAqB;YACpC,OAAO,EAAE,kCAAkC;YAC3C,QAAQ,EAAE,6BAA6B;SACxC;QACD;YACE,aAAa,EAAE,4BAA4B;YAC3C,OAAO,EAAE,wCAAwC;YACjD,QAAQ,EAAE,qBAAqB;SAChC;QACD;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,sDAAsD;YAC/D,QAAQ,EAAE,4CAA4C;SACvD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yBAAyB;YACrC,QAAQ,EAAE,iJAAiJ;SAC5J;QACD;YACE,UAAU,EAAE,6BAA6B;YACzC,QAAQ,EAAE,mKAAmK;SAC9K;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,oQAAoQ;SAC/Q;QACD;YACE,UAAU,EAAE,gDAAgD;YAC5D,QAAQ,EAAE,uGAAuG;SAClH;QACD;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,4IAA4I;SACvJ;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6DAA6D;QACtE,KAAK,EAAE,0GAA0G;KAClH;IACD,eAAe,EAAE,wUAAwU;IACzV,cAAc,EAAE;QACd,0RAA0R;KAC3R;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/findElement.js

@@ -34,6 +34,7 @@ const builtinDoc = {
     "behaviors": [
         "`tree` must be a scalar RunMat `htmlTree` object or a cell array of `htmlTree` objects.",
         "`selector` must be a string scalar or character vector.",
+        "Numeric, logical, complex, and provider-resident inputs are not htmlTree or selector values and reject before any provider access.",
         "Supported selectors include element tags, `*`, `.class`, `#id`, `[attr]`, `[attr=value]`, `[attr~=value]`, `[attr|=value]`, `[attr^=value]`, `[attr$=value]`, `[attr*=value]`, descendant combinators, child combinators (`>`), adjacent-sibling combinators (`+`), general-sibling combinators (`~`), comma-separated groups, `:empty`, `:first-child`, `:first-of-type`, and `:not(...)` for these supported pseudo-classes.",
         "Attribute names are matched case-insensitively through the parser's lowercase attribute map. Attribute values, ids, and classes use CSS-style exact, whitespace-list, dash-prefix, prefix, suffix, or substring string matching according to the selector operator.",
         "Sibling matching follows element siblings and ignores intervening whitespace text nodes.",

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

@@ -1 +1 @@
-{"version":3,"file":"findElement.js","sourceRoot":"","sources":["../../../src/generated/builtins/findElement.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,aAAa;IACtB,UAAU,EAAE,wBAAwB;IACpC,UAAU,EAAE;QACV,aAAa;QACb,UAAU;QACV,MAAM;QACN,KAAK;QACL,cAAc;QACd,gBAAgB;KACjB;IACD,SAAS,EAAE,+CAA+C;IAC1D,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,wFAAwF;KAClG;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,gDAAgD;QACxD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,sJAAsJ;IACrK,WAAW,EAAE;QACX,yFAAyF;QACzF,yDAAyD;QACzD,gaAAga;QACha,qQAAqQ;QACrQ,0FAA0F;QAC1F,qIAAqI;QACrI,0HAA0H;QAC1H,8FAA8F;KAC/F;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,YAAY;YAC3B,OAAO,EAAE,oKAAoK;YAC7K,QAAQ,EAAE,6BAA6B;SACxC;QACD;YACE,aAAa,EAAE,iBAAiB;YAChC,OAAO,EAAE,0GAA0G;YACnH,QAAQ,EAAE,yEAAyE;SACpF;QACD;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,+IAA+I;YACxJ,QAAQ,EAAE,yDAAyD;SACpE;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,oIAAoI;YAC7I,QAAQ,EAAE,+DAA+D;SAC1E;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,6JAA6J;SACxK;QACD;YACE,UAAU,EAAE,4DAA4D;YACxE,QAAQ,EAAE,kPAAkP;SAC7P;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,mFAAmF;SAC9F;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,cAAc;YACvB,KAAK,EAAE,gBAAgB;SACxB;QACD;YACE,OAAO,EAAE,iBAAiB;YAC1B,KAAK,EAAE,mBAAmB;SAC3B;KACF;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,gBAAgB;YAC/B,OAAO,EAAE,wCAAwC;YACjD,QAAQ,EAAE,iEAAiE;SAC5E;QACD,QAAQ,EAAE;YACR,4EAA4E;YAC5E,qEAAqE;SACtE;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,qEAAqE;QAC9E,KAAK,EAAE,kHAAkH;KAC1H;IACD,eAAe,EAAE,iFAAiF;IAClG,KAAK,EAAE,aAAa;IACpB,MAAM,EAAE,aAAa;IACrB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;QACT,gBAAgB;KACjB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"findElement.js","sourceRoot":"","sources":["../../../src/generated/builtins/findElement.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,aAAa;IACtB,UAAU,EAAE,wBAAwB;IACpC,UAAU,EAAE;QACV,aAAa;QACb,UAAU;QACV,MAAM;QACN,KAAK;QACL,cAAc;QACd,gBAAgB;KACjB;IACD,SAAS,EAAE,+CAA+C;IAC1D,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,wFAAwF;KAClG;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,gDAAgD;QACxD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,sJAAsJ;IACrK,WAAW,EAAE;QACX,yFAAyF;QACzF,yDAAyD;QACzD,oIAAoI;QACpI,gaAAga;QACha,qQAAqQ;QACrQ,0FAA0F;QAC1F,qIAAqI;QACrI,0HAA0H;QAC1H,8FAA8F;KAC/F;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,YAAY;YAC3B,OAAO,EAAE,oKAAoK;YAC7K,QAAQ,EAAE,6BAA6B;SACxC;QACD;YACE,aAAa,EAAE,iBAAiB;YAChC,OAAO,EAAE,0GAA0G;YACnH,QAAQ,EAAE,yEAAyE;SACpF;QACD;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,+IAA+I;YACxJ,QAAQ,EAAE,yDAAyD;SACpE;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,oIAAoI;YAC7I,QAAQ,EAAE,+DAA+D;SAC1E;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,6JAA6J;SACxK;QACD;YACE,UAAU,EAAE,4DAA4D;YACxE,QAAQ,EAAE,kPAAkP;SAC7P;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,mFAAmF;SAC9F;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,cAAc;YACvB,KAAK,EAAE,gBAAgB;SACxB;QACD;YACE,OAAO,EAAE,iBAAiB;YAC1B,KAAK,EAAE,mBAAmB;SAC3B;KACF;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,gBAAgB;YAC/B,OAAO,EAAE,wCAAwC;YACjD,QAAQ,EAAE,iEAAiE;SAC5E;QACD,QAAQ,EAAE;YACR,4EAA4E;YAC5E,qEAAqE;SACtE;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,qEAAqE;QAC9E,KAAK,EAAE,kHAAkH;KAC1H;IACD,eAAe,EAAE,iFAAiF;IAClG,KAAK,EAAE,aAAa;IACpB,MAAM,EAAE,aAAa;IACrB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;QACT,gBAAgB;KACjB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/findgroups.js

@@ -7,29 +7,63 @@ const builtinDoc = {
         "findgroups",
         "groups",
         "table",
-        "categorical"
+        "categorical",
+        "integer",
+        "missing"
     ],
-    "summary": "Find groups and return group numbers.",
+    "summary": "Assign sorted group numbers while preserving exact grouping identifiers.",
     "gpu_support": {
         "elementwise": false,
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Grouping runs on the host."
+        "notes": "MATLAB does not document gpuArray support for findgroups. RunMat can gather resident grouping data only when the resident-input extension is enabled."
     },
     "tested": {
         "unit": "builtins::array::grouping::tests"
     },
-    "description": "`G = findgroups(A)` assigns one-based group IDs to matching nonmissing values in `A`; missing values receive NaN group IDs.",
+    "description": "`G = findgroups(A)` assigns one-based double group numbers in sorted unique-key order. Numeric grouping includes all eight integer classes, whose values are compared exactly. Missing strings, empty character vectors, NaN, NaT, and undefined categorical values produce NaN in G.",
     "behaviors": [
-        "Supports numeric, logical, string, cell, categorical, datetime/duration, multiple grouping inputs, and table variable grouping.",
-        "Group IDs are assigned in sorted group-key order."
+        "A must be a scalar or vector. G has the same size and row-or-column orientation as A.",
+        "`findgroups(A1,...,AN)` groups sorted unique tuples. Every input vector must have the same size, and a missing value in any role makes the corresponding G element NaN.",
+        "`[G,ID] = findgroups(A)` returns sorted unique identifiers in A's class. Integer IDs preserve authoritative values above flintmax.",
+        "`[G,ID1,...,IDN] = findgroups(A1,...,AN)` preserves each identifier output's corresponding input class.",
+        "`[G,TID] = findgroups(T)` groups all supported table variables and preserves their names and classes in TID.",
+        "Supported grouping variables are numeric, logical, string, cell arrays of character vectors, categorical, datetime, duration, and calendarDuration. Sparse and complex grouping variables reject explicitly.",
+        "Matrix-as-columns grouping, `findgroups(T,selector)`, timetable input, and resident input are independent gated RunMat extensions. The table selector form accepts exactly one selector and never ignores trailing arguments."
     ],
     "examples": [
         {
             "description": "Group strings",
             "input": "G = findgroups([\"b\";\"a\";\"b\"])",
             "output": "G = [2; 1; 2]"
+        },
+        {
+            "description": "Group exact integers",
+            "input": "A = uint64([9007199254740992 9007199254740993 9007199254740992]);\n[G,ID] = findgroups(A)",
+            "output": "G = [1 2 1]\nID = uint64([9007199254740992 9007199254740993])"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Are group numbers integer-typed?",
+            "answer": "No. G contains positive integer-valued doubles and NaN for missing rows. Integer grouping identifiers retain their integer class in ID or TID."
+        },
+        {
+            "question": "Are integer values converted to double for grouping?",
+            "answer": "No. RunMat compares authoritative signed or unsigned integer values directly, including values above flintmax."
+        },
+        {
+            "question": "Can I pass a matrix as A?",
+            "answer": "MATLAB documents grouping vectors. RunMat can interpret matrix columns as grouping roles only when the matrix-as-columns extension is enabled."
+        },
+        {
+            "question": "Can findgroups consume GPU-resident data?",
+            "answer": "Only in RunMat extension mode. The gate is checked recursively before any resident input or table variable is gathered."
+        },
+        {
+            "question": "Does findgroups accept timetables?",
+            "answer": "Timetable input is a separate RunMat extension. Its identifier output is currently an ordinary table of selected variable values; row times are not grouping variables."
         }
     ],
     "source": {

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

@@ -1 +1 @@
-{"version":3,"file":"findgroups.js","sourceRoot":"","sources":["../../../src/generated/builtins/findgroups.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,YAAY;QACZ,QAAQ;QACR,OAAO;QACP,aAAa;KACd;IACD,SAAS,EAAE,uCAAuC;IAClD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,4BAA4B;KACtC;IACD,QAAQ,EAAE;QACR,MAAM,EAAE,kCAAkC;KAC3C;IACD,aAAa,EAAE,6HAA6H;IAC5I,WAAW,EAAE;QACX,iIAAiI;QACjI,mDAAmD;KACpD;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,eAAe;YAC9B,OAAO,EAAE,qCAAqC;YAC9C,QAAQ,EAAE,eAAe;SAC1B;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,wDAAwD;QACjE,KAAK,EAAE,qGAAqG;KAC7G;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"findgroups.js","sourceRoot":"","sources":["../../../src/generated/builtins/findgroups.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,gBAAgB;IAC5B,UAAU,EAAE;QACV,YAAY;QACZ,QAAQ;QACR,OAAO;QACP,aAAa;QACb,SAAS;QACT,SAAS;KACV;IACD,SAAS,EAAE,0EAA0E;IACrF,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uJAAuJ;KACjK;IACD,QAAQ,EAAE;QACR,MAAM,EAAE,kCAAkC;KAC3C;IACD,aAAa,EAAE,uRAAuR;IACtS,WAAW,EAAE;QACX,uFAAuF;QACvF,yKAAyK;QACzK,oIAAoI;QACpI,yGAAyG;QACzG,8GAA8G;QAC9G,8MAA8M;QAC9M,+NAA+N;KAChO;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,eAAe;YAC9B,OAAO,EAAE,qCAAqC;YAC9C,QAAQ,EAAE,eAAe;SAC1B;QACD;YACE,aAAa,EAAE,sBAAsB;YACrC,OAAO,EAAE,2FAA2F;YACpG,QAAQ,EAAE,+DAA+D;SAC1E;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,gJAAgJ;SAC3J;QACD;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,gHAAgH;SAC3H;QACD;YACE,UAAU,EAAE,2BAA2B;YACvC,QAAQ,EAAE,gJAAgJ;SAC3J;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,yHAAyH;SACpI;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,yKAAyK;SACpL;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,wDAAwD;QACjE,KAAK,EAAE,qGAAqG;KAC7G;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/findobj.js

@@ -33,10 +33,12 @@ const builtinDoc = {
     "behaviors": [
         "`findobj()` returns the graphics root, figures, axes, and searchable descendants in traversal order.",
         "`findobj(prop, value)` returns objects whose property exactly matches `value`.",
-        "`findobj(objhandles, ...)` restricts the search to the supplied numeric graphics handle or numeric handle array. Duplicate roots can produce duplicate result handles, matching MATLAB traversal behavior.",
+        "`findobj(objhandles, ...)` restricts the search to supplied graphics roots. RunMat currently represents graphics objects with numeric double handles; typed-integer aliases for that registry are a RunMat-only extension and must be exactly representable as double.",
         "`findobj(objhandles, 'flat', ...)` searches only the supplied root handles.",
         "`findobj(objhandles, '-depth', d, ...)` limits descendant traversal to depth `d`; `Inf` means unlimited depth.",
         "Multiple property predicates are combined with implicit `-and` when no logical operator is supplied.",
+        "Typed-integer property values compare class-sensitively and exactly from authoritative storage, including values above `flintmax`; they are not rounded through double.",
+        "Provider-resident numeric buffers are not graphics objects or host property metadata and are never gathered by `findobj`.",
         "An empty result is returned as a numeric `0x0` tensor; nonempty results are returned as a numeric column vector of handles."
     ],
     "options": [
@@ -81,7 +83,7 @@ const builtinDoc = {
         },
         {
             "question": "Can `findobj` search only a figure or axes?",
-            "answer": "Yes. Pass a numeric figure, axes, or plot-object handle as the first argument to use that object as the search root."
+            "answer": "Yes. Pass a RunMat numeric figure, axes, or plot-object handle as the first argument to use that object as the search root. Typed-integer numeric aliases require RunMat extension mode because MATLAB's public contract uses graphics objects."
         },
         {
             "question": "Does `findobj` gather GPU arrays?",

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

@@ -1 +1 @@
-{"version":3,"file":"findobj.js","sourceRoot":"","sources":["../../../src/generated/builtins/findobj.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,UAAU;QACV,QAAQ;QACR,iBAAiB;QACjB,UAAU;KACX;IACD,SAAS,EAAE,oEAAoE;IAC/E,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,0FAA0F;KACpG;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,IAAI;QAClB,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,oCAAoC;QAC5C,IAAI,EAAE,qCAAqC;KAC5C;IACD,aAAa,EAAE,0TAA0T;IACzU,WAAW,EAAE;QACX,sGAAsG;QACtG,gFAAgF;QAChF,4MAA4M;QAC5M,6EAA6E;QAC7E,gHAAgH;QAChH,sGAAsG;QACtG,6HAA6H;KAC9H;IACD,SAAS,EAAE;QACT,uFAAuF;QACvF,iFAAiF;QACjF,0GAA0G;QAC1G,0KAA0K;QAC1K,uHAAuH;QACvH,oIAAoI;QACpI,+JAA+J;KAChK;IACD,aAAa,EAAE;QACb,uPAAuP;QACvP,mJAAmJ;QACnJ,yLAAyL;KAC1L;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,uBAAuB;YACtC,OAAO,EAAE,6EAA6E;YACtF,QAAQ,EAAE,iDAAiD;SAC5D;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,+FAA+F;YACxG,QAAQ,EAAE,sCAAsC;SACjD;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,yCAAyC;YAClD,QAAQ,EAAE,gEAAgE;SAC3E;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,mGAAmG;SAC7G;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,wGAAwG;SACnH;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,sHAAsH;SACjI;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,+GAA+G;SAC1H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,8DAA8D;QACvE,KAAK,EAAE,2GAA2G;KACnH;IACD,eAAe,EAAE,oHAAoH;IACrI,cAAc,EAAE;QACd,qHAAqH;QACrH,qJAAqJ;KACtJ;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":"findobj.js","sourceRoot":"","sources":["../../../src/generated/builtins/findobj.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,UAAU;QACV,QAAQ;QACR,iBAAiB;QACjB,UAAU;KACX;IACD,SAAS,EAAE,oEAAoE;IAC/E,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,0FAA0F;KACpG;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,IAAI;QAClB,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,oCAAoC;QAC5C,IAAI,EAAE,qCAAqC;KAC5C;IACD,aAAa,EAAE,0TAA0T;IACzU,WAAW,EAAE;QACX,sGAAsG;QACtG,gFAAgF;QAChF,wQAAwQ;QACxQ,6EAA6E;QAC7E,gHAAgH;QAChH,sGAAsG;QACtG,yKAAyK;QACzK,2HAA2H;QAC3H,6HAA6H;KAC9H;IACD,SAAS,EAAE;QACT,uFAAuF;QACvF,iFAAiF;QACjF,0GAA0G;QAC1G,0KAA0K;QAC1K,uHAAuH;QACvH,oIAAoI;QACpI,+JAA+J;KAChK;IACD,aAAa,EAAE;QACb,uPAAuP;QACvP,mJAAmJ;QACnJ,yLAAyL;KAC1L;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,uBAAuB;YACtC,OAAO,EAAE,6EAA6E;YACtF,QAAQ,EAAE,iDAAiD;SAC5D;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,+FAA+F;YACxG,QAAQ,EAAE,sCAAsC;SACjD;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,yCAAyC;YAClD,QAAQ,EAAE,gEAAgE;SAC3E;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,mGAAmG;SAC7G;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,wGAAwG;SACnH;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,iPAAiP;SAC5P;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,+GAA+G;SAC1H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,8DAA8D;QACvE,KAAK,EAAE,2GAA2G;KACnH;IACD,eAAe,EAAE,oHAAoH;IACrI,cAAc,EAAE;QACd,qHAAqH;QACrH,qJAAqJ;KACtJ;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/findprop.d.ts.map

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

package/dist/generated/builtins/findprop.js

@@ -32,6 +32,7 @@ const builtinDoc = {
     "description": "`prop = findprop(obj, name)` returns property metadata for class-defined or dynamic properties. Dynamic properties on handle objects return a `matlab.metadata.DynamicProperty` handle; class-defined properties return a `matlab.metadata.Property` object. Missing properties return an empty double.",
     "behaviors": [
         "The target must be an object or valid handle object.",
+        "Numeric, logical, complex, and provider-resident values are not object targets; all integer classes reject without conversion into metadata.",
         "Dynamic property lookup on handle objects returns a metadata handle that can later be passed to `delete`.",
         "Class-defined property lookup returns metadata fields including `Name`, `DefiningClass`, `GetAccess`, `SetAccess`, and `Dependent`.",
         "Missing properties return `[]`.",

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

@@ -1 +1 @@
-{"version":3,"file":"findprop.js","sourceRoot":"","sources":["../../../src/generated/builtins/findprop.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,UAAU;QACV,cAAc;QACd,mBAAmB;QACnB,0BAA0B;QAC1B,iCAAiC;KAClC;IACD,SAAS,EAAE,uDAAuD;IAClE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,qEAAqE;KAC/E;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,gGAAgG;KAChH;IACD,aAAa,EAAE,ySAAyS;IACxT,WAAW,EAAE;QACX,sDAAsD;QACtD,2GAA2G;QAC3G,qIAAqI;QACrI,iCAAiC;QACjC,mEAAmE;KACpE;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,kEAAkE;YAC3E,QAAQ,EAAE,eAAe;SAC1B;QACD;YACE,aAAa,EAAE,kBAAkB;YACjC,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,QAAQ;SACnB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,8EAA8E;YAC1F,QAAQ,EAAE,iGAAiG;SAC5G;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,yDAAyD;SACpE;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;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,oEAAoE;QAC7E,KAAK,EAAE,iHAAiH;KACzH;IACD,eAAe,EAAE,0EAA0E;IAC3F,aAAa,EAAE;QACb,kCAAkC;QAClC,wFAAwF;KACzF;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,eAAe;KAChB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"findprop.js","sourceRoot":"","sources":["../../../src/generated/builtins/findprop.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,UAAU;IACnB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,UAAU;QACV,cAAc;QACd,mBAAmB;QACnB,0BAA0B;QAC1B,iCAAiC;KAClC;IACD,SAAS,EAAE,uDAAuD;IAClE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,qEAAqE;KAC/E;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,gGAAgG;KAChH;IACD,aAAa,EAAE,ySAAyS;IACxT,WAAW,EAAE;QACX,sDAAsD;QACtD,8IAA8I;QAC9I,2GAA2G;QAC3G,qIAAqI;QACrI,iCAAiC;QACjC,mEAAmE;KACpE;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,kEAAkE;YAC3E,QAAQ,EAAE,eAAe;SAC1B;QACD;YACE,aAAa,EAAE,kBAAkB;YACjC,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,QAAQ;SACnB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,8EAA8E;YAC1F,QAAQ,EAAE,iGAAiG;SAC5G;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,yDAAyD;SACpE;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;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,oEAAoE;QAC7E,KAAK,EAAE,iHAAiH;KACzH;IACD,eAAe,EAAE,0EAA0E;IAC3F,aAAa,EAAE;QACb,kCAAkC;QAClC,wFAAwF;KACzF;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,eAAe;KAChB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/fir1.js

@@ -18,7 +18,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Coefficient design runs on the host. The returned coefficients can be passed to GPU-aware filtering functions."
+        "notes": "The current implementation gathers resident numeric arguments and returns host double coefficients; restoring documented GPU output residency is a tracked compatibility gap."
     },
     "fusion": {
         "elementwise": false,
@@ -65,7 +65,7 @@ const builtinDoc = {
         },
         {
             "question": "Does `fir1` run on the GPU?",
-            "answer": "No. It generates a small coefficient vector on the host. GPU acceleration applies when those coefficients are used by filtering builtins with gpuArray signals."
+            "answer": "The current implementation gathers resident numeric arguments and returns host double coefficients. Returning the documented resident GPU result remains a tracked compatibility gap."
         }
     ],
     "links": [
@@ -87,8 +87,8 @@ const builtinDoc = {
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/signal/fir1.rs"
     },
     "gpu_behavior": [
-        "Host-side coefficient design only.",
-        "The resulting coefficient vector can be passed to `filter` or `filtfilt` with gpuArray signal data."
+        "Resident numeric arguments currently gather for host-side coefficient design.",
+        "The result is currently a host double row vector; documented GPU output residency is not yet restored."
     ],
     "key": "fir1",
     "slug": "fir1",

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

@@ -1 +1 @@
-{"version":3,"file":"fir1.js","sourceRoot":"","sources":["../../../src/generated/builtins/fir1.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,MAAM;QACN,KAAK;QACL,eAAe;QACf,SAAS;QACT,UAAU;QACV,UAAU;QACV,UAAU;KACX;IACD,SAAS,EAAE,mCAAmC;IAC9C,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,gHAAgH;KAC1H;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,gQAAgQ;IAC/Q,WAAW,EAAE;QACX,iDAAiD;QACjD,wEAAwE;QACxE,mEAAmE;QACnE,2DAA2D;QAC3D,+EAA+E;KAChF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,8DAA8D;YACvE,QAAQ,EAAE,UAAU;SACrB;QACD;YACE,aAAa,EAAE,sDAAsD;YACrE,OAAO,EAAE,oKAAoK;YAC7K,QAAQ,EAAE,cAAc;SACzB;QACD;YACE,aAAa,EAAE,iDAAiD;YAChE,OAAO,EAAE,oDAAoD;SAC9D;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,wFAAwF;SACnG;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,4DAA4D;SACvE;QACD;YACE,UAAU,EAAE,6BAA6B;YACzC,QAAQ,EAAE,iKAAiK;SAC5K;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,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,0DAA0D;QACnE,KAAK,EAAE,uGAAuG;KAC/G;IACD,cAAc,EAAE;QACd,oCAAoC;QACpC,qGAAqG;KACtG;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"fir1.js","sourceRoot":"","sources":["../../../src/generated/builtins/fir1.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,MAAM;QACN,KAAK;QACL,eAAe;QACf,SAAS;QACT,UAAU;QACV,UAAU;QACV,UAAU;KACX;IACD,SAAS,EAAE,mCAAmC;IAC9C,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,+KAA+K;KACzL;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,gQAAgQ;IAC/Q,WAAW,EAAE;QACX,iDAAiD;QACjD,wEAAwE;QACxE,mEAAmE;QACnE,2DAA2D;QAC3D,+EAA+E;KAChF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,8DAA8D;YACvE,QAAQ,EAAE,UAAU;SACrB;QACD;YACE,aAAa,EAAE,sDAAsD;YACrE,OAAO,EAAE,oKAAoK;YAC7K,QAAQ,EAAE,cAAc;SACzB;QACD;YACE,aAAa,EAAE,iDAAiD;YAChE,OAAO,EAAE,oDAAoD;SAC9D;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,wFAAwF;SACnG;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,4DAA4D;SACvE;QACD;YACE,UAAU,EAAE,6BAA6B;YACzC,QAAQ,EAAE,uLAAuL;SAClM;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,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,0DAA0D;QACnE,KAAK,EAAE,uGAAuG;KAC/G;IACD,cAAc,EAAE;QACd,+EAA+E;QAC/E,wGAAwG;KACzG;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/fitclinear.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "GPU inputs are gathered to host. Linear classification fitting runs on CPU."
+        "notes": "Linear classification fitting runs on CPU. Provider-resident inputs use a RunMat-only, compatibility-gated gather fallback; MATLAB-compatible mode rejects them before provider access."
     },
     "fusion": {
         "elementwise": false,
@@ -39,9 +39,12 @@ const builtinDoc = {
         "`Learner` supports `svm` and `logistic`. Logistic models use logistic-loss training and return posterior-style scores by default; SVM models return raw signed-margin scores.",
         "`Regularization` supports `ridge` and `lasso`. `Lambda` accepts a nonnegative scalar or vector, producing one coefficient column per Lambda value.",
         "`ObservationsIn` supports `rows` and `columns` for numeric matrices. Table input requires row observations.",
-        "`Y` can contain numeric, logical, string, char, or cell-string labels. The predicted label output preserves the label family.",
+        "`Y` can contain numeric, logical, string, char, cell-string, or any of the eight signed and unsigned integer label classes. Integer grouping identity and class are preserved exactly in `ClassNames` and prediction, including adjacent `int64` or `uint64` labels above `flintmax`.",
+        "Typed-integer matrix predictors and table numeric predictor variables are a compatibility-gated RunMat extension. Every value must be exactly representable in binary64 before statistical computation; inexact wide integers are rejected rather than rounded.",
+        "Typed-integer `Weights` and numeric name-value controls are a separate compatibility-gated RunMat extension and use the same exact binary64 boundary. MATLAB-compatible mode accepts the documented floating forms and rejects these integer extensions.",
         "Name-value options `ClassNames`, `PredictorNames`, `ResponseName`, `Weights`, `Prior`, `FitBias`, `Beta`, `Bias`, `Solver`, `IterationLimit`, `PassLimit`, and `ScoreTransform` are accepted.",
         "Rows containing `NaN` in predictors or response, or zero weights, are omitted before fitting; `Inf` values and negative weights are rejected.",
+        "Host and table fitting remain CPU operations. Resident input support is reported as `GatherFallback` and is independently gated as a RunMat extension before download.",
         "Cross-validation, cost matrices, leaveout/holdout partitions, and hyperparameter optimization are not implemented yet and raise explicit errors instead of silently producing partial models.",
         "The returned object exposes `Beta`, `Bias`, `Lambda`, `Learner`, `Regularization`, `Solver`, `ScoreTransform`, `ResponseName`, `PredictorNames`, `ClassNames`, `Prior`, `NumObservations`, `NumPredictors`, and `ModelParameters` properties. `[Mdl,FitInfo]` returns training diagnostics including `Lambda`, `Objective`, `NumIterations`, `NumPasses`, and `GradientNorm`."
     ],

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

@@ -1 +1 @@
-{"version":3,"file":"fitclinear.js","sourceRoot":"","sources":["../../../src/generated/builtins/fitclinear.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,YAAY;QACZ,uBAAuB;QACvB,KAAK;QACL,qBAAqB;QACrB,kBAAkB;QAClB,YAAY;KACb;IACD,SAAS,EAAE,2CAA2C;IACtD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6EAA6E;KACvF;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,MAAM;KACpB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,mDAAmD;QAC3D,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,kJAAkJ;IACjK,WAAW,EAAE;QACX,iHAAiH;QACjH,kLAAkL;QAClL,+KAA+K;QAC/K,oJAAoJ;QACpJ,6GAA6G;QAC7G,+HAA+H;QAC/H,+LAA+L;QAC/L,+IAA+I;QAC/I,+LAA+L;QAC/L,+WAA+W;KAChX;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,uJAAuJ;YAChK,QAAQ,EAAE,uEAAuE;SAClF;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,4HAA4H;YACrI,QAAQ,EAAE,4EAA4E;SACvF;QACD;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,yGAAyG;YAClH,QAAQ,EAAE,sEAAsE;SACjF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,2HAA2H;SACtI;QACD;YACE,UAAU,EAAE,wDAAwD;YACpE,QAAQ,EAAE,4LAA4L;SACvM;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,wEAAwE;QACjF,KAAK,EAAE,qHAAqH;KAC7H;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,IAAI;KACL;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"fitclinear.js","sourceRoot":"","sources":["../../../src/generated/builtins/fitclinear.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,YAAY;QACZ,uBAAuB;QACvB,KAAK;QACL,qBAAqB;QACrB,kBAAkB;QAClB,YAAY;KACb;IACD,SAAS,EAAE,2CAA2C;IACtD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,yLAAyL;KACnM;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,MAAM;KACpB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,mDAAmD;QAC3D,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,kJAAkJ;IACjK,WAAW,EAAE;QACX,iHAAiH;QACjH,kLAAkL;QAClL,+KAA+K;QAC/K,oJAAoJ;QACpJ,6GAA6G;QAC7G,uRAAuR;QACvR,iQAAiQ;QACjQ,0PAA0P;QAC1P,+LAA+L;QAC/L,+IAA+I;QAC/I,wKAAwK;QACxK,+LAA+L;QAC/L,+WAA+W;KAChX;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,uJAAuJ;YAChK,QAAQ,EAAE,uEAAuE;SAClF;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,4HAA4H;YACrI,QAAQ,EAAE,4EAA4E;SACvF;QACD;YACE,aAAa,EAAE,8BAA8B;YAC7C,OAAO,EAAE,yGAAyG;YAClH,QAAQ,EAAE,sEAAsE;SACjF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,2HAA2H;SACtI;QACD;YACE,UAAU,EAAE,wDAAwD;YACpE,QAAQ,EAAE,4LAA4L;SACvM;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,wEAAwE;QACjF,KAAK,EAAE,qHAAqH;KAC7H;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,IAAI;KACL;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/fitctree.js

@@ -18,7 +18,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "GPU inputs are gathered to host. Classification tree fitting runs on CPU."
+        "notes": "Classification tree fitting runs on CPU. Provider-resident inputs use a RunMat-only, compatibility-gated gather fallback; MATLAB-compatible mode rejects them before provider access."
     },
     "fusion": {
         "elementwise": false,
@@ -35,10 +35,13 @@ const builtinDoc = {
     "behaviors": [
         "`fitctree(X,Y)` fits a classification tree with observations in rows of `X` and class labels in `Y`.",
         "Table input supports `fitctree(Tbl,ResponseVarName)`, `fitctree(Tbl,formula)`, and `fitctree(Tbl,Y)`. Formula support covers additive predictor lists such as `Y ~ A + B`.",
-        "`Y` can contain numeric, logical, string, char, or cell-string labels. The predicted label output preserves the label family.",
+        "`Y` can contain numeric, logical, string, char, cell-string, or any of the eight signed and unsigned integer label classes. Integer grouping identity and class are preserved exactly in `ClassNames` and prediction, including adjacent `int64` or `uint64` labels above `flintmax`.",
+        "Typed-integer matrix predictors and table numeric predictor variables are a compatibility-gated RunMat extension. Every value must be exactly representable in binary64 before statistical computation; inexact wide integers are rejected rather than rounded.",
+        "Typed-integer `Weights` and numeric name-value controls are a separate compatibility-gated RunMat extension and use the same exact binary64 boundary. MATLAB-compatible mode accepts the documented floating forms and rejects these integer extensions.",
         "Name-value options `ClassNames`, `PredictorNames`, `ResponseName`, `MaxNumSplits`, `MinLeafSize`, `MinParentSize`, `SplitCriterion`, `Weights`, and `ScoreTransform` are accepted.",
         "`SplitCriterion` supports `gdi` and `deviance`. `ScoreTransform` currently accepts `none`.",
-        "Rows containing `NaN` in predictors, response, or zero weights are omitted before fitting; `Inf` values and negative weights are rejected.",
+        "Rows with missing responses, zero weights, or all predictor values missing are omitted. Rows with only some missing predictors remain available for split evaluation on observed variables. `Inf` values and negative weights are rejected.",
+        "Host and table fitting remain CPU operations. Resident input support is reported as `GatherFallback` and is independently gated as a RunMat extension before download.",
         "Categorical predictors, pruning, surrogate splits, cross-validation, prior/cost matrices, and hyperparameter optimization are not implemented yet and raise explicit errors instead of silently producing partial models.",
         "The returned object exposes `ResponseName`, `PredictorNames`, `ClassNames`, `CategoricalPredictors`, `ScoreTransform`, `NumObservations`, `NumPredictors`, `NumNodes`, `NumSplits`, and `ModelParameters` properties."
     ],

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

@@ -1 +1 @@
-{"version":3,"file":"fitctree.js","sourceRoot":"","sources":["../../../src/generated/builtins/fitctree.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,kBAAkB;QAClB,YAAY;KACb;IACD,SAAS,EAAE,2DAA2D;IACtE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,2EAA2E;KACrF;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,MAAM;KACpB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,iDAAiD;QACzD,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,2JAA2J;IAC1K,WAAW,EAAE;QACX,sGAAsG;QACtG,4KAA4K;QAC5K,+HAA+H;QAC/H,oLAAoL;QACpL,4FAA4F;QAC5F,4IAA4I;QAC5I,2NAA2N;QAC3N,uNAAuN;KACxN;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,8IAA8I;YACvJ,QAAQ,EAAE,4EAA4E;SACvF;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,qFAAqF;YAC9F,QAAQ,EAAE,+DAA+D;SAC1E;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,uHAAuH;SAClI;QACD;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,wMAAwM;SACnN;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,sEAAsE;QAC/E,KAAK,EAAE,mHAAmH;KAC3H;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,IAAI;KACL;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"fitctree.js","sourceRoot":"","sources":["../../../src/generated/builtins/fitctree.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,kBAAkB;QAClB,YAAY;KACb;IACD,SAAS,EAAE,2DAA2D;IACtE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uLAAuL;KACjM;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,MAAM;KACpB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,iDAAiD;QACzD,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,2JAA2J;IAC1K,WAAW,EAAE;QACX,sGAAsG;QACtG,4KAA4K;QAC5K,uRAAuR;QACvR,iQAAiQ;QACjQ,0PAA0P;QAC1P,oLAAoL;QACpL,4FAA4F;QAC5F,6OAA6O;QAC7O,wKAAwK;QACxK,2NAA2N;QAC3N,uNAAuN;KACxN;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,8IAA8I;YACvJ,QAAQ,EAAE,4EAA4E;SACvF;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,qFAAqF;YAC9F,QAAQ,EAAE,+DAA+D;SAC1E;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,uHAAuH;SAClI;QACD;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,wMAAwM;SACnN;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,sEAAsE;QAC/E,KAAK,EAAE,mHAAmH;KAC3H;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,IAAI;KACL;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/fitdist.js

@@ -22,7 +22,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "GPU inputs are gathered to host. Parameter estimation currently runs on CPU."
+        "notes": "GPU inputs use a separately declared RunMat-only resident-fallback extension: admitted inputs are gathered to host, parameter estimation runs on CPU, and the result is a host ProbabilityDistribution object. MATLAB-compatible mode rejects this fallback before provider access."
     },
     "fusion": {
         "elementwise": false,
@@ -38,8 +38,8 @@ const builtinDoc = {
     "description": "`fitdist(x,distname)` estimates distribution parameters from vector data and returns a `ProbabilityDistribution` object accepted by `pdf`, `cdf`, `icdf`, and `random`.",
     "behaviors": [
         "Supported fitted distributions are `\"Normal\"`, `\"Exponential\"`, `\"Lognormal\"`, `\"Gamma\"`, `\"Weibull\"`, and `\"Poisson\"`; common short aliases such as `\"norm\"`, `\"exp\"`, `\"logn\"`, `\"gam\"`, `\"wbl\"`, and `\"poiss\"` are accepted.",
-        "Input data must be a numeric vector. `NaN` observations are ignored and `Inf` observations are rejected.",
-        "`fitdist(x,distname,\"Frequency\",w)` accepts nonnegative finite observation weights with one weight per observation. Zero-weight observations are ignored.",
+        "Input data must be a numeric vector. The compatibility target documents double observations; typed-integer observations are a mode-gated RunMat extension and must be exactly representable as binary64. `NaN` observations are ignored and `Inf` observations are rejected.",
+        "`fitdist(x,distname,\"Frequency\",w)` requires one nonnegative finite integer-valued count per observation. The compatibility target documents single or double count storage; typed-integer Frequency storage is an independently gated RunMat extension. Zero-frequency observations are ignored.",
         "Range constraints follow the selected distribution: exponential data must be nonnegative, lognormal/gamma/weibull data must be positive, and Poisson data must be nonnegative integers.",
         "The returned object exposes `DistributionName`, `DistName`, `ParameterNames`, `ParameterValues`, `NumParameters`, `NumObservations`, `NLogL`, `IsTruncated`, and scalar parameter properties such as `mu`, `sigma`, `lambda`, `a`, or `b`."
     ],
@@ -54,6 +54,10 @@ const builtinDoc = {
         }
     ],
     "faqs": [
+        {
+            "question": "Can fitdist fit typed-integer observations or Frequency arrays?",
+            "answer": "In MATLAB-compatible mode, no. RunMat mode adds separately declared integer-data and integer-Frequency extensions for all eight built-in integer classes, with exact binary64-boundary validation. Results remain host probability-distribution objects with floating parameters."
+        },
         {
             "question": "Does fitdist support censoring or custom optimization options?",
             "answer": "Not yet. `Censoring`, `Options`, and grouped `By` fits are rejected explicitly rather than ignored."

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

@@ -1 +1 @@
-{"version":3,"file":"fitdist.js","sourceRoot":"","sources":["../../../src/generated/builtins/fitdist.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,SAAS;QACT,0BAA0B;QAC1B,QAAQ;QACR,aAAa;QACb,WAAW;QACX,OAAO;QACP,SAAS;QACT,SAAS;QACT,YAAY;KACb;IACD,SAAS,EAAE,uDAAuD;IAClE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,8EAA8E;KACxF;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,MAAM;KACpB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,0CAA0C;QAClD,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,yKAAyK;IACxL,WAAW,EAAE;QACX,yPAAyP;QACzP,0GAA0G;QAC1G,6JAA6J;QAC7J,yLAAyL;QACzL,4OAA4O;KAC7O;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,sFAAsF;SAChG;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,4DAA4D;SACtE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,gEAAgE;YAC5E,QAAQ,EAAE,qGAAqG;SAChH;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"fitdist.js","sourceRoot":"","sources":["../../../src/generated/builtins/fitdist.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,SAAS;QACT,0BAA0B;QAC1B,QAAQ;QACR,aAAa;QACb,WAAW;QACX,OAAO;QACP,SAAS;QACT,SAAS;QACT,YAAY;KACb;IACD,SAAS,EAAE,uDAAuD;IAClE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,qRAAqR;KAC/R;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,MAAM;KACpB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,0CAA0C;QAClD,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,yKAAyK;IACxL,WAAW,EAAE;QACX,yPAAyP;QACzP,8QAA8Q;QAC9Q,qSAAqS;QACrS,yLAAyL;QACzL,4OAA4O;KAC7O;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,sFAAsF;SAChG;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,4DAA4D;SACtE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iEAAiE;YAC7E,QAAQ,EAAE,mRAAmR;SAC9R;QACD;YACE,UAAU,EAAE,gEAAgE;YAC5E,QAAQ,EAAE,qGAAqG;SAChH;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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