runmat 0.6.1 → 0.6.2-dev.1

package/dist/generated/builtins/log10.js

@@ -19,12 +19,12 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "Falls back to the host implementation when the provider lacks unary_log10 or when the result requires complex values."
+        "notes": "Uses `reduce_min` plus `unary_log10` for resident real data when possible; otherwise computes on the host and restores the result to the exact owner when representable."
     },
     "fusion": {
-        "elementwise": true,
+        "elementwise": false,
         "reduction": false,
-        "max_inputs": 1,
+        "max_inputs": 0,
         "constants": "inline"
     },
     "requires_feature": null,
@@ -33,11 +33,12 @@ const builtinDoc = {
         "integration": "builtins::math::elementwise::log10::tests::log10_gpu_provider_roundtrip",
         "gpu": "builtins::math::elementwise::log10::tests::log10_wgpu_matches_cpu_elementwise"
     },
-    "description": "`Y = log10(X)` computes the base-10 logarithm of each element of `X`. Domain promotion to complex values and type handling follow MATLAB semantics.",
+    "description": "`Y = log10(X)` computes the base-10 logarithm of each floating-point element of `X`, including principal-branch complex promotion. Integer, logical, character, and explicit-GPU real-to-complex forms are separately gated RunMat extensions.",
     "behaviors": [
         "`log10` operates element-wise with MATLAB broadcasting rules.",
-        "Logical inputs convert to doubles (`true → 1.0`, `false → 0.0`) before the logarithm is applied.",
-        "Character arrays are interpreted as their numeric code points and return dense double tensors.",
+        "In RunMat extension mode, logical inputs convert to doubles (`true → 1.0`, `false → 0.0`) before the logarithm is applied; compatibility mode rejects this extension.",
+        "In RunMat extension mode, character arrays are interpreted as their numeric code points and return dense double tensors; compatibility mode rejects this extension.",
+        "Integer input is a RunMat-only extension. All eight integer classes are accepted only when every value is exactly representable in binary64, and the result is double or complex double.",
         "`log10(0)` returns `-Inf`, matching MATLAB's handling of the logarithm singularity at zero.",
         "Negative real values promote to complex results: `log10(-10)` returns `1 + i·π/ln(10)`.",
         "Complex inputs follow MATLAB's definition: `log10(z) = log(z) / ln(10)`."
@@ -88,11 +89,11 @@ const builtinDoc = {
         },
         {
             "question": "Does the GPU implementation support complex outputs?",
-            "answer": "Current providers operate on real buffers. When complex outputs are required, RunMat gathers the tensor to the host while keeping fusion metadata consistent."
+            "answer": "The real provider hook cannot produce complex output. RunMat gathers through the exact owner, computes the complex result on the host, and restores it to that owner when the complex class is representable. Explicit `gpuArray` input requiring this extension is rejected in compatibility mode."
         },
         {
             "question": "Is `log10` numerically stable for very small or large values?",
-            "answer": "Yes. The implementation promotes to 64-bit doubles throughout and clamps tiny imaginary parts to zero, mirroring MATLAB's behavior for well-conditioned inputs."
+            "answer": "Double input is computed in double precision and single input preserves single precision. RunMat clamps tiny finite components created by floating-point roundoff to zero. Integer extensions enter the double domain only when exactly representable in binary64."
         }
     ],
     "links": [
@@ -205,9 +206,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/math/elementwise/log10.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/log10.rs"
     },
-    "gpu_residency": "You typically do **not** need to call `gpuArray` yourself. The auto-offload planner keeps tensors on the GPU when profitable and the result stays real. When complex results are required, RunMat automatically gathers the data to the host to produce the precise MATLAB-compatible answer. Use `gpuArray`/`gather` only when you want to mirror MathWorks MATLAB workflows explicitly.",
+    "gpu_residency": "You typically do **not** need to call `gpuArray` yourself. RunMat resolves the exact provider that owns the input. Real data can remain resident through `reduce_min` and `unary_log10`; integer, logical, complex, unsupported-hook, and real-to-complex paths gather through that owner and restore the correctly typed result when representable. Explicit `gpuArray` input that requires real-to-complex promotion is a RunMat-only extension and is rejected in compatibility mode.",
     "gpu_behavior": [
-        "RunMat Accelerate keeps tensors on the GPU when the active provider implements `unary_log10` and the data is known to stay in the real domain. If complex outputs are required (for example, negative inputs) or the provider lacks the hook, RunMat gathers the tensor to the host, computes the exact MATLAB-compatible result, updates residency metadata, and returns the host-resident value."
+        "RunMat Accelerate uses the exact owning provider's `reduce_min` to classify resident real data, then validates any `unary_log10` output for non-aliasing, shape, device, owner, storage, and precision. When complex output or a fallback is required, it downloads through that owner, computes on the host, and restores the result to the same owner when representable while preserving provenance. `log10` is intentionally excluded from fusion until fused execution can represent its complex-domain semantics."
     ],
     "key": "log10",
     "slug": "log10",

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

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

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

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

package/dist/generated/builtins/log1p.js

