runmat 0.3.6 → 0.4.1

package/dist/generated/builtins/single.js

@@ -0,0 +1,249 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "single",
+    "category": "math/elementwise",
+    "keywords": [
+        "single",
+        "float32",
+        "cast",
+        "convert to single",
+        "gpuArray single"
+    ],
+    "summary": "Convert numeric values, character arrays, and gpuArray handles to IEEE single precision.",
+    "references": [
+        "https://www.mathworks.com/help/matlab/ref/single.html"
+    ],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Prefers a device-side cast when providers expose a dedicated unary hook; otherwise gathers, converts on the host, and re-uploads when a provider is present."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::elementwise::single::tests",
+        "gpu": "builtins::math::elementwise::single::tests::single_gpu_roundtrip",
+        "wgpu": "builtins::math::elementwise::single::tests::single_wgpu_matches_cpu"
+    },
+    "description": "`single(X)` converts scalars, arrays, complex values, characters, logical inputs, and gpuArray handles into single-precision (`float32`) values while preserving MATLAB's column-major shapes.",
+    "behaviors": [
+        "Numeric scalars and arrays (double or integer) are rounded to IEEE single precision. Scalars remain scalars; arrays keep their exact shape and column-major layout.",
+        "Logical inputs become floating-point `0`/`1`, matching MATLAB’s implicit promotion rules for logical arithmetic.",
+        "Complex values convert both the real and imaginary components to single precision using MATLAB’s analytic extension rules.",
+        "Character arrays return their Unicode code points (equivalent to `double(char)`), quantised to single precision. Strings, structs, cells, objects, and other unsupported classes raise MATLAB-style errors (`\"single: conversion to single from <type> is not possible\"`).",
+        "Empty arrays stay empty, singleton expansion is unaffected, and metadata such as orientation is preserved exactly."
+    ],
+    "examples": [
+        {
+            "description": "Convert a matrix to single precision",
+            "input": "A = [1 2 3; 4 5 6];\nB = single(A)",
+            "output": "B =\n  2×3 single matrix\n     1     2     3\n     4     5     6"
+        },
+        {
+            "description": "Convert a scalar double to single precision",
+            "input": "pi_single = single(pi)",
+            "output": "pi_single =\n  single\n     3.1416"
+        },
+        {
+            "description": "Convert complex numbers to single precision",
+            "input": "z = [1+2i, 3-4i];\nsingle_z = single(z)",
+            "output": "single_z =\n  1×2 single complex row vector\n   1.0000 + 2.0000i   3.0000 - 4.0000i"
+        },
+        {
+            "description": "Convert a character array to single precision codes",
+            "input": "codes = single('ABC')",
+            "output": "codes =\n  1×3 single row vector\n    65    66    67"
+        },
+        {
+            "description": "Keep gpuArray inputs on the GPU",
+            "input": "G = gpuArray(reshape(0:5, 3, 2));\nH = single(G);\ngather(H)",
+            "output": "ans =\n  3×2 single matrix\n     0     3\n     1     4\n     2     5"
+        },
+        {
+            "description": "Convert logical masks to single precision values",
+            "input": "mask = logical([0 1 0 1]);\nweights = single(mask)",
+            "output": "weights =\n  1×4 single row vector\n     0     1     0     1"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Why does `single` change the numeric value slightly?",
+            "answer": "Single precision has ~7 decimal digits of accuracy. Values that require more precision are rounded to the nearest representable float32 number, matching MATLAB exactly."
+        },
+        {
+            "question": "Does `single` accept integer types?",
+            "answer": "Yes. Integer and logical inputs are promoted to floating point with MATLAB’s semantics. Saturation is not required because the target type is floating-point."
+        },
+        {
+            "question": "Can I convert strings with `single`?",
+            "answer": "No. RunMat mirrors MATLAB’s behaviour: strings raise `\"single: conversion to single from string is not possible\"`. Convert strings to character arrays first with `char`."
+        },
+        {
+            "question": "What about structs, cells, or user objects?",
+            "answer": "They raise the same conversion error with their class name. Extract the numeric data you need before calling `single`."
+        },
+        {
+            "question": "Does `single` support complex numbers?",
+            "answer": "Yes. Both the real and imaginary components are converted elementwise, just like MATLAB’s analytic extension."
+        },
+        {
+            "question": "How does `single` behave on empty arrays?",
+            "answer": "Empty arrays stay empty. Shapes and orientations are preserved (`0×n` stays `0×n`)."
+        },
+        {
+            "question": "Will gpuArray inputs stay on the GPU?",
+            "answer": "Yes. RunMat attempts a device-side cast, and if the provider lacks one it converts on the host and re-uploads the result so downstream GPU code still sees a gpuArray."
+        },
+        {
+            "question": "How does this affect `class` or `isa`?",
+            "answer": "RunMat currently reports host tensors as `\"double\"` because their backing storage is f64. This mirrors other parts of the runtime (for example, `gather` of a single-precision gpuArray). GPU results still behave correctly when dispatched through Accelerate."
+        },
+        {
+            "question": "Do NaN or Inf values survive the cast?",
+            "answer": "Yes. IEEE semantics are preserved; NaNs, ±Inf, and signed zeros remain after conversion."
+        },
+        {
+            "question": "Where can I learn more?",
+            "answer": "See MathWorks’ documentation linked above or inspect this builtin’s source file for the exact implementation."
+        }
+    ],
+    "links": [
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "single",
+            "url": "./single"
+        },
+        {
+            "label": "abs",
+            "url": "./abs"
+        },
+        {
+            "label": "angle",
+            "url": "./angle"
+        },
+        {
+            "label": "conj",
+            "url": "./conj"
+        },
+        {
+            "label": "double",
+            "url": "./double"
+        },
+        {
+            "label": "exp",
+            "url": "./exp"
+        },
+        {
+            "label": "expm1",
+            "url": "./expm1"
+        },
+        {
+            "label": "factorial",
+            "url": "./factorial"
+        },
+        {
+            "label": "gamma",
+            "url": "./gamma"
+        },
+        {
+            "label": "hypot",
+            "url": "./hypot"
+        },
+        {
+            "label": "imag",
+            "url": "./imag"
+        },
+        {
+            "label": "ldivide",
+            "url": "./ldivide"
+        },
+        {
+            "label": "log",
+            "url": "./log"
+        },
+        {
+            "label": "log10",
+            "url": "./log10"
+        },
+        {
+            "label": "log1p",
+            "url": "./log1p"
+        },
+        {
+            "label": "log2",
+            "url": "./log2"
+        },
+        {
+            "label": "minus",
+            "url": "./minus"
+        },
+        {
+            "label": "plus",
+            "url": "./plus"
+        },
+        {
+            "label": "pow2",
+            "url": "./pow2"
+        },
+        {
+            "label": "power",
+            "url": "./power"
+        },
+        {
+            "label": "rdivide",
+            "url": "./rdivide"
+        },
+        {
+            "label": "real",
+            "url": "./real"
+        },
+        {
+            "label": "sign",
+            "url": "./sign"
+        },
+        {
+            "label": "sqrt",
+            "url": "./sqrt"
+        },
+        {
+            "label": "times",
+            "url": "./times"
+        }
+    ],
+    "source": {
+        "label": "crates/runmat-runtime/src/builtins/math/elementwise/single.rs",
+        "url": "crates/runmat-runtime/src/builtins/math/elementwise/single.rs"
+    },
+    "gpu_residency": "You rarely need to call `gpuArray` solely for type conversion. RunMat’s planner already keeps hot paths on the GPU. When `single` runs on gpuArray inputs it attempts a device-side cast first, and falls back to gather/convert/re-upload when hooks are missing. The fallback is documented so users understand the temporary host hop.",
+    "gpu_behavior": [
+        "When the input is a gpuArray and the provider implements `unary_single`, RunMat keeps the data on device and returns a new gpuArray handle that already contains single-precision values. This path is also used by fused elementwise kernels emitted by Turbine.",
+        "If the provider lacks the hook, RunMat gathers the data to host memory, converts it to single precision, and re-uploads it so downstream GPU code still receives a device-resident value. The original handle is freed once the replacement upload succeeds.",
+        "When no provider is active the fallback stops after the host conversion, returning a CPU tensor that still respects single-precision rounding. Scalars follow the same logic (`single(gpuArray(pi))` returns a device scalar when possible, or a host scalar if the provider is absent)."
+    ],
+    "key": "single",
+    "slug": "single",
+    "categoryPath": [
+        "math",
+        "elementwise"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=single.js.map

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

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

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

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

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

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

package/dist/generated/builtins/sinh.js

@@ -0,0 +1,182 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "sinh",
+    "category": "math/trigonometry",
+    "keywords": [
+        "sinh",
+        "hyperbolic",
+        "trigonometry",
+        "gpu"
+    ],
+    "summary": "Hyperbolic sine of scalars, vectors, matrices, or N-D tensors (element-wise).",
+    "references": [],
+    "gpu_support": {
+        "elementwise": true,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Prefers provider unary_sinh hooks; falls back to the host path when the active provider cannot service the request."
+    },
+    "fusion": {
+        "elementwise": true,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::trigonometry::sinh::tests",
+        "integration": "builtins::math::trigonometry::sinh::tests::sinh_gpu_provider_roundtrip"
+    },
+    "description": "`Y = sinh(X)` computes the hyperbolic sine of every element in `X`, treating angles as real numbers and extending naturally to complex values.",
+    "behaviors": [
+        "Works on scalars, vectors, matrices, and N-D tensors with MATLAB broadcasting semantics.",
+        "Logical inputs are converted to double precision (`true → 1.0`, `false → 0.0`) before evaluation.",
+        "Complex inputs follow the analytic definition `sinh(a + bi) = sinh(a)cos(b) + i·cosh(a)sin(b)`, propagating `NaN`/`Inf` components independently.",
+        "Character arrays are converted to their numeric code points prior to evaluation, returning double arrays of the same size.",
+        "Empty arrays return empty results that respect MATLAB’s shape semantics."
+    ],
+    "examples": [
+        {
+            "description": "Compute the hyperbolic sine of a scalar value",
+            "input": "y = sinh(1)",
+            "output": "y = 1.1752"
+        },
+        {
+            "description": "Apply `sinh` to each element of a vector",
+            "input": "x = linspace(-1, 1, 5);\ny = sinh(x)",
+            "output": "y = [-1.1752 -0.5211 0 0.5211 1.1752]"
+        },
+        {
+            "description": "Evaluate `sinh` on a matrix",
+            "input": "A = [0 1; 2 3];\nB = sinh(A)",
+            "output": "B = [0 1.1752; 3.6269 10.0179]"
+        },
+        {
+            "description": "Compute the hyperbolic sine on the GPU",
+            "input": "G = gpuArray([0.25 0.5; 0.75 1.0]);\nresult_gpu = sinh(G);\nresult = gather(result_gpu)",
+            "output": "result = [0.2526 0.5211; 0.8223 1.1752]"
+        },
+        {
+            "description": "Work with complex inputs",
+            "input": "z = 1 + 2i;\nw = sinh(z)",
+            "output": "w = -0.4891 + 1.4031i"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "When should I use `sinh`?",
+            "answer": "Use `sinh` for hyperbolic sine transformations, signal-processing workflows, and analytic continuations where the hyperbolic trigonometric family is required."
+        },
+        {
+            "question": "Does `sinh` work with complex numbers?",
+            "answer": "Yes. The real and imaginary parts are evaluated using the analytic definition `sinh(a + bi) = sinh(a)cos(b) + i·cosh(a)sin(b)`."
+        },
+        {
+            "question": "What happens if the provider does not implement `unary_sinh`?",
+            "answer": "RunMat gathers the GPU tensor to host memory, performs the computation on the CPU, and leaves the result on the host unless later operations require GPU residency."
+        },
+        {
+            "question": "Can `sinh` participate in fusion?",
+            "answer": "Yes. The fusion planner can inline `sinh` inside elementwise groups, generating WGSL kernels that execute directly on the GPU."
+        },
+        {
+            "question": "Does `sinh` respect MATLAB broadcasting rules?",
+            "answer": "It operates elementwise and therefore respects the same scalar-expansion (broadcasting) semantics as other MATLAB math functions in RunMat."
+        },
+        {
+            "question": "Are integers preserved?",
+            "answer": "Inputs are promoted to double precision before evaluation. To keep data in integer form, perform downstream casting explicitly."
+        },
+        {
+            "question": "How does `sinh` handle NaN or Inf values?",
+            "answer": "Hyperbolic functions propagate `NaN` and `Inf` components consistently with MATLAB. For complex inputs, each component is treated independently."
+        },
+        {
+            "question": "Can I combine `sinh` with other hyperbolic functions?",
+            "answer": "Yes. `sinh`, `cosh`, and `tanh` will share the same residency rules. Fused expressions can include any combination of elementwise builtins."
+        },
+        {
+            "question": "Is there a GPU warmup penalty?",
+            "answer": "Providers may warm up pipelines during initialization. If `unary_sinh` is unavailable, the CPU fallback ensures correctness without warmup."
+        }
+    ],
+    "links": [
+        {
+            "label": "sin",
+            "url": "./sin"
+        },
+        {
+            "label": "cos",
+            "url": "./cos"
+        },
+        {
+            "label": "tan",
+            "url": "./tan"
+        },
+        {
+            "label": "gpuArray",
+            "url": "./gpuarray"
+        },
+        {
+            "label": "gather",
+            "url": "./gather"
+        },
+        {
+            "label": "acos",
+            "url": "./acos"
+        },
+        {
+            "label": "acosh",
+            "url": "./acosh"
+        },
+        {
+            "label": "asin",
+            "url": "./asin"
+        },
+        {
+            "label": "asinh",
+            "url": "./asinh"
+        },
+        {
+            "label": "atan",
+            "url": "./atan"
+        },
+        {
+            "label": "atan2",
+            "url": "./atan2"
+        },
+        {
+            "label": "atanh",
+            "url": "./atanh"
+        },
+        {
+            "label": "cosh",
+            "url": "./cosh"
+        },
+        {
+            "label": "tanh",
+            "url": "./tanh"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/math/trigonometry/sinh.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/trigonometry/sinh.rs"
+    },
+    "gpu_residency": "You usually do **not** need to call `gpuArray` explicitly. The fusion planner keeps tensors on the GPU whenever the active provider exposes the necessary kernels (such as `unary_sinh`). Manual `gpuArray` / `gather` calls remain supported for MATLAB compatibility or when you need to pin residency before interacting with external code.",
+    "gpu_behavior": [
+        "When RunMat Accelerate is active, tensors that already reside on the GPU stay there. Providers that implement `unary_sinh` execute the operation entirely on the device (and fused elementwise kernels can inline `sinh` as part of a larger expression). If the active provider lacks this hook, RunMat gathers the data back to the host, computes the result, and re-uploads only when later operations require GPU residency."
+    ],
+    "key": "sinh",
+    "slug": "sinh",
+    "categoryPath": [
+        "math",
+        "trigonometry"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=sinh.js.map

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

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

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

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

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

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

package/dist/generated/builtins/size.js

@@ -0,0 +1,166 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "size",
+    "category": "array/introspection",
+    "keywords": [
+        "size",
+        "dimensions",
+        "shape",
+        "gpu",
+        "introspection"
+    ],
+    "summary": "Get the dimensions of scalars, vectors, matrices, and N-D arrays.",
+    "references": [],
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "none",
+        "notes": "Reads tensor metadata from handles; no device kernels are dispatched."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 0,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::array::introspection::size::tests",
+        "integration": "builtins::array::introspection::size::tests::size_gpu_tensor_uses_handle_shape"
+    },
+    "description": "`size(A)` reports the length of every dimension of `A`. The return value is always a row vector describing the current shape, with scalars reported as `1×1`. This matches MathWorks MATLAB semantics for scalars, vectors, matrices, N-D arrays, strings, chars, tables, and cells.",
+    "behaviors": [
+        "`size(A)` returns a `1×N` row vector listing the extents of each dimension.",
+        "`size(A, dim)` returns the extent of the specified dimension as a scalar. Dimensions outside the current rank return `1`.",
+        "`size(A, dims)` accepts a vector of dimensions and returns the corresponding extents.",
+        "Column and row vectors are distinguished by the tensor metadata: `size(A)` yields `[m n]` for `m×n` matrices, `[1 n]` for row vectors, and `[m 1]` for column vectors.",
+        "Character arrays return `[rows cols]`; string scalars return `[1 1]`.",
+        "Cell arrays and struct scalars follow MATLAB's array semantics.",
+        "Empty dimensions (zeros) are preserved in the output vector.",
+        "Multiple output variables follow MATLAB rules: `[m, n, p] = size(A)` peels off leading dimensions, padding with `1`s when the array has fewer than the requested outputs."
+    ],
+    "examples": [
+        {
+            "description": "Find the size of a matrix",
+            "input": "A = [1 2 3; 4 5 6];\nshape = size(A)",
+            "output": "shape = [2 3]"
+        },
+        {
+            "description": "Determine the number of rows in a matrix",
+            "input": "A = randn(8, 4);\nm = size(A, 1)",
+            "output": "m = 8"
+        },
+        {
+            "description": "Query multiple dimensions at once",
+            "input": "A = rand(5, 4, 3);\nselected = size(A, [1 3])",
+            "output": "selected = [5 3]"
+        },
+        {
+            "description": "Inspect a gpuArray without gathering",
+            "input": "G = gpuArray(ones(256, 512));\nshape = size(G)",
+            "output": "shape = [256 512]"
+        },
+        {
+            "description": "Check the size of a cell array",
+            "input": "C = {1, 2, 3; 4, 5, 6};\ngrid = size(C)",
+            "output": "grid = [2 3]"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "How is `size` different from `length`?",
+            "answer": "`length(A)` returns the length of the largest dimension, whereas `size(A)` returns every dimension."
+        },
+        {
+            "question": "What happens when I request a dimension larger than the array rank?",
+            "answer": "MATLAB semantics apply: `size(A, dim)` returns `1` when `dim` exceeds the number of stored dimensions."
+        },
+        {
+            "question": "Can I pass a vector of dimensions?",
+            "answer": "Yes. `size(A, [1 3])` returns a row vector with the size of the first and third dimensions."
+        },
+        {
+            "question": "Does `size` gather GPU data?",
+            "answer": "No. The runtime reads shape metadata stored alongside the GPU buffer. Gathering only happens if a provider fails to report the shape, in which case RunMat downloads the tensor before continuing."
+        },
+        {
+            "question": "How are row and column vectors reported?",
+            "answer": "Row vectors are `[1 n]`, column vectors are `[n 1]`, matching MATLAB."
+        },
+        {
+            "question": "What about empty arrays?",
+            "answer": "Empty dimensions (0-length) are preserved exactly in the returned vector."
+        },
+        {
+            "question": "Can I pass non-integer dimensions?",
+            "answer": "No. The dimension argument must be positive integers; fractions or negatives raise an error."
+        },
+        {
+            "question": "How can I check multiple dimensions and keep the result on the GPU?",
+            "answer": "`size` always returns a host double array because it is metadata. Use the values to plan GPU computations, but no GPU array is produced."
+        }
+    ],
+    "links": [
+        {
+            "label": "length",
+            "url": "./length"
+        },
+        {
+            "label": "ndims",
+            "url": "./ndims"
+        },
+        {
+            "label": "numel",
+            "url": "./numel"
+        },
+        {
+            "label": "size",
+            "url": "./size"
+        },
+        {
+            "label": "isempty",
+            "url": "./isempty"
+        },
+        {
+            "label": "ismatrix",
+            "url": "./ismatrix"
+        },
+        {
+            "label": "isscalar",
+            "url": "./isscalar"
+        },
+        {
+            "label": "isvector",
+            "url": "./isvector"
+        },
+        {
+            "label": "length",
+            "url": "./length"
+        },
+        {
+            "label": "ndims",
+            "url": "./ndims"
+        },
+        {
+            "label": "numel",
+            "url": "./numel"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/array/introspection/size.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/array/introspection/size.rs"
+    },
+    "gpu_behavior": [
+        "When a value already resides on the GPU, `size` reads the shape metadata carried by the GPU tensor handle. No kernels are launched and no device data is gathered. If a provider does not populate the shape field on its handles, RunMat falls back to materialising the tensor on the host so the answer stays correct. The builtin never allocates device memory and always returns a host double array, making it safe to call inside fused GPU expressions without breaking residency."
+    ],
+    "key": "size",
+    "slug": "size",
+    "categoryPath": [
+        "array",
+        "introspection"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=size.js.map

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

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

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

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

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

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