runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/cumsum.js

@@ -0,0 +1,189 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "cumsum",
+    "category": "math/reduction",
+    "keywords": [
+        "cumsum",
+        "cumulative sum",
+        "running total",
+        "reverse",
+        "omitnan",
+        "gpu"
+    ],
+    "summary": "Cumulative sum of scalars, vectors, matrices, or N-D tensors.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Falls back to host accumulation when the active provider lacks prefix-sum hooks. Result shape always matches the input."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::reduction::cumsum::tests",
+        "integration": "builtins::math::reduction::cumsum::tests::cumsum_gpu_provider_roundtrip"
+    },
+    "description": "`cumsum(X)` computes the cumulative sum of the elements in `X`. The result has the same size as `X` and each element stores the running total along a chosen dimension.",
+    "behaviors": [
+        "By default, the running total is taken along the first dimension whose length is greater than 1.",
+        "`cumsum(X, dim)` lets you pick the dimension explicitly; if `dim > ndims(X)`, the input is returned unchanged.",
+        "Passing `[]` for the dimension argument keeps the default dimension (MATLAB uses this as a placeholder).",
+        "`cumsum(..., \"reverse\")` works from the end toward the beginning, whereas `\"forward\"` (default) works from start to finish.",
+        "`cumsum(..., \"omitnan\")` treats `NaN` values as missing. Leading `NaN` values yield zeros until a valid number appears.",
+        "Synonyms such as `\"omitmissing\"` / `\"includemissing\"` are also accepted for MATLAB compatibility.",
+        "The function supports real or complex scalars and dense tensors. Logical inputs are promoted to double precision."
+    ],
+    "examples": [
+        {
+            "description": "Running totals down each column (default dimension)",
+            "input": "A = [1 2 3; 4 5 6];\ncolumnTotals = cumsum(A)",
+            "output": "columnTotals =\n     1     2     3\n     5     7     9"
+        },
+        {
+            "description": "Tracking cumulative sums across rows",
+            "input": "A = [1 2 3; 4 5 6];\nrowTotals = cumsum(A, 2)",
+            "output": "rowTotals =\n     1     3     6\n     4     9    15"
+        },
+        {
+            "description": "Reversing the direction of accumulation",
+            "input": "v = [1 3 5 7];\nreverseTotals = cumsum(v, \"reverse\")",
+            "output": "reverseTotals =\n    16    15    12     7"
+        },
+        {
+            "description": "Ignoring NaN values while accumulating",
+            "input": "v = [2 NaN 5 NaN 1];\nrunning = cumsum(v, \"omitnan\")",
+            "output": "running =\n     2     2     7     7     8"
+        },
+        {
+            "description": "Computing a cumulative sum inside a GPU workflow",
+            "input": "G = gpuArray(rand(1, 5));\ntotals = cumsum(G);\nhostResult = gather(totals)"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does `cumsum` change the size of the input?",
+            "answer": "No. The output is always the same size as the input tensor."
+        },
+        {
+            "question": "What happens if I request a dimension larger than `ndims(X)`?",
+            "answer": "The function returns `X` unchanged, matching MATLAB behaviour."
+        },
+        {
+            "question": "How are complex numbers handled?",
+            "answer": "`cumsum` accumulates the real and imaginary parts independently. NaN checks treat a complex number as missing if either part is `NaN`."
+        },
+        {
+            "question": "What does `\"omitnan\"` do for leading `NaN` values?",
+            "answer": "Leading `NaN` values contribute zeros so the running total remains 0 until a non-NaN value appears."
+        },
+        {
+            "question": "Does `\"reverse\"` affect which dimension is used?",
+            "answer": "No. Direction only decides whether accumulation walks from the start or from the end along the selected dimension."
+        },
+        {
+            "question": "Can I combine `\"reverse\"` and `\"omitnan\"`?",
+            "answer": "Yes. You can specify both options (in any order) and RunMat mirrors MATLAB’s results."
+        },
+        {
+            "question": "Does the GPU path respect `\"omitnan\"`?",
+            "answer": "If the active provider does not natively handle `\"omitnan\"`, RunMat gathers back to host and computes there to preserve MATLAB semantics."
+        }
+    ],
+    "links": [
+        {
+            "label": "sum",
+            "url": "./sum"
+        },
+        {
+            "label": "cumprod",
+            "url": "./cumprod"
+        },
+        {
+            "label": "diff",
+            "url": "./diff"
+        },
+        {
+            "label": "mean",
+            "url": "./mean"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "all",
+            "url": "./all"
+        },
+        {
+            "label": "any",
+            "url": "./any"
+        },
+        {
+            "label": "cummax",
+            "url": "./cummax"
+        },
+        {
+            "label": "cummin",
+            "url": "./cummin"
+        },
+        {
+            "label": "max",
+            "url": "./max"
+        },
+        {
+            "label": "median",
+            "url": "./median"
+        },
+        {
+            "label": "min",
+            "url": "./min"
+        },
+        {
+            "label": "nnz",
+            "url": "./nnz"
+        },
+        {
+            "label": "prod",
+            "url": "./prod"
+        },
+        {
+            "label": "std",
+            "url": "./std"
+        },
+        {
+            "label": "var",
+            "url": "./var"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/reduction/cumsum.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/reduction/cumsum.rs"
+    },
+    "gpu_residency": "Manual `gpuArray` calls are optional. RunMat promotes tensors automatically when the planner predicts a benefit, and it keeps fused expressions resident on the device. Explicit `gpuArray` is still supported for MATLAB compatibility or when you want to guarantee GPU residency before entering a critical loop.",
+    "gpu_behavior": [
+        "When a tensor already lives on the GPU, RunMat asks the active acceleration provider for a device-side prefix-sum implementation. The WGPU provider ships a native scan kernel; other providers may still fall back. If no hook is available, RunMat gathers the data to host memory, performs the cumulative sum on the CPU, and returns a dense tensor value. Residency metadata is cleared so later operations can re-promote the tensor when profitable."
+    ],
+    "key": "cumsum",
+    "slug": "cumsum",
+    "categoryPath": [
+        "math",
+        "reduction"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=cumsum.js.map

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

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

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

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

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

@@ -0,0 +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,UAwJjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/deconv.js

@@ -0,0 +1,157 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "deconv",
+    "category": "math/signal",
+    "keywords": [
+        "deconv",
+        "deconvolution",
+        "polynomial division",
+        "signal",
+        "gpu"
+    ],
+    "summary": "Divide one polynomial (or 1-D sequence) by another, returning the quotient and remainder.",
+    "references": [
+        "title: \"MATLAB deconv documentation\""
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "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."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 2,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::signal::deconv::tests",
+        "integration": "builtins::math::signal::deconv::tests::deconv_gpu_roundtrip"
+    },
+    "description": "`deconv(b, a)` performs one-dimensional polynomial long division. Given coefficient vectors `b` and `a`, it returns a quotient `q` and remainder `r` such that\n\n```\nconv(a, q) + r == b\n```\n\nCoefficients follow MATLAB conventions: the first entry stores the highest-order term and the last entry stores the constant term. Both real and complex inputs are supported.",
+    "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).",
+        "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."
+    ],
+    "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"
+        },
+        {
+            "description": "Obtaining a non-zero remainder",
+            "input": "[q, r] = deconv([1 4 7], [1 2])",
+            "output": "q = [1 2];\nr = [3]"
+        },
+        {
+            "description": "Dividing by a longer sequence",
+            "input": "[q, r] = deconv([3 5], [1 0 2])",
+            "output": "q = 0;\nr = [3 5]"
+        },
+        {
+            "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]"
+        },
+        {
+            "description": "Complex polynomial division",
+            "input": "b = [1+2i 3-4i 2];\na = [1-i 2+i];\n[q, r] = deconv(b, a)",
+            "output": "q = [-0.5+1.5i 6-0.5i];\nr = [-10.5-5i]"
+        },
+        {
+            "description": "GPU inputs with automatic host fallback",
+            "input": "b = gpuArray([1 3 3 1]);\na = gpuArray([1 1]);\n[q, r] = deconv(b, a); % Quotient stays on the GPU when possible\nr = gather(r);         % Explicitly gather the remainder if needed on the host"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What happens if the denominator is empty or entirely zero?",
+            "answer": "An error is raised. MATLAB requires a non-empty, non-zero denominator polynomial."
+        },
+        {
+            "question": "Can I pass logical or integer vectors?",
+            "answer": "Yes. They are promoted to double precision before division so the results match MATLAB exactly."
+        },
+        {
+            "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": "Does `deconv` support column vectors?",
+            "answer": "Absolutely. The orientation of the numerator (`b`) determines the orientation of both the quotient and remainder."
+        },
+        {
+            "question": "How should I reconstruct the original polynomial?",
+            "answer": "`conv(a, q) + r` (using MATLAB’s polynomial addition rules, which pad shorter vectors on the left) recreates the original numerator."
+        },
+        {
+            "question": "Are FFT-based deconvolutions supported?",
+            "answer": "`deconv` implements exact polynomial long division. For FFT-based signal deconvolution, combine `fft`, elementwise division, and `ifft` manually."
+        },
+        {
+            "question": "What about numerical stability?",
+            "answer": "`deconv` mirrors MATLAB’s long-division semantics. For ill-conditioned problems, consider scaling the coefficients or using higher precision (e.g., symbolic toolboxes) just as you would in MATLAB."
+        },
+        {
+            "question": "Can I request both outputs in one statement?",
+            "answer": "Yes. `[q, r] = deconv(b, a)` returns both quotient and remainder; requesting only one output returns the quotient."
+        }
+    ],
+    "links": [
+        {
+            "label": "conv",
+            "url": "./conv"
+        },
+        {
+            "label": "conv2",
+            "url": "./conv2"
+        },
+        {
+            "label": "fft",
+            "url": "./fft"
+        },
+        {
+            "label": "ifft",
+            "url": "./ifft"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "filter",
+            "url": "./filter"
+        }
+    ],
+    "source": {
+        "label": "Open a ticket",
+        "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."
+    ],
+    "key": "deconv",
+    "slug": "deconv",
+    "categoryPath": [
+        "math",
+        "signal"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=deconv.js.map

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

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

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

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

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

@@ -0,0 +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,UAiNjB,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/delete.js

@@ -0,0 +1,214 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "delete",
+    "category": "io/repl_fs",
+    "keywords": [
+        "delete",
+        "remove file",
+        "wildcard delete",
+        "cleanup",
+        "temporary files",
+        "MATLAB delete"
+    ],
+    "summary": "Remove files using MATLAB-compatible wildcard expansion, array inputs, and error diagnostics.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/delete.html"
+    ],
+    "gpu_support": {
+        "elementwise": false,
+        "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."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::io::repl_fs::delete::tests",
+        "integration": "builtins::io::repl_fs::delete::tests::delete_removes_files_with_wildcard"
+    },
+    "description": "`delete(filename)` removes files from disk, and `delete(obj)` invalidates handle objects or listeners. RunMat mirrors MATLAB behaviour: it accepts character vectors, string scalars, string arrays, char matrices, and cell arrays of names for filesystem removal, gathers GPU-resident inputs automatically, and raises MATLAB-style errors when a file cannot be removed or when handle inputs are invalid.",
+    "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.",
+        "Expands shell-style wildcards (`*` and `?`) using MATLAB-compatible rules. Patterns must resolve to existing files; otherwise, the builtin throws `RunMat:DELETE:FileNotFound`.",
+        "Rejects folders. When a target is a directory, RunMat raises `RunMat:DELETE:Directories`, matching MATLAB’s “Use rmdir to remove directories” diagnostic.",
+        "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."
+    ],
+    "examples": [
+        {
+            "description": "Deleting a single temporary file",
+            "input": "fname = \"scratch.txt\";\nfid = fopen(fname, \"w\");\nfclose(fid);\ndelete(fname)"
+        },
+        {
+            "description": "Removing multiple files with a wildcard pattern",
+            "input": "logs = [\"log-01.txt\", \"log-02.txt\"];\nfor i = 1:numel(logs)\n    fid = fopen(logs(i), \"w\");\n    fclose(fid);\nend\nfor i = 1:numel(logs)\n    delete(logs(i));\nend"
+        },
+        {
+            "description": "Deleting files listed in a string array",
+            "input": "files = [\"stageA.dat\", \"stageB.dat\"];\nfor i = 1:numel(files)\n    fid = fopen(files(i), \"w\");\n    fclose(fid);\nend\ndelete(files)"
+        },
+        {
+            "description": "Handling missing files safely with try/catch",
+            "input": "try\n    delete(\"missing-file.txt\");\ncatch err\n    disp(err.identifier)\n    disp(err.message)\nend"
+        },
+        {
+            "description": "Cleaning up build artifacts stored under your home folder",
+            "input": "delete(\"~/runmat/build/*.o\")"
+        },
+        {
+            "description": "Deleting char-matrix filenames generated programmatically",
+            "input": "names = char(\"stage1.tmp\", \"stage2.tmp\");\nfor row = 1:size(names, 1)\n    fname = strtrim(names(row, :));\n    fid = fopen(fname, \"w\");\n    fclose(fid);\nend\ndelete(names)"
+        },
+        {
+            "description": "Deleting graphics handles after use",
+            "input": "fig = figure;\ndelete(fig);\ntf = isvalid(fig)",
+            "output": "tf =\n     0"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What message IDs does `delete` produce?",
+            "answer": "Missing files raise `RunMat:DELETE:FileNotFound`, directories raise `RunMat:DELETE:Directories`, wildcard syntax issues raise `RunMat:DELETE:InvalidPattern`, operating-system failures raise `RunMat:DELETE:PermissionDenied`, and invalid handle inputs raise `RunMat:DELETE:InvalidHandle`."
+        },
+        {
+            "question": "Can I delete folders with `delete`?",
+            "answer": "No. MATLAB reserves folder deletion for `rmdir`. RunMat follows suit and throws `RunMat:DELETE:Directories` when a target is a directory."
+        },
+        {
+            "question": "Does `delete` support multiple filenames at once?",
+            "answer": "Yes. Pass a string array, a cell array of character vectors, or a char matrix. Each element is deleted in turn."
+        },
+        {
+            "question": "How are wildcard patterns resolved?",
+            "answer": "RunMat uses MATLAB-compatible globbing: `*` matches any sequence, `?` matches a single character, and the pattern is evaluated relative to the current folder (`pwd`) unless you pass an absolute path."
+        },
+        {
+            "question": "What happens when a wildcard matches nothing?",
+            "answer": "The builtin raises `RunMat:DELETE:FileNotFound` (just like MATLAB) and leaves the filesystem unchanged."
+        },
+        {
+            "question": "Do empty arrays raise errors?",
+            "answer": "Empty string arrays or empty cell arrays simply result in no deletions. Empty strings, however, are invalid and trigger `RunMat:DELETE:EmptyFilename`."
+        },
+        {
+            "question": "How do GPU inputs behave?",
+            "answer": "Inputs on the GPU are gathered to the host automatically. No GPU kernels are launched."
+        },
+        {
+            "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."
+        },
+        {
+            "question": "Can I detect failures programmatically?",
+            "answer": "Wrap the call in `try/catch` and inspect `err.identifier` and `err.message` just as you would in MATLAB."
+        },
+        {
+            "question": "Will `delete` follow relative paths updated by `cd`?",
+            "answer": "Yes. Paths are interpreted using the process working directory, so calling `cd` before `delete` mirrors MATLAB’s behaviour."
+        }
+    ],
+    "links": [
+        {
+            "label": "copyfile",
+            "url": "./copyfile"
+        },
+        {
+            "label": "movefile",
+            "url": "./movefile"
+        },
+        {
+            "label": "rmdir",
+            "url": "./rmdir"
+        },
+        {
+            "label": "dir",
+            "url": "./dir"
+        },
+        {
+            "label": "pwd",
+            "url": "./pwd"
+        },
+        {
+            "label": "addpath",
+            "url": "./addpath"
+        },
+        {
+            "label": "cd",
+            "url": "./cd"
+        },
+        {
+            "label": "exist",
+            "url": "./exist"
+        },
+        {
+            "label": "fullfile",
+            "url": "./fullfile"
+        },
+        {
+            "label": "genpath",
+            "url": "./genpath"
+        },
+        {
+            "label": "getenv",
+            "url": "./getenv"
+        },
+        {
+            "label": "ls",
+            "url": "./ls"
+        },
+        {
+            "label": "mkdir",
+            "url": "./mkdir"
+        },
+        {
+            "label": "path",
+            "url": "./path"
+        },
+        {
+            "label": "rmpath",
+            "url": "./rmpath"
+        },
+        {
+            "label": "savepath",
+            "url": "./savepath"
+        },
+        {
+            "label": "setenv",
+            "url": "./setenv"
+        },
+        {
+            "label": "tempdir",
+            "url": "./tempdir"
+        },
+        {
+            "label": "tempname",
+            "url": "./tempname"
+        }
+    ],
+    "source": {
+        "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_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."
+    ],
+    "key": "delete",
+    "slug": "delete",
+    "categoryPath": [
+        "io",
+        "repl_fs"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=delete.js.map

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

@@ -0,0 +1 @@
+{"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

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

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

@@ -0,0 +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,UA0KjB,CAAC;AAEF,eAAe,UAAU,CAAC"}