runmat 0.6.1 → 0.6.2-dev.0

package/dist/generated/builtins/dbstack.js

@@ -31,10 +31,10 @@ const builtinDoc = {
     "description": "`dbstack` inspects RunMat's runtime call-stack context and returns MATLAB-style frame metadata.",
     "behaviors": [
         "`dbstack` with no output displays the active stack.",
-        "`ST = dbstack` returns stack entries as a 1-by-N cell row of scalar structs because RunMat does not yet have first-class MATLAB struct arrays.",
-        "Each frame struct contains `file`, `name`, `line`, and `I` fields.",
-        "`dbstack(n)` omits the first `n` returned entries. `'-completenames'` is accepted; RunMat already reports the full source path when the source catalog has one.",
-        "`[ST,I] = dbstack(...)` returns the stack cell row and a current workspace index of `1` when a stack is available."
+        "`ST = dbstack` returns stack entries as an N-by-1 cell column of scalar structs because RunMat does not yet have first-class MATLAB struct arrays.",
+        "Each frame struct contains exactly the public `file`, `name`, and `line` fields; `I` is a separate second output.",
+        "`dbstack(n)` omits the first `n` returned entries; both `dbstack('-completenames', n)` and `dbstack(n, '-completenames')` additionally report full source paths when the source catalog has them.",
+        "`[ST,I] = dbstack(...)` returns the stack cell column and a current workspace index of `1` when a stack is available; more than two requested outputs reject."
     ],
     "examples": [
         {
@@ -43,13 +43,13 @@ const builtinDoc = {
         },
         {
             "description": "Skip the current frame",
-            "input": "ST = dbstack(1, '-completenames');"
+            "input": "ST = dbstack('-completenames', 1);"
         }
     ],
     "faqs": [
         {
-            "question": "Why is `ST` a cell row instead of a struct array?",
-            "answer": "RunMat currently represents heterogeneous struct-list results as cell rows of scalar structs. This preserves the frame fields until struct-array infrastructure lands."
+            "question": "Why is `ST` a cell column instead of a struct array?",
+            "answer": "RunMat currently represents heterogeneous struct-list results as an N-by-1 cell column of scalar structs. This preserves the public frame fields and shape orientation until struct-array infrastructure lands."
         }
     ],
     "links": [

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

@@ -1 +1 @@
-{"version":3,"file":"dbstack.js","sourceRoot":"","sources":["../../../src/generated/builtins/dbstack.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,SAAS;QACT,OAAO;QACP,YAAY;QACZ,aAAa;KACd;IACD,SAAS,EAAE,iDAAiD;IAC5D,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,iFAAiF;KAC3F;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,aAAa,EAAE,kDAAkD;KAClE;IACD,aAAa,EAAE,iGAAiG;IAChH,WAAW,EAAE;QACX,qDAAqD;QACrD,gJAAgJ;QAChJ,oEAAoE;QACpE,iKAAiK;QACjK,oHAAoH;KACrH;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,eAAe;SACzB;QACD;YACE,aAAa,EAAE,wBAAwB;YACvC,OAAO,EAAE,oCAAoC;SAC9C;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,wKAAwK;SACnL;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,aAAa;YACtB,KAAK,EAAE,eAAe;SACvB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,cAAc,EAAE;QACd,qFAAqF;KACtF;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,eAAe;KAChB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"dbstack.js","sourceRoot":"","sources":["../../../src/generated/builtins/dbstack.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,SAAS;QACT,OAAO;QACP,YAAY;QACZ,aAAa;KACd;IACD,SAAS,EAAE,iDAAiD;IAC5D,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,iFAAiF;KAC3F;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,aAAa,EAAE,kDAAkD;KAClE;IACD,aAAa,EAAE,iGAAiG;IAChH,WAAW,EAAE;QACX,qDAAqD;QACrD,oJAAoJ;QACpJ,mHAAmH;QACnH,mMAAmM;QACnM,+JAA+J;KAChK;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,eAAe;SACzB;QACD;YACE,aAAa,EAAE,wBAAwB;YACvC,OAAO,EAAE,oCAAoC;SAC9C;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,iNAAiN;SAC5N;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,aAAa;YACtB,KAAK,EAAE,eAAe;SACvB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,iEAAiE;QAC1E,KAAK,EAAE,8GAA8G;KACtH;IACD,cAAc,EAAE;QACd,qFAAqF;KACtF;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,eAAe;KAChB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/dcgain.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "`dcgain` evaluates host-side transfer-function metadata."
+        "notes": "`dcgain` accepts a host dynamic-system object. Resident numeric values are invalid `sys` inputs and reject before provider access."
     },
     "fusion": {
         "elementwise": false,
@@ -30,18 +30,25 @@ const builtinDoc = {
         "unit": "builtins::control::dcgain::tests",
         "integration": "crates/runmat-vm/tests/control.rs"
     },
-    "description": "`dcgain(sys)` evaluates a SISO transfer function at `s = 0` for continuous-time models or `z = 1` for discrete-time models.",
+    "description": "`dcgain(sys)` computes the low-frequency gain of an LTI model: the transfer-function value at `s = 0` for continuous-time models or `z = 1` for discrete-time models. RunMat currently implements the SISO `tf` subset.",
     "behaviors": [
-        "Supports SISO `tf` objects.",
+        "Current RunMat support is limited to SISO `tf` objects; MATLAB also supports broader LTI model families and MIMO gain matrices.",
         "Returns a real scalar for real-valued gains and a complex scalar for complex-valued gains.",
         "Continuous-time models are evaluated at zero frequency.",
-        "Discrete-time models are evaluated at `z = 1`."
+        "Discrete-time models are evaluated at `z = 1`.",
+        "A typed integer array is not a valid `sys` input. Integer coefficients admitted by `tf` have already crossed the model constructor's numeric boundary and do not make `dcgain` an integer-array operation.",
+        "The documented DC gain is infinite for systems with integrators. RunMat derives the sign or complex axis from the first nonzero local denominator coefficient at the DC evaluation point, avoiding spurious NaN components while preserving exact pole-zero cancellation as indeterminate."
     ],
     "examples": [
         {
             "description": "Continuous-time DC gain",
             "input": "H = tf(2, [1 3]);\ndcgain(H)",
             "output": "ans = 0.6667"
+        },
+        {
+            "description": "Infinite gain of an integrator",
+            "input": "H = tf(2, [1 0]);\ndcgain(H)",
+            "output": "ans = Inf"
         }
     ],
     "faqs": [
@@ -71,17 +78,18 @@ const builtinDoc = {
             "output": "gain is a scalar."
         },
         "points": [
-            "`sys` must be a SISO `tf` object."
+            "`sys` must currently be a SISO `tf` object in RunMat.",
+            "Typed integer and resident numeric values are rejected as invalid model inputs before provider access."
         ]
     },
     "validation": {
-        "summary": "`dcgain` validates the input model and evaluates numerator and denominator polynomials at the steady-state point. Tests cover real continuous-time gains and VM integration.",
+        "summary": "`dcgain` validates the object boundary before provider access and evaluates SISO transfer-function numerator and denominator polynomials at the steady-state point. Tests cover finite gains, signed continuous integrator infinity, discrete integrator infinity, complex-axis singular direction, exact pole-zero cancellation, invalid integer `sys` inputs, and integer coefficients already admitted by `tf`; broader LTI families and MIMO gain matrices remain explicit general control-system gaps.",
         "implementation": {
             "label": "`crates/runmat-runtime/src/builtins/control/dcgain.rs`",
             "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/control/dcgain.rs"
         }
     },
-    "gpu_residency": "`dcgain` returns a host scalar.",
+    "gpu_residency": "`dcgain` returns a host scalar for the currently supported SISO form. A resident numeric array is not a dynamic-system object and is rejected without gather or provider dispatch.",
     "key": "dcgain",
     "slug": "dcgain",
     "aliases": [],

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

@@ -1 +1 @@
-{"version":3,"file":"dcgain.js","sourceRoot":"","sources":["../../../src/generated/builtins/dcgain.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,SAAS;IACrB,UAAU,EAAE;QACV,QAAQ;QACR,cAAc;QACd,gBAAgB;QAChB,mBAAmB;QACnB,IAAI;KACL;IACD,SAAS,EAAE,8DAA8D;IACzE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,0DAA0D;KACpE;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;QACrB,OAAO,EAAE,qDAAqD;KAC/D;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,kCAAkC;QAC1C,aAAa,EAAE,mCAAmC;KACnD;IACD,aAAa,EAAE,6HAA6H;IAC5I,WAAW,EAAE;QACX,6BAA6B;QAC7B,4FAA4F;QAC5F,yDAAyD;QACzD,gDAAgD;KACjD;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,8BAA8B;YACvC,QAAQ,EAAE,cAAc;SACzB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,wFAAwF;SACnG;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,MAAM;SACd;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,wDAAwD;QACjE,KAAK,EAAE,qGAAqG;KAC7G;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,gBAAgB;YAC/B,OAAO,EAAE,oBAAoB;YAC7B,QAAQ,EAAE,mBAAmB;SAC9B;QACD,QAAQ,EAAE;YACR,mCAAmC;SACpC;KACF;IACD,YAAY,EAAE;QACZ,SAAS,EAAE,8KAA8K;QACzL,gBAAgB,EAAE;YAChB,OAAO,EAAE,wDAAwD;YACjE,KAAK,EAAE,qGAAqG;SAC7G;KACF;IACD,eAAe,EAAE,iCAAiC;IAClD,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"dcgain.js","sourceRoot":"","sources":["../../../src/generated/builtins/dcgain.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,QAAQ;IACjB,UAAU,EAAE,SAAS;IACrB,UAAU,EAAE;QACV,QAAQ;QACR,cAAc;QACd,gBAAgB;QAChB,mBAAmB;QACnB,IAAI;KACL;IACD,SAAS,EAAE,8DAA8D;IACzE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,oIAAoI;KAC9I;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;QACrB,OAAO,EAAE,qDAAqD;KAC/D;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,kCAAkC;QAC1C,aAAa,EAAE,mCAAmC;KACnD;IACD,aAAa,EAAE,yNAAyN;IACxO,WAAW,EAAE;QACX,iIAAiI;QACjI,4FAA4F;QAC5F,yDAAyD;QACzD,gDAAgD;QAChD,4MAA4M;QAC5M,4RAA4R;KAC7R;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yBAAyB;YACxC,OAAO,EAAE,8BAA8B;YACvC,QAAQ,EAAE,cAAc;SACzB;QACD;YACE,aAAa,EAAE,gCAAgC;YAC/C,OAAO,EAAE,8BAA8B;YACvC,QAAQ,EAAE,WAAW;SACtB;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,wFAAwF;SACnG;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,MAAM;SACd;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,wDAAwD;QACjE,KAAK,EAAE,qGAAqG;KAC7G;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,gBAAgB;YAC/B,OAAO,EAAE,oBAAoB;YAC7B,QAAQ,EAAE,mBAAmB;SAC9B;QACD,QAAQ,EAAE;YACR,uDAAuD;YACvD,wGAAwG;SACzG;KACF;IACD,YAAY,EAAE;QACZ,SAAS,EAAE,6eAA6e;QACxf,gBAAgB,EAAE;YAChB,OAAO,EAAE,wDAAwD;YACjE,KAAK,EAAE,qGAAqG;SAC7G;KACF;IACD,eAAe,EAAE,oLAAoL;IACrM,KAAK,EAAE,QAAQ;IACf,MAAM,EAAE,QAAQ;IAChB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/deal.js

@@ -0,0 +1,90 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "deal",
+    "category": "common",
+    "keywords": [
+        "deal",
+        "multiple outputs",
+        "comma-separated list",
+        "assignment"
+    ],
+    "summary": "Distribute input values to requested outputs.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "`deal` performs no numeric computation. RunMat can pass resident values through without gather behind an explicit compatibility gate."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline",
+        "notes": "`deal` is output-list construction and is not fused."
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::common::deal::tests",
+        "integration": "crates/runmat-vm/tests/integer_builtin_compatibility_datetime_to_dcgain.rs"
+    },
+    "description": "`[B1,...,Bn] = deal(A1,...,An)` copies matching inputs positionally. `[B1,...,Bn] = deal(A)` copies one input to every requested output.",
+    "behaviors": [
+        "With multiple inputs, the number of requested outputs must equal the number of inputs.",
+        "With one input, any requested output count receives the same value.",
+        "Values pass through structurally without numeric conversion, preserving integer class, shape, exact values, and handle identity.",
+        "Resident pass-through is a RunMat-only extension because the current public page documents GPU code generation but not interactive GPU Arrays. The gate runs without gather or provider access.",
+        "RunMat does not retain the former one-output cell-packing behavior; use a cell-array literal when a packed cell row is intended."
+    ],
+    "examples": [
+        {
+            "description": "Distribute matching values",
+            "input": "[a,b] = deal(int64(7), uint64(9))",
+            "output": "a is int64(7) and b is uint64(9)."
+        },
+        {
+            "description": "Replicate one value",
+            "input": "u = uint64(9007199254740992) + uint64(1); [a,b,c] = deal(u)",
+            "output": "All three outputs preserve the exact uint64 value."
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `deal` convert integer inputs to double?",
+            "answer": "No. It copies values without arithmetic or class conversion."
+        }
+    ],
+    "links": [],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/common/deal.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/common/deal.rs"
+    },
+    "syntax": {
+        "example": {
+            "description": "Supported forms",
+            "input": "[B1,...,Bn] = deal(A1,...,An)\n[B1,...,Bn] = deal(A)",
+            "output": "Outputs preserve their corresponding input values."
+        },
+        "points": [
+            "Multiple inputs require the same number of outputs.",
+            "One input is replicated to every requested output."
+        ]
+    },
+    "validation": {
+        "summary": "Focused tests cover matching distribution, single-input replication, count errors, all eight exact integer storage classes, zero-output behavior, and pre-access resident gating.",
+        "implementation": {
+            "label": "`crates/runmat-runtime/src/builtins/common/deal.rs`",
+            "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/common/deal.rs"
+        }
+    },
+    "gpu_residency": "When its RunMat-only extension is enabled, `deal` preserves a resident handle and its owner without gather, upload, allocation, or provider dispatch.",
+    "key": "deal",
+    "slug": "deal",
+    "aliases": [],
+    "categoryPath": [
+        "common"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=deal.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"deal.js","sourceRoot":"","sources":["../../../src/generated/builtins/deal.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,QAAQ;IACpB,UAAU,EAAE;QACV,MAAM;QACN,kBAAkB;QAClB,sBAAsB;QACtB,YAAY;KACb;IACD,SAAS,EAAE,+CAA+C;IAC1D,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,uIAAuI;KACjJ;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;QACrB,OAAO,EAAE,sDAAsD;KAChE;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,+BAA+B;QACvC,aAAa,EAAE,4EAA4E;KAC5F;IACD,aAAa,EAAE,0IAA0I;IACzJ,WAAW,EAAE;QACX,wFAAwF;QACxF,qEAAqE;QACrE,kIAAkI;QAClI,iMAAiM;QACjM,kIAAkI;KACnI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,4BAA4B;YAC3C,OAAO,EAAE,mCAAmC;YAC5C,QAAQ,EAAE,mCAAmC;SAC9C;QACD;YACE,aAAa,EAAE,qBAAqB;YACpC,OAAO,EAAE,6DAA6D;YACtE,QAAQ,EAAE,oDAAoD;SAC/D;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,8DAA8D;SACzE;KACF;IACD,OAAO,EAAE,EAAE;IACX,QAAQ,EAAE;QACR,OAAO,EAAE,qDAAqD;QAC9D,KAAK,EAAE,kGAAkG;KAC1G;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,iBAAiB;YAChC,OAAO,EAAE,sDAAsD;YAC/D,QAAQ,EAAE,oDAAoD;SAC/D;QACD,QAAQ,EAAE;YACR,qDAAqD;YACrD,oDAAoD;SACrD;KACF;IACD,YAAY,EAAE;QACZ,SAAS,EAAE,mLAAmL;QAC9L,gBAAgB,EAAE;YAChB,OAAO,EAAE,qDAAqD;YAC9D,KAAK,EAAE,kGAAkG;SAC1G;KACF;IACD,eAAe,EAAE,uJAAuJ;IACxK,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/decomposition.js

@@ -13,7 +13,7 @@ const builtinDoc = {
         "triangular",
         "diagonal"
     ],
-    "summary": "Create MATLAB-compatible matrix decomposition objects for reusable linear solves.",
+    "summary": "Create matrix decomposition objects for reusable linear solves, with explicitly gated RunMat extensions.",
     "gpu_support": {
         "elementwise": false,
         "reduction": false,
@@ -22,7 +22,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "Construction gathers gpuArray inputs to host object storage. Solving through the object delegates to mldivide or mrdivide, so GPU residency follows those solve builtins when a provider accepts the transformed matrix."
+        "notes": "In `runmat` compatibility mode, construction accepts gpuArray arguments as a RunMat extension and gathers them to host object storage. Solving through the object delegates to mldivide or mrdivide, so GPU residency follows those solve builtins when a provider accepts the transformed matrix."
     },
     "fusion": {
         "elementwise": false,
@@ -36,14 +36,16 @@ const builtinDoc = {
     },
     "description": "`dA = decomposition(A)` creates a decomposition object that can be reused with `dA \\ b` and `b / dA`. RunMat stores a validated coefficient matrix and routes solves through the same MATLAB-compatible `mldivide` and `mrdivide` engines used by ordinary matrix division.",
     "behaviors": [
-        "The constructor accepts dense real, dense complex, scalar numeric, logical scalar, and integer scalar coefficient matrices. Sparse inputs are rejected until RunMat has a sparse solve path behind the decomposition object.",
+        "The MATLAB-compatible surface accepts full real or complex coefficient matrices of class `single` or `double`. With RunMat extensions enabled, all eight integer coefficient classes and logical coefficients are accepted and retained exactly in the object; strict compatibility mode rejects those forms before gathering a resident value. Sparse inputs remain rejected until RunMat has a sparse solve path behind the decomposition object.",
         "Supported type strings are `'auto'`, `'lu'`, `'qr'`, `'chol'`, `'triangular'`, and `'diagonal'`. The default `'auto'` selects `diagonal`, `triangular`, `lu`, or `qr` based on the matrix shape and structure.",
         "Square-only types reject rectangular matrices. The `diagonal` and `triangular` types validate the corresponding structure. The optional `'upper'` or `'lower'` triangular flag is supported for `decomposition(A, 'triangular', flag)` and ignores the opposite triangle.",
-        "Name-value options include `CheckCondition` and `RankTolerance`. `CheckCondition` is exposed as an object property; `RankTolerance` is accepted and stored for QR compatibility metadata.",
+        "Name-value options include `CheckCondition` and `RankTolerance`. MATLAB-compatible `CheckCondition` values are logical; accepting an integer scalar is a separately gated RunMat extension. `CheckCondition` is exposed as an object property, while `RankTolerance` is accepted and stored for QR compatibility metadata.",
+        "Typed-integer `RankTolerance` and real or paired-complex typed-integer scale factors are independently gated RunMat extensions. Each authoritative integer component must be exactly representable before crossing into binary64 scale or tolerance metadata.",
         "Object properties include `MatrixSize`, `Type`, `CheckCondition`, `Datatype`, `IsConjugateTransposed`, `IsReal`, `IsSparse`, and `ScaleFactor`. Internal coefficient storage is not publicly readable.",
-        "Unary plus returns the same decomposition. Unary minus, scalar multiplication, and scalar division return a new decomposition with an adjusted scale factor.",
-        "Conjugate transpose (`dA'`) toggles `IsConjugateTransposed`, conjugates the scale factor, and solves against the conjugate-transposed coefficient matrix.",
-        "Left division (`dA \\ b`) and right division (`b / dA`) support the same real, complex, square, rectangular, and least-squares behavior as RunMat's `mldivide` and `mrdivide` builtins."
+        "Unary plus returns the same decomposition. Unary minus, scalar multiplication, and scalar division return a new decomposition with an adjusted scale factor. GPU scalar operands are gated before provider access because the public decomposition surface does not document GPU Arrays.",
+        "Conjugate transpose (`dA'`) toggles `IsConjugateTransposed`, conjugates the scale factor, and solves against the conjugate-transposed coefficient matrix. Gated integer and logical objects retain exact coefficient storage through this structural operation.",
+        "Left division (`dA \\ b`) and right division (`b / dA`) support the same real, complex, square, rectangular, and least-squares behavior as RunMat's `mldivide` and `mrdivide` builtins. Integer and logical coefficients are promoted explicitly to binary64 only at this solve boundary, so their solutions are double or complex double.",
+        "Element-wise left division (`ldivide` or `.\\`) is not a decomposition-object method, and `decomposition.ldivide` is absent from the builtin registry."
     ],
     "examples": [
         {
@@ -80,6 +82,10 @@ const builtinDoc = {
             "question": "Which object operations are supported?",
             "answer": "RunMat supports property access, unary plus/minus, conjugate transpose, scalar multiplication, scalar division, left division, and right division for decomposition objects."
         },
+        {
+            "question": "How are integer and logical coefficient matrices handled?",
+            "answer": "They are RunMat-only extensions. With extensions enabled, construction and structural transpose preserve exact host storage for all eight integer classes and logical arrays. A solve promotes the effective coefficient matrix to double at the solve boundary and reports a double or complex-double solution. With extensions disabled, construction and later object methods reject the extended object with a stable compatibility identifier."
+        },
         {
             "question": "Are condition warnings emitted?",
             "answer": "No. The `CheckCondition` property is parsed and preserved, but RunMat does not yet emit MATLAB-compatible condition warnings during decomposition construction or solve."
@@ -87,6 +93,10 @@ const builtinDoc = {
         {
             "question": "Are sparse decomposition objects supported?",
             "answer": "Not yet. RunMat rejects sparse coefficient matrices instead of silently densifying them, because large sparse matrices need a dedicated sparse solve path to be safe and MATLAB-compatible."
+        },
+        {
+            "question": "Which broader decomposition features are still incomplete?",
+            "answer": "The current object does not implement sparse decomposition, cached native factor storage, condition warnings, algorithmic use of RankTolerance, or the additional banded, Hessenberg, LDL, COD, and permuted-triangular forms. Unsupported type strings are rejected explicitly."
         }
     ],
     "links": [
@@ -120,7 +130,7 @@ const builtinDoc = {
         "url": "crates/runmat-runtime/src/builtins/math/linalg/factor/decomposition.rs"
     },
     "gpu_behavior": [
-        "Constructing a decomposition object gathers any gpuArray coefficient matrix to host storage because the object owns normalized matrix metadata.",
+        "The compatibility target does not document GPU Array support for `decomposition`. RunMat retains gpuArray arguments behind its explicit extension mode and gathers them to host storage because the object owns normalized matrix metadata.",
         "Solves through `dA \\ b` and `b / dA` call the existing `mldivide` and `mrdivide` implementations with the effective coefficient matrix. If a provider accepts that solve, residency follows the same provider behavior as direct matrix division; otherwise RunMat uses the host fallback."
     ],
     "key": "decomposition",

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

@@ -1 +1 @@
-{"version":3,"file":"decomposition.js","sourceRoot":"","sources":["../../../src/generated/builtins/decomposition.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,eAAe;IACxB,UAAU,EAAE,oBAAoB;IAChC,UAAU,EAAE;QACV,eAAe;QACf,cAAc;QACd,eAAe;QACf,IAAI;QACJ,IAAI;QACJ,MAAM;QACN,YAAY;QACZ,UAAU;KACX;IACD,SAAS,EAAE,mFAAmF;IAC9F,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,0NAA0N;KACpO;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,SAAS;KACvB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,sDAAsD;KAC/D;IACD,aAAa,EAAE,8QAA8Q;IAC7R,WAAW,EAAE;QACX,8NAA8N;QAC9N,gNAAgN;QAChN,2QAA2Q;QAC3Q,2LAA2L;QAC3L,wMAAwM;QACxM,8JAA8J;QAC9J,2JAA2J;QAC3J,yLAAyL;KAC1L;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,uDAAuD;YACtE,OAAO,EAAE,4DAA4D;YACrE,QAAQ,EAAE,qBAAqB;SAChC;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,0DAA0D;YACnE,QAAQ,EAAE,mBAAmB;SAC9B;QACD;YACE,aAAa,EAAE,iEAAiE;YAChF,OAAO,EAAE,oFAAoF;YAC7F,QAAQ,EAAE,qBAAqB;SAChC;QACD;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,gEAAgE;YACzE,QAAQ,EAAE,yBAAyB;SACpC;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,kKAAkK;SAC7K;QACD;YACE,UAAU,EAAE,oDAAoD;YAChE,QAAQ,EAAE,yUAAyU;SACpV;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,8KAA8K;SACzL;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,0KAA0K;SACrL;QACD;YACE,UAAU,EAAE,6CAA6C;YACzD,QAAQ,EAAE,6LAA6L;SACxM;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,MAAM;SACd;QACD;YACE,OAAO,EAAE,IAAI;YACb,KAAK,EAAE,MAAM;SACd;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,wEAAwE;QACjF,KAAK,EAAE,wEAAwE;KAChF;IACD,cAAc,EAAE;QACd,iJAAiJ;QACjJ,6RAA6R;KAC9R;IACD,KAAK,EAAE,eAAe;IACtB,MAAM,EAAE,eAAe;IACvB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,QAAQ;QACR,QAAQ;KACT;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"decomposition.js","sourceRoot":"","sources":["../../../src/generated/builtins/decomposition.ts"],"names":[],"mappings":"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"}

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

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

package/dist/generated/builtins/deconv.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "When the active provider lacks a dedicated deconvolution kernel, RunMat gathers the data to the host, evaluates the quotient/remainder, and uploads the outputs back to the GPU if possible."
+        "notes": "RunMat gathers through each input's owning provider, requires resident inputs to share one owner/device, evaluates on the host, and restores only when that owner can physically supply the computed precision and the output owner, device, shape, storage, and precision all validate."
     },
     "fusion": {
         "elementwise": false,
@@ -35,22 +35,23 @@ const builtinDoc = {
     "description": "`deconv(b, a)` performs one-dimensional polynomial long division and returns quotient `q` plus remainder `r`. Coefficients use MATLAB/RunMat polynomial ordering (highest-order term first), with support for real and complex inputs.",
     "behaviors": [
         "Inputs must be scalars, row vectors, or column vectors. Multi-dimensional tensors are rejected.",
-        "Leading zeros are ignored during division, matching MATLAB’s behaviour. The outputs include just enough coefficients to represent the resulting polynomials (with at least one element for the zero polynomial).",
+        "Only exact zero coefficients are treated as leading zeros. The remainder retains the numerator's full length and orientation so `conv(a, q) + r` reconstructs the numerator with ordinary aligned polynomial addition.",
         "When `length(b) < length(a)`, the quotient is zero and the remainder equals `b`.",
-        "Logical inputs are promoted to double precision prior to division (TRUE → 1.0, FALSE → 0.0).",
-        "Complex coefficients are handled exactly; the quotient and remainder retain complex values.",
-        "Empty denominators and all-zero denominators raise MATLAB-compatible errors."
+        "MATLAB documents single and double coefficients. RunMat extension mode additionally accepts logical coefficients and integer coefficients that are exactly representable as double; inexact wide integers are rejected.",
+        "Single and complex-single coefficients preserve single output precision when every coefficient input is floating-point. Any logical or typed-integer coefficient selects double output precision, independent of whether inputs are host values or resident gpuArrays; complex coefficients preserve complex output storage.",
+        "Empty denominators and all-zero denominators raise MATLAB-compatible errors.",
+        "This implementation currently covers classic vector polynomial division. The newer shape, least-squares Method, and RegularizationFactor forms remain an explicit compatibility gap."
     ],
     "examples": [
         {
             "description": "Recovering a factor from a polynomial product",
             "input": "p = conv([1 2], [1 -3 2]);   % Multiply two polynomials\n[q, r] = deconv(p, [1 2])   % Divide by the first factor",
-            "output": "q = [1 -3 2];\nr = 0"
+            "output": "q = [1 -3 2];\nr = [0 0 0 0]"
         },
         {
             "description": "Obtaining a non-zero remainder",
             "input": "[q, r] = deconv([1 4 7], [1 2])",
-            "output": "q = [1 2];\nr = [3]"
+            "output": "q = [1 2];\nr = [0 0 3]"
         },
         {
             "description": "Dividing by a longer sequence",
@@ -60,7 +61,7 @@ const builtinDoc = {
         {
             "description": "Handling leading zeros explicitly",
             "input": "b = [0 0 1 2];\na = [0 1 1];\n[q, r] = deconv(b, a)",
-            "output": "q = [1];\nr = [1]"
+            "output": "q = [1];\nr = [0 0 0 1]"
         },
         {
             "description": "Complex polynomial division",
@@ -79,11 +80,11 @@ const builtinDoc = {
         },
         {
             "question": "Can I pass logical or integer vectors?",
-            "answer": "Yes. They are promoted to double precision before division so the results match MATLAB exactly."
+            "answer": "They are RunMat-only extensions, not MATLAB-compatible input forms. Extension mode accepts logical coefficients and exactly-double-representable integer coefficients; strict compatibility mode rejects them before data access. If either coefficient input is logical or typed integer, quotient and remainder use double precision on both host and resident execution paths."
         },
         {
-            "question": "Why are leading zeros dropped from the outputs?",
-            "answer": "They do not change the represented polynomial. Dropping them keeps results compact and mirrors MATLAB’s behaviour. The zero polynomial is returned as a single zero."
+            "question": "Why does the remainder contain leading zeros?",
+            "answer": "The remainder has the numerator's full length. This preserves the documented coefficient identity and makes reconstruction with `conv(a, q) + r` unambiguous."
         },
         {
             "question": "Does `deconv` support column vectors?",
@@ -141,7 +142,7 @@ const builtinDoc = {
         "url": "https://github.com/runmat-org/runmat/issues/new/choose"
     },
     "gpu_behavior": [
-        "When either input resides on the GPU (`gpuArray` values), RunMat first checks whether the active acceleration provider exposes a dedicated deconvolution hook. The current providers (in-process and WGPU) do not yet offer this kernel, so the runtime always:\n\n1. Gathers the device operands into host memory. 2. Performs the polynomial long division on the CPU. 3. Re-uploads real-valued results to the provider so downstream fused kernels can remain device-resident (complex outputs stay on the host until providers add complex buffer uploads).\n\nThis fallback keeps behaviour identical to MATLAB. Gather the outputs explicitly only when you need them on the host."
+        "When either input is resident, RunMat gathers it through its registered owner and performs polynomial division on the CPU. Two resident inputs must already share an owner and device. Results return to that owner/device only when it can physically supply the computed precision, and restored handles are accepted only when their owner, device, shape, storage, and precision match the computed result."
     ],
     "key": "deconv",
     "slug": "deconv",

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

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

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

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

package/dist/generated/builtins/deg2rad.js

@@ -20,7 +20,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "GPU inputs can be gathered to the host for the reference implementation. Fusion can keep compatible elementwise expressions on the active provider."
+        "notes": "Floating GPU inputs can participate in fusion. Typed integer and logical gpuArray extensions gather through their owning provider and restore a validated result to the same device when that owner can physically supply the required result precision; otherwise the call rejects instead of silently narrowing."
     },
     "fusion": {
         "elementwise": true,
@@ -36,8 +36,9 @@ const builtinDoc = {
     "description": "`r = deg2rad(d)` converts each angle in `d` from degrees to radians using `d*pi/180`, with element-wise behavior matching MATLAB and RunMat.",
     "behaviors": [
         "Operates element-wise on scalars, vectors, matrices, and N-D tensors.",
-        "Integer and logical inputs are promoted to double precision before conversion.",
+        "MATLAB documents single and double input. RunMat extension mode additionally accepts logical input and integer values that are exactly representable as double; inexact wide integers are rejected rather than rounded.",
         "Complex inputs are scaled component-wise, matching ordinary multiplication by `pi/180`.",
+        "Single and complex-single inputs preserve single precision.",
         "Output shape matches the input shape.",
         "String inputs are unsupported and raise a builtin-scoped error."
     ],

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

@@ -1 +1 @@
-{"version":3,"file":"deg2rad.js","sourceRoot":"","sources":["../../../src/generated/builtins/deg2rad.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,SAAS;QACT,SAAS;QACT,SAAS;QACT,OAAO;QACP,cAAc;QACd,aAAa;KACd;IACD,SAAS,EAAE,8DAA8D;IACzE,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,qJAAqJ;KAC/J;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,8CAA8C;QACtD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,8IAA8I;IAC7J,WAAW,EAAE;QACX,uEAAuE;QACvE,gFAAgF;QAChF,yFAAyF;QACzF,uCAAuC;QACvC,iEAAiE;KAClE;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2BAA2B;YAC1C,OAAO,EAAE,iBAAiB;YAC1B,QAAQ,EAAE,YAAY;SACvB;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,gDAAgD;YACzD,QAAQ,EAAE,qCAAqC;SAChD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,mEAAmE;SAC9E;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,mFAAmF;SAC9F;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,mEAAmE;QAC5E,KAAK,EAAE,gHAAgH;KACxH;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,cAAc;KACf;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"deg2rad.js","sourceRoot":"","sources":["../../../src/generated/builtins/deg2rad.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,mBAAmB;IAC/B,UAAU,EAAE;QACV,SAAS;QACT,SAAS;QACT,SAAS;QACT,OAAO;QACP,cAAc;QACd,aAAa;KACd;IACD,SAAS,EAAE,8DAA8D;IACzE,aAAa,EAAE;QACb,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,oTAAoT;KAC9T;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,IAAI;QACnB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,8CAA8C;QACtD,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,8IAA8I;IAC7J,WAAW,EAAE;QACX,uEAAuE;QACvE,yNAAyN;QACzN,yFAAyF;QACzF,6DAA6D;QAC7D,uCAAuC;QACvC,iEAAiE;KAClE;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2BAA2B;YAC1C,OAAO,EAAE,iBAAiB;YAC1B,QAAQ,EAAE,YAAY;SACvB;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,gDAAgD;YACzD,QAAQ,EAAE,qCAAqC;SAChD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,mEAAmE;SAC9E;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,mFAAmF;SAC9F;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,mEAAmE;QAC5E,KAAK,EAAE,gHAAgH;KACxH;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,cAAc;KACf;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/delete.js

@@ -17,7 +17,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Filesystem operations always execute on the host CPU. If path inputs reside on the GPU, RunMat gathers them before removing files."
+        "notes": "Filesystem operations execute on the host CPU. Resident arguments, including nested resident values, are rejected before provider or filesystem access."
     },
     "fusion": {
         "elementwise": false,
@@ -30,7 +30,7 @@ const builtinDoc = {
         "unit": "builtins::io::repl_fs::delete::tests",
         "integration": "builtins::io::repl_fs::delete::tests::delete_removes_files_with_wildcard"
     },
-    "description": "`delete(filename)` removes files, while `delete(obj)` invalidates handle objects or listeners. Supported filename forms, wildcard handling, and diagnostics follow MATLAB semantics.",
+    "description": "`delete(filename)` removes files without producing a MATLAB-facing output, while `delete(obj)` invalidates handle objects or listeners. `delete(___, \"ResolveSymbolicLinks\", tf)` controls whether a symbolic-link filename removes the link or its target.",
     "behaviors": [
         "Accepts individual paths, string arrays, cell arrays of character vectors, and char matrices. Each element targets one file.",
         "Accepts handle objects (`handle`) and event listeners, marking them invalid (`isvalid` returns `false`) without touching the filesystem when invoked with non-string inputs.",
@@ -39,7 +39,9 @@ const builtinDoc = {
         "Propagates operating-system failures (for example, permission errors or read-only files) through `RunMat:DELETE:PermissionDenied`.",
         "Expands `~` to the user’s home directory and resolves relative paths against the current working folder (`pwd`).",
         "Treats empty character vectors or empty string scalars as invalid inputs and raises `RunMat:DELETE:EmptyFilename`.",
-        "When passed an empty string array or empty cell array, the builtin performs no action and returns without error, just like MATLAB."
+        "When passed an empty string array or empty cell array, the builtin performs no action and returns without error, just like MATLAB.",
+        "`ResolveSymbolicLinks` accepts scalar logical values or exact numeric zero/one, including all eight integer classes. False removes the link itself; true removes the resolved file or empty-folder target and leaves the link. The option is rejected for handle deletion.",
+        "Multiple targets are processed sequentially. If a later target fails, earlier successful deletions are not rolled back."
     ],
     "examples": [
         {
@@ -99,11 +101,11 @@ const builtinDoc = {
         },
         {
             "question": "How do GPU inputs behave?",
-            "answer": "Inputs on the GPU are gathered to the host automatically. No GPU kernels are launched."
+            "answer": "Resident inputs are rejected before provider or filesystem access. Paths and control values must already be host values."
         },
         {
             "question": "Does `delete` preserve symbolic links?",
-            "answer": "Yes. RunMat delegates to the operating system: deleting a symlink removes the link itself, not the target—matching MATLAB."
+            "answer": "By default, deleting a symbolic link removes the link itself. Set `ResolveSymbolicLinks` to logical true or exact numeric one to remove the resolved target instead; the link then remains."
         },
         {
             "question": "Can I detect failures programmatically?",
@@ -196,9 +198,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/io/repl_fs/delete.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/repl_fs/delete.rs"
     },
-    "gpu_residency": "No. `delete` executes on the CPU. If a script accidentally wraps path strings in `gpuArray`, RunMat gathers the scalars before issuing filesystem calls. Keeping paths on the GPU provides no benefit.",
+    "gpu_residency": "No. `delete` executes on the CPU and rejects resident arguments before provider or filesystem access.",
     "gpu_behavior": [
-        "`delete` performs host-side filesystem I/O. When a path argument lives on the GPU (for example, `gpuArray(\"scratch.log\")`), RunMat gathers the scalar to CPU memory before touching the filesystem. Acceleration providers do not implement dedicated hooks for `delete`, so there are no GPU kernels or device transfers beyond the automatic gathering of inputs."
+        "`delete` performs host-side filesystem I/O. Acceleration providers do not implement a `delete` hook, and resident arguments are rejected without a download."
     ],
     "key": "delete",
     "slug": "delete",

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

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

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

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