@@ -20,12 +20,12 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "Falls back to the host when the provider lacks unary_log1p or reduce_min, or when complex outputs are required."
+        "notes": "Uses `reduce_min` plus `unary_log1p` for resident real data when possible; otherwise computes on the host and restores the result to the exact owner when representable."
     },
     "fusion": {
-        "elementwise": true,
+        "elementwise": false,
         "reduction": false,
-        "max_inputs": 1,
+        "max_inputs": 0,
         "constants": "inline"
     },
     "requires_feature": null,
@@ -33,14 +33,15 @@ const builtinDoc = {
         "unit": "builtins::math::elementwise::log1p::tests",
         "integration": "builtins::math::elementwise::log1p::tests::log1p_gpu_provider_roundtrip"
     },
-    "description": "`Y = log1p(X)` evaluates `log(1 + X)` element-wise with improved near-zero accuracy. Input coercion and complex/domain behavior follow MATLAB semantics.",
+    "description": "`Y = log1p(X)` evaluates `log(1 + X)` element-wise with improved near-zero accuracy for floating-point inputs and principal-branch complex promotion. Integer, logical, character, and explicit-GPU real-to-complex forms are separately gated RunMat extensions.",
     "behaviors": [
-        "Logical inputs are promoted to double precision (`true -> 1.0`, `false -> 0.0`) before execution.",
-        "Character arrays are interpreted as their numeric code points and return dense double tensors.",
+        "In RunMat extension mode, logical inputs are promoted to double precision (`true -> 1.0`, `false -> 0.0`) before execution; compatibility mode rejects this extension.",
+        "In RunMat extension mode, character arrays are interpreted as their numeric code points and return dense double tensors; compatibility mode rejects this extension.",
+        "Integer input is a RunMat-only extension. All eight integer classes are accepted only when every value is exactly representable in binary64, and the result is double or complex double.",
         "Values equal to `-1` yield `-Inf`, matching MATLAB's handling of `log(0)`.",
         "Inputs smaller than `-1` promote to complex outputs: `log1p(-2)` returns `0 + iπ`.",
         "Complex inputs follow MATLAB's definition by computing the natural logarithm of `1 + z`.",
-        "Existing GPU tensors remain on the device when the registered provider implements `unary_log1p` alongside `reduce_min`. RunMat queries the device-side minimum to confirm the data stays within the real-valued domain; otherwise it gathers to the host, computes the exact result, and preserves residency metadata."
+        "Existing real GPU tensors remain on the device when their exact owner implements `unary_log1p` alongside `reduce_min`. Other paths gather through that owner, compute on the host, and restore the result when its class and precision are representable."
     ],
     "examples": [
         {
@@ -80,7 +81,7 @@ const builtinDoc = {
         },
         {
             "question": "How are logical arrays handled?",
-            "answer": "Logical values convert to doubles before applying `log1p`, so `log1p([true false])` yields a double array `[log(2), 0]`."
+            "answer": "In RunMat extension mode, logical values convert to doubles before applying `log1p`, so `log1p([true false])` yields a double array `[log(2), 0]`. Compatibility mode rejects logical input."
         },
         {
             "question": "What about inputs smaller than `-1`?",
@@ -92,15 +93,15 @@ const builtinDoc = {
         },
         {
             "question": "What happens when the GPU provider lacks `unary_log1p`?",
-            "answer": "RunMat gathers the tensor to the host, computes the result in double precision, and returns it. This ensures users always see MATLAB-compatible behavior without manual residency management."
+            "answer": "RunMat gathers through the input's exact owner, computes on the host in the input's floating class, and restores the result to that owner when representable; otherwise it returns the correctly typed host value."
         },
         {
             "question": "Is double precision guaranteed?",
-            "answer": "Yes. RunMat stores dense numeric tensors in double precision (`f64`). GPU providers may choose single precision internally but convert back to double when returning data to the runtime."
+            "answer": "No single rule applies to every input: double input produces double output and single input preserves single precision. Integer, logical, and character extensions produce double-domain output."
         },
         {
             "question": "Can `log1p` participate in fusion?",
-            "answer": "Yes. The fusion planner recognizes `log1p` as an element-wise op. Providers that support fused kernels can materialize `log(1 + x)` directly in generated WGSL."
+            "answer": "Not currently. Fusion is disabled because replacing `log1p(x)` with a raw fused `log(1 + x)` would lose the near-zero accuracy that defines this function."
         },
         {
             "question": "What's the inverse of `log1p`?",
@@ -229,9 +230,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/math/elementwise/log1p.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/log1p.rs"
     },
-    "gpu_residency": "```matlab:runnable\nG = gpuArray(linspace(-0.5, 0.5, 5));\nout = log1p(G);\nrealResult = gather(out);\n```\n\nExpected output:\n\n```matlab\nrealResult = [-0.6931 -0.2877 0 0.2231 0.4055];\n```",
+    "gpu_residency": "RunMat resolves the exact provider that owns a resident input. Real data can stay on device through `reduce_min` and `unary_log1p`; integer, logical, complex, unsupported-hook, and real-to-complex paths gather through that owner and restore the correctly typed result when representable. Explicit `gpuArray` input that requires real-to-complex promotion is a RunMat-only extension and is rejected in compatibility mode.",
     "gpu_behavior": [
-        "RunMat Accelerate keeps tensors resident on the GPU whenever the provider exposes the `unary_log1p` hook together with `reduce_min`. The runtime uses the device-side minimum to ensure that `1 + X` stays non-negative; when complex outputs are required or either hook is missing, RunMat automatically gathers the tensor, computes on the CPU using double precision, and returns the result with the expected MATLAB semantics."
+        "RunMat Accelerate uses the exact owning provider's `reduce_min` to determine whether resident real data stays in the real domain, then validates any `unary_log1p` output for non-aliasing, shape, device, owner, storage, and precision. Fallbacks download through that owner, compute on the host, and restore when representable while preserving provenance. `log1p` is intentionally excluded from fusion to retain its near-zero accuracy."
     ],
     "syntax": {
         "example": {
@@ -239,7 +240,7 @@ const builtinDoc = {
             "input": "Y = log1p(X)"
         },
         "points": [
-            "`X` is a numeric array of any shape — scalars, vectors, matrices, or N-D tensors. Real and complex inputs are both supported; logical and character inputs are promoted to double before evaluation.",
+            "`X` is a real or complex floating array of any shape — scalars, vectors, matrices, or N-D tensors. RunMat extension mode additionally accepts exact-binary64 integers, logical values, and character arrays and promotes them to double; compatibility mode rejects those extensions.",
             "`Y` has the same shape as `X` and equals `log(1 + X)` computed element-wise with high accuracy for small `|X|`. For `X = -1` the result is `-Inf`; for real `X < -1` the output promotes to complex (principal branch).",
             "Use `log1p` instead of `log(1 + x)` whenever `x` can be close to zero. Forming `1 + x` in double precision drops bits of `x` (catastrophic cancellation), so `log(1 + 1e-15)` is wrong by nearly 10%, while `log1p(1e-15)` is correct to the last bit."
         ]

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

@@ -1 +1 @@
-{"version":3,"file":"log1p.js","sourceRoot":"","sources":["../../../src/generated/builtins/log1p.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"log1p.js","sourceRoot":"","sources":["../../../src/generated/builtins/log1p.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,kBAAkB;IAC9B,UAAU,EAAE;QACV,OAAO;QACP,UAAU;QACV,mBAAmB;QACnB,aAAa;QACb,KAAK;QACL,WAAW;KACZ;IACD,SAAS,EAAE,mDAAmD;IAC9D,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,0KAA0K;KACpL;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,yEAAyE;KACzF;IACD,aAAa,EAAE,mQAAmQ;IAClR,WAAW,EAAE;QACX,wKAAwK;QACxK,qKAAqK;QACrK,0LAA0L;QAC1L,4EAA4E;QAC5E,oFAAoF;QACpF,0FAA0F;QAC1F,2PAA2P;KAC5P;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,sCAAsC;YAC/C,QAAQ,EAAE,4BAA4B;SACvC;QACD;YACE,aAAa,EAAE,sDAAsD;YACrE,OAAO,EAAE,2DAA2D;YACpE,QAAQ,EAAE,4CAA4C;SACvD;QACD;YACE,aAAa,EAAE,mCAAmC;YAClD,OAAO,EAAE,eAAe;YACxB,QAAQ,EAAE,UAAU;SACrB;QACD;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,0CAA0C;YACnD,QAAQ,EAAE,iEAAiE;SAC5E;QACD;YACE,aAAa,EAAE,wDAAwD;YACvE,OAAO,EAAE,kFAAkF;YAC3F,QAAQ,EAAE,gDAAgD;SAC3D;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,yJAAyJ;SACpK;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,2FAA2F;SACtG;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,8LAA8L;SACzM;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,oHAAoH;SAC/H;QACD;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,wIAAwI;SACnJ;QACD;YACE,UAAU,EAAE,yDAAyD;YACrE,QAAQ,EAAE,oNAAoN;SAC/N;QACD;YACE,UAAU,EAAE,iCAAiC;YAC7C,QAAQ,EAAE,kMAAkM;SAC7M;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,4JAA4J;SACvK;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,mOAAmO;SAC9O;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,6SAA6S;SACxT;QACD;YACE,UAAU,EAAE,sEAAsE;YAClF,QAAQ,EAAE,gQAAgQ;SAC3Q;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,KAAK;YACd,KAAK,EAAE,OAAO;SACf;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,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;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,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;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;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,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;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,gEAAgE;QACzE,KAAK,EAAE,6GAA6G;KACrH;IACD,eAAe,EAAE,qaAAqa;IACtb,cAAc,EAAE;QACd,mbAAmb;KACpb;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,QAAQ;YACvB,OAAO,EAAE,cAAc;SACxB;QACD,QAAQ,EAAE;YACR,uRAAuR;YACvR,yNAAyN;YACzN,wPAAwP;SACzP;KACF;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,aAAa;KACd;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/log2.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "Falls back to the host implementation when the provider lacks unary_log2 or when complex results are required."
+        "notes": "Uses the provider unary_log2 hook for supported real inputs. Provider results are checked for shape, precision, storage kind, and exact device ownership before being accepted."
     },
     "fusion": {
         "elementwise": true,
@@ -33,11 +33,13 @@ const builtinDoc = {
         "integration": "builtins::math::elementwise::log2::tests::log2_gpu_provider_roundtrip",
         "gpu": "builtins::math::elementwise::log2::tests::log2_wgpu_matches_cpu_elementwise"
     },
-    "description": "`Y = log2(X)` computes the base-2 logarithm of each element of `X`. Domain promotion to complex values and type handling follow MATLAB semantics.",
+    "description": "`Y = log2(X)` computes the base-2 logarithm of each element of `X`. Real and complex single inputs preserve single precision, while double inputs preserve double precision. When RunMat extensions are enabled, integer, logical, and character inputs are additionally accepted and promoted to double.",
     "behaviors": [
-        "`log2` operates element-wise with MATLAB broadcasting rules.",
-        "Logical inputs convert to doubles (`true → 1.0`, `false → 0.0`) before the logarithm is applied.",
-        "Character arrays are interpreted as their numeric code points and return dense double tensors of the same shape.",
+        "Only the one-output `Y = log2(X)` form is implemented; the two-output mantissa/exponent form is not available yet.",
+        "`log2` operates element-wise and preserves the input shape.",
+        "When RunMat extensions are enabled, logical inputs convert to doubles (`true → 1.0`, `false → 0.0`) before the logarithm is applied.",
+        "When RunMat extensions are enabled, character arrays are interpreted as their numeric code points and return dense double tensors of the same shape.",
+        "When RunMat extensions are enabled, integer inputs are promoted to double before the logarithm is applied.",
         "`log2(0)` returns `-Inf`; positive infinity stays `Inf`; `NaN` propagates unchanged.",
         "Negative real values promote to complex results: `log2([-1 1])` returns `[0 + i·π/ln(2), 0]`.",
         "Complex inputs follow MATLAB's definition `log2(z) = log(z) / ln(2)` and clamp subnormal imaginary parts to zero for readability."
@@ -69,7 +71,7 @@ const builtinDoc = {
             "output": "host = [0 2 4 6]"
         },
         {
-            "description": "Applying `log2` to character codes",
+            "description": "Computing base-2 logarithms of character codes",
             "input": "C = 'ABC';\nvalues = log2(C)",
             "output": "values = [6.0224 6.0444 6.0661]"
         }
@@ -93,11 +95,11 @@ const builtinDoc = {
         },
         {
             "question": "Does the GPU implementation support complex outputs?",
-            "answer": "Current providers operate on real buffers. When complex outputs are required, RunMat gathers the tensor to the host while keeping fusion metadata consistent."
+            "answer": "The device hook currently operates on real buffers. A real GPU input that would require complex promotion raises an error asking for an explicitly complex GPU input; RunMat does not silently gather that explicit input and change its residency contract."
         },
         {
             "question": "Is `log2` numerically stable for very small or large values?",
-            "answer": "Yes. The implementation promotes to 64-bit doubles throughout and clamps tiny imaginary parts to zero, mirroring MATLAB's behavior for well-conditioned inputs."
+            "answer": "The implementation preserves single precision for single inputs and double precision for double inputs. Integer, logical, and character extensions are promoted to double. Tiny imaginary components introduced by floating-point evaluation may be normalized to zero."
         }
     ],
     "links": [
@@ -210,9 +212,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/math/elementwise/log2.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/elementwise/log2.rs"
     },
-    "gpu_residency": "You typically do **not** need to call `gpuArray` yourself. The auto-offload planner keeps tensors on the GPU when profitable and the result stays real. When complex results are required, RunMat automatically gathers the data to the host to produce the precise MATLAB-compatible answer. Use `gpuArray`/`gather` only when you want to mirror MathWorks MATLAB workflows explicitly.",
+    "gpu_residency": "Automatically resident inputs may gather to the host when the provider cannot perform the operation. Explicit `gpuArray` inputs use the same exact device owner for supported fallback restoration. If a real GPU input would require promotion to a complex result, RunMat reports that the input must be explicitly complex instead of silently returning a host value.",
     "gpu_behavior": [
-        "RunMat Accelerate keeps tensors on the GPU when the active provider implements `unary_log2` and the data is known to remain in the real domain. If complex outputs are required (for example, negative inputs) or the provider lacks the hook, RunMat gathers the tensor to the host, computes the exact MATLAB-compatible result, updates residency metadata, and returns the host-resident value."
+        "RunMat Accelerate keeps supported real inputs on their exact GPU owner when the active provider implements `unary_log2`. If the provider lacks the hook, automatic residency may fall back to a host result, while explicit residency is restored to the originating owner. Real GPU inputs that require complex promotion must be made explicitly complex before calling `log2`."
     ],
     "key": "log2",
     "slug": "log2",

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

@@ -1 +1 @@
-{"version":3,"file":"log2.js","sourceRoot":"","sources":["../../../src/generated/builtins/log2.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,kBAAkB;IAC9B,UAAU,EAAE;QACV,MAAM;QACN,kBAAkB;QAClB,aAAa;QACb,KAAK;QACL,SAAS;KACV;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,gHAAgH;KAC1H;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,0CAA0C;QAClD,aAAa,EAAE,uEAAuE;QACtF,KAAK,EAAE,6EAA6E;KACrF;IACD,aAAa,EAAE,mJAAmJ;IAClK,WAAW,EAAE;QACX,8DAA8D;QAC9D,kGAAkG;QAClG,kHAAkH;QAClH,sFAAsF;QACtF,+FAA+F;QAC/F,mIAAmI;KACpI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,4CAA4C;YACrD,QAAQ,EAAE,oBAAoB;SAC/B;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,aAAa;YACtB,QAAQ,EAAE,UAAU;SACrB;QACD;YACE,aAAa,EAAE,oDAAoD;YACnE,OAAO,EAAE,iCAAiC;YAC1C,QAAQ,EAAE,4CAA4C;SACvD;QACD;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,6CAA6C;YACtD,QAAQ,EAAE,wBAAwB;SACnC;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,sEAAsE;YAC/E,QAAQ,EAAE,kBAAkB;SAC7B;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,8BAA8B;YACvC,QAAQ,EAAE,iCAAiC;SAC5C;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,sNAAsN;SACjO;QACD;YACE,UAAU,EAAE,qCAAqC;YACjD,QAAQ,EAAE,yEAAyE;SACpF;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,mJAAmJ;SAC9J;QACD;YACE,UAAU,EAAE,sCAAsC;YAClD,QAAQ,EAAE,4FAA4F;SACvG;QACD;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,+JAA+J;SAC1K;QACD;YACE,UAAU,EAAE,8DAA8D;YAC1E,QAAQ,EAAE,iKAAiK;SAC5K;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,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;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,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;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;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,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;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,2XAA2X;IAC5Y,cAAc,EAAE;QACd,qYAAqY;KACtY;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,aAAa;KACd;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"log2.js","sourceRoot":"","sources":["../../../src/generated/builtins/log2.ts"],"names":[],"mappings":"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"}

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

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

package/dist/generated/builtins/logical.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "matlab",
-        "notes": "Prefers a device-side elem\\_ne(X, 0) cast when the provider supports elem_ne and zeros_like; otherwise gathers to the host, converts, and re-uploads the logical result."
+        "notes": "Prefers a device-side elem\\_ne(X, 0) cast when the provider supports elem_ne and zeros_like. Provider results are validated for exact owner, shape, storage kind, and aliasing."
     },
     "fusion": {
         "elementwise": false,
@@ -32,14 +32,15 @@ const builtinDoc = {
         "unit": "builtins::logical::ops::tests",
         "integration": "builtins::logical::ops::tests::logical_gpu_roundtrip"
     },
-    "description": "`logical(X)` converts numeric, character, and other supported inputs into logical values. Zero maps to false and nonzero maps to true, with coercion behavior following MATLAB semantics.",
+    "description": "`logical(X)` converts supported real numeric and character inputs into logical values. Zero maps to false and nonzero maps to true. NaN and complex numeric inputs are rejected. When RunMat extensions are enabled, string arrays and symbolic numeric constants are additionally accepted.",
     "behaviors": [
         "`logical` accepts scalars, dense arrays, N-D tensors, and gpuArrays. Shapes are preserved bit-for-bit.",
-        "Non-zero numeric values, `NaN`, and `Inf` map to `true`; `0` and `-0` map to `false`.",
-        "Complex inputs are considered `true` when either the real or imaginary component is non-zero.",
+        "Finite non-zero real numeric values and real infinities map to `true`; `0` and `-0` map to `false`.",
+        "NaN and complex numeric inputs raise conversion errors rather than being coerced.",
         "Character arrays are converted elementwise by interpreting code points (so `'A'` becomes `true`, `'\\0'` becomes `false`).",
-        "Strings, structs, cells, objects, and other non-numeric types raise MATLAB-compatible errors (`\"Conversion to logical from <type> is not possible\"`).",
-        "Scalar results become logical scalars (`true`/`false`); higher-rank arrays produce dense logical arrays."
+        "When RunMat extensions are enabled, string arrays convert elementwise by whether each element is nonempty; scalar strings remain unsupported.",
+        "Structs, cells, objects, and other unsupported types raise conversion errors.",
+        "Scalar results become logical scalars (`true`/`false`); dense higher-rank arrays produce dense logical arrays, and sparse inputs preserve sparse storage."
     ],
     "examples": [
         {
@@ -53,14 +54,14 @@ const builtinDoc = {
             "output": "mask =\n  2×3 logical array\n     1     0     1\n     0     1     0"
         },
         {
-            "description": "Treating NaN and Inf values as true",
-            "input": "flags = logical([NaN Inf 0])",
+            "description": "Treating real infinities as true",
+            "input": "flags = logical([-Inf Inf 0])",
             "output": "flags =\n  1×3 logical array\n     1     1     0"
         },
         {
-            "description": "Converting complex numbers to logical scalars",
-            "input": "z = logical(3 + 4i);\nw = logical(0 + 0i)",
-            "output": "z =\n     1\nw =\n     0"
+            "description": "Rejecting complex numeric conversion",
+            "input": "logical(3 + 4i)",
+            "output": "Error: conversion to logical from complex numeric data is not possible"
         },
         {
             "description": "Converting character arrays to logical values",
@@ -81,15 +82,15 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "Which input types does `logical` support?",
-            "answer": "Numeric, logical, complex, character, and gpuArray values are accepted. Strings, structs, cells, objects, and function handles are rejected with MATLAB-compatible error messages."
+            "answer": "Real numeric, logical, character, sparse numeric, and supported gpuArray values are accepted. NaN and complex numeric values are rejected. Enabling RunMat extensions additionally accepts string arrays and symbolic numeric constants; structs, cells, objects, and function handles remain unsupported."
         },
         {
             "question": "How are NaN or Inf values treated?",
-            "answer": "They evaluate to `true`. MATLAB defines logical conversion as “non-zero”, and `NaN` / `Inf` both satisfy that rule."
+            "answer": "Real positive and negative infinity evaluate to `true`. NaN is rejected with a conversion error."
         },
         {
             "question": "How does `logical` handle complex numbers?",
-            "answer": "The result is `true` when either the real or imaginary component is non-zero (or `NaN`/`Inf`). Only `0 + 0i` converts to `false`."
+            "answer": "Complex numeric inputs are rejected, including values whose imaginary component is zero."
         },
         {
             "question": "Does the builtin change array shapes?",
@@ -101,7 +102,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I convert strings with `logical`?",
-            "answer": "No. MATLAB rejects string inputs, and RunMat mirrors that behaviour: `\"logical: conversion to logical from string is not possible\"`."
+            "answer": "Scalar strings are rejected. When RunMat extensions are enabled, string arrays are accepted as an extension: each nonempty element becomes `true` and each empty element becomes `false`."
         },
         {
             "question": "What about structs, cells, or objects?",
@@ -109,7 +110,7 @@ const builtinDoc = {
         },
         {
             "question": "Does the GPU path allocate new buffers?",
-            "answer": "Only when the provider cannot operate in-place. The preferred path performs `elem_ne` against a zero tensor and reuses the resulting buffer. Fallback paths allocate a new gpuArray after gathering to the host."
+            "answer": "Yes. The preferred device path computes `elem_ne` against a zero tensor into a distinct logical result. Fallback may create a host result, and explicit residency may require a new upload to the original owner."
         },
         {
             "question": "Where can I learn more?",
@@ -138,10 +139,10 @@ const builtinDoc = {
         "label": "crates/runmat-runtime/src/builtins/logical/ops.rs",
         "url": "crates/runmat-runtime/src/builtins/logical/ops.rs"
     },
-    "gpu_residency": "You rarely need to call `gpuArray` manually. When the acceleration provider is active, RunMat keeps logical conversions on the GPU by issuing `elem_ne(X, 0)` kernels (backed by `zeros_like` allocations) and flagging the handle as logical metadata. Explicit `gpuArray` calls are available for MATLAB compatibility or when you want to pin residency before interacting with external libraries. When the provider lacks the necessary hook, RunMat documents the fallback: it gathers the data, converts it on the host, and—if a provider is still available—re-uploads the logical mask so downstream GPU code continues to work without residency surprises.",
+    "gpu_residency": "When the acceleration provider supports the required hooks, RunMat creates a logical result on the input's exact GPU owner. If fallback is needed, automatically resident inputs may return a host logical value; explicitly resident inputs are restored to the originating owner or the operation fails rather than silently changing the residency contract.",
     "gpu_behavior": [
-        "When a GPU provider implements `elem_ne` and `zeros_like`, RunMat performs the conversion in-place on the device by evaluating `elem_ne(X, 0)`, then marks the resulting handle as logical so predicates like `islogical` work without downloads.",
-        "If the provider cannot service the request (missing hooks, unsupported dtype, or allocation failure), the value is transparently gathered to the host, converted, and—when a provider is still available—re-uploaded as a logical gpuArray. The fallback is documented so users understand potential host/device transitions.",
+        "When a GPU provider implements `elem_ne` and `zeros_like`, RunMat evaluates `elem_ne(X, 0)` into a new device result and marks that result as logical. The result is validated before use and does not alias the input.",
+        "If the provider cannot service the request, RunMat converts through the host. Automatically resident inputs may remain on the host; explicit `gpuArray` inputs are re-uploaded to the same owner or return an error.",
         "Handles that are already flagged as logical (`gpuArray.logical`) are returned without modification.",
         "Scalars remain scalars: converting a `gpuArray` scalar preserves the residency and returns a logical gpuArray scalar."
     ],

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

@@ -1 +1 @@
-{"version":3,"file":"logical.js","sourceRoot":"","sources":["../../../src/generated/builtins/logical.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"logical.js","sourceRoot":"","sources":["../../../src/generated/builtins/logical.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,SAAS;IAClB,UAAU,EAAE,SAAS;IACrB,UAAU,EAAE;QACV,SAAS;QACT,oBAAoB;QACpB,YAAY;QACZ,UAAU;QACV,YAAY;KACb;IACD,SAAS,EAAE,sDAAsD;IACjE,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,kLAAkL;KAC5L;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,+BAA+B;QACvC,aAAa,EAAE,sDAAsD;KACtE;IACD,aAAa,EAAE,8RAA8R;IAC7S,WAAW,EAAE;QACX,wGAAwG;QACxG,qGAAqG;QACrG,mFAAmF;QACnF,4HAA4H;QAC5H,+IAA+I;QAC/I,+EAA+E;QAC/E,2JAA2J;KAC5J;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,8CAA8C;YACvD,QAAQ,EAAE,uDAAuD;SAClE;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,yCAAyC;YAClD,QAAQ,EAAE,qEAAqE;SAChF;QACD;YACE,aAAa,EAAE,kCAAkC;YACjD,OAAO,EAAE,+BAA+B;YACxC,QAAQ,EAAE,kDAAkD;SAC7D;QACD;YACE,aAAa,EAAE,sCAAsC;YACrD,OAAO,EAAE,iBAAiB;YAC1B,QAAQ,EAAE,wEAAwE;SACnF;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,6CAA6C;YACtD,QAAQ,EAAE,iDAAiD;SAC5D;QACD;YACE,aAAa,EAAE,uCAAuC;YACtD,OAAO,EAAE,2EAA2E;YACpF,QAAQ,EAAE,qDAAqD;SAChE;QACD;YACE,aAAa,EAAE,oDAAoD;YACnE,OAAO,EAAE,2DAA2D;YACpE,QAAQ,EAAE,8CAA8C;SACzD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,4SAA4S;SACvT;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,kGAAkG;SAC7G;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,0FAA0F;SACrG;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,uFAAuF;SAClG;QACD;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,wGAAwG;SACnH;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,2LAA2L;SACtM;QACD;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,uHAAuH;SAClI;QACD;YACE,UAAU,EAAE,yCAAyC;YACrD,QAAQ,EAAE,mNAAmN;SAC9N;QACD;YACE,UAAU,EAAE,yBAAyB;YACrC,QAAQ,EAAE,4EAA4E;SACvF;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,aAAa;YACtB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,YAAY;YACrB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,QAAQ;SAChB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,mDAAmD;QAC5D,KAAK,EAAE,mDAAmD;KAC3D;IACD,eAAe,EAAE,iWAAiW;IAClX,cAAc,EAAE;QACd,yNAAyN;QACzN,sNAAsN;QACtN,qGAAqG;QACrG,uHAAuH;KACxH;IACD,KAAK,EAAE,SAAS;IAChB,MAAM,EAAE,SAAS;IACjB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

package/dist/generated/builtins/logspace.js

@@ -20,7 +20,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "Providers can compose `logspace` from `linspace`, scalar multiplication, and `unary_exp`. When hooks are missing, RunMat generates the sequence on the host and uploads it once to preserve residency."
+        "notes": "Providers can compose `logspace` from `linspace`, scalar multiplication, and `unary_exp`. Device results are validated for exact ownership, shape, precision, storage kind, and aliasing before use."
     },
     "fusion": {
         "elementwise": false,
@@ -34,15 +34,16 @@ const builtinDoc = {
         "integration": "builtins::array::creation::logspace::tests::logspace_gpu_roundtrip",
         "wgpu": "builtins::array::creation::logspace::tests::logspace_wgpu_matches_cpu"
     },
-    "description": "`logspace(a, b, n)` returns `n` points spaced logarithmically between `10^a` and `10^b`. Default point count and row-vector output behavior follow MATLAB semantics.",
+    "description": "`logspace(a, b, n)` returns a row vector of logarithmically spaced points from `10^a` to `10^b`. When `b` is exactly `pi`, the final value is `pi`. Real or complex single endpoints produce single output when either endpoint is single; otherwise output is double.",
     "behaviors": [
         "`logspace(a, b)` is equivalent to `logspace(a, b, 50)`.",
-        "`logspace(a, b, 0)` returns a `1 × 0` empty double row vector.",
-        "`logspace(a, b, 1)` returns `10^b`.",
-        "`logspace(a, b, 2)` returns `[10^a 10^b]`.",
+        "`logspace(a, b, 0)` returns a `1 × 0` empty row vector whose precision follows the endpoints.",
+        "`logspace(a, b, 1)` returns the effective final endpoint: `10^b`, or `pi` when `b` is exactly `pi`.",
+        "`logspace(a, b, 2)` returns both effective endpoints.",
         "Endpoints may be real or complex scalars. Complex inputs produce complex outputs using the analytic definition `10^z = e^{z ln 10}`.",
-        "Scalar inputs may be numeric literals, `1×1` tensors, or gathered GPU scalars (`gpuArray` handles). Non-scalar inputs raise an error.",
-        "The third argument must be a finite, non-negative integer."
+        "Endpoints must be real or complex single or double scalars. Integer and logical endpoints are rejected.",
+        "Scalar inputs may be numeric literals, `1×1` tensors, or GPU scalars. Non-scalar inputs raise an error.",
+        "The third argument must be a finite real numeric scalar. Fractional values are floored, and zero or negative values produce a `1 × 0` row vector."
     ],
     "examples": [
         {
@@ -73,7 +74,7 @@ const builtinDoc = {
         {
             "description": "Matching MATLAB's legacy `logspace(a, pi, n)` syntax",
             "input": "theta = logspace(-1, pi, 5)",
-            "output": "% Interprets pi literally: theta(end) == 10^pi\ndisp(theta(end))"
+            "output": "% Interprets pi literally: theta(end) == pi\ndisp(theta(end))"
         }
     ],
     "faqs": [
@@ -83,7 +84,7 @@ const builtinDoc = {
         },
         {
             "question": "Does `logspace` include both endpoints?",
-            "answer": "Yes. The first element is exactly `10^a` and the final element is exactly `10^b`, even when rounding errors could otherwise accumulate."
+            "answer": "Yes. The first element is exactly `10^a`. The final element is exactly `10^b`, except for the special `b == pi` form, whose final element is exactly `pi`."
         },
         {
             "question": "Can I request zero points?",
@@ -99,15 +100,15 @@ const builtinDoc = {
         },
         {
             "question": "Is the third argument required to be an integer?",
-            "answer": "Yes. Non-integer or negative counts raise an error, matching MATLAB semantics."
+            "answer": "No. Finite fractional counts are floored. Zero and negative counts return an empty `1 × 0` row vector."
         },
         {
             "question": "Does the function support GPU scalars?",
-            "answer": "Yes. GPU scalars are gathered once to determine the sequence, and the resulting vector is uploaded back to the device when profitable."
+            "answer": "Yes. Endpoint scalars are read without discarding their owner or explicit-residency provenance. Supported sequences are generated on that owner; explicit fallback restores the result to the same owner."
         },
         {
             "question": "How accurate is the last element?",
-            "answer": "The implementation explicitly overwrites the final element with `10^b` to match MATLAB’s behavior and avoid floating-point drift."
+            "answer": "The implementation explicitly overwrites the final element with the effective endpoint—`10^b`, or `pi` for the exact `b == pi` form—to avoid floating-point drift."
         },
         {
             "question": "How does `logspace` differ from `linspace`?",
@@ -192,9 +193,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/array/creation/logspace.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/creation/logspace.rs"
     },
-    "gpu_residency": "You usually do **not** need to call `gpuArray` yourself in RunMat. When an acceleration provider is active and either endpoint already lives on the GPU, RunMat keeps the generated sequence on the device whenever the provider exposes the necessary hooks. If the hooks are missing, RunMat generates the vector on the host and uploads it once. This strategy preserves residency for subsequent kernels while avoiding partial GPU execution.",
+    "gpu_residency": "GPU endpoints establish an exact device owner, and endpoints from different owners are rejected. Explicitly resident endpoints force the result back to that owner when fallback is needed. Automatically resident inputs may fall back to a host result. Large host-generated sequences may be automatically placed on the active provider when the offload threshold is met.",
     "gpu_behavior": [
-        "When either endpoint already resides on the GPU, RunMat attempts to keep the sequence on the device. Providers that implement `linspace`, scalar multiplication, and `unary_exp` can build the vector entirely in device memory. If any hook is unavailable, RunMat generates the sequence on the host and performs a single upload, ensuring downstream kernels still receive a GPU tensor without surprising performance cliffs."
+        "Providers that implement `linspace`, scalar multiplication, and `unary_exp` can build real sequences entirely on the exact endpoint owner. If a hook is unavailable, explicit residency is restored to that same owner after host fallback, while automatic residency may return a host value. Complex explicit endpoints are computed on the host and uploaded back to their owner."
     ],
     "key": "logspace",
     "slug": "logspace",

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

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

package/dist/generated/builtins/lower.js

@@ -16,7 +16,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Runs on the CPU; if any element lives on the GPU, RunMat gathers it before converting."
+        "notes": "Text is host-only; numeric resident handles reject without implicit text conversion or provider access."
     },
     "fusion": {
         "elementwise": false,
@@ -161,9 +161,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/strings/transform/lower.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/strings/transform/lower.rs"
     },
-    "gpu_residency": "RunMat automatically keeps string data on the host for now. If text originates from GPU-based computations (for example as numeric code points stored on the device), `lower` gathers those values before applying the transformation, so you never need to call `gpuArray` explicitly for this builtin.",
+    "gpu_residency": "RunMat keeps string data on the host. Numeric GPU handles are not text and reject before provider access; convert numeric code points to host text explicitly before calling `lower`.",
     "gpu_behavior": [
-        "`lower` executes on the CPU. When the input (or any nested element) resides on the GPU, RunMat gathers it to host memory before performing the conversion so results remain identical to MATLAB. Providers do not need to implement custom kernels for this builtin."
+        "`lower` executes on host text. Numeric resident inputs reject before provider access, and no provider string kernel is required."
     ],
     "key": "lower",
     "slug": "lower",