runmat 0.6.1 → 0.6.2-dev.1

package/dist/generated/builtins/feof.js

@@ -15,7 +15,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Runs entirely on the CPU. Arguments that live on the GPU are gathered automatically, and file handles remain host-resident."
+        "notes": "Runs entirely on the CPU. Provider-resident identifiers are a gated RunMat extension and are gathered only after compatibility preflight; file handles remain host-resident."
     },
     "fusion": {
         "elementwise": false,
@@ -26,15 +26,18 @@ const builtinDoc = {
     "requires_feature": null,
     "tested": {
         "unit": "builtins::io::filetext::feof::tests",
-        "integration": "builtins::io::filetext::feof::tests::feof_returns_true_after_reading_to_end"
+        "integration": "builtins::io::filetext::feof::tests::feof_returns_true_after_a_read_encounters_end_of_file"
     },
-    "description": "`feof(fid)` reports whether the file position indicator for `fid` is at end-of-file. It returns a logical scalar and is typically used to terminate loops that read with `fread`, `fgets`, or related I/O functions under MATLAB semantics.",
+    "description": "`feof(fid)` reports the end-of-file indicator associated with the open file identified by `fid`. It returns a logical scalar. Opening a file initializes the indicator to false; a read that encounters end-of-file sets it, and successful repositioning clears it.",
     "behaviors": [
-        "`tf = feof(fid)` returns logical `1` when the file position indicator is at end-of-file and logical `0` otherwise.",
-        "`fid` must be a non-negative integer returned by `fopen`. Passing an invalid identifier raises the same error message as other file I/O builtins.",
+        "`tf = feof(fid)` returns logical `1` only after a prior read on that open file encountered end-of-file; merely reaching the exact final byte does not set the indicator.",
+        "The MATLAB-compatible identifier form is a finite integer-valued double scalar returned by `fopen`, checked against the runtime i32 identifier range before registry access.",
+        "Typed integer identifiers across all eight built-in integer classes, logical identifiers, and provider-resident identifiers are three independently gated RunMat extensions. Compatibility preflight occurs before provider gathering or registry access.",
         "Standard input/output identifiers (`0`, `1`, `2`) always report `false` because RunMat does not yet expose end-of-file state for those streams.",
-        "`feof` preserves the file position indicator; checking the flag does not modify where subsequent reads continue.",
-        "When a file is empty, `feof` immediately returns `true` because the initial file position coincides with the end of the file."
+        "`feof` only queries registry state: it does not seek, inspect file length, contact a provider after host conversion, or modify the file position.",
+        "A newly opened empty file reports `false`. The first read attempt that encounters end-of-file sets the indicator to true.",
+        "`frewind` and other successful positioning operations clear the end-of-file indicator. Closing the file removes its state with the registry entry.",
+        "The compatibility classification is grounded in the linked public documentation and remains evidence-open for additional release-specific findings."
     ],
     "examples": [
         {
@@ -46,26 +49,26 @@ const builtinDoc = {
             "input": "[fid, msg] = fopen('payload.bin', 'rb');\nassert(fid ~= -1, msg);\nwhile ~feof(fid)\n    chunk = fread(fid, 1024, 'uint8');\n    process(chunk);\nend\nfclose(fid)"
         },
         {
-            "description": "Handle empty files gracefully",
-            "input": "[fid, msg] = fopen('empty.txt', 'r');\nassert(fid ~= -1, msg);\nisAtEnd = feof(fid);   % returns true immediately because the file is empty\nfclose(fid)"
+            "description": "Observe read-driven state for an empty file",
+            "input": "[fid, msg] = fopen('empty.txt', 'r');\nassert(fid ~= -1, msg);\nassert(~feof(fid));\nfgets(fid);            % encounters end-of-file\nassert(feof(fid));\nfrewind(fid);\nassert(~feof(fid));\nfclose(fid)"
         },
         {
             "description": "Protect against invalid identifiers",
             "input": "try\n    feof(9999);\ncatch err\n    disp(err.message);\nend"
         },
         {
-            "description": "Guard reads that rely on gpuArray identifiers",
-            "input": "fid = gpuArray(int32(fopen('samples.dat', 'rb')));\ntf = feof(fid);        % argument is gathered automatically before the check"
+            "description": "Checking end-of-file with typed and resident identifiers",
+            "input": "fid = gpuArray(int32(fopen('samples.dat', 'rb')));\ntf = feof(fid);        % resident and typed-integer extension gates apply before gathering"
         }
     ],
     "faqs": [
         {
             "question": "What kind of input does `feof` accept?",
-            "answer": "Pass a scalar numeric file identifier returned by `fopen`. The identifier must be non-negative and finite. Character vectors or strings are not accepted."
+            "answer": "The MATLAB-compatible form is a finite integer-valued double scalar returned by `fopen`. RunMat mode can additionally enable typed integer, logical, and provider-resident identifier extensions. Character vectors and strings are not accepted."
         },
         {
             "question": "Does `feof` move the file position indicator?",
-            "answer": "No. The builtin queries the current position and restores it before returning, so subsequent reads resume where they left off."
+            "answer": "No. The builtin reads the registry's end-of-file flag and performs no seek or length query, so subsequent reads resume exactly where they left off."
         },
         {
             "question": "How does `feof` behave for standard input/output?",
@@ -73,7 +76,7 @@ const builtinDoc = {
         },
         {
             "question": "Does `feof` require a previous read attempt to return true?",
-            "answer": "No. RunMat compares the current position against the end of the file. As soon as the indicator reaches the end (for example after reading all bytes or when the file is empty), `feof` returns `true`."
+            "answer": "Yes. Reaching the exact end position is not sufficient. A read operation must attempt to read at end-of-file; successful repositioning such as `frewind` clears the flag."
         },
         {
             "question": "Can I call `feof` on closed files?",
@@ -120,15 +123,23 @@ const builtinDoc = {
         {
             "label": "frewind",
             "url": "./frewind"
+        },
+        {
+            "label": "MathWorks feof documentation",
+            "url": "https://www.mathworks.com/help/matlab/ref/feof.html"
+        },
+        {
+            "label": "C file end-of-file indicator",
+            "url": "https://en.cppreference.com/w/c/io/feof.html"
         }
     ],
     "source": {
-        "label": "Open an issue",
-        "url": "https://github.com/runmat-org/runmat/issues/new/choose"
+        "label": "crates/runmat-runtime/src/builtins/io/filetext/feof.rs",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/filetext/feof.rs"
     },
-    "gpu_residency": "No. File identifiers are always owned by the host-side registry maintained by `fopen`. Wrapping a scalar identifier in `gpuArray` does not keep the file handle on the GPU—the runtime gathers the scalar before performing the lookup. This means you can freely mix host and GPU code when driving file I/O loops, and `feof` remains inexpensive regardless of execution tier.",
+    "gpu_residency": "No. File handles and end-of-file state are owned by the host registry. A provider-resident scalar identifier is a gated RunMat extension; compatibility preflight runs before the provider is contacted, then the scalar is gathered for exact identifier validation and the host registry query.",
     "gpu_behavior": [
-        "`feof` is a host-only query. If `fid` resides on the GPU (for example inside a `gpuArray`), RunMat gathers the scalar to host memory before consulting the file registry. File handles always remain on the CPU, so there are no provider hooks or fusion paths for this builtin. The result is produced on the host as a logical scalar that mirrors MATLAB behaviour."
+        "`feof` is a host-only state query with no provider hooks or fusion path. In RunMat extension mode, a resident identifier is compatibility-gated before gathering; the resulting host scalar is range-checked before the registry is queried. The result is always a host logical scalar."
     ],
     "key": "feof",
     "slug": "feof",

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

@@ -1 +1 @@
-{"version":3,"file":"feof.js","sourceRoot":"","sources":["../../../src/generated/builtins/feof.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,MAAM;QACN,aAAa;QACb,IAAI;QACJ,iBAAiB;KAClB;IACD,SAAS,EAAE,oEAAoE;IAC/E,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6HAA6H;KACvI;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,qCAAqC;QAC7C,aAAa,EAAE,6EAA6E;KAC7F;IACD,aAAa,EAAE,6OAA6O;IAC5P,WAAW,EAAE;QACX,oHAAoH;QACpH,mJAAmJ;QACnJ,iJAAiJ;QACjJ,kHAAkH;QAClH,+HAA+H;KAChI;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,2IAA2I;SACrJ;QACD;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,oKAAoK;SAC9K;QACD;YACE,aAAa,EAAE,+BAA+B;YAC9C,OAAO,EAAE,0JAA0J;SACpK;QACD;YACE,aAAa,EAAE,qCAAqC;YACpD,OAAO,EAAE,8DAA8D;SACxE;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,kIAAkI;SAC5I;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,2JAA2J;SACtK;QACD;YACE,UAAU,EAAE,+CAA+C;YAC3D,QAAQ,EAAE,gIAAgI;SAC3I;QACD;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,yNAAyN;SACpO;QACD;YACE,UAAU,EAAE,6DAA6D;YACzE,QAAQ,EAAE,wMAAwM;SACnN;QACD;YACE,UAAU,EAAE,oCAAoC;YAChD,QAAQ,EAAE,8HAA8H;SACzI;QACD;YACE,UAAU,EAAE,8CAA8C;YAC1D,QAAQ,EAAE,kJAAkJ;SAC7J;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,QAAQ;YACjB,KAAK,EAAE,UAAU;SAClB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;QACD;YACE,OAAO,EAAE,SAAS;YAClB,KAAK,EAAE,WAAW;SACnB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,eAAe;QACxB,KAAK,EAAE,wDAAwD;KAChE;IACD,eAAe,EAAE,mXAAmX;IACpY,cAAc,EAAE;QACd,yWAAyW;KAC1W;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,IAAI;QACJ,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"feof.js","sourceRoot":"","sources":["../../../src/generated/builtins/feof.ts"],"names":[],"mappings":"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"}

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

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

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

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

package/dist/generated/builtins/feval.js

@@ -0,0 +1,104 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "feval",
+    "category": "introspection",
+    "keywords": [
+        "feval",
+        "function handle",
+        "dynamic dispatch",
+        "varargin",
+        "varargout"
+    ],
+    "summary": "Evaluate a function selected by name or function handle.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [],
+        "broadcasting": "function-specific",
+        "notes": "feval performs no provider operation of its own. GPU admission, kernels, fallback, output residency, and precision are inherited from the selected function."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": null,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "feval_forwards_all_integer_classes_without_conversion",
+        "integration": "runmat-vm/tests/functions.rs and runmat-vm/tests/closures.rs"
+    },
+    "description": "`feval(fun, x1, ..., xM)` evaluates the function selected by the name or function handle `fun` and forwards the requested number of outputs. Argument and result classes, shapes, overflow behavior, and provider residency are defined by the selected function rather than by `feval`.",
+    "behaviors": [
+        "A plain character-vector or string-scalar function name such as `'round'` or `\"round\"` is resolved using the same callable dispatch rules as a direct named call.",
+        "A function handle invokes its bound function identity. Closures preserve their captured values and semantic function identity.",
+        "Input arguments are forwarded without numeric conversion. This includes all eight integer classes, logical values, native single values, complex values, and provider-resident arrays when the selected function supports them.",
+        "The number and classes of outputs are inherited from the selected function and the number of outputs requested by the caller.",
+        "RunMat mode additionally accepts text targets prefixed with `@`, such as `\"@sin\"`, and callable object receivers. Strict compatibility mode rejects those extensions before dispatch."
+    ],
+    "examples": [
+        {
+            "description": "Evaluate a function by its documented plain name",
+            "input": "y = feval('round', pi, 2)",
+            "output": "y = 3.1400"
+        },
+        {
+            "description": "Evaluate a function handle",
+            "input": "f = @max;\ny = feval(f, int32([2 7 4]))",
+            "output": "y = int32(7)"
+        },
+        {
+            "description": "Forward multiple outputs",
+            "input": "[value, index] = feval(@max, uint64([4 9 2]))",
+            "output": "% value and index follow max's documented output rules"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "Does feval convert integer arguments to double?",
+            "answer": "No. feval forwards each value unchanged. Any conversion, overflow rule, or output-class choice belongs to the selected function."
+        },
+        {
+            "question": "Does feval gather a GPU array?",
+            "answer": "Not by itself. The selected function determines whether a resident input stays on its provider, launches a kernel, falls back through the host, or is rejected."
+        },
+        {
+            "question": "Can I pass the function name without an @ prefix?",
+            "answer": "Yes. A plain function name is the documented text form. An @-prefixed text value is a separate RunMat-mode convenience; an actual function handle such as @sin is supported in compatibility mode."
+        },
+        {
+            "question": "Why can the output type vary?",
+            "answer": "feval is dynamic dispatch. Its output count, class, shape, and residency are exactly those produced by the selected function for the supplied arguments."
+        }
+    ],
+    "links": [
+        {
+            "label": "functions",
+            "url": "./functions"
+        },
+        {
+            "label": "str2func",
+            "url": "./str2func"
+        },
+        {
+            "label": "func2str",
+            "url": "./func2str"
+        }
+    ],
+    "source": {
+        "label": "`crates/runmat-runtime/src/builtins/introspection/feval.rs`",
+        "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/introspection/feval.rs"
+    },
+    "gpu_behavior": [
+        "feval does not launch a kernel, gather an input, or upload an output on its own. It passes the original values to the selected callable, whose registered provider contract controls all GPU behavior."
+    ],
+    "key": "feval",
+    "slug": "feval",
+    "aliases": [],
+    "categoryPath": [
+        "introspection"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=feval.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"feval.js","sourceRoot":"","sources":["../../../src/generated/builtins/feval.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,eAAe;IAC3B,UAAU,EAAE;QACV,OAAO;QACP,iBAAiB;QACjB,kBAAkB;QAClB,UAAU;QACV,WAAW;KACZ;IACD,SAAS,EAAE,0DAA0D;IACrE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,mBAAmB;QACnC,OAAO,EAAE,8JAA8J;KACxK;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,IAAI;QAClB,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,uDAAuD;QAC/D,aAAa,EAAE,8DAA8D;KAC9E;IACD,aAAa,EAAE,0RAA0R;IACzS,WAAW,EAAE;QACX,qKAAqK;QACrK,gIAAgI;QAChI,iOAAiO;QACjO,+HAA+H;QAC/H,yLAAyL;KAC1L;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,kDAAkD;YACjE,OAAO,EAAE,2BAA2B;YACpC,QAAQ,EAAE,YAAY;SACvB;QACD;YACE,aAAa,EAAE,4BAA4B;YAC3C,OAAO,EAAE,yCAAyC;YAClD,QAAQ,EAAE,cAAc;SACzB;QACD;YACE,aAAa,EAAE,0BAA0B;YACzC,OAAO,EAAE,+CAA+C;YACxD,QAAQ,EAAE,wDAAwD;SACnE;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,iDAAiD;YAC7D,QAAQ,EAAE,kIAAkI;SAC7I;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,iKAAiK;SAC5K;QACD;YACE,UAAU,EAAE,mDAAmD;YAC/D,QAAQ,EAAE,oMAAoM;SAC/M;QACD;YACE,UAAU,EAAE,+BAA+B;YAC3C,QAAQ,EAAE,0JAA0J;SACrK;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,WAAW;YACpB,KAAK,EAAE,aAAa;SACrB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,6DAA6D;QACtE,KAAK,EAAE,0GAA0G;KAClH;IACD,cAAc,EAAE;QACd,wMAAwM;KACzM;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,eAAe;KAChB;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/fft.js

@@ -37,7 +37,7 @@ const builtinDoc = {
         "`fft(X)` transforms along the first dimension whose size is greater than 1.",
         "`fft(X, n)` zero-pads or truncates `X` to length `n` before transforming along the default dimension.",
         "`fft(X, n, dim)` applies the transform along dimension `dim`.",
-        "Real inputs produce complex outputs; complex inputs are handled element-wise with no additional conversion.",
+        "Integer inputs through 32 bits are transformed in double precision; single inputs produce single output and all other documented numeric classes produce double output.",
         "Empty inputs remain empty; zero-padding with `n` produces zero-valued spectra.",
         "GPU arrays are gathered to the host when the selected provider has no FFT implementation."
     ],
@@ -72,7 +72,7 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "Does `fft` always return complex values?",
-            "answer": "Yes. Even when the imaginary part is zero, the result is stored as a complex array to match MATLAB semantics."
+            "answer": "FFT results represent a complex spectrum. For gpuArray input the result is always stored as complex even when every imaginary component is zero."
         },
         {
             "question": "What happens if I pass `[]` as the second argument?",
@@ -96,11 +96,11 @@ const builtinDoc = {
         },
         {
             "question": "Is inverse FFT (`ifft`) available?",
-            "answer": "`ifft` will be provided in a companion builtin. Until then, you can recover a time-domain signal by dividing by the length and taking the complex conjugate manually."
+            "answer": "Yes. Use `ifft` for the inverse transform."
         },
         {
             "question": "How do I compute multi-dimensional FFTs?",
-            "answer": "Call `fft` repeatedly along each dimension (`fft(fft(X, [], 1), [], 2)` for a 2-D FFT). Future releases will add dedicated helpers."
+            "answer": "Use `fft2` for the first two dimensions or `fftn` for an N-dimensional transform."
         },
         {
             "question": "Does `fft` support complex strides or non-unit sampling intervals?",

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

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

package/dist/generated/builtins/fft2.js

@@ -36,10 +36,10 @@ const builtinDoc = {
     "behaviors": [
         "`fft2(X)` transforms along the first and second dimensions that have size greater than one.",
         "`fft2(X, M, N)` zero-pads or truncates `X` to `M` rows and `N` columns before evaluating the 2-D transform.",
-        "`fft2(X, SIZE)` accepts a two-element vector (or scalar) specifying the transform lengths.",
+        "RunMat extension: `fft2(X, SIZE)` accepts a two-element vector (or scalar) specifying the transform lengths when RunMat extensions are enabled.",
         "Real inputs produce complex outputs; complex inputs are transformed element-wise with no additional conversion.",
         "Higher-dimensional inputs are transformed slice-by-slice across trailing dimensions, matching MATLAB behaviour.",
-        "Empty dimensions yield empty outputs; zero padding with `0` produces a zero-sized complex tensor.",
+        "MATLAB-compatible `M` and `N` controls are positive integer scalars. Empty and zero transform sizes are separately gated RunMat extensions.",
         "GPU arrays execute on-device when the provider advertises the `fft_dim` hook; otherwise RunMat gathers the data and performs the transform on the host using `rustfft`."
     ],
     "examples": [
@@ -54,7 +54,7 @@ const builtinDoc = {
         },
         {
             "description": "Specifying transform lengths with a size vector",
-            "input": "X = rand(4, 6);\nF = fft2(X, [8 4]);   % pad rows to 8 and truncate columns to 4"
+            "input": "X = rand(4, 6);\nF = fft2(X, [8 4]);   % requires RunMat extension mode"
         },
         {
             "description": "Using `fft2` on `gpuArray` data",
@@ -76,11 +76,11 @@ const builtinDoc = {
         },
         {
             "question": "How do zero-length transform sizes behave?",
-            "answer": "Passing `0` for either `M` or `N` produces a complex tensor with zero elements along that dimension."
+            "answer": "MATLAB-compatible mode requires positive `M` and `N`. RunMat extension mode can use `0` to produce a zero-sized complex tensor."
         },
         {
             "question": "Can I use a single scalar for the size argument?",
-            "answer": "Yes. `fft2(X, K)` is shorthand for `fft2(X, [K K])`, padding or truncating both dimensions to `K`."
+            "answer": "In RunMat extension mode, `fft2(X, K)` is shorthand for `fft2(X, [K K])`. The documented compatibility forms are `fft2(X)` and `fft2(X,M,N)`."
         },
         {
             "question": "What happens when `X` has more than two dimensions?",
@@ -92,7 +92,7 @@ const builtinDoc = {
         },
         {
             "question": "Will `fft2` run on the GPU automatically?",
-            "answer": "Yes if the active provider implements `fft_dim`. Otherwise RunMat gathers to the host and performs the transform with `rustfft`."
+            "answer": "Yes if the input's owning provider implements `fft_dim` for its storage class. Otherwise RunMat gathers to the host, performs the transform with `rustfft`, and restores the result to that provider."
         },
         {
             "question": "Does `fft2` normalise the output?",
@@ -100,7 +100,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I mix `[]` with explicit sizes (e.g., `fft2(X, [], 128)`)?",
-            "answer": "Yes. Passing `[]` leaves that dimension unchanged while applying the specified size to the other dimension."
+            "answer": "This is a RunMat extension. MATLAB-compatible mode requires positive scalar `M` and `N` values."
         }
     ],
     "links": [

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

@@ -1 +1 @@
-{"version":3,"file":"fft2.js","sourceRoot":"","sources":["../../../src/generated/builtins/fft2.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"fft2.js","sourceRoot":"","sources":["../../../src/generated/builtins/fft2.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,MAAM;QACN,QAAQ;QACR,mCAAmC;QACnC,0BAA0B;QAC1B,KAAK;KACN;IACD,SAAS,EAAE,2EAA2E;IACtF,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,oGAAoG;KAC9G;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,kCAAkC;QAC1C,aAAa,EAAE,kEAAkE;KAClF;IACD,aAAa,EAAE,kNAAkN;IACjO,WAAW,EAAE;QACX,6FAA6F;QAC7F,6GAA6G;QAC7G,iJAAiJ;QACjJ,iHAAiH;QACjH,iHAAiH;QACjH,6IAA6I;QAC7I,yKAAyK;KAC1K;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,yCAAyC;YACxD,OAAO,EAAE,8BAA8B;YACvC,QAAQ,EAAE,mDAAmD;SAC9D;QACD;YACE,aAAa,EAAE,2CAA2C;YAC1D,OAAO,EAAE,uDAAuD;SACjE;QACD;YACE,aAAa,EAAE,iDAAiD;YAChE,OAAO,EAAE,yEAAyE;SACnF;QACD;YACE,aAAa,EAAE,iCAAiC;YAChD,OAAO,EAAE,4DAA4D;SACtE;QACD;YACE,aAAa,EAAE,+CAA+C;YAC9D,OAAO,EAAE,0CAA0C;SACpD;QACD;YACE,aAAa,EAAE,iDAAiD;YAChE,OAAO,EAAE,4EAA4E;SACtF;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,uDAAuD;YACnE,QAAQ,EAAE,mGAAmG;SAC9G;QACD;YACE,UAAU,EAAE,4CAA4C;YACxD,QAAQ,EAAE,iIAAiI;SAC5I;QACD;YACE,UAAU,EAAE,kDAAkD;YAC9D,QAAQ,EAAE,+IAA+I;SAC1J;QACD;YACE,UAAU,EAAE,qDAAqD;YACjE,QAAQ,EAAE,oHAAoH;SAC/H;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,mHAAmH;SAC9H;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,uMAAuM;SAClN;QACD;YACE,UAAU,EAAE,mCAAmC;YAC/C,QAAQ,EAAE,gHAAgH;SAC3H;QACD;YACE,UAAU,EAAE,gEAAgE;YAC5E,QAAQ,EAAE,iGAAiG;SAC5G;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;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;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,eAAe;QACxB,KAAK,EAAE,wDAAwD;KAChE;IACD,eAAe,EAAE,+aAA+a;IAChc,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

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

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

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

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

package/dist/generated/builtins/fftn.js

@@ -0,0 +1,92 @@
+// @generated by scripts/generate-builtins.cjs
+// Do not edit by hand.
+const builtinDoc = {
+    "title": "fftn",
+    "category": "math/fft",
+    "keywords": [
+        "fftn",
+        "n-dimensional fft",
+        "fourier transform",
+        "gpu"
+    ],
+    "summary": "Compute an N-dimensional discrete Fourier transform.",
+    "gpu_support": {
+        "elementwise": false,
+        "reduction": false,
+        "precisions": [
+            "f32",
+            "f64"
+        ],
+        "broadcasting": "matlab",
+        "notes": "Runs provider-backed fft_dim passes when available; host fallback restores the result to the provider that owns the input."
+    },
+    "fusion": {
+        "elementwise": false,
+        "reduction": false,
+        "max_inputs": 1,
+        "constants": "inline"
+    },
+    "requires_feature": null,
+    "tested": {
+        "unit": "builtins::math::fft::fftn::tests",
+        "integration": "builtins::math::fft::fftn::tests::fftn_matches_sequential_fft_on_3d"
+    },
+    "description": "`fftn(X)` transforms every dimension of `X`. `fftn(X,SIZE)` pads or truncates each transformed dimension according to a positive integer size vector whose length is at least `ndims(X)`.",
+    "behaviors": [
+        "Integer inputs through 32 bits and logical inputs are documented and produce double output; single input produces single output.",
+        "`SIZE` must be a row or column vector of positive integers with at least one entry per input dimension.",
+        "RunMat extension mode can admit exact int64 and uint64 structural controls and positive SIZE vectors shorter than `ndims(X)` through independent gates.",
+        "gpuArray results remain resident when a provider hook succeeds or when RunMat completes a supported fallback on the host."
+    ],
+    "examples": [
+        {
+            "description": "Transforming every dimension of a volume",
+            "input": "X = rand(4, 5, 6);\nY = fftn(X)"
+        },
+        {
+            "description": "Padding an N-dimensional transform",
+            "input": "X = rand(4, 5, 6);\nY = fftn(X, [8 8 8])"
+        }
+    ],
+    "faqs": [
+        {
+            "question": "What shape does `fftn(X,SIZE)` return?",
+            "answer": "Its transformed dimensions have the lengths listed in `SIZE`; the compatibility form requires `length(SIZE) >= ndims(X)`."
+        },
+        {
+            "question": "What precision is used for integer input?",
+            "answer": "Documented integer classes enter the double-precision FFT domain and return double output."
+        }
+    ],
+    "links": [
+        {
+            "label": "fft",
+            "url": "./fft"
+        },
+        {
+            "label": "fft2",
+            "url": "./fft2"
+        },
+        {
+            "label": "ifftn",
+            "url": "./ifftn"
+        },
+        {
+            "label": "fftshift",
+            "url": "./fftshift"
+        }
+    ],
+    "source": {
+        "label": "Open a ticket",
+        "url": "https://github.com/runmat-org/runmat/issues/new/choose"
+    },
+    "key": "fftn",
+    "slug": "fftn",
+    "aliases": [],
+    "categoryPath": [
+        "math",
+        "fft"
+    ]
+};
+export default builtinDoc;
+//# sourceMappingURL=fftn.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"fftn.js","sourceRoot":"","sources":["../../../src/generated/builtins/fftn.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,MAAM;IACf,UAAU,EAAE,UAAU;IACtB,UAAU,EAAE;QACV,MAAM;QACN,mBAAmB;QACnB,mBAAmB;QACnB,KAAK;KACN;IACD,SAAS,EAAE,sDAAsD;IACjE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE;YACZ,KAAK;YACL,KAAK;SACN;QACD,cAAc,EAAE,QAAQ;QACxB,OAAO,EAAE,4HAA4H;KACtI;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,kCAAkC;QAC1C,aAAa,EAAE,qEAAqE;KACrF;IACD,aAAa,EAAE,2LAA2L;IAC1M,WAAW,EAAE;QACX,kIAAkI;QAClI,yGAAyG;QACzG,yJAAyJ;QACzJ,2HAA2H;KAC5H;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,0CAA0C;YACzD,OAAO,EAAE,iCAAiC;SAC3C;QACD;YACE,aAAa,EAAE,oCAAoC;YACnD,OAAO,EAAE,0CAA0C;SACpD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,wCAAwC;YACpD,QAAQ,EAAE,2HAA2H;SACtI;QACD;YACE,UAAU,EAAE,2CAA2C;YACvD,QAAQ,EAAE,4FAA4F;SACvG;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,KAAK;YACd,KAAK,EAAE,OAAO;SACf;QACD;YACE,OAAO,EAAE,MAAM;YACf,KAAK,EAAE,QAAQ;SAChB;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,eAAe;QACxB,KAAK,EAAE,wDAAwD;KAChE;IACD,KAAK,EAAE,MAAM;IACb,MAAM,EAAE,MAAM;IACd,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,MAAM;QACN,KAAK;KACN;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/fftshift.js

@@ -19,7 +19,7 @@ const builtinDoc = {
             "f64"
         ],
         "broadcasting": "none",
-        "notes": "Uses the provider circshift hook when available; otherwise gathers once, shifts on the host, and re-uploads."
+        "notes": "Uses the owning provider's circshift hook when available; otherwise gathers once, shifts on the host, and restores the result to that provider."
     },
     "fusion": {
         "elementwise": false,
@@ -35,7 +35,7 @@ const builtinDoc = {
     "description": "`fftshift(X)` circularly shifts FFT output so the zero-frequency component moves to the center of each shifted dimension. The default all-dimension behavior and optional dimension selection follow MATLAB semantics.",
     "behaviors": [
         "When called without a dimension list, `fftshift` shifts along every dimension by `floor(size(X, dim) / 2)`.",
-        "`fftshift(X, dims)` shifts only the specified dimensions. `dims` can be a scalar, vector, or logical mask.",
+        "`fftshift(X, DIM)` shifts one documented scalar dimension. Numeric vectors and logical masks are separately gated RunMat extensions.",
         "Dimensions of length 0 or 1 are left unchanged.",
         "Inputs can be real or complex and may already reside on the GPU (`gpuArray`)."
     ],
@@ -81,7 +81,7 @@ const builtinDoc = {
         },
         {
             "question": "Can I apply `fftshift` to only one dimension?",
-            "answer": "Yes. Pass a dimension index or vector, e.g. `fftshift(X, 2)` to shift column channels only."
+            "answer": "Pass a positive scalar dimension such as `fftshift(X,2)`. RunMat extension mode additionally accepts numeric dimension vectors and logical masks."
         },
         {
             "question": "Does `fftshift` work with gpuArray inputs?",
@@ -134,9 +134,9 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/math/fft/fftshift.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/math/fft/fftshift.rs"
     },
-    "gpu_residency": "RunMat's auto-offload keeps FFT spectra on the GPU whenever the active provider exposes the `circshift` hook. In that case `fftshift` runs entirely on the device and downstream fused operations continue without a gather. If no GPU provider is registered—or it does not expose `circshift`—RunMat gathers the data once, performs the host shift, and uploads the result back to the device so subsequent work can still benefit from acceleration. You can always call `gpuArray` explicitly when you need MATLAB compatibility or want to guarantee a specific residency boundary.",
+    "gpu_residency": "RunMat keeps FFT spectra on the GPU whenever the input's owning provider can execute the required `circshift`. Otherwise RunMat gathers the data once, performs the host shift, and restores the result to the same provider so subsequent work can remain resident. You can call `gpuArray` explicitly when you want to guarantee a residency boundary.",
     "gpu_behavior": [
-        "RunMat asks the active acceleration provider to execute `fftshift` via the `circshift` hook (with predetermined offsets). If the provider cannot satisfy the request, the tensor is gathered exactly once, shifted on the host, and optionally re-uploaded. Scalars remain on their existing device."
+        "RunMat asks the input's owning provider to execute `fftshift` via the `circshift` hook. If the provider cannot satisfy the request, the tensor is gathered once, shifted on the host, and restored to that provider. Scalars remain on their existing device."
     ],
     "key": "fftshift",
     "slug": "fftshift",

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

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

package/dist/generated/builtins/fgetl.js

@@ -15,7 +15,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Runs entirely on the host CPU. When the file identifier lives on the GPU, RunMat gathers it before performing host I/O."
+        "notes": "Runs entirely on the host CPU. Provider-resident file identifiers are a gated RunMat extension and are gathered before host I/O."
     },
     "fusion": {
         "elementwise": false,
@@ -30,10 +30,10 @@ const builtinDoc = {
     "description": "`fgetl(fid)` reads the next line from a text file and removes trailing line terminators from the returned character row vector. End-of-file signaling and file-position behavior follow MATLAB semantics, so empty lines remain distinguishable from EOF.",
     "behaviors": [
         "`tline = fgetl(fid)` reads from the current file position to the next line terminator or to end-of-file when no terminator is found.",
-        "Line terminators are consumed but not included in the returned character row vector. RunMat recognises `\\n`, `\\r\\n`, and `\\r`.",
+        "Line terminators are consumed but not included in the returned character row vector. RunMat recognises `\\n`, `\\r\\n`, `\\n\\r`, and `\\r`; the `\\n\\r` pair is consumed as one newline sequence.",
         "When the file is empty or the file position indicator is already at end-of-file, `fgetl` returns the numeric sentinel `-1`.",
         "An empty line returns an empty character row vector, not `-1`.",
-        "Lines are decoded using the text encoding recorded by `fopen`. UTF-8, US-ASCII, ISO-8859-1 (`latin1`), Windows-1252, Shift_JIS, and binary mode are recognised without additional user work."
+        "Lines are decoded using the text encoding recorded by `fopen`."
     ],
     "examples": [
         {
@@ -111,12 +111,12 @@ const builtinDoc = {
             "input": "line = fgetl(fileID)"
         },
         "points": [
-            "`fileID` is a file handle returned by `fopen`. The file must be opened with read permission (`'r'`, `'r+'`, `'w+'`, or `'a+'`).",
+            "`fileID` is an integer-valued double file handle returned by `fopen`. Typed-integer, single-precision, and provider-resident identifiers are independently gated RunMat extensions. The file must be opened with read permission (`'r'`, `'r+'`, `'w+'`, or `'a+'`).",
             "`line` is a character row vector without the trailing line terminator. When the file position is already at end-of-file, `fgetl` returns the numeric sentinel `-1`."
         ]
     },
     "gpu_behavior": [
-        "`fgetl` is a host-only operation. File identifiers live in the host registry created by `fopen`, so GPU-resident scalar arguments are gathered back to the CPU before the read occurs."
+        "`fgetl` is a host-only operation. Provider-resident identifiers are a gated RunMat extension; when enabled, RunMat gathers the scalar before reading and returns a regular host value."
     ],
     "key": "fgetl",
     "slug": "fgetl",

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

@@ -1 +1 @@
-{"version":3,"file":"fgetl.js","sourceRoot":"","sources":["../../../src/generated/builtins/fgetl.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,OAAO;QACP,WAAW;QACX,YAAY;QACZ,SAAS;KACV;IACD,SAAS,EAAE,qEAAqE;IAChF,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,yHAAyH;KACnI;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,sCAAsC;KAC/C;IACD,aAAa,EAAE,2PAA2P;IAC1Q,WAAW,EAAE;QACX,sIAAsI;QACtI,oIAAoI;QACpI,6HAA6H;QAC7H,gEAAgE;QAChE,8LAA8L;KAC/L;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,wQAAwQ;YACjR,QAAQ,EAAE,sBAAsB;SACjC;QACD;YACE,aAAa,EAAE,0BAA0B;YACzC,OAAO,EAAE,2UAA2U;YACpV,QAAQ,EAAE,UAAU;SACrB;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,2TAA2T;YACpU,QAAQ,EAAE,8DAA8D;SACzE;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,wRAAwR;YACjS,QAAQ,EAAE,2CAA2C;SACtD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,+HAA+H;SAC1I;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,6KAA6K;SACxL;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,2GAA2G;SACtH;QACD;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,sJAAsJ;SACjK;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;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;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,yDAAyD;QAClE,KAAK,EAAE,yDAAyD;KACjE;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,QAAQ;YACvB,OAAO,EAAE,sBAAsB;SAChC;QACD,QAAQ,EAAE;YACR,iIAAiI;YACjI,qKAAqK;SACtK;KACF;IACD,cAAc,EAAE;QACd,wLAAwL;KACzL;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,IAAI;QACJ,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"fgetl.js","sourceRoot":"","sources":["../../../src/generated/builtins/fgetl.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,OAAO;IAChB,UAAU,EAAE,aAAa;IACzB,UAAU,EAAE;QACV,OAAO;QACP,WAAW;QACX,YAAY;QACZ,SAAS;KACV;IACD,SAAS,EAAE,qEAAqE;IAChF,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,kIAAkI;KAC5I;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,CAAC;QACf,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,sCAAsC;KAC/C;IACD,aAAa,EAAE,2PAA2P;IAC1Q,WAAW,EAAE;QACX,sIAAsI;QACtI,qMAAqM;QACrM,6HAA6H;QAC7H,gEAAgE;QAChE,gEAAgE;KACjE;IACD,UAAU,EAAE;QACV;YACE,aAAa,EAAE,mDAAmD;YAClE,OAAO,EAAE,wQAAwQ;YACjR,QAAQ,EAAE,sBAAsB;SACjC;QACD;YACE,aAAa,EAAE,0BAA0B;YACzC,OAAO,EAAE,2UAA2U;YACpV,QAAQ,EAAE,UAAU;SACrB;QACD;YACE,aAAa,EAAE,4CAA4C;YAC3D,OAAO,EAAE,2TAA2T;YACpU,QAAQ,EAAE,8DAA8D;SACzE;QACD;YACE,aAAa,EAAE,8CAA8C;YAC7D,OAAO,EAAE,wRAAwR;YACjS,QAAQ,EAAE,2CAA2C;SACtD;KACF;IACD,MAAM,EAAE;QACN;YACE,UAAU,EAAE,0CAA0C;YACtD,QAAQ,EAAE,+HAA+H;SAC1I;QACD;YACE,UAAU,EAAE,uCAAuC;YACnD,QAAQ,EAAE,6KAA6K;SACxL;QACD;YACE,UAAU,EAAE,gCAAgC;YAC5C,QAAQ,EAAE,2GAA2G;SACtH;QACD;YACE,UAAU,EAAE,sDAAsD;YAClE,QAAQ,EAAE,sJAAsJ;SACjK;KACF;IACD,OAAO,EAAE;QACP;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;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;QACD;YACE,OAAO,EAAE,OAAO;YAChB,KAAK,EAAE,SAAS;SACjB;QACD;YACE,OAAO,EAAE,UAAU;YACnB,KAAK,EAAE,YAAY;SACpB;KACF;IACD,QAAQ,EAAE;QACR,OAAO,EAAE,yDAAyD;QAClE,KAAK,EAAE,yDAAyD;KACjE;IACD,QAAQ,EAAE;QACR,SAAS,EAAE;YACT,aAAa,EAAE,QAAQ;YACvB,OAAO,EAAE,sBAAsB;SAChC;QACD,QAAQ,EAAE;YACR,sQAAsQ;YACtQ,qKAAqK;SACtK;KACF;IACD,cAAc,EAAE;QACd,wLAAwL;KACzL;IACD,KAAK,EAAE,OAAO;IACd,MAAM,EAAE,OAAO;IACf,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,IAAI;QACJ,UAAU;KACX;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}