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

package/dist/generated/builtins/det.js

@@ -15,10 +15,11 @@ const builtinDoc = {
         "elementwise": false,
         "reduction": false,
         "precisions": [
+            "f32",
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "Uses provider LU factorization when available; real matrices re-upload a scalar result, while complex inputs gather to the host."
+        "notes": "Uses owner-resolved provider LU for floating storage. Typed integer, logical, and complex storage use an explicit gathered fallback; restoration requires the owner to physically support the computed precision, and results are validated against input owner/device and computed shape/storage/precision."
     },
     "fusion": {
         "elementwise": false,
@@ -29,15 +30,15 @@ const builtinDoc = {
     "requires_feature": null,
     "tested": {
         "unit": "builtins::math::linalg::solve::det::tests",
-        "gpu": "builtins::math::linalg::solve::det::tests::det_gpu_roundtrip_matches_cpu",
+        "gpu": "builtins::math::linalg::solve::det::tests::det_rejects_aliased_or_mistyped_provider_lu_results_and_frees_safely",
         "wgpu": "builtins::math::linalg::solve::det::tests::det_wgpu_matches_cpu"
     },
     "description": "`det(A)` returns the determinant of real or complex square matrix `A`. Scalar and empty-matrix cases (`det([]) = 1`) follow MATLAB and RunMat conventions.",
     "behaviors": [
         "Inputs must be 2-D square matrices. RunMat rejects non-square or higher-rank inputs with the MATLAB error `\"det: input must be a square matrix.\"`",
         "Determinants are computed from an LU factorization with partial pivoting, ensuring numerical behavior that mirrors MATLAB. Singular matrices return `0` (within floating-point round-off).",
-        "Logical and integer inputs are promoted to double precision before evaluation.",
-        "Complex inputs are handled with full complex arithmetic. The result has complex type whenever the input is complex.",
+        "MATLAB documents single and double matrices. Integer and logical matrices are separately gated RunMat-only extensions; integer values must be exactly representable as double rather than silently rounded.",
+        "Single input produces a single result. Complex input retains complex result storage and its single/double class.",
         "The determinant of the empty matrix (`[]`) is `1`."
     ],
     "examples": [
@@ -99,7 +100,7 @@ const builtinDoc = {
         },
         {
             "question": "Do logical inputs work?",
-            "answer": "Yes. Logical arrays are promoted to doubles before computing the determinant."
+            "answer": "Logical matrices are a named RunMat-only extension. Strict MATLAB compatibility mode rejects them before data access."
         },
         {
             "question": "Is the determinant computed exactly?",
@@ -156,9 +157,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/math/linalg/solve/det.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/linalg/solve/det.rs"
     },
-    "gpu_residency": "You usually do NOT need to call `gpuArray` yourself in RunMat (unlike MATLAB). The fusion planner keeps producers on the GPU, `det` invokes the provider's `lu` hook when available, and real determinants are re-uploaded as device scalars so subsequent kernels keep their residency. When the provider lacks `lu`, RunMat transparently gathers the matrix, computes the determinant with the host fallback, and re-uploads the scalar for real inputs. Complex determinants currently return host scalars until device complex scalars land. `gpuArray` and `gather` remain available for explicit residency control and MATLAB compatibility.",
+    "gpu_residency": "You usually do NOT need to call `gpuArray` yourself in RunMat. Floating storage uses the owning provider's `lu` hook when available. Explicit fallback paths gather through that owner and restore real or complex scalar results to the same device while preserving single/double precision.",
     "gpu_behavior": [
-        "When a GPU acceleration provider is active, RunMat first asks the provider for an LU factorization via the `lu` hook. Providers that implement it keep the factors on device, multiply the diagonal of `U`, and re-upload the scalar determinant for real inputs so downstream kernels keep running on the GPU. Complex matrices currently gather to the host for the final scalar. Providers that do not expose `lu` (including the current fallback backends) automatically route to the shared CPU implementation with no user intervention required."
+        "RunMat resolves the provider from the input handle rather than a global provider. Floating matrices use its `lu` hook when possible; typed integer, logical, complex, and unsupported-provider cases gather explicitly. Re-uploaded results must match the input owner/device and the computed shape, storage, and precision or they are freed and rejected."
     ],
     "key": "det",
     "slug": "det",

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

@@ -1 +1 @@
-{"version":3,"file":"det.js","sourceRoot":"","sources":["../../../src/generated/builtins/det.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,KAAK;IACd,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,KAAK;QACL,aAAa;QACb,gBAAgB;QAChB,QAAQ;QACR,KAAK;KACN;IACD,SAAS,EAAE,+DAA+D;IAC1E,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;SACN;QACD,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,kIAAkI;KAC5I;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,2CAA2C;QACnD,KAAK,EAAE,0EAA0E;QACjF,MAAM,EAAE,iEAAiE;KAC1E;IACD,aAAa,EAAE,4JAA4J;IAC3K,WAAW,EAAE;QACX,qJAAqJ;QACrJ,4LAA4L;QAC5L,gFAAgF;QAChF,qHAAqH;QACrH,oDAAoD;KACrD;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,8BAA8B;YACvC,QAAQ,EAAE,QAAQ;SACnB;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,6BAA6B;YACtC,QAAQ,EAAE,OAAO;SAClB;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,oCAAoC;YAC7C,QAAQ,EAAE,YAAY;SACvB;QACD;YACE,aAAa,EAAE,8DAA8D;YAC7E,OAAO,EAAE,yCAAyC;YAClD,QAAQ,EAAE,QAAQ;SACnB;QACD;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,aAAa;YACtB,QAAQ,EAAE,OAAO;SAClB;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,2HAA2H;YACpI,QAAQ,EAAE,QAAQ;SACnB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,0JAA0J;SACrK;QACD;YACE,UAAU,EAAE,oBAAoB;YAChC,QAAQ,EAAE,uHAAuH;SAClI;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,+IAA+I;SAC1J;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,oLAAoL;SAC/L;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,wOAAwO;SACnP;QACD;YACE,UAAU,EAAE,kCAAkC;YAC9C,QAAQ,EAAE,yLAAyL;SACpM;QACD;YACE,UAAU,EAAE,yBAAyB;YACrC,QAAQ,EAAE,+EAA+E;SAC1F;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,+HAA+H;SAC1I;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,MAAM;SACd;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;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;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,+DAA+D;QACxE,KAAK,EAAE,4GAA4G;KACpH;IACD,eAAe,EAAE,qnBAAqnB;IACtoB,cAAc,EAAE;QACd,0hBAA0hB;KAC3hB;IACD,KAAK,EAAE,KAAK;IACZ,MAAM,EAAE,KAAK;IACb,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;QACR,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"det.js","sourceRoot":"","sources":["../../../src/generated/builtins/det.ts"],"names":[],"mappings":"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"}

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

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

package/dist/generated/builtins/detectImportOptions.js

@@ -19,7 +19,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Runs on the host. The returned options are metadata consumed by later import calls."
+        "notes": "Runs on the host. Resident arguments, including nested option values, are rejected before provider or file access."
     },
     "fusion": {
         "elementwise": false,
@@ -41,9 +41,12 @@ const builtinDoc = {
         "Detects text delimiters from comma, tab, semicolon, pipe, and whitespace-separated records unless `Delimiter` is supplied.",
         "Infers variable names from a non-data header row and sets `NumHeaderLines` so readers import only data rows.",
         "Infers `VariableTypes` as `double`, `logical`, `datetime`, or text (`string`/`char`) using the same token rules as `readtable`.",
-        "Honors supported overrides including `FileType`, `Delimiter`, `NumHeaderLines`, `Range`, `Sheet`, `VariableNames`, `VariableTypes`, `ReadVariableNames`, `ReadRowNames`, `TreatAsMissing`, `VariableNamingRule`, `TextType`, `DatetimeType`, `EmptyLineRule`, and `Encoding`.",
+        "Honors the implemented text/spreadsheet override subset, including `FileType`, `Delimiter`, `NumHeaderLines`, `Range`, `DataRange`, `Sheet`, `ExpectedNumVariables`, `VariableNamesLine`, `VariableNames`, `VariableTypes`, `ReadVariableNames`, `ReadRowNames`, `TreatAsMissing`, `VariableNamingRule`, `TextType`, `DatetimeType`, `EmptyLineRule`, and `Encoding`.",
+        "Integer `Range`, `DataRange`, `Sheet`, `ExpectedNumVariables`, and `VariableNamesLine` controls are parsed exactly from all eight integer classes. `ExpectedNumVariables` and `Sheet` must be positive; boolean controls accept only logical values or exact numeric zero/one.",
+        "Numeric `DataRange` currently supports a positive scalar start row or one 1-by-2 increasing row interval. Textual cell references are supported for detected-option replay; multiple numeric Nx2 intervals remain a recorded general gap.",
+        "Typed-integer `NumHeaderLines` is a RunMat-only extension. Compatibility mode rejects it before provider or file access; scalar single and double remain public inputs.",
         "For spreadsheet files, uses the same sheet/range reader as `readtable` and emits spreadsheet-compatible option fields.",
-        "The returned struct intentionally contains fields understood by current RunMat readers; unsupported MATLAB option fields are not emitted."
+        "The returned struct intentionally contains fields understood by current RunMat readers. Concrete MATLAB import-options classes and JSON, XML, Word, HTML, and archive option families remain recorded general gaps."
     ],
     "examples": [
         {
@@ -71,6 +74,10 @@ const builtinDoc = {
         {
             "question": "Does detection read the whole file?",
             "answer": "RunMat currently reads the file into host memory and samples the parsed rows, matching the existing `readtable` import pipeline."
+        },
+        {
+            "question": "Can detection options be GPU-resident?",
+            "answer": "No. Resident path or option values, including nested values, are rejected before provider or file access."
         }
     ],
     "links": [
@@ -88,12 +95,12 @@ const builtinDoc = {
         }
     ],
     "source": {
-        "label": "`crates/runmat-runtime/src/builtins/table/mod.rs`",
-        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/table/mod.rs"
+        "label": "`crates/runmat-runtime/src/builtins/table/builtins/io.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/table/builtins/io.rs"
     },
     "gpu_residency": "`detectImportOptions` performs file inspection on the host and returns host metadata. It does not create GPU-resident arrays.",
     "gpu_behavior": [
-        "No acceleration provider hooks are used."
+        "No acceleration provider hooks are used. Resident arguments are rejected without a download."
     ],
     "key": "detectimportoptions",
     "slug": "detectimportoptions",

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

@@ -1 +1 @@
-{"version":3,"file":"detectImportOptions.js","sourceRoot":"","sources":["../../../src/generated/builtins/detectImportOptions.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,qBAAqB;IAC9B,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE;QACV,qBAAqB;QACrB,WAAW;QACX,YAAY;QACZ,KAAK;QACL,KAAK;QACL,aAAa;QACb,eAAe;QACf,eAAe;KAChB;IACD,SAAS,EAAE,iFAAiF;IAC5F,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,qFAAqF;KAC/F;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,wBAAwB;QAChC,aAAa,EAAE;YACb,qFAAqF;YACrF,2EAA2E;YAC3E,0EAA0E;SAC3E;KACF;IACD,aAAa,EAAE,gMAAgM;IAC/M,WAAW,EAAE;QACX,4HAA4H;QAC5H,8GAA8G;QAC9G,iIAAiI;QACjI,+QAA+Q;QAC/Q,wHAAwH;QACxH,2IAA2I;KAC5I;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,+FAA+F;SACzG;QACD;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,yJAAyJ;SACnK;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,oFAAoF;SAC9F;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,uIAAuI;SAClJ;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,oKAAoK;SAC/K;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,kIAAkI;SAC7I;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,cAAc;SACtB;QACD;YACE,OAAO,EAAE,0BAA0B;YACnC,KAAK,EAAE,4BAA4B;SACpC;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,mDAAmD;QAC5D,KAAK,EAAE,gGAAgG;KACxG;IACD,eAAe,EAAE,+HAA+H;IAChJ,cAAc,EAAE;QACd,0CAA0C;KAC3C;IACD,KAAK,EAAE,qBAAqB;IAC5B,MAAM,EAAE,qBAAqB;IAC7B,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,IAAI;QACJ,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"detectImportOptions.js","sourceRoot":"","sources":["../../../src/generated/builtins/detectImportOptions.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,qBAAqB;IAC9B,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE;QACV,qBAAqB;QACrB,WAAW;QACX,YAAY;QACZ,KAAK;QACL,KAAK;QACL,aAAa;QACb,eAAe;QACf,eAAe;KAChB;IACD,SAAS,EAAE,iFAAiF;IAC5F,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,oHAAoH;KAC9H;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,wBAAwB;QAChC,aAAa,EAAE;YACb,qFAAqF;YACrF,2EAA2E;YAC3E,0EAA0E;SAC3E;KACF;IACD,aAAa,EAAE,gMAAgM;IAC/M,WAAW,EAAE;QACX,4HAA4H;QAC5H,8GAA8G;QAC9G,iIAAiI;QACjI,uWAAuW;QACvW,gRAAgR;QAChR,2OAA2O;QAC3O,yKAAyK;QACzK,wHAAwH;QACxH,qNAAqN;KACtN;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,+FAA+F;SACzG;QACD;YACE,aAAa,EAAE,6BAA6B;YAC5C,OAAO,EAAE,yJAAyJ;SACnK;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,oFAAoF;SAC9F;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,uIAAuI;SAClJ;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,oKAAoK;SAC/K;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,kIAAkI;SAC7I;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,2GAA2G;SACtH;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,cAAc;SACtB;QACD;YACE,OAAO,EAAE,0BAA0B;YACnC,KAAK,EAAE,4BAA4B;SACpC;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,2DAA2D;QACpE,KAAK,EAAE,wGAAwG;KAChH;IACD,eAAe,EAAE,+HAA+H;IAChJ,cAAc,EAAE;QACd,8FAA8F;KAC/F;IACD,KAAK,EAAE,qBAAqB;IAC5B,MAAM,EAAE,qBAAqB;IAC7B,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,IAAI;QACJ,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/diag.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "Keeps results on the GPU when providers implement custom diag hooks; otherwise gathers to the host, materialises the result once, and uploads it back to the device."
+        "notes": "Keeps supported real and logical results on the originating provider. Exact integer and complex inputs use a validated gather, structural host operation, and owner-preserving re-upload when native hooks cannot preserve their storage contract."
     },
     "fusion": {
         "elementwise": false,
@@ -32,18 +32,15 @@ const builtinDoc = {
         "unit": "builtins::array::shape::diag::tests",
         "integration": "builtins::array::shape::diag::tests::diag_wgpu_rectangular_and_extract_paths_stay_resident"
     },
-    "description": "`diag` either constructs a diagonal matrix from a vector or extracts a diagonal from a matrix. Offset handling and supported input classes follow MATLAB semantics.",
+    "description": "`diag` either constructs a diagonal matrix from a vector or extracts a diagonal from a matrix. The four public forms, offset handling, input classes, and GPU residency follow MATLAB semantics; additional size, vector, class, and like forms are named RunMat-only extensions.",
     "behaviors": [
         "`diag(v)` with a vector `v` returns a square matrix whose main diagonal is `v`.",
         "`diag(v, k)` places `v` on the `k`-th diagonal: super-diagonals for `k > 0`, sub-diagonals for `k < 0`. The output size grows by `abs(k)`.",
         "`diag(A)` with a matrix `A` returns a column vector containing the main diagonal of `A`.",
         "`diag(A, k)` extracts the `k`-th diagonal. When the requested diagonal does not exist, an empty column vector is returned.",
-        "`diag(v, 'vector')` always returns a column vector copy of `v`, even when `v` is already a vector.",
-        "`diag(v, [m n])` creates an explicit rectangular size. You can combine it with offsets (e.g. `diag(v, k, [m n])`) when you need a wider diagonal band.",
-        "`diag(___, 'logical')` converts the result to a logical array. `diag(___, 'double')` forces a double-precision result when inputs are logical.",
-        "`diag(___, 'like', prototype)` matches the numeric flavour and residency of `prototype` (including GPU handles).",
+        "RunMat mode additionally supports `diag(v, 'vector')`, explicit rectangular sizes, output-class overrides, and `'like'` prototypes; each extension rejects independently in MATLAB-compatible mode.",
         "Logical inputs stay logical; complex inputs stay complex; character arrays preserve padding with spaces off the diagonal.",
-        "Higher-dimensional inputs are accepted when trailing dimensions are singleton—only the leading 2-D slice participates in the diagonal operation."
+        "MATLAB-compatible mode rejects every input with more than two dimensions. RunMat mode retains trailing-singleton support as a named extension."
     ],
     "examples": [
         {
@@ -89,11 +86,11 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "Does `diag` always return a square matrix?",
-            "answer": "Only when the input is a vector and you do not request otherwise. Use `'vector'` to keep the result as a column vector, or pass a size vector (e.g. `diag(v, [m n])`) to create rectangular matrices."
+            "answer": "The public vector form returns a square matrix. RunMat mode offers separately gated `'vector'` and explicit-size extensions for column-vector and rectangular results."
         },
         {
             "question": "What happens if I request a diagonal outside the matrix bounds?",
-            "answer": "You receive an empty column vector (size `0 × 0`), matching MATLAB's behaviour."
+            "answer": "You receive an empty column vector with size `0 × 1`, matching MATLAB's behaviour."
         },
         {
             "question": "Can I use `diag` with logical or character arrays?",
@@ -109,7 +106,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I place a diagonal inside a non-square matrix?",
-            "answer": "Yes. Pass an explicit size vector such as `diag(v, [m n])`, and optionally combine it with an offset via `diag(v, k, [m n])`."
+            "answer": "RunMat mode can do this through the gated explicit-size extension, such as `diag(v, [m n])` or `diag(v, k, [m n])`; these are not public MATLAB `diag` forms."
         },
         {
             "question": "What if the vector is empty?",
@@ -117,7 +114,7 @@ const builtinDoc = {
         },
         {
             "question": "Do GPU results stay on the device?",
-            "answer": "Yes. Real and logical gpuArray inputs use provider hooks for vector placement, explicit rectangular sizes, `'vector'` mode, and matrix diagonal extraction. Complex, character, and conversion-heavy template forms use the host fallback."
+            "answer": "Yes. Validated provider hooks serve compatible real and logical paths. Exact integer and complex inputs use an exact gather and owner-preserving re-upload when native hooks cannot preserve their storage contract."
         },
         {
             "question": "Is the offset argument required to be an integer?",
@@ -129,11 +126,11 @@ const builtinDoc = {
         },
         {
             "question": "How do I match another array's type or residency?",
-            "answer": "Use the `'like'` syntax: `diag(v, 'like', prototype)`. Logical, complex, and GPU prototypes are respected even when the computation falls back to the CPU path."
+            "answer": "RunMat mode provides a separately gated `'like'` extension. Logical, complex, integer, and GPU prototypes are respected even when computation uses an exact host fallback."
         },
         {
             "question": "Is single precision supported?",
-            "answer": "Not yet. Requesting `'single'` currently raises an error. Use `'like'` with an appropriate prototype once single-precision support lands."
+            "answer": "Yes. Native single input preserves single output, and RunMat extension mode can request single output with a single-precision `'like'` prototype."
         }
     ],
     "links": [
@@ -226,9 +223,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/array/shape/diag.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/shape/diag.rs"
     },
-    "gpu_residency": "You usually do NOT need to call `gpuArray` yourself in RunMat (unlike MATLAB).\n\nIn RunMat, the auto-offload planner keeps residency on the GPU when expressions make use of GPU providers. For `diag`, real and logical GPU inputs stay resident when the active provider exposes the required diagonal hooks. If those hooks are missing, or if the requested class semantics require host conversion, the builtin gathers once and returns the host result unless a GPU `'like'` prototype explicitly requests device residency.\n\nTo preserve backwards compatibility with MathWorks MATLAB, and for when you want to explicitly bootstrap GPU residency, you can call `gpuArray` to move data to the GPU. That mirrors MATLAB's behaviour while still allowing RunMat's planner to decide whether the GPU offers an advantage for the surrounding computation.\n\nSince MathWorks MATLAB does not have a fusion planner, and they kept their parallel execution toolbox separate from the core language, as their toolbox is a separate commercial product, MathWorks MATLAB users need to call `gpuArray` to move data to the GPU manually whereas RunMat users can rely on the fusion planner to keep data on the GPU automatically.",
+    "gpu_residency": "You usually do NOT need to call `gpuArray` yourself in RunMat (unlike MATLAB).\n\nIn RunMat, the auto-offload planner keeps residency on the GPU when expressions make use of GPU providers. For `diag`, compatible real and logical GPU inputs use the owning provider's diagonal hooks. If a hook is missing or the requested storage/class semantics require host evaluation, RunMat gathers through that owner, computes the result on the host, and validates a re-upload to the same owner and device. A GPU `'like'` prototype instead selects its own registered owner and device for the validated result.\n\nTo preserve backwards compatibility with MathWorks MATLAB, and for when you want to explicitly bootstrap GPU residency, you can call `gpuArray` to move data to the GPU. That mirrors MATLAB's behaviour while still allowing RunMat's planner to decide whether the GPU offers an advantage for the surrounding computation.\n\nSince MathWorks MATLAB does not have a fusion planner, and they kept their parallel execution toolbox separate from the core language, as their toolbox is a separate commercial product, MathWorks MATLAB users need to call `gpuArray` to move data to the GPU manually whereas RunMat users can rely on the fusion planner to keep data on the GPU automatically.",
     "gpu_behavior": [
-        "When a real or logical input lives on the GPU, RunMat calls the acceleration provider's `diag_from_vector`, `diag_from_vector_sized`, `diag_extract`, or metadata-only `reshape` hook as appropriate. That covers native vector-to-matrix placement, explicit rectangular size overrides, `'vector'` mode, matrix diagonal extraction, and empty out-of-bounds diagonals without gathering. Providers that do not expose these hooks fall back to a host result. Complex, character, and conversion-heavy template forms also use the host path so MATLAB-compatible class conversion semantics remain intact."
+        "When a compatible real or logical input lives on the GPU, RunMat calls its owning acceleration provider's `diag_from_vector`, `diag_from_vector_sized`, `diag_extract`, or metadata-only `reshape` hook as appropriate. That covers native vector-to-matrix placement, explicit rectangular size overrides, `'vector'` mode, matrix diagonal extraction, and empty out-of-bounds diagonals without gathering. Missing hooks and complex or conversion-heavy forms use an owner-resolved gather, host computation, and validated re-upload, so the result remains on the originating provider and device. A resident GPU `'like'` prototype deliberately selects the prototype's owner and device instead."
     ],
     "key": "diag",
     "slug": "diag",

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

@@ -1 +1 @@
-{"version":3,"file":"diag.js","sourceRoot":"","sources":["../../../src/generated/builtins/diag.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,UAAU;QACV,QAAQ;QACR,YAAY;QACZ,KAAK;KACN;IACD,SAAS,EAAE,qEAAqE;IAChF,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,sKAAsK;KAChL;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;QAC7C,aAAa,EAAE,4FAA4F;KAC5G;IACD,aAAa,EAAE,qKAAqK;IACpL,WAAW,EAAE;QACX,iFAAiF;QACjF,4IAA4I;QAC5I,0FAA0F;QAC1F,4HAA4H;QAC5H,oGAAoG;QACpG,wJAAwJ;QACxJ,gJAAgJ;QAChJ,kHAAkH;QAClH,2HAA2H;QAC3H,kJAAkJ;KACnJ;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,2BAA2B;YACpC,QAAQ,EAAE,iEAAiE;SAC5E;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,8BAA8B;YACvC,QAAQ,EAAE,6GAA6G;SACxH;QACD;YACE,aAAa,EAAE,6CAA6C;YAC5D,OAAO,EAAE,6CAA6C;YACtD,QAAQ,EAAE,qBAAqB;SAChC;QACD;YACE,aAAa,EAAE,gDAAgD;YAC/D,OAAO,EAAE,4CAA4C;YACrD,QAAQ,EAAE,6GAA6G;SACxH;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,wEAAwE;YACjF,QAAQ,EAAE,wCAAwC;SACnD;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,wCAAwC;YACjD,QAAQ,EAAE,6BAA6B;SACxC;QACD;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,gCAAgC;YACzC,QAAQ,EAAE,yDAAyD;SACpE;QACD;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,uDAAuD;SACjE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,uMAAuM;SAClN;QACD;YACE,UAAU,EAAE,iEAAiE;YAC7E,QAAQ,EAAE,iFAAiF;SAC5F;QACD;YACE,UAAU,EAAE,oDAAoD;YAChE,QAAQ,EAAE,uIAAuI;SAClJ;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,qFAAqF;SAChG;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,mGAAmG;SAC9G;QACD;YACE,UAAU,EAAE,oDAAoD;YAChE,QAAQ,EAAE,+HAA+H;SAC1I;QACD;YACE,UAAU,EAAE,8BAA8B;YAC1C,QAAQ,EAAE,gHAAgH;SAC3H;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,4OAA4O;SACvP;QACD;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,wDAAwD;SACnE;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,iEAAiE;SAC5E;QACD;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,iKAAiK;SAC5K;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,2IAA2I;SACtJ;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;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,eAAe,EAAE,+qCAA+qC;IAChsC,cAAc,EAAE;QACd,glBAAglB;KACjlB;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;QACP,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"diag.js","sourceRoot":"","sources":["../../../src/generated/builtins/diag.ts"],"names":[],"mappings":"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"}

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

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

package/dist/generated/builtins/dictionary.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Dictionary objects are host metadata containers."
+        "notes": "Dictionary objects are host metadata containers. Resident input is a RunMat-only extension gated before exact download through the owning provider."
     },
     "fusion": {
         "elementwise": false,
@@ -29,10 +29,15 @@ const builtinDoc = {
         "unit": "builtins::table::tests",
         "integration": "crates/runmat-vm/tests/tables_timetables.rs"
     },
-    "description": "`dictionary(keys, values)` creates a dictionary object with cell-backed `Keys` and `Values` properties. Alternating key/value pairs are also accepted.",
+    "description": "`dictionary(keys, values)` creates a host dictionary object. Alternating key/value pairs are also accepted, including array-valued pairs.",
     "behaviors": [
-        "Keys and values must have the same number of elements.",
-        "String, numeric, logical, char, and cell collections are expanded into element lists."
+        "Keys and values must have the same size unless the value input is scalar, in which case it expands to every key.",
+        "String, numeric, logical, char, and cell collections are expanded into entries and normalized to one compatible configured key class and one compatible configured value class.",
+        "All eight integer classes remain exact, including `uint64` keys beyond binary64's exact range. Construction, lookup, assignment, and removal compare authoritative configured-class integers.",
+        "Duplicate keys keep their first insertion position and the last supplied value.",
+        "Multi-key lookup preserves the configured uniform value class and the query shape; scalar lookup returns a scalar. Non-scalar assignment values must match the key-query shape, while scalar assignment expands.",
+        "Resident keys or values are a RunMat-only interactive extension. Compatibility mode rejects them before provider access; RunMat mode gathers them exactly through the owning provider.",
+        "Concrete MATLAB dictionary class metadata and unsupported heterogeneous object-type conversions remain recorded general gaps."
     ],
     "examples": [
         {
@@ -48,8 +53,8 @@ const builtinDoc = {
         }
     ],
     "source": {
-        "label": "`crates/runmat-runtime/src/builtins/table/mod.rs`",
-        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/table/mod.rs"
+        "label": "`crates/runmat-runtime/src/builtins/table/containers/dictionary.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/table/containers/dictionary.rs"
     },
     "key": "dictionary",
     "slug": "dictionary",

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

@@ -1 +1 @@
-{"version":3,"file":"dictionary.js","sourceRoot":"","sources":["../../../src/generated/builtins/dictionary.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE;QACV,YAAY;QACZ,KAAK;QACL,MAAM;QACN,QAAQ;QACR,gBAAgB;KACjB;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,kDAAkD;KAC5D;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,wBAAwB;QAChC,aAAa,EAAE,6CAA6C;KAC7D;IACD,aAAa,EAAE,wJAAwJ;IACvK,WAAW,EAAE;QACX,wDAAwD;QACxD,uFAAuF;KACxF;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,qBAAqB;YACpC,OAAO,EAAE,sCAAsC;YAC/C,QAAQ,EAAE,uBAAuB;SAClC;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,gBAAgB;YACzB,KAAK,EAAE,kBAAkB;SAC1B;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,mDAAmD;QAC5D,KAAK,EAAE,gGAAgG;KACxG;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"dictionary.js","sourceRoot":"","sources":["../../../src/generated/builtins/dictionary.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,OAAO;IACnB,UAAU,EAAE;QACV,YAAY;QACZ,KAAK;QACL,MAAM;QACN,QAAQ;QACR,gBAAgB;KACjB;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,qJAAqJ;KAC/J;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,wBAAwB;QAChC,aAAa,EAAE,6CAA6C;KAC7D;IACD,aAAa,EAAE,2IAA2I;IAC1J,WAAW,EAAE;QACX,kHAAkH;QAClH,iLAAiL;QACjL,+LAA+L;QAC/L,iFAAiF;QACjF,kNAAkN;QAClN,wLAAwL;QACxL,+HAA+H;KAChI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,qBAAqB;YACpC,OAAO,EAAE,sCAAsC;YAC/C,QAAQ,EAAE,uBAAuB;SAClC;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,gBAAgB;YACzB,KAAK,EAAE,kBAAkB;SAC1B;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,qEAAqE;QAC9E,KAAK,EAAE,kHAAkH;KAC1H;IACD,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,OAAO;KACR;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/diff.js

@@ -20,7 +20,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "Calls the provider's `diff_dim` hook; falls back to host when that hook is unavailable."
+        "notes": "Calls the provider's `diff_dim` hook for real floating storage. Typed integer, logical, and complex gpuArray inputs use owner-resolved host fallbacks and return validated results to the same device only when the owner physically supports the required result precision."
     },
     "fusion": {
         "elementwise": false,
@@ -36,10 +36,10 @@ const builtinDoc = {
     "description": "`diff(X)` computes forward finite differences along the first non-singleton dimension by default. Higher-order and explicit-dimension forms follow MATLAB semantics. When `X` is a scalar symbolic expression, `diff` builds a symbolic derivative expression.",
     "behaviors": [
         "`diff(X)` walks along the first non-singleton dimension. Column vectors therefore differentiate down the rows, while row vectors operate across columns.",
-        "`diff(X, N)` computes the Nth forward difference. `N = 0` returns `X` unchanged. Each order reduces the length of the working dimension by one, so the output length becomes `max(len - N, 0)`.",
-        "`diff(X, N, dim)` lets you choose the dimension explicitly. Passing `[]` for `N` or `dim` keeps the defaults, and dimensions larger than `ndims(X)` behave like length-1 axes (so any positive order yields an empty result).",
+        "`diff(X, N)` computes the Nth forward difference without cascading into later dimensions when N exhausts the initially selected dimension. Each positive order reduces that dimension by one, so its output length becomes `max(len - N, 0)`.",
+        "`diff(X, N, dim)` lets you choose the dimension explicitly. Dimensions larger than `ndims(X)` behave like length-1 axes, so any positive order yields an empty result. RunMat extension mode also accepts `N = 0` and empty `N` or `dim` placeholders.",
         "For scalar symbolic inputs, `diff(expr, var)` and `diff(expr, var, N)` return symbolic derivative expressions. `diff(expr, N, var)` is accepted for MATLAB-compatible argument order.",
-        "Real, logical, and character inputs promote to double precision tensors before differencing. Complex inputs retain their complex type, with forward differences applied to both the real and imaginary parts independently.",
+        "Floating and logical data follow their numeric domains. All eight integer classes preserve their input class and use saturating adjacent subtraction. Character data is a named RunMat-only extension that promotes character codes to double.",
         "Empty slices propagate: if the selected dimension has length 0 or 1, the corresponding axis in the output has length 0."
     ],
     "examples": [
@@ -86,11 +86,11 @@ const builtinDoc = {
         },
         {
             "question": "How are higher-order differences computed?",
-            "answer": "RunMat applies the first-order forward difference repeatedly. This mirrors MATLAB’s definition and produces the same numerical results."
+            "answer": "RunMat applies the first-order forward difference repeatedly along the initially selected dimension. Current MATLAB behavior does not cascade into a later dimension after that dimension is exhausted."
         },
         {
             "question": "Can I pass `[]` for the order or dimension arguments?",
-            "answer": "Yes. An empty array keeps the default value (`N = 1`, first non-singleton dimension)."
+            "answer": "RunMat extension mode accepts empty placeholders and keeps the default value (`N = 1`, first non-singleton dimension)."
         },
         {
             "question": "Does `diff` support complex numbers?",
@@ -98,11 +98,11 @@ const builtinDoc = {
         },
         {
             "question": "What happens for character or logical inputs?",
-            "answer": "Characters and logical values are promoted to double precision differences, matching MATLAB."
+            "answer": "Logical data is supported. Character data is a named RunMat-only extension and promotes character codes to double; integer data instead preserves its class and uses saturating subtraction."
         },
         {
             "question": "Will the GPU path produce the same results as the CPU path?",
-            "answer": "Yes. When a provider lacks a finite-difference kernel, RunMat gathers the data and computes on the CPU to preserve MATLAB semantics exactly. Otherwise, the WGPU backend produces identical results on the GPU."
+            "answer": "Real floating storage can use the provider kernel. Typed integer, logical, complex, and unsupported-provider paths gather through the input owner, compute with the matching host semantics, and restore a validated resident result."
         },
         {
             "question": "What does diff do in MATLAB?",
@@ -122,7 +122,7 @@ const builtinDoc = {
         },
         {
             "question": "Does diff support GPU acceleration in RunMat?",
-            "answer": "Yes. `diff` runs on GPU arrays in RunMat. The GPU path produces the same results as the CPU path for both real and complex inputs."
+            "answer": "Yes. Real floating arrays can execute in the provider kernel. Complex, logical, and typed integer arrays currently use owner-preserving host fallbacks rather than a native WGPU difference kernel."
         },
         {
             "question": "Does `diff` support symbolic expressions?",
@@ -207,9 +207,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/math/reduction/diff.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/diff.rs"
     },
-    "gpu_residency": "Manual `gpuArray` promotion is optional. RunMat keeps tensors on the GPU when providers implement the relevant hooks and the planner predicts a benefit. With the WGPU backend registered, `diff` executes fully on the GPU and returns a device-resident tensor. When the hook is missing, RunMat gathers transparently, computes on the CPU, and keeps residency metadata consistent so fused expressions can re-promote values when profitable.",
+    "gpu_residency": "Manual `gpuArray` promotion is optional. Real floating tensors use `diff_dim` when the owning provider supports it. Typed integer, logical, complex, and unsupported-provider paths gather through that owner, compute on the host, and re-upload a validated result to the same owner and device.",
     "gpu_behavior": [
-        "When the operand already resides on the GPU, RunMat asks the active acceleration provider for a finite-difference kernel via `diff_dim`. The WGPU backend implements this hook, so forward differences execute entirely on the device and the result stays resident on the GPU. Providers that have not wired `diff_dim` yet transparently gather the data, run the CPU implementation, and hand the result back to the planner so subsequent kernels can re-promote it when beneficial."
+        "For real floating storage, RunMat asks the handle's owning provider for `diff_dim` and accepts only a result with matching owner, device, shape, storage, precision, and no integer or logical metadata. Typed integer, logical, complex, and unsupported-provider paths gather explicitly and restore through the same validated owner/device path."
     ],
     "key": "diff",
     "slug": "diff",

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

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

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

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

package/dist/generated/builtins/digits.js

@@ -27,10 +27,12 @@ const builtinDoc = {
     "tested": {
         "unit": "builtins::math::symbolic::digits::tests"
     },
-    "description": "`digits` returns the current default precision for `vpa`. `digits(d)` sets the precision and returns the previous value. `digits('default')` resets the setting to 32.",
+    "description": "`digits` returns the current default precision for `vpa`. `digits(d)` rounds a finite numeric scalar to the nearest integer, sets that precision, and returns the previous value as a double scalar. RunMat mode additionally supports `digits('default')` as an explicitly gated reset extension.",
     "behaviors": [
         "The default value is 32 significant digits.",
-        "Accepted digit counts are positive integer scalar values in the supported range.",
+        "The public precision range is 2 through 100000000 significant digits, inclusive, and noninteger floating controls round to the nearest integer.",
+        "Host controls can use single, double, or any of the eight built-in integer classes; logical and resident controls reject.",
+        "Numeric text and the `'default'` reset are named RunMat-only extensions and reject in MATLAB-compatible mode.",
         "The setting affects later `vpa(x)` calls that omit an explicit precision."
     ],
     "examples": [

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

@@ -1 +1 @@
-{"version":3,"file":"digits.js","sourceRoot":"","sources":["../../../src/generated/builtins/digits.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,QAAQ;QACR,KAAK;QACL,UAAU;QACV,WAAW;KACZ;IACD,SAAS,EAAE,wDAAwD;IACnE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,yFAAyF;KACnG;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,yCAAyC;KAClD;IACD,aAAa,EAAE,wKAAwK;IACvL,WAAW,EAAE;QACX,6CAA6C;QAC7C,kFAAkF;QAClF,2EAA2E;KAC5E;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,0DAA0D;SACpE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4DAA4D;YACxE,QAAQ,EAAE,wHAAwH;SACnI;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,8DAA8D;QACvE,KAAK,EAAE,2GAA2G;KACnH;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"digits.js","sourceRoot":"","sources":["../../../src/generated/builtins/digits.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,QAAQ;QACR,KAAK;QACL,UAAU;QACV,WAAW;KACZ;IACD,SAAS,EAAE,wDAAwD;IACnE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,yFAAyF;KACnG;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,yCAAyC;KAClD;IACD,aAAa,EAAE,oSAAoS;IACnT,WAAW,EAAE;QACX,6CAA6C;QAC7C,iJAAiJ;QACjJ,2HAA2H;QAC3H,+GAA+G;QAC/G,2EAA2E;KAC5E;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,0DAA0D;SACpE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,4DAA4D;YACxE,QAAQ,EAAE,wHAAwH;SACnI;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,8DAA8D;QACvE,KAAK,EAAE,2GAA2G;KACnH;IACD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/digitsPattern.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "No GPU kernel is registered for this compatibility builtin; GPU-resident inputs are gathered to host memory before evaluation."
+        "notes": "Pattern construction is a host operation. The documented count controls are host scalars, and resident controls reject before provider access."
     },
     "fusion": {
         "elementwise": false,
@@ -30,24 +30,58 @@ const builtinDoc = {
         "unit": "builtins::strings::core::compat::tests",
         "integration": null
     },
-    "description": "pat = digitsPattern(N) - Create a pattern matching digit characters.",
+    "description": "`digitsPattern` creates a greedy pattern for Unicode digit characters. It supports one-or-more matching, an exact count, or inclusive minimum and maximum counts.",
     "signatures": [
+        {
+            "label": "pat = digitsPattern",
+            "inputs": [],
+            "outputs": [
+                {
+                    "name": "out",
+                    "ty": "Any",
+                    "arity": "Required",
+                    "default": null,
+                    "description": "Unicode digit pattern object."
+                }
+            ]
+        },
         {
             "label": "pat = digitsPattern(N)",
             "inputs": [
                 {
-                    "name": "text",
+                    "name": "N",
+                    "ty": "NumericScalar",
+                    "arity": "Required",
+                    "default": null,
+                    "description": "Exact nonnegative number of Unicode digit characters."
+                }
+            ],
+            "outputs": [
+                {
+                    "name": "out",
                     "ty": "Any",
                     "arity": "Required",
                     "default": null,
-                    "description": "Input text."
+                    "description": "Unicode digit pattern object."
+                }
+            ]
+        },
+        {
+            "label": "pat = digitsPattern(minCharacters, maxCharacters)",
+            "inputs": [
+                {
+                    "name": "minCharacters",
+                    "ty": "NumericScalar",
+                    "arity": "Required",
+                    "default": null,
+                    "description": "Inclusive nonnegative minimum count."
                 },
                 {
-                    "name": "arg",
-                    "ty": "Any",
-                    "arity": "Variadic",
+                    "name": "maxCharacters",
+                    "ty": "NumericScalar",
+                    "arity": "Required",
                     "default": null,
-                    "description": "Additional arguments."
+                    "description": "Inclusive nonnegative maximum count, or positive infinity."
                 }
             ],
             "outputs": [
@@ -56,14 +90,16 @@ const builtinDoc = {
                     "ty": "Any",
                     "arity": "Required",
                     "default": null,
-                    "description": "Output value."
+                    "description": "Unicode digit pattern object."
                 }
             ]
         }
     ],
     "behaviors": [
-        "Create a pattern matching digit characters.",
-        "Creates a regular-expression-backed pattern for digit runs, with optional exact count."
+        "With no inputs, the pattern matches one or more Unicode digit characters.",
+        "A single nonnegative integer scalar matches exactly that many digits.",
+        "Two nonnegative integer scalars specify inclusive minimum and maximum counts; positive infinity is accepted as an unbounded maximum, and matching is greedy toward the maximum.",
+        "Count controls accept host single, double, and every built-in integer class. Fractional, negative, logical, and resident controls reject."
     ],
     "examples": [
         "contains(\"A12\", digitsPattern) can match the digit run through pattern-aware string APIs."

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

@@ -1 +1 @@
-{"version":3,"file":"digitsPattern.js","sourceRoot":"","sources":["../../../src/generated/builtins/digitsPattern.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,eAAe;IACxB,UAAU,EAAE,iBAAiB;IAC7B,UAAU,EAAE;QACV,eAAe;QACf,SAAS;QACT,SAAS;QACT,QAAQ;QACR,eAAe;KAChB;IACD,SAAS,EAAE,6CAA6C;IACxD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,gIAAgI;KAC1I;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,IAAI;QAClB,WAAW,EAAE,gBAAgB;QAC7B,OAAO,EAAE,kFAAkF;KAC5F;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,wCAAwC;QAChD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,sEAAsE;IACrF,YAAY,EAAE;QACZ;YACE,OAAO,EAAE,wBAAwB;YACjC,QAAQ,EAAE;gBACR;oBACE,MAAM,EAAE,MAAM;oBACd,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,aAAa;iBAC7B;gBACD;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,uBAAuB;iBACvC;aACF;YACD,SAAS,EAAE;gBACT;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,eAAe;iBAC/B;aACF;SACF;KACF;IACD,WAAW,EAAE;QACX,6CAA6C;QAC7C,wFAAwF;KACzF;IACD,UAAU,EAAE;QACV,6FAA6F;KAC9F;IACD,MAAM,EAAE,EAAE;IACV,OAAO,EAAE;QACP;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,6DAA6D;QACtE,KAAK,EAAE,0GAA0G;KAClH;IACD,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,eAAe;IACvB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;QACT,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"digitsPattern.js","sourceRoot":"","sources":["../../../src/generated/builtins/digitsPattern.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,eAAe;IACxB,UAAU,EAAE,iBAAiB;IAC7B,UAAU,EAAE;QACV,eAAe;QACf,SAAS;QACT,SAAS;QACT,QAAQ;QACR,eAAe;KAChB;IACD,SAAS,EAAE,6CAA6C;IACxD,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,gJAAgJ;KAC1J;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,IAAI;QAClB,WAAW,EAAE,gBAAgB;QAC7B,OAAO,EAAE,kFAAkF;KAC5F;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,wCAAwC;QAChD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,mKAAmK;IAClL,YAAY,EAAE;QACZ;YACE,OAAO,EAAE,qBAAqB;YAC9B,QAAQ,EAAE,EAAE;YACZ,SAAS,EAAE;gBACT;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,+BAA+B;iBAC/C;aACF;SACF;QACD;YACE,OAAO,EAAE,wBAAwB;YACjC,QAAQ,EAAE;gBACR;oBACE,MAAM,EAAE,GAAG;oBACX,IAAI,EAAE,eAAe;oBACrB,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,uDAAuD;iBACvE;aACF;YACD,SAAS,EAAE;gBACT;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,+BAA+B;iBAC/C;aACF;SACF;QACD;YACE,OAAO,EAAE,mDAAmD;YAC5D,QAAQ,EAAE;gBACR;oBACE,MAAM,EAAE,eAAe;oBACvB,IAAI,EAAE,eAAe;oBACrB,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,sCAAsC;iBACtD;gBACD;oBACE,MAAM,EAAE,eAAe;oBACvB,IAAI,EAAE,eAAe;oBACrB,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,4DAA4D;iBAC5E;aACF;YACD,SAAS,EAAE;gBACT;oBACE,MAAM,EAAE,KAAK;oBACb,IAAI,EAAE,KAAK;oBACX,OAAO,EAAE,UAAU;oBACnB,SAAS,EAAE,IAAI;oBACf,aAAa,EAAE,+BAA+B;iBAC/C;aACF;SACF;KACF;IACD,WAAW,EAAE;QACX,2EAA2E;QAC3E,uEAAuE;QACvE,iLAAiL;QACjL,2IAA2I;KAC5I;IACD,UAAU,EAAE;QACV,6FAA6F;KAC9F;IACD,MAAM,EAAE,EAAE;IACV,OAAO,EAAE;QACP;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,6DAA6D;QACtE,KAAK,EAAE,0GAA0G;KAClH;IACD,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,eAAe;IACvB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;QACT,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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