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

package/dist/generated/builtins/double.js

@@ -18,7 +18,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "Prefers the provider's `unary_double` hook on float64-capable backends; gathers to the host when the GPU cannot represent doubles and only re-uploads when supported."
+        "notes": "Uses the input handle's proven owning provider. Native and upload results are accepted only when they have the expected owner, device, shape, real/complex storage, float64 precision, noninteger/nonlogical metadata, and a fresh allocation. A malformed native result triggers the gather fallback; a malformed RunMat-only `'like'` upload is rejected with an error. Providers that cannot represent float64 return a documented host fallback."
     },
     "fusion": {
         "elementwise": true,
@@ -34,13 +34,15 @@ const builtinDoc = {
     },
     "description": "`double(X)` converts supported scalars and arrays to MATLAB’s default double-precision representation (`float64`) while preserving shape and layout. Numeric, logical, character, and GPU-resident values follow MATLAB/RunMat conversion semantics.",
     "behaviors": [
-        "Numeric inputs that are already double precision are returned unchanged; single-precision and integer values are promoted without altering shapes.",
+        "Numeric inputs that are already double precision are returned unchanged; single-precision and all eight integer classes are converted without altering shapes. Wide int64 and uint64 values follow ordinary IEEE binary64 rounding.",
         "Logical inputs become dense double arrays containing `0` and `1`, matching MATLAB’s promotion rules used by arithmetic on logical masks.",
-        "Sparse double matrices are densified into full double arrays, matching MATLAB's `double(sparse(...))` behavior.",
+        "Sparse inputs preserve their sparse structure while stored values are converted to double.",
         "Character arrays are converted to their Unicode code points and returned as doubles (`'A'` becomes `65`).",
         "Complex scalars and arrays remain complex, but both components are stored as double precision.",
         "Empty arrays stay empty, orientation is preserved, and singleton dimensions are untouched.",
-        "Strings, structs, cells, objects, and other unsupported classes raise MATLAB-style errors of the form `\"double: conversion to double from <type> is not possible\"`."
+        "String scalars and arrays convert each element as one numeric value; elements that do not represent one number become NaN.",
+        "Complex inputs preserve complexity even when the converted imaginary component is zero, matching the compatibility target's rule.",
+        "`double(X, \"like\", prototype)` is a separately declared RunMat-only compatibility extension and is rejected when RunMat extensions are disabled."
     ],
     "examples": [
         {
@@ -69,9 +71,9 @@ const builtinDoc = {
             "output": "ans = [1 2 3 4]"
         },
         {
-            "description": "Densify sparse matrices",
-            "input": "S = sparse([1 3], [1 2], [4 -1], 3, 2);\nA = double(S)",
-            "output": "A = [4 0; 0 0; 0 -1]"
+            "description": "Preserve sparse structure while converting stored values",
+            "input": "S = sparse([1 3], [1 2], [4 -1], 3, 2);\nA = double(S);\n[issparse(A), nnz(A)]",
+            "output": "ans = [1 2]"
         },
         {
             "description": "Handle double precision with `'like'` prototypes",
@@ -99,11 +101,11 @@ const builtinDoc = {
         },
         {
             "question": "Can I convert strings with `double`?",
-            "answer": "No. Strings are not implicitly convertible; convert them to character arrays first with `char` and then take `double`."
+            "answer": "Yes. Each string element is parsed as one numeric value; text that does not represent one numeric value produces NaN. Character arrays instead convert to Unicode code values."
         },
         {
             "question": "What happens to sparse inputs?",
-            "answer": "`double` returns a full dense double array for sparse matrices, matching MATLAB."
+            "answer": "Sparse structure is preserved and its stored values are converted to double."
         },
         {
             "question": "Will `double` keep results on the GPU?",
@@ -115,7 +117,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I request GPU residency with `'like'`?",
-            "answer": "Yes. Pass `'like', prototype` to mirror the prototype’s residency. Provide a gpuArray prototype to keep the result on the device when the backend supports float64."
+            "answer": "In RunMat extension mode, pass `'like', prototype` to mirror host or GPU residency when the selected provider supports true float64 storage. This overload is not part of the current public MATLAB `double` syntax and is rejected when RunMat extensions are disabled."
         },
         {
             "question": "How does `double` interact with complex inputs?",
@@ -230,11 +232,11 @@ const builtinDoc = {
     ],
     "source": {
         "label": "crates/runmat-runtime/src/builtins/math/elementwise/double.rs",
-        "url": "crates/runmat-runtime/src/builtins/math/elementwise/double.rs"
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/double.rs"
     },
     "gpu_residency": "RunMat keeps tensors on the GPU whenever the active provider supports double precision. You only need explicit `gpuArray` / `gather` calls when interfacing with legacy code or when you must force residency. On float32-only providers, `double` returns host data, matching MATLAB systems where the GPU lacks native double support.",
     "gpu_behavior": [
-        "RunMat first inspects the active acceleration provider:\n\n1. **Provider exposes float64 (double) precision:** gpuArray inputs are kept on device. The runtime downloads once only when the provider lacks a native cast primitive, performs the conversion on the host, and uploads the double-precision result back to the device, freeing the original handle. Providers may later add a `unary_double` hook to avoid the temporary host hop. 2. **Provider is float32-only:** gpuArray inputs are gathered to host memory because the backend cannot store double precision. The result is returned as a host tensor; subsequent operations can choose to re-upload if profitable. 3. **No provider registered:** gpuArray values behave like gathered host arrays, mirroring MATLAB’s behaviour when Parallel Computing Toolbox is absent.\n\nAll GPU fallbacks are documented so you know exactly when data leaves the device."
+        "RunMat resolves GPU conversion only through an owner whose reported device matches the handle; a global-provider fallback for an unknown device is not accepted as ownership. Float64-capable owners may use `unary_double`; malformed native results trigger the gather fallback, while malformed RunMat-only `'like'` uploads return an error. Outputs that alias an input or prototype are rejected and never freed as provider-owned results. Other rejected allocations are freed only through a proven actual owner. The `'like'` upload path also validates prototype device, result shape, real/complex storage, float64 precision, and absence of integer/logical metadata. Integer handles gather exact native storage before conversion when a native float cast is unavailable. Float32-only providers cannot represent the documented double result, so RunMat returns a host double tensor as an explicit backend limitation. The input handle remains owned by the caller."
     ],
     "key": "double",
     "slug": "double",

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

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

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

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

package/dist/generated/builtins/downsample.js

@@ -18,7 +18,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "Real, logical, and complex-interleaved GPU inputs use the active provider's storage-aware linear-gather path to keep the downsampled output resident."
+        "notes": "GPU inputs use a proven owning provider's storage-aware linear-gather path. RunMat requires the resolved owner to report the input device before invoking it, then validates the returned owner, device, shape, storage kind, integer or logical class, and floating-point precision before accepting the resident result."
     },
     "fusion": {
         "elementwise": false,
@@ -28,15 +28,18 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "builtins::math::signal::sample_rate::tests",
+        "unit": "downsample_row_vector_keeps_every_nth_sample, downsample_phase_offsets_first_kept_sample, downsample_preserves_all_integer_classes_exactly, downsample_typed_controls_are_separately_extension_gated, downsample_nd_input_is_extension_gated, downsample_resident_integer_preserves_owner_class_and_values, downsample_rejects_hostile_provider_results_and_falls_back_only_on_hook_error",
         "integration": "runmat-vm basics upsample_downsample_builtin_executes_for_discrete_signal_workflow"
     },
     "description": "`y = downsample(x, n)` keeps every `n`th sample of `x`, starting at the first sample, along the first non-singleton dimension. `y = downsample(x, n, phase)` starts at the zero-based `phase` offset.",
     "behaviors": [
-        "Accepts numeric, logical, integer, complex, vector, matrix, N-D tensor, and GPU tensor inputs.",
+        "The documented input surface is vectors and matrices. RunMat also accepts N-D inputs; inputs with more than two dimensions are a compatibility-gated RunMat extension.",
         "Operates along the first non-singleton dimension, matching MATLAB's column-wise behavior for matrices and row-wise behavior for row vectors.",
-        "`n` must be a finite positive integer scalar.",
-        "`phase` is optional, defaults to 0, and must be an integer scalar in the range `0 <= phase < n`.",
+        "`n` must be a finite positive integer-valued single or double scalar. Typed-integer `n` values are a separately gated RunMat extension and are parsed exactly.",
+        "`phase` is optional, defaults to 0, and must be an integer-valued single or double scalar in the range `0 <= phase < n`. Typed-integer `phase` values are a separately gated RunMat extension and are parsed exactly.",
+        "Integer input samples preserve all eight signed and unsigned integer classes and their exact element values; downsampling performs structural selection rather than floating-point conversion.",
+        "An input handle whose device has no proven owner is rejected before any provider hook or gather. For a proven owner, a provider hook error or unsupported hook triggers owner-resolved gathering and the host fallback. A provider result that violates owner, device, shape, storage, integer/logical class, or precision invariants is treated as a provider-contract error instead of silently falling back.",
+        "Malformed resident outputs are freed only when their owner can be resolved. RunMat never sends an unknown-owner handle to the input provider for cleanup.",
         "The output keeps samples at zero-based positions `phase`, `phase + n`, `phase + 2*n`, and so on.",
         "No anti-aliasing filter is applied; use filtering operations separately when decimating sampled signals."
     ],
@@ -68,7 +71,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I pass GPU tensors?",
-            "answer": "Yes. Real, logical, and complex-interleaved GPU inputs stay resident through the provider `gather_linear` hook."
+            "answer": "Yes. Inputs stay resident through a proven owning provider's `gather_linear` hook when it returns a result with the required owner, device, shape, storage, class, and precision invariants. Unknown-device inputs reject before provider work. Unsupported hooks from a proven owner fall back through an owner-resolved host gather; malformed successful results raise a provider-contract error."
         }
     ],
     "links": [

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

@@ -1 +1 @@
-{"version":3,"file":"downsample.js","sourceRoot":"","sources":["../../../src/generated/builtins/downsample.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,YAAY;QACZ,aAAa;QACb,YAAY;QACZ,mBAAmB;KACpB;IACD,SAAS,EAAE,8DAA8D;IACzE,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,uJAAuJ;KACjK;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,oFAAoF;KACpG;IACD,aAAa,EAAE,uMAAuM;IACtN,WAAW,EAAE;QACX,gGAAgG;QAChG,8IAA8I;QAC9I,+CAA+C;QAC/C,kGAAkG;QAClG,kGAAkG;QAClG,0GAA0G;KAC3G;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,wCAAwC;YACjD,QAAQ,EAAE,aAAa;SACxB;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,2CAA2C;YACpD,QAAQ,EAAE,WAAW;SACtB;QACD;YACE,aAAa,EAAE,2BAA2B;YAC1C,OAAO,EAAE,4CAA4C;YACrD,QAAQ,EAAE,gBAAgB;SAC3B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,uFAAuF;SAClG;QACD;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,sGAAsG;SACjH;QACD;YACE,UAAU,EAAE,yBAAyB;YACrC,QAAQ,EAAE,iHAAiH;SAC5H;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;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,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"downsample.js","sourceRoot":"","sources":["../../../src/generated/builtins/downsample.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,YAAY;QACZ,aAAa;QACb,YAAY;QACZ,mBAAmB;KACpB;IACD,SAAS,EAAE,8DAA8D;IACzE,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,4TAA4T;KACtU;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,2XAA2X;QACnY,aAAa,EAAE,oFAAoF;KACpG;IACD,aAAa,EAAE,uMAAuM;IACtN,WAAW,EAAE;QACX,wKAAwK;QACxK,8IAA8I;QAC9I,gKAAgK;QAChK,uNAAuN;QACvN,gMAAgM;QAChM,iZAAiZ;QACjZ,2JAA2J;QAC3J,kGAAkG;QAClG,0GAA0G;KAC3G;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,wCAAwC;YACjD,QAAQ,EAAE,aAAa;SACxB;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,2CAA2C;YACpD,QAAQ,EAAE,WAAW;SACtB;QACD;YACE,aAAa,EAAE,2BAA2B;YAC1C,OAAO,EAAE,4CAA4C;YACrD,QAAQ,EAAE,gBAAgB;SAC3B;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,uFAAuF;SAClG;QACD;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,sGAAsG;SACjH;QACD;YACE,UAAU,EAAE,yBAAyB;YACrC,QAAQ,EAAE,sYAAsY;SACjZ;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;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,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/dummyvar.js

@@ -18,7 +18,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "GPU inputs are gathered to host. Encoding runs on CPU because it depends on class discovery and label matching."
+        "notes": "GPU input is a compatibility-gated RunMat extension. The owning provider gathers it to host before CPU encoding, and the result is a host double matrix."
     },
     "fusion": {
         "elementwise": false,
@@ -28,16 +28,18 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "builtins::stats::summary::encoding::tests",
+        "unit": "dummyvar_encodes_numeric_columns_and_missing, dummyvar_reads_typed_integer_labels_exactly, dummyvar_supports_all_integer_classes_in_extension_mode, dummyvar_rejects_wide_typed_levels_before_floating_conversion, dummyvar_integer_extension_rejects_before_computation_in_strict_mode, dummyvar_gpu_extension_rejects_before_provider_access",
         "integration": "crates/runmat-vm/tests/stats_ml.rs"
     },
     "description": "`dummyvar(group)` converts grouping variables into a numeric design matrix with one dummy column per level.",
     "behaviors": [
         "Numeric vector inputs use positive integer levels `1:max(group)`; `NaN` rows become `NaN` across that grouping variable's dummy columns.",
+        "The documented numeric input classes are single and double. Typed integer grouping values are a compatibility-gated RunMat extension supporting all eight signed and unsigned classes. RunMat validates sign and the bounded feasible output domain from exact integer storage before converting feasible levels, which are below the binary64 exact-integer boundary; wider levels reject with a controlled output-size error. The output remains double.",
         "Numeric row and column vectors are treated as one grouping variable; nonscalar numeric matrices treat each column as a separate grouping variable and concatenate the dummy columns for each variable.",
         "Cell arrays can hold multiple grouping variables when supplied as a row cell array; cell-string vectors are encoded by first appearance.",
         "Categorical inputs use the full category order, including categories not observed in the input values.",
-        "String, character-row, logical, and cell-string grouping variables are supported."
+        "String, character-row, logical, and cell-string grouping variables are supported by RunMat.",
+        "GPU grouping values are a separately gated RunMat extension and are rejected before provider access when compatibility extensions are disabled."
     ],
     "examples": [
         {

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

@@ -1 +1 @@
-{"version":3,"file":"dummyvar.js","sourceRoot":"","sources":["../../../src/generated/builtins/dummyvar.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,iBAAiB;QACjB,SAAS;QACT,aAAa;QACb,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,iHAAiH;KAC3H;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,MAAM;KACpB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,2CAA2C;QACnD,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,6GAA6G;IAC5H,WAAW,EAAE;QACX,0IAA0I;QAC1I,wMAAwM;QACxM,0IAA0I;QAC1I,wGAAwG;QACxG,mFAAmF;KACpF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,yBAAyB;YAClC,QAAQ,EAAE,uBAAuB;SAClC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,+HAA+H;SAC1I;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,cAAc;YACvB,KAAK,EAAE,gBAAgB;SACxB;QACD;YACE,OAAO,EAAE,cAAc;YACvB,KAAK,EAAE,gBAAgB;SACxB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,gEAAgE;QACzE,KAAK,EAAE,6GAA6G;KACrH;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"dummyvar.js","sourceRoot":"","sources":["../../../src/generated/builtins/dummyvar.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,iBAAiB;QACjB,SAAS;QACT,aAAa;QACb,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,0JAA0J;KACpK;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,gVAAgV;QACxV,aAAa,EAAE,oCAAoC;KACpD;IACD,aAAa,EAAE,6GAA6G;IAC5H,WAAW,EAAE;QACX,0IAA0I;QAC1I,4bAA4b;QAC5b,wMAAwM;QACxM,0IAA0I;QAC1I,wGAAwG;QACxG,6FAA6F;QAC7F,iJAAiJ;KAClJ;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,yBAAyB;YAClC,QAAQ,EAAE,uBAAuB;SAClC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,+HAA+H;SAC1I;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,cAAc;YACvB,KAAK,EAAE,gBAAgB;SACxB;QACD;YACE,OAAO,EAAE,cAAc;YACvB,KAAK,EAAE,gBAAgB;SACxB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,gEAAgE;QACzE,KAAK,EAAE,6GAA6G;KACrH;IACD,KAAK,EAAE,UAAU;IACjB,MAAM,EAAE,UAAU;IAClB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/duration.js

@@ -10,13 +10,13 @@ const builtinDoc = {
         "Format",
         "MATLAB compatibility"
     ],
-    "summary": "Create duration arrays from hour, minute, second, and unit-helper forms with MATLAB-compatible construction behavior.",
+    "summary": "Create duration arrays from numeric component or three-column matrix inputs.",
     "gpu_support": {
         "elementwise": false,
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "duration values are host-side objects backed by day-count tensors; there is no GPU-resident duration type."
+        "notes": "GPU numeric constructor input is a compatibility-gated RunMat extension. The owning provider gathers it before RunMat constructs a host-side duration object backed by a day-count tensor."
     },
     "fusion": {
         "elementwise": false,
@@ -26,17 +26,22 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
-        "unit": "builtins::duration::tests"
+        "unit": "duration_builds_from_components, duration_integer_matrix_form_supports_all_classes_and_returns_column, duration_four_component_form_adds_milliseconds, duration_public_components_preserve_nan_and_infinity, duration_short_numeric_forms_are_extension_gated_but_matrix_is_public, duration_gpu_extension_rejects_before_provider_access"
     },
-    "description": "`duration` constructs duration objects from numeric hour, minute, and second components or from unit helper functions such as `days`, `hours`, `minutes`, `seconds`, `milliseconds`, and fixed-length `years`. It supports MATLAB-compatible scalar expansion, internal elapsed-time representation, conversion back to numeric unit counts, and display-format controls.",
+    "description": "`duration(H, MI, S)` and `duration(H, MI, S, MS)` construct duration arrays from numeric components. `duration(X)` accepts an `N`-by-3 numeric matrix whose columns are hours, minutes, and seconds. RunMat stores elapsed time as binary64 day counts and supports display-format controls.",
     "behaviors": [
-        "`duration(H)` treats the input as hours.",
-        "`duration(H, M)` treats the inputs as hours and minutes.",
+        "`duration(X)` requires a numeric matrix with exactly three columns and returns an `N`-by-1 duration array.",
         "`duration(H, M, S)` treats the inputs as hours, minutes, and seconds.",
+        "`duration(H, M, S, MS)` adds the millisecond component to the elapsed time.",
+        "All eight signed and unsigned integer classes are accepted in the documented numeric forms. Computation and storage use binary64 day counts, so wide integer values follow the constructor's documented numeric conversion boundary rather than preserving integer storage.",
+        "`NaN`, positive infinity, and negative infinity components remain nonfinite duration values and display as `NaN`, `Inf`, and `-Inf` without changing their stored values.",
+        "The one-component `duration(H)` and two-component `duration(H, M)` conveniences are compatibility-gated RunMat extensions.",
         "`days(X)`, `hours(X)`, `minutes(X)`, `seconds(X)`, `milliseconds(X)`, and `years(X)` create duration values from numeric inputs.",
         "Calling the unit helpers on a duration converts that duration back to numeric counts in the requested unit.",
         "`isduration(x)` returns true for duration objects and false for non-duration values.",
         "Scalar component inputs broadcast to match non-scalar component arrays; non-scalar inputs must share the same shape.",
+        "GPU numeric inputs are a compatibility-gated RunMat extension, are rejected before provider access in strict mode, and produce host duration objects after owner-resolved gathering.",
+        "Text parsing forms of `duration` are not yet implemented.",
         "The `Format` property controls text rendering. Supported values are `hh:mm:ss`, `hh:mm`, `mm:ss`, `s`, and `ss`.",
         "Linear indexing `d(k)` is supported and returns duration values.",
         "Comparison operators and `plus`/`minus` duration arithmetic are supported.",
@@ -50,7 +55,7 @@ const builtinDoc = {
         },
         {
             "description": "Broadcasting scalar minutes across an hour vector",
-            "input": "t = duration([1 2], 15)",
+            "input": "t = duration([1 2], 15, 0)",
             "output": "t =\n01:15:00  02:15:00"
         },
         {
@@ -80,7 +85,7 @@ const builtinDoc = {
         },
         {
             "question": "Does `duration` run on the GPU?",
-            "answer": "No. duration values are represented as host-side objects. Numeric inputs may be gathered first, but the resulting duration object remains on the CPU."
+            "answer": "The resulting duration object is always host-side. RunMat can accept GPU numeric inputs as a compatibility-gated extension, gather them through their owning provider, and then build the host object."
         },
         {
             "question": "Can I add a duration to a datetime?",
@@ -115,7 +120,7 @@ const builtinDoc = {
     },
     "gpu_residency": "No. RunMat represents `duration` values as host-side objects with an internal day-count tensor and a `Format` property. Even when the constructor receives gathered numeric data, the resulting object remains resident on the CPU.",
     "gpu_behavior": [
-        "`duration` does not allocate GPU objects or invoke provider kernels. If a numeric input originates on the GPU, RunMat gathers it before building the duration object."
+        "`duration` does not allocate GPU objects or invoke provider kernels. GPU numeric constructor input is a RunMat extension; strict compatibility mode rejects it before provider access, while extension mode gathers through the owning provider before building the host object."
     ],
     "key": "duration",
     "slug": "duration",

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

@@ -1 +1 @@
-{"version":3,"file":"duration.js","sourceRoot":"","sources":["../../../src/generated/builtins/duration.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,cAAc;QACd,WAAW;QACX,QAAQ;QACR,sBAAsB;KACvB;IACD,SAAS,EAAE,uHAAuH;IAClI,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,4GAA4G;KACtH;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,2BAA2B;KACpC;IACD,aAAa,EAAE,2WAA2W;IAC1X,WAAW,EAAE;QACX,0CAA0C;QAC1C,0DAA0D;QAC1D,uEAAuE;QACvE,kIAAkI;QAClI,6GAA6G;QAC7G,sFAAsF;QACtF,sHAAsH;QACtH,kHAAkH;QAClH,kEAAkE;QAClE,4EAA4E;QAC5E,kFAAkF;KACnF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wDAAwD;YACvE,OAAO,EAAE,yBAAyB;YAClC,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,yBAAyB;YAClC,QAAQ,EAAE,yBAAyB;SACpC;QACD;YACE,aAAa,EAAE,+DAA+D;YAC9E,OAAO,EAAE,sDAAsD;YAC/D,QAAQ,EAAE,OAAO;SAClB;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,mEAAmE;YAC5E,QAAQ,EAAE,8BAA8B;SACzC;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,QAAQ;SACnB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,wIAAwI;SACnJ;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,yEAAyE;SACpF;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,uJAAuJ;SAClK;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,0GAA0G;SACrH;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,kBAAkB;YAC3B,KAAK,EAAE,oBAAoB;SAC5B;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,sDAAsD;QAC/D,KAAK,EAAE,mGAAmG;KAC3G;IACD,eAAe,EAAE,qOAAqO;IACtP,cAAc,EAAE;QACd,uKAAuK;KACxK;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":"duration.js","sourceRoot":"","sources":["../../../src/generated/builtins/duration.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,cAAc;QACd,WAAW;QACX,QAAQ;QACR,sBAAsB;KACvB;IACD,SAAS,EAAE,8EAA8E;IACzF,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,4LAA4L;KACtM;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,2UAA2U;KACpV;IACD,aAAa,EAAE,8RAA8R;IAC7S,WAAW,EAAE;QACX,4GAA4G;QAC5G,uEAAuE;QACvE,6EAA6E;QAC7E,6QAA6Q;QAC7Q,2KAA2K;QAC3K,4HAA4H;QAC5H,kIAAkI;QAClI,6GAA6G;QAC7G,sFAAsF;QACtF,sHAAsH;QACtH,sLAAsL;QACtL,2DAA2D;QAC3D,kHAAkH;QAClH,kEAAkE;QAClE,4EAA4E;QAC5E,kFAAkF;KACnF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,wDAAwD;YACvE,OAAO,EAAE,yBAAyB;YAClC,QAAQ,EAAE,iBAAiB;SAC5B;QACD;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,yBAAyB;SACpC;QACD;YACE,aAAa,EAAE,+DAA+D;YAC9E,OAAO,EAAE,sDAAsD;YAC/D,QAAQ,EAAE,OAAO;SAClB;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,mEAAmE;YAC5E,QAAQ,EAAE,8BAA8B;SACzC;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,4BAA4B;YACrC,QAAQ,EAAE,QAAQ;SACnB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,wIAAwI;SACnJ;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,yEAAyE;SACpF;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,wMAAwM;SACnN;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,0GAA0G;SACrH;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,kBAAkB;YAC3B,KAAK,EAAE,oBAAoB;SAC5B;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,sDAAsD;QAC/D,KAAK,EAAE,mGAAmG;KAC3G;IACD,eAAe,EAAE,qOAAqO;IACtP,cAAc,EAAE;QACd,kRAAkR;KACnR;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/ecdf.d.ts.map

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

package/dist/generated/builtins/ecdf.js

@@ -11,6 +11,16 @@ const builtinDoc = {
         "statistics"
     ],
     "summary": "Compute or plot empirical distribution functions.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f64",
+            "f32"
+        ],
+        "broadcasting": "none",
+        "notes": "Documented floating gpuArray sample data uses an owner-aware host fallback and restores numeric outputs to the source provider. Plotting remains a host graphics sink."
+    },
     "signatures": [
         "[f,x] = ecdf(y)",
         "[f,x] = ecdf(y,Name,Value)",
@@ -23,9 +33,12 @@ const builtinDoc = {
         "NaN sample, censoring, and frequency entries are omitted.",
         "`Function` accepts `\"cdf\"`, `\"survivor\"`, and `\"cumulative hazard\"`.",
         "`Frequency` supplies nonnegative observation counts.",
+        "Typed-integer or logical sample data, typed-integer or logical Frequency data, and typed-integer Censoring data are separately named RunMat-only extensions. Strict modes reject each role before provider access.",
+        "Admitted integer values must be exactly representable at the explicit binary64 statistics boundary; all numeric outputs from an integer extension call are double.",
         "`Censoring` supports fully observed data (`0`), left-censored observations (`-1`), and right-censored observations (`1`). Interval and double-censored Turnbull estimation are reported as unsupported instead of approximated.",
         "`Function`, `\"cumulative hazard\"` uses Nelson-Aalen cumulative hazard steps for fully observed and right-censored data.",
-        "`Alpha` controls pointwise confidence bounds. `Bounds`, `\"on\"` includes confidence-bound lines when plotting."
+        "`Alpha` controls pointwise confidence bounds. `Bounds`, `\"on\"` includes confidence-bound lines when plotting.",
+        "Interval-censored EMICM estimation, double-censored Turnbull estimation, and their iteration controls remain explicit implementation gaps and return stable unsupported-form errors."
     ],
     "examples": [
         {

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

@@ -1 +1 @@
-{"version":3,"file":"ecdf.js","sourceRoot":"","sources":["../../../src/generated/builtins/ecdf.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,MAAM;QACN,eAAe;QACf,UAAU;QACV,mBAAmB;QACnB,YAAY;KACb;IACD,SAAS,EAAE,mDAAmD;IAC9D,YAAY,EAAE;QACZ,iBAAiB;QACjB,4BAA4B;QAC5B,2BAA2B;QAC3B,WAAW;QACX,cAAc;KACf;IACD,aAAa,EAAE,6PAA6P;IAC5Q,OAAO,EAAE;QACP,2DAA2D;QAC3D,4EAA4E;QAC5E,sDAAsD;QACtD,iOAAiO;QACjO,2HAA2H;QAC3H,iHAAiH;KAClH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,0BAA0B;YACzC,OAAO,EAAE,yBAAyB;YAClC,QAAQ,EAAE,0CAA0C;SACrD;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,2EAA2E;SACrF;QACD;YACE,aAAa,EAAE,uBAAuB;YACtC,OAAO,EAAE,oBAAoB;SAC9B;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"ecdf.js","sourceRoot":"","sources":["../../../src/generated/builtins/ecdf.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,MAAM;QACN,eAAe;QACf,UAAU;QACV,mBAAmB;QACnB,YAAY;KACb;IACD,SAAS,EAAE,mDAAmD;IAC9D,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,wKAAwK;KAClL;IACD,YAAY,EAAE;QACZ,iBAAiB;QACjB,4BAA4B;QAC5B,2BAA2B;QAC3B,WAAW;QACX,cAAc;KACf;IACD,aAAa,EAAE,6PAA6P;IAC5Q,OAAO,EAAE;QACP,2DAA2D;QAC3D,4EAA4E;QAC5E,sDAAsD;QACtD,oNAAoN;QACpN,oKAAoK;QACpK,iOAAiO;QACjO,2HAA2H;QAC3H,iHAAiH;QACjH,sLAAsL;KACvL;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,0BAA0B;YACzC,OAAO,EAAE,yBAAyB;YAClC,QAAQ,EAAE,0CAA0C;SACrD;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,2EAA2E;SACrF;QACD;YACE,aAAa,EAAE,uBAAuB;YACtC,OAAO,EAAE,oBAAoB;SAC9B;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;KACF;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/eig.js

@@ -36,12 +36,14 @@ const builtinDoc = {
         "Single output `d = eig(A)` returns the eigenvalues as an `n × 1` column vector (values may be complex even when `A` is real).",
         "Two outputs `[V,D] = eig(A)` return the eigenvectors (columns of `V`) and the diagonal eigenvalue matrix `D`.",
         "Three outputs `[V,D,W] = eig(A)` additionally return the left eigenvectors `W` satisfying `W' * A = D * W'`.",
-        "Generalized calls `d = eig(A,B)`, `[V,D] = eig(A,B)`, and `[V,D,W] = eig(A,B)` solve `A*V = B*V*D` for square, same-size numeric or logical matrices. Native BLAS/LAPACK builds use `ZGGEV` and can return infinite eigenvalues for singular pencils; non-LAPACK builds support the nonsingular `B` case.",
+        "Generalized calls `d = eig(A,B)`, `[V,D] = eig(A,B)`, and `[V,D,W] = eig(A,B)` solve `A*V = B*V*D` for square, same-size single or double matrices. Native BLAS/LAPACK builds use `ZGGEV` and can return infinite eigenvalues for singular pencils; non-LAPACK builds support the nonsingular `B` case.",
         "The selector `'vector'` may be supplied (`eig(A,'vector')`, `eig(A,B,'vector')`, `[V,d] = eig(A,'vector')`) to request the eigenvalues as a column vector even when two outputs are requested. `'matrix'` resets the second output to the diagonal-matrix form.",
-        "Logical and integer inputs are promoted to double precision. Complex inputs remain complex throughout the factorisation.",
+        "Logical and typed-integer coefficient matrices are a named RunMat-only extension. Strict modes reject them before provider access; RunMat mode promotes them to double only after every integer coefficient passes an exact binary64-representability check.",
+        "Single host and gpuArray inputs retain single output storage. Complex inputs remain complex throughout the factorisation.",
         "Empty and scalar matrices follow MATLAB’s shape conventions (`eig([])` returns `[]`, `eig(5)` returns `5`).",
         "When the BLAS/LAPACK feature is unavailable and `B` is singular, RunMat detects that the fallback path would need full QZ support and raises a clear error instead of returning a partial factorization.",
-        "Optional balancing keywords (`'balance'`, `'nobalance'`) are accepted. Balancing defaults to on; the current implementation leaves balancing as a no-op while retaining the option for forward compatibility."
+        "Optional balancing keywords (`'balance'`, `'nobalance'`) are accepted. Balancing defaults to on; true balancing remains an explicit numerical-compatibility gap in the current implementation.",
+        "Explicit generalized `'chol'` and `'qz'` selectors and MATLAB's limited real-symmetric sparse eig form remain explicit implementation gaps rather than advertised completed behavior."
     ],
     "examples": [
         {
@@ -106,7 +108,7 @@ const builtinDoc = {
         },
         {
             "question": "What about the optional balancing keywords?",
-            "answer": "`'balance'` (default) and `'nobalance'` are accepted. The current release treats balancing as a no-op; the option remains so future releases can introduce a true balancing implementation without breaking user code."
+            "answer": "`'balance'` (default) and `'nobalance'` are accepted, but true balancing is not implemented yet. This is a documented numerical-compatibility gap."
         },
         {
             "question": "Are generalized eigenvalue problems supported?",
@@ -118,11 +120,11 @@ const builtinDoc = {
         },
         {
             "question": "Does `eig` participate in fusion or auto-offload?",
-            "answer": "No. Eigenvalue decomposition executes eagerly and acts as a residency sink. The fusion planner will gather any GPU-resident inputs before factorisation."
+            "answer": "No. Eigenvalue decomposition executes eagerly and terminates fusion. Resident inputs remain available to the builtin for provider dispatch or an explicit owning-provider gather fallback."
         },
         {
             "question": "How can I continue on the GPU after calling `eig` today?",
-            "answer": "When the active provider implements the standard `eig(A)` hook (the WGPU backend does for real spectra), the outputs remain on the GPU automatically. If the decomposition falls back to the CPU—because the call is generalized, the spectrum is complex, or `'nobalance'` was requested—call `gpuArray` on whichever results you need on the device."
+            "answer": "When the input provider implements the standard `eig(A)` hook, validated outputs remain resident. Generalized, complex, `'nobalance'`, and unsupported-provider paths gather through the input owner, compute on the host, and upload eligible numeric results back to that same owner."
         },
         {
             "question": "What happens if the eigenvector matrix is singular?",
@@ -142,7 +144,7 @@ const builtinDoc = {
         },
         {
             "question": "When should I use `eig` versus `eigs`?",
-            "answer": "Use `eig` for dense matrices when you want the full spectrum. Use `eigs` for sparse or very large matrices when you only need a few eigenvalues (for example the `k` largest or smallest), since it uses iterative Arnoldi/Lanczos methods instead of a full factorization."
+            "answer": "Use `eig` for dense matrices when you want the full spectrum. The current RunMat `eigs` implementation selects a subset from the dense `eig` fallback; a true iterative Arnoldi/Lanczos provider path remains future work."
         }
     ],
     "links": [
@@ -191,8 +193,8 @@ const builtinDoc = {
     },
     "gpu_behavior": [
         "The WGPU provider implements the reserved standard `eig(A)` hook by downloading the input, running the same CPU decomposition used by the host path, and immediately re-uploading the double-precision eigenvalues, eigenvectors, and diagonal matrix. When the spectrum is real, the outputs therefore remain on the GPU without any user intervention.",
-        "If any output requires complex storage, you pass generalized `eig(A,B)`, or you pass `'nobalance'`, RunMat automatically falls back to the host implementation and returns CPU-resident arrays. The `'vector'` selector also triggers this transparent host fallback today. Reapply `gpuArray` if you want to continue on the device after such a fallback.",
-        "Because `eig` is a residency sink, the fusion planner treats it as a barrier and does not attempt to fuse surrounding elementwise work."
+        "If the provider hook cannot serve a call, including generalized or complex problems and calls using `'nobalance'` or `'vector'`, RunMat gathers through the input handle's owning provider, computes with the host implementation, and uploads eligible numeric outputs back through that same owner. Floating-point outputs therefore retain accelerator residency across these transparent fallbacks.",
+        "The fusion planner treats `eig` as an allocation boundary: its result handles are not fused into the decomposition itself, but eligible floating-point outputs remain available to subsequent accelerator work without an explicit `gpuArray` round trip."
     ],
     "validation": {
         "summary": "`eig` uses a dense complex Schur decomposition for standard problems. Generalized `eig(A,B)` uses LAPACK `ZGGEV` when the native BLAS/LAPACK feature is enabled, including singular pencils with infinite eigenvalues; otherwise it solves the equivalent standard problem `B\\A` for nonsingular `B` and rejects singular fallback cases with a descriptive QZ-required error. CPU correctness is exercised by the in-module tests linked below; GPU residency is validated at the host-fallback boundary described above rather than via a separate GPU eigensolver.",

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

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

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

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

package/dist/generated/builtins/eigs.js

@@ -18,7 +18,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "`eigs` is currently a host residency sink. gpuArray inputs are gathered before the exact dense fallback, and outputs are host tensors until a provider-side partial eigensolver lands."
+        "notes": "In `runmat` compatibility mode, gpuArray arguments are accepted as a RunMat extension. `eigs` gathers them before the exact dense fallback and returns host tensors until a provider-side partial eigensolver lands."
     },
     "fusion": {
         "elementwise": false,
@@ -30,14 +30,17 @@ const builtinDoc = {
     "tested": {
         "unit": "builtins::math::linalg::factor::eigs::tests"
     },
-    "description": "`eigs(A)` returns a subset of eigenvalues. RunMat accepts dense, complex, logical, and small sparse or gpuArray compatibility inputs by materializing them on the host, computes the exact full eigendecomposition through the shared `eig` path, and selects the requested subset.",
+    "description": "`eigs(A)` returns a subset of eigenvalues. MATLAB-compatible coefficient matrices `A` and `B` use class `single` or `double`; in `runmat` compatibility mode, supported integer and logical coefficient matrices are accepted as a RunMat extension. Inputs are materialized on the host, decomposed through the shared exact `eig` path, and reduced to the requested subset.",
     "behaviors": [
         "`eigs(A)` returns up to six eigenvalues with largest magnitude.",
         "`eigs(A,k)` clamps `k` to `size(A,2)` when larger than the matrix order.",
+        "Typed-integer `k` is an exact documented structural control. Typed-integer `sigma` and typed-integer `StartVector` are separately named RunMat-only extensions because the public data-type lists for those roles are single and double.",
+        "Admitted integer coefficient and sigma values must be exactly representable at the explicit binary64 dense-fallback boundary; integer k and CholeskyPermutation are parsed structurally.",
         "`eigs(A,k,sigma)` supports numeric `sigma` and the documented text selectors `largestabs`, `smallestabs`, `largestreal`, `smallestreal`, `bothendsreal`, `largestimag`, `smallestimag`, and `bothendsimag`, plus documented short aliases.",
         "`eigs(A,B,...)` solves the generalized problem by reusing `eig(A,B)` and then selecting the requested subset.",
         "Two outputs return selected right eigenvectors and a diagonal eigenvalue matrix. Three outputs append convergence flag `0` because the current exact fallback either succeeds fully or raises an error.",
-        "Options supplied as a struct or name-value pairs are validated for MATLAB-compatible field names, value shapes, subspace-dimension minimums, and generalized-problem sigma constraints. Iterative controls such as tolerance, maximum iterations, subspace dimension, start vector, display, and failure treatment do not change the exact fallback result.",
+        "Options supplied as a struct or name-value pairs are validated for MATLAB-compatible field names, value shapes, subspace-dimension minimums, and generalized-problem sigma constraints. Iterative controls such as tolerance, maximum iterations, subspace dimension, start vector, display, and failure treatment do not change the current dense fallback result.",
+        "Single coefficient or StartVector data preserves single output storage, matching the R2025a-and-later precision rule.",
         "Function-handle `Afun` forms are intentionally rejected with a deterministic unsupported-form error until RunMat has iterative operator eigensolver support.",
         "Sparse inputs are materialized to dense host tensors for compatibility only. Very large sparse problems are not a completed high-performance `eigs` path and should be queued for a future sparse/provider implementation."
     ],
@@ -61,7 +64,7 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "Does `eigs` use an iterative sparse algorithm?",
-            "answer": "Not yet. RunMat currently uses an exact dense fallback through `eig`, then applies `eigs` subset ordering. This is correct for small and medium compatibility cases but is not the final high-performance sparse path."
+            "answer": "Not yet. RunMat currently uses a dense fallback through `eig`, then applies `eigs` subset ordering. It covers small and medium value-selection cases but does not reproduce iterative convergence, failure-treatment, or performance behavior."
         },
         {
             "question": "Which sigma selectors are supported?",
@@ -91,7 +94,7 @@ const builtinDoc = {
         "url": "crates/runmat-runtime/src/builtins/math/linalg/factor/eigs.rs"
     },
     "gpu_behavior": [
-        "`eigs` currently gathers gpuArray inputs and returns host tensors because subset eigenvalue selection needs host-side ordering.",
+        "The compatibility target does not document GPU Array support for `eigs`. RunMat retains gpuArray arguments behind its explicit extension mode, gathers them, and returns host tensors because subset eigenvalue selection needs host-side ordering.",
         "The builtin is explicitly marked `ResidencyPolicy::GatherImmediately` so the runtime does not imply a false GPU fast path.",
         "A future provider implementation should add a true partial eigensolver hook in `runmat-accelerate` and parity tests against this exact fallback."
     ],

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

@@ -1 +1 @@
-{"version":3,"file":"eigs.js","sourceRoot":"","sources":["../../../src/generated/builtins/eigs.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,oBAAoB;IAChC,UAAU,EAAE;QACV,MAAM;QACN,aAAa;QACb,cAAc;QACd,QAAQ;QACR,QAAQ;KACT;IACD,SAAS,EAAE,iGAAiG;IAC5G,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,wLAAwL;KAClM;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,6CAA6C;KACtD;IACD,aAAa,EAAE,qRAAqR;IACpS,WAAW,EAAE;QACX,iEAAiE;QACjE,0EAA0E;QAC1E,4OAA4O;QAC5O,+GAA+G;QAC/G,yMAAyM;QACzM,6VAA6V;QAC7V,8JAA8J;QAC9J,4NAA4N;KAC7N;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,uCAAuC;YAChD,QAAQ,EAAE,YAAY;SACvB;QACD;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,6DAA6D;YACtE,QAAQ,EAAE,aAAa;SACxB;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,qEAAqE;YAC9E,QAAQ,EAAE,OAAO;SAClB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,gDAAgD;YAC5D,QAAQ,EAAE,wNAAwN;SACnO;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,6PAA6P;SACxQ;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,oLAAoL;SAC/L;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,+DAA+D;KACvE;IACD,cAAc,EAAE;QACd,iIAAiI;QACjI,4HAA4H;QAC5H,kJAAkJ;KACnJ;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;QACR,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"eigs.js","sourceRoot":"","sources":["../../../src/generated/builtins/eigs.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,oBAAoB;IAChC,UAAU,EAAE;QACV,MAAM;QACN,aAAa;QACb,cAAc;QACd,QAAQ;QACR,QAAQ;KACT;IACD,SAAS,EAAE,iGAAiG;IAC5G,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,sNAAsN;KAChO;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,6CAA6C;KACtD;IACD,aAAa,EAAE,gXAAgX;IAC/X,WAAW,EAAE;QACX,iEAAiE;QACjE,0EAA0E;QAC1E,0OAA0O;QAC1O,0LAA0L;QAC1L,4OAA4O;QAC5O,+GAA+G;QAC/G,yMAAyM;QACzM,qWAAqW;QACrW,uHAAuH;QACvH,8JAA8J;QAC9J,4NAA4N;KAC7N;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,uCAAuC;YAChD,QAAQ,EAAE,YAAY;SACvB;QACD;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,6DAA6D;YACtE,QAAQ,EAAE,aAAa;SACxB;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,qEAAqE;YAC9E,QAAQ,EAAE,OAAO;SAClB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,gDAAgD;YAC5D,QAAQ,EAAE,gPAAgP;SAC3P;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,6PAA6P;SACxQ;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,oLAAoL;SAC/L;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,+DAA+D;KACvE;IACD,cAAc,EAAE;QACd,qPAAqP;QACrP,4HAA4H;QAC5H,kJAAkJ;KACnJ;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;QACR,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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