runmat 0.6.1-dev.1 → 0.6.2-dev.0

package/dist/generated/builtins/fgets.js

@@ -15,7 +15,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Runs entirely on the host CPU. When arguments live on the GPU, RunMat gathers them before performing host I/O."
+        "notes": "Runs entirely on the host CPU. Provider-resident arguments are gated RunMat extensions and are gathered before host I/O."
     },
     "fusion": {
         "elementwise": false,
@@ -27,13 +27,13 @@ const builtinDoc = {
     "tested": {
         "unit": "builtins::io::filetext::fgets::tests"
     },
-    "description": "`fgets(fid)` reads the next line from a text file and preserves any trailing newline characters in the returned text. Optional length limits, terminator behavior, and EOF handling follow MATLAB semantics.",
+    "description": "`fgets(fid)` reads the next line from a text file and preserves trailing newline characters in the returned text. The optional `nchar` limit caps the number of characters returned.",
     "behaviors": [
         "`tline = fgets(fid)` reads from the current position to the next newline (including the newline) or to end-of-file when no terminator is found. The result is a character row vector with MATLAB's column-major semantics.",
-        "`tline = fgets(fid, nchar)` limits the read to at most `nchar-1` characters (with `nchar` rounded toward zero), matching MATLAB. The call stops early if a newline is encountered before the limit. When the newline appears beyond the limit, the delimiter is left unread for the next call.",
-        "`[tline, ltout] = fgets(___)` additionally returns the line terminators as a row vector of doubles. For Windows newlines (`\\r\\n`) the second output is `[13 10]`, for Unix newlines (`\\n`) it is `10`, and it is empty when the line has no terminator.",
-        "When the file is empty or the file position indicator is already at end-of-file, `tline` (and `ltout`, if requested) return `-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."
+        "`tline = fgets(fid, nchar)` limits the read to at most `nchar` characters. The call stops early if a newline is encountered before the limit, and content beyond the limit remains unread for the next call.",
+        "`[tline, ltout] = fgets(___)` additionally reports the line terminator integer code or codes, if any.",
+        "When no characters can be read because the file position is already at end-of-file, `tline` returns the double sentinel `-1`.",
+        "Lines are decoded using the text encoding recorded by `fopen`."
     ],
     "examples": [
         {
@@ -44,17 +44,17 @@ const builtinDoc = {
         {
             "description": "Limit the number of characters returned",
             "input": "fname = tempname;\nfid = fopen(fname, 'w');\nfprintf(fid, 'Example line\\n');\nfclose(fid);\n\nfid = fopen(fname, 'r');\nsnippet = fgets(fid, 5);\nfclose(fid);\ndelete(fname);\n\nsnippet\ndouble(snippet)",
-            "output": "snippet =\n    'Exam'\nans =\n    69   120    97   109"
+            "output": "snippet =\n    'Examp'\nans =\n    69   120    97   109   112"
         },
         {
-            "description": "Retrieve line terminators separately",
-            "input": "fname = tempname;\nfid = fopen(fname, 'w');\nfprintf(fid, 'Windows line\\r\\n');\nfclose(fid);\n\nfid = fopen(fname, 'r');\n[line, ltout] = fgets(fid);\nfclose(fid);\ndelete(fname);\n\ncontent = line(1:end-numel(ltout));\nterminators = double(ltout);\n\ncontent\nterminators",
-            "output": "content =\n    'Windows line'\nterminators =\n    13    10"
+            "description": "Retrieve a line terminator separately",
+            "input": "fname = tempname;\nfid = fopen(fname, 'w');\nfprintf(fid, 'Line\\n');\nfclose(fid);\n\nfid = fopen(fname, 'r');\n[line, ltout] = fgets(fid);\nfclose(fid);\ndelete(fname);\n\nline\nltout",
+            "output": "line =\n    'Line\n     '\nltout =\n    10"
         },
         {
             "description": "Handle lines without a trailing newline",
-            "input": "fname = tempname;\nfid = fopen(fname, 'w');\nfprintf(fid, 'last line');\nfclose(fid);\n\nfid = fopen(fname, 'r');\n[line1, lt1] = fgets(fid);\nline2 = fgets(fid);\nfclose(fid);\ndelete(fname);\n\nline1\nlt1\nline2",
-            "output": "line1 =\n    'last line'\nlt1 =\n     []\nline2 =\n    -1"
+            "input": "fname = tempname;\nfid = fopen(fname, 'w');\nfprintf(fid, 'last line');\nfclose(fid);\n\nfid = fopen(fname, 'r');\nline1 = fgets(fid);\nline2 = fgets(fid);\nfclose(fid);\ndelete(fname);\n\nline1\nline2",
+            "output": "line1 =\n    'last line'\nline2 =\n    -1"
         },
         {
             "description": "Detect end of file using the return value",
@@ -70,7 +70,7 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "What does `fgets` return at end-of-file?",
-            "answer": "When no characters can be read because the file position indicator is at end-of-file, `fgets` returns the numeric value `-1`. If you request two outputs, `ltout` is also `-1` in this case."
+            "answer": "When no characters can be read because the file position indicator is at end-of-file, `fgets` returns the double value `-1` for `tline`."
         },
         {
             "question": "Does `fgets` strip newline characters?",
@@ -78,15 +78,15 @@ const builtinDoc = {
         },
         {
             "question": "How do I interpret the second output `ltout`?",
-            "answer": "`ltout` contains the numeric codes for the terminators that ended the line. Use `char(ltout)` or `double(ltout)` to inspect them. On Windows you typically see `[13 10]`, on Unix-like platforms `10`, `[]` when the line has no terminator, and `-1` when end-of-file is reached."
+            "answer": "`ltout` reports the integer code or codes for the terminator that ended the line. The precise container behavior for every multi-character and no-terminator boundary is not claimed here."
         },
         {
             "question": "What happens if I specify an `nchar` limit?",
-            "answer": "RunMat reads at most `nchar-1` characters (MATLAB-compatible). If the newline characters appear before reaching the limit, they are included in the output. If the limit is reached first, the newline remains unread and `ltout` is empty."
+            "answer": "RunMat reads at most `nchar` characters. If a newline is encountered first, the read stops there; otherwise content beyond the limit remains unread for the next call."
         },
         {
             "question": "Which encodings are supported?",
-            "answer": "`fgets` honours the encoding recorded by `fopen`. UTF-8, US-ASCII, Latin-1 (ISO-8859-1), Windows-1252, Shift_JIS, and binary mode are recognised. On most Unix-like systems the `system` encoding resolves to UTF-8; on Windows it defaults to Windows-1252."
+            "answer": "`fgets` decodes the line using the encoding recorded by `fopen`."
         },
         {
             "question": "How does `fgets` differ from `fgetl`?",
@@ -106,7 +106,7 @@ const builtinDoc = {
         },
         {
             "question": "How do I reliably detect end-of-file with `fgets`?",
-            "answer": "Compare the return value to `-1` (`if line == -1`) or query `feof(fid)` before the next read. Do not use `ischar(line)`, because MATLAB's implicit numeric-to-char rules can report `true` for the sentinel value on some inputs."
+            "answer": "Test `ischar(line)` or compare the return value to `-1`. A successful line read returns a character vector, while an EOF read with no characters available returns the double sentinel `-1`."
         }
     ],
     "links": [
@@ -161,14 +161,14 @@ const builtinDoc = {
             "input": "line = fgets(fileID)\nline = fgets(fileID, nchar)\n[line, ltout] = fgets(___)"
         },
         "points": [
-            "`fileID` is a file handle returned by `fopen`. The file must be opened with read permission (`'r'`, `'r+'`, `'w+'`, or `'a+'`).",
-            "`nchar` is an optional positive integer that caps the read at `nchar - 1` characters. The call still stops early when a newline is encountered first.",
+            "`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+'`).",
+            "`nchar` is an optional non-negative integer-valued double that caps the read at `nchar` characters. Typed-integer, single-precision, and provider-resident limits are independently gated RunMat extensions. The call still stops early when a newline is encountered first.",
             "`line` is a character row vector **including** any trailing newline (`\\n` or `\\r\\n`). When the file position is already at end-of-file, `fgets` returns the numeric sentinel `-1`.",
-            "The optional second output `ltout` reports the line terminator as a row of numeric codes (`10` for `\\n`, `[13 10]` for `\\r\\n`, `[]` when the line has no terminator, and `-1` at end-of-file)."
+            "The optional second output `ltout` reports the line terminator integer code or codes, if any."
         ]
     },
     "gpu_behavior": [
-        "`fgets` is a host-only operation. File identifiers live in the host registry created by `fopen`, so arguments that arrive as GPU-resident scalars are gathered back to the CPU before the read occurs. The returned line and optional terminator vector are regular host values; no GPU residency is tracked."
+        "`fgets` is a host-only operation. Provider-resident arguments are gated RunMat extensions; when enabled, RunMat gathers them before reading and returns regular host values."
     ],
     "key": "fgets",
     "slug": "fgets",

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

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

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

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

package/dist/generated/builtins/fieldnames.js

@@ -6,13 +6,13 @@ const builtinDoc = {
     "keywords": [
         "fieldnames",
         "struct",
-        "introspection",
         "struct array",
+        "introspection",
         "object",
         "handle",
         "properties"
     ],
-    "summary": "List struct or object field names in MATLAB and RunMat.",
+    "summary": "List struct field names, with gated RunMat object introspection.",
     "gpu_support": {
         "elementwise": false,
         "reduction": false,
@@ -29,16 +29,17 @@ const builtinDoc = {
     "requires_feature": null,
     "tested": {
         "unit": "builtins::structs::core::fieldnames::tests",
-        "integration": "builtins::structs::core::fieldnames::tests::fieldnames_struct_array_collects_union"
+        "integration": "builtins::structs::core::fieldnames::tests::fieldnames_collects_fields_from_cell_backed_struct_arrays"
     },
-    "description": "`fieldnames(S)` returns a column cell array of character vectors containing field names defined on `S`. Struct arrays return the union of field names across elements, and object/property handling follows MATLAB semantics with deterministic, case-sensitive output.",
+    "description": "`fieldnames(S)` returns a column cell array of character vectors containing the fields stored on a structure. Scalar structures preserve field insertion order. RunMat currently represents structure arrays with cell-backed storage; `fieldnames` accepts that representation when every element is a scalar structure and returns the sorted union of represented fields. RunMat object-family introspection is available only in RunMat extension mode.",
     "behaviors": [
-        "Works with scalar structs as well as struct arrays created by `struct`, `load`, or other builtins.",
+        "Works with scalar structs and RunMat's current cell-backed struct-array representation. A nonempty cell-backed input rejects if any element is not a scalar struct.",
         "Returns a column cell array (`n × 1`) whose elements are character vectors (1 × N char arrays).",
-        "Objects (value or handle) report the union of their public, non-static class properties together with any dynamic properties stored on the instance.",
-        "For struct arrays, the union of field names across all elements is reported.",
-        "Field names are sorted alphabetically and remain case-sensitive (`name` and `Name` are distinct).",
-        "Empty structs yield an empty `0 × 1` cell array. GPU-resident field values stay on the device— `fieldnames` only inspects metadata."
+        "Scalar-struct field names preserve the structure's insertion order and remain case-sensitive (`name` and `Name` are distinct).",
+        "Cell-backed struct arrays return a deterministic, alphabetically sorted union of their represented field names.",
+        "In RunMat extension mode, value objects, handle objects, and listeners expose RunMat's currently available property metadata. This surface is not claimed as complete MATLAB object introspection.",
+        "Empty scalar structs and empty cell-backed struct arrays yield an empty `0 × 1` cell array. GPU-resident field values nested inside a struct stay on the device because `fieldnames` only inspects host metadata.",
+        "Integer, logical, floating-point, and resident numeric arrays are not applicable inputs and reject without numeric or text coercion."
     ],
     "examples": [
         {
@@ -52,12 +53,12 @@ const builtinDoc = {
             "output": "median not available"
         },
         {
-            "description": "Gathering field names from a struct array",
+            "description": "Gathering represented field names from a struct array",
             "input": "people = struct(\"name\", {\"Ada\", \"Grace\"}, \"id\", {101, 102});\nfields = fieldnames(people)",
             "output": "fields =\n    {'id'}\n    {'name'}"
         },
         {
-            "description": "Listing the properties of an object",
+            "description": "Listing represented object properties",
             "input": "% Save this class in Counter.m before running the example:\n% classdef Counter\n%     properties\n%         Value = 0\n%         Step  = 1\n%     end\n% end\nc = Counter;\nprops = fieldnames(c)",
             "output": "props =\n    {'Step'}\n    {'Value'}"
         },
@@ -75,31 +76,31 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "What does `fieldnames` return?",
-            "answer": "It returns a column cell array of character vectors for every field or property defined on the input struct, struct array, or object instance."
+            "answer": "For a scalar struct, it returns a column cell array of character vectors in stored field order. For RunMat's cell-backed struct arrays, it returns the sorted union of represented fields. RunMat extension mode also exposes the property metadata currently represented for supported object families."
         },
         {
             "question": "Are the field names sorted?",
-            "answer": "Yes. RunMat stores fields and properties in hash maps, so `fieldnames` sorts them alphabetically to produce a stable, deterministic result."
+            "answer": "Scalar-struct names preserve the order in which fields were inserted. Cell-backed struct-array names are sorted after their union is collected. RunMat object-family extensions currently use their own deterministic property ordering."
         },
         {
             "question": "Does `fieldnames` gather GPU data back to the CPU?",
             "answer": "No. The builtin only inspects host-side metadata; GPU-resident tensors or handles remain untouched."
         },
         {
-            "question": "How do struct arrays affect the result?",
-            "answer": "All struct elements are examined and the union of their field names is returned. Duplicate names are collapsed automatically."
+            "question": "Can `fieldnames` inspect struct arrays?",
+            "answer": "Yes, for RunMat's current cell-backed struct-array representation. Every nonempty element must be a scalar struct. Because this backing is shared with ordinary cell arrays, a cell containing only structs is currently interpreted as a represented struct array by `fieldnames`; a future discriminated struct-array value can remove that representation ambiguity."
         },
         {
             "question": "Does `fieldnames` work with objects and handle objects?",
-            "answer": "Yes. The builtin merges public, non-static class properties with any dynamic properties stored on the instance. Handle objects reuse the same logic even when their payloads are shared across references."
+            "answer": "Only in RunMat extension mode. The builtin merges the object property metadata currently represented by RunMat, but this is an explicit extension and not a claim of complete MATLAB object-property policy."
         },
         {
             "question": "What happens with empty structs or empty struct arrays?",
-            "answer": "The result is an empty column cell array (`0 × 1`). This matches MATLAB behaviour for empty scalars and for struct arrays that contain no elements."
+            "answer": "An empty scalar struct or empty cell-backed struct array returns an empty column cell array (`0 × 1`)."
         },
         {
             "question": "Can I use `fieldnames` on unsupported inputs?",
-            "answer": "No. Passing anything other than a struct, struct array, or object raises `fieldnames: expected struct, struct array, or object`."
+            "answer": "No. Compatibility mode accepts scalar structures and cell-backed arrays whose elements are all scalar structures. Numeric arrays and cells containing non-struct elements reject, and supported object families require RunMat extension mode."
         }
     ],
     "links": [

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

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

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

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

package/dist/generated/builtins/figure.js

@@ -9,7 +9,7 @@ const builtinDoc = {
         "graphics handle",
         "window selection"
     ],
-    "summary": "Create or select plotting figures in MATLAB and RunMat.",
+    "summary": "Create or select RunMat plotting figures.",
     "gpu_support": {
         "elementwise": false,
         "reduction": false,
@@ -25,13 +25,19 @@ const builtinDoc = {
     },
     "requires_feature": null,
     "tested": {
+        "unit": "builtins::plotting::figure::tests",
         "integration": "runmat-plot/tests/renderer_tests.rs"
     },
-    "description": "`figure` creates a new plotting figure or selects an existing one as current. With no arguments (or `'next'`) it allocates a fresh handle; passing a positive numeric handle selects that figure, creating it if needed. `figure` also accepts figure property/value pairs such as `'Name'`, `'NumberTitle'`, `'Visible'`, `'Position'`, and `'Color'`. Handle selection, creation, and property assignment behavior follow MATLAB semantics.",
+    "description": "`figure` creates a new plotting figure or selects an existing one as current. RunMat currently encodes graphics handles as host `f64` identifiers instead of MATLAB Figure objects; this is a general graphics-representation gap, not numeric MATLAB equivalence. Double numeric selection is the compatibility form, while typed-integer targets, single-precision targets, the `'next'` selector, and typed-integer property values are independently gated RunMat-only extensions.",
     "behaviors": [
-        "`figure()` creates a new figure and returns its numeric handle.",
+        "`figure()` creates a new figure and returns RunMat's current host `f64` graphics-handle encoding.",
         "`figure(n)` selects figure `n`. If that handle does not exist yet, RunMat creates it.",
-        "`figure('next')` creates a new figure instead of selecting an existing one.",
+        "In RunMat extension mode, `figure('next')` creates a new figure instead of selecting an existing one.",
+        "In RunMat extension mode, a positive scalar from any of the eight integer classes is read exactly as a figure identifier and must fit in `u32`.",
+        "In RunMat extension mode, a positive single-precision scalar can select a figure. Logical and GPU-resident numeric targets reject without provider access.",
+        "Typed-integer values for `Position`, `Color`, `NumberTitle`, `Visible`, `CurrentAxes`, and `SgTitle` are RunMat-only extensions and are rejected in compatibility mode before graphics state changes.",
+        "Integer `Position` values cross an explicit host `f64` geometry boundary only after every authoritative integer element is proved exactly representable. Integer RGB values are read authoritatively and the normal `[0,1]` constraint admits only exact zero and one components.",
+        "Integer `NumberTitle` and `Visible` values use an exact zero/nonzero predicate with no floating conversion. Integer `CurrentAxes` and `SgTitle` aliases must be exactly representable before lookup in RunMat's current `f64` graphics registry.",
         "`figure('Property', value, ...)` creates a fresh figure and applies the requested figure properties.",
         "`figure(n, 'Property', value, ...)` selects or creates figure `n` and applies the requested figure properties.",
         "`figure('Position', [left bottom width height])` stores MATLAB-style figure window geometry and makes it available through `get(f, 'Position')` and figure scene metadata.",
@@ -42,7 +48,7 @@ const builtinDoc = {
         "`'NumberTitle'` accepts logical values or MATLAB-style `'on'`/`'off'` strings.",
         "`'Visible'` accepts logical values or MATLAB-style `'on'`/`'off'` strings. Hidden figures keep their graphics state but do not open or update interactive windows until made visible again.",
         "`'Position'` accepts a finite four-element numeric vector `[left bottom width height]`; width and height must be positive.",
-        "`'Color'` and `'BackgroundColor'` accept exact MATLAB color letters, full color names such as `'black'`, or RGB triples, and update the figure background color."
+        "`'Color'` accepts supported color letters, full color names such as `'black'`, or RGB triples, and updates the figure background color."
     ],
     "examples": [
         {
@@ -51,7 +57,7 @@ const builtinDoc = {
             "output": "% f is a positive numeric figure handle"
         },
         {
-            "description": "Create another figure with the explicit 'next' selector",
+            "description": "Selecting the next available figure",
             "input": "f1 = figure();\nf2 = figure(\"next\")",
             "output": "% f2 is a different figure handle from f1"
         },
@@ -78,7 +84,7 @@ const builtinDoc = {
         },
         {
             "question": "What does `figure('next')` do?",
-            "answer": "It forces creation of a new figure rather than reusing an existing handle."
+            "answer": "In RunMat extension mode it forces creation of a new figure rather than reusing an existing handle. Compatibility mode rejects this selector before changing graphics state."
         },
         {
             "question": "Can `figure` set window properties at creation time?",
@@ -87,6 +93,18 @@ const builtinDoc = {
         {
             "question": "Does `figure` draw anything by itself?",
             "answer": "No. It only manages the active figure selection. Plotting happens when you call builtins like `plot`, `scatter`, or `surf`."
+        },
+        {
+            "question": "Why is the returned handle a double scalar?",
+            "answer": "RunMat's current graphics registry uses a host `f64` identifier. MATLAB uses Figure objects, so this representation is tracked as a general graphics-model gap rather than claimed as numeric compatibility."
+        },
+        {
+            "question": "Can integer, single, logical, or GPU-resident values select a figure?",
+            "answer": "Host scalar integers and singles are independent RunMat-only extensions. Integers are read from authoritative storage and must be positive `u32` values. Logical and resident numeric targets reject."
+        },
+        {
+            "question": "Can figure property values use typed integers?",
+            "answer": "Only in RunMat extension mode. `Position` and graphics-object aliases reject integer values that would round at an `f64` boundary, `Color` accepts only the usual zero/one integer RGB components, and `NumberTitle`/`Visible` use exact zero/nonzero tests. These gates run before figure creation, selection, or property mutation."
         }
     ],
     "links": [
@@ -127,7 +145,7 @@ const builtinDoc = {
         "label": "`crates/runmat-runtime/src/builtins/plotting/ops/figure.rs`",
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/plotting/ops/figure.rs"
     },
-    "gpu_residency": "`figure` only updates plotting state and returns a host-side numeric handle. It does not affect array residency.",
+    "gpu_residency": "`figure` only updates plotting state and returns RunMat's host-side `f64` handle encoding. Resident numeric values are not admitted as figure targets and are not gathered.",
     "gpu_behavior": [
         "`figure` performs no provider dispatch. GPU-resident arrays passed to later plotting calls may still remain on device when the renderer supports that path."
     ],

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

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

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

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

package/dist/generated/builtins/fileattrib.js

@@ -12,7 +12,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Host-side compatibility builtin; GPU-resident inputs are gathered before execution."
+        "notes": "Host-only filesystem operation. Numeric and provider-resident path/control inputs are invalid text and are rejected before gather, provider access, or filesystem mutation."
     },
     "fusion": {
         "elementwise": false,
@@ -25,11 +25,12 @@ const builtinDoc = {
         "unit": "builtins::io::repl_fs::compat::tests",
         "integration": null
     },
-    "description": "Return filesystem attribute metadata for a path.",
+    "description": "Return filesystem attribute metadata for a textual path. Numeric and integer inputs are inapplicable. RunMat currently exposes only the subset representable by the active filesystem abstraction; complete MATLAB user/group/other permission, wildcard, recursion, and setter-output semantics remain implementation gaps.",
     "behaviors": [
+        "Accepts host string scalars, scalar string arrays, and character row vectors for the path and textual controls.",
         "Reads file metadata and returns status plus an attribute struct containing Name, hidden, directory, and user/group/other permission flags.",
         "Supports common writable flag mutation with +w and -w through the active filesystem provider.",
-        "Accepts read flags as no-op compatibility forms and rejects unsupported attribute flags explicitly."
+        "The current read-flag no-op and synthesized permission fields are implementation limitations, not claims of complete MATLAB compatibility."
     ],
     "examples": [],
     "faqs": [],

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

@@ -1 +1 @@
-{"version":3,"file":"fileattrib.js","sourceRoot":"","sources":["../../../src/generated/builtins/fileattrib.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE;QACV,YAAY;KACb;IACD,SAAS,EAAE,kDAAkD;IAC7D,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,qFAAqF;KAC/F;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,sCAAsC;QAC9C,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,kDAAkD;IACjE,WAAW,EAAE;QACX,4IAA4I;QAC5I,+FAA+F;QAC/F,qGAAqG;KACtG;IACD,UAAU,EAAE,EAAE;IACd,MAAM,EAAE,EAAE;IACV,OAAO,EAAE,EAAE;IACX,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,IAAI;QACJ,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"fileattrib.js","sourceRoot":"","sources":["../../../src/generated/builtins/fileattrib.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,YAAY;IACrB,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE;QACV,YAAY;KACb;IACD,SAAS,EAAE,kDAAkD;IAC7D,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,6KAA6K;KACvL;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,sCAAsC;QAC9C,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,8TAA8T;IAC7U,WAAW,EAAE;QACX,iHAAiH;QACjH,4IAA4I;QAC5I,+FAA+F;QAC/F,4IAA4I;KAC7I;IACD,UAAU,EAAE,EAAE;IACd,MAAM,EAAE,EAAE;IACV,OAAO,EAAE,EAAE;IACX,KAAK,EAAE,YAAY;IACnB,MAAM,EAAE,YAAY;IACpB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,IAAI;QACJ,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/fileparts.js

@@ -12,7 +12,7 @@ const builtinDoc = {
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Host-side compatibility builtin; GPU-resident inputs are gathered before execution."
+        "notes": "Host-only lexical parser. Numeric and provider-resident inputs are invalid text and are rejected before gather or provider access."
     },
     "fusion": {
         "elementwise": false,
@@ -25,11 +25,11 @@ const builtinDoc = {
         "unit": "builtins::io::repl_fs::compat::tests",
         "integration": null
     },
-    "description": "Split a path into folder, base filename, and extension.",
+    "description": "Split a textual path into folder, base filename, and extension without consulting the filesystem. Numeric and integer inputs are inapplicable. RunMat currently implements the scalar character-result subset; documented string-array and cell-array type/shape preservation remains incomplete.",
     "behaviors": [
-        "Accepts MATLAB text inputs such as string scalars and character row vectors for path, name, or URL arguments where applicable.",
-        "Runs on the host using the active RunMat filesystem, environment, or HTTP abstraction as appropriate.",
-        "Reports MATLAB-style runtime errors for unsupported argument shapes or unavailable host capabilities."
+        "Accepts a string scalar, scalar string array, or character row vector.",
+        "Runs as a host-only lexical parser and does not require the path to exist.",
+        "Nonscalar string arrays, cell arrays of character vectors, type/shape-preserving output, and complete dotfile/trailing-delimiter behavior remain implementation gaps."
     ],
     "examples": [],
     "faqs": [],

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

@@ -1 +1 @@
-{"version":3,"file":"fileparts.js","sourceRoot":"","sources":["../../../src/generated/builtins/fileparts.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,WAAW;IACpB,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE;QACV,WAAW;KACZ;IACD,SAAS,EAAE,yDAAyD;IACpE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,qFAAqF;KAC/F;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,sCAAsC;QAC9C,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,yDAAyD;IACxE,WAAW,EAAE;QACX,gIAAgI;QAChI,uGAAuG;QACvG,uGAAuG;KACxG;IACD,UAAU,EAAE,EAAE;IACd,MAAM,EAAE,EAAE;IACV,OAAO,EAAE,EAAE;IACX,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,WAAW;IACnB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,IAAI;QACJ,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}
+{"version":3,"file":"fileparts.js","sourceRoot":"","sources":["../../../src/generated/builtins/fileparts.ts"],"names":[],"mappings":"AAAA,8CAA8C;AAC9C,uBAAuB;AAIvB,MAAM,UAAU,GAAe;IAC7B,OAAO,EAAE,WAAW;IACpB,UAAU,EAAE,YAAY;IACxB,UAAU,EAAE;QACV,WAAW;KACZ;IACD,SAAS,EAAE,yDAAyD;IACpE,aAAa,EAAE;QACb,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,EAAE;QAChB,cAAc,EAAE,MAAM;QACtB,OAAO,EAAE,oIAAoI;KAC9I;IACD,QAAQ,EAAE;QACR,aAAa,EAAE,KAAK;QACpB,WAAW,EAAE,KAAK;QAClB,YAAY,EAAE,IAAI;QAClB,WAAW,EAAE,QAAQ;KACtB;IACD,kBAAkB,EAAE,IAAI;IACxB,QAAQ,EAAE;QACR,MAAM,EAAE,sCAAsC;QAC9C,aAAa,EAAE,IAAI;KACpB;IACD,aAAa,EAAE,mSAAmS;IAClT,WAAW,EAAE;QACX,wEAAwE;QACxE,4EAA4E;QAC5E,uKAAuK;KACxK;IACD,UAAU,EAAE,EAAE;IACd,MAAM,EAAE,EAAE;IACV,OAAO,EAAE,EAAE;IACX,KAAK,EAAE,WAAW;IAClB,MAAM,EAAE,WAAW;IACnB,SAAS,EAAE,EAAE;IACb,cAAc,EAAE;QACd,IAAI;QACJ,SAAS;KACV;CACF,CAAC;AAEF,eAAe,UAAU,CAAC"}

package/dist/generated/builtins/fileread.js

@@ -10,13 +10,13 @@ const builtinDoc = {
         "text file",
         "character vector"
     ],
-    "summary": "Read full text files into character vectors in MATLAB and RunMat.",
+    "summary": "Read a full text file into a character vector.",
     "gpu_support": {
         "elementwise": false,
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Runs entirely on the host CPU. When the file path lives on the GPU, RunMat gathers it first; the file contents remain host-resident."
+        "notes": "Runs entirely on the host CPU. Numeric and provider-resident filename/Encoding inputs are invalid text and are rejected before gather, provider access, or filesystem reads."
     },
     "fusion": {
         "elementwise": false,
@@ -29,11 +29,11 @@ const builtinDoc = {
         "unit": "builtins::io::filetext::fileread::tests",
         "integration": "builtins::io::filetext::fileread::tests::fileread_reads_text_file"
     },
-    "description": "`fileread(filename)` loads an entire text file into memory and returns a 1-by-N character row vector. Newlines and byte content are preserved in the returned text, with path and encoding behavior matching MATLAB semantics.",
+    "description": "`fileread(filename)` loads an entire text file into memory and returns a 1-by-N character row vector. The documented filename and `Encoding` roles are textual, so numeric and integer inputs are inapplicable. RunMat currently supports local filesystem paths and a bounded encoding set; MATLAB search-path, URL, remote-filesystem, home-expansion, and broader encoding behavior are not yet fully implemented.",
     "behaviors": [
         "Accepts paths provided as character vectors or string scalars. String arrays must contain exactly one element.",
         "Supports an optional encoding argument: `fileread(filename, encoding)` or `fileread(filename, 'Encoding', encoding)`. Recognised values include `auto` (default), `utf-8`, `ascii`, `latin1`, and `raw`.",
-        "Resolves relative paths with respect to the current working directory of the RunMat process, just like MATLAB.",
+        "Resolves relative paths with respect to the current working directory of the RunMat process. Bare-name MATLAB search-path lookup is not yet implemented.",
         "Returns a `1×N` character array. Empty files yield a `1×0` character vector.",
         "Leaves line endings untouched (`\\r`, `\\n`, or `\\r\\n`) so scripts can inspect original formatting.",
         "When `auto` decoding detects invalid UTF-8 sequences, RunMat maps each byte to the corresponding extended-ASCII code point so that callers can recover the raw data.",
@@ -74,7 +74,7 @@ const builtinDoc = {
     "faqs": [
         {
             "question": "What does `fileread` return?",
-            "answer": "It returns a `1×N` character vector containing every byte from the file. Convert it to a string with `string(...)` when you prefer string scalars."
+            "answer": "It returns a `1×N` character vector containing decoded file text. Convert it to a string with `string(...)` when you prefer string scalars."
         },
         {
             "question": "Does `fileread` change line endings?",
@@ -82,7 +82,7 @@ const builtinDoc = {
         },
         {
             "question": "Can `fileread` read binary data?",
-            "answer": "While designed for text, `fileread` will happily return any bytes. The result is a character vector whose numeric codes match the file's bytes."
+            "answer": "The RunMat-only `raw` encoding alias maps each byte to one character code. The MATLAB-compatible contract is text-oriented."
         },
         {
             "question": "How are encodings handled?",
@@ -148,7 +148,7 @@ const builtinDoc = {
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/filetext/fileread.rs"
     },
     "gpu_behavior": [
-        "`fileread` performs synchronous host I/O and never dispatches GPU work. If the provided file name lives on the GPU (for example, produced by a GPU array that was gathered lazily), RunMat gathers that scalar first. File contents are returned as an ordinary character array that resides on the CPU. Providers do not need to implement any hooks for this builtin."
+        "`fileread` performs host I/O and never dispatches GPU work. Provider-resident inputs are rejected before provider access, and file contents are returned as an ordinary host character array."
     ],
     "key": "fileread",
     "slug": "fileread",

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

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

package/dist/generated/builtins/filewrite.js

@@ -11,13 +11,13 @@ const builtinDoc = {
         "append",
         "encoding"
     ],
-    "summary": "Write text or raw bytes to files in MATLAB and RunMat.",
+    "summary": "Write text or raw bytes with RunMat's native file-writing extension.",
     "gpu_support": {
         "elementwise": false,
         "reduction": false,
         "precisions": [],
         "broadcasting": "none",
-        "notes": "Executes entirely on the host CPU. When either the file path or data reside on the GPU they are gathered before the write; providers are not involved."
+        "notes": "Executes file I/O on the host CPU. Provider-resident numeric data is gathered through its owning provider before the write; no specialized filewrite provider hook or kernel is required."
     },
     "fusion": {
         "elementwise": false,
@@ -30,15 +30,15 @@ const builtinDoc = {
         "unit": "builtins::io::filetext::filewrite::tests",
         "integration": "builtins::io::filetext::filewrite::tests::filewrite_writes_text_content"
     },
-    "description": "`filewrite(filename, data)` writes text or raw byte content to a file and returns the number of bytes written. By default it overwrites existing content; use `'WriteMode','append'` to append. Encoding options and input coercions follow MATLAB semantics.",
+    "description": "`filewrite(filename, data)` is a RunMat-native extension that writes text or raw byte content to a file and returns the number of bytes written. MATLAB does not provide a `filewrite` builtin; MATLAB-compatible mode therefore rejects this API before gathering data or modifying the filesystem. Enable RunMat extensions to use it.",
     "behaviors": [
         "Accepts file names supplied as character vectors, string scalars, or scalar string arrays.",
-        "Accepts data supplied as character vectors, string scalars, string arrays, or numeric arrays of bytes (`uint8`/`double` values in the range 0–255). Logical arrays map to bytes `0` and `1`.",
+        "Accepts data supplied as character vectors, string scalars, string arrays, or numeric arrays of bytes. All eight integer classes (`int8`, `int16`, `int32`, `int64`, `uint8`, `uint16`, `uint32`, and `uint64`) are read exactly and must lie in the range 0–255; double inputs use the existing integral-byte validation in that range, and logical arrays map to bytes `0` and `1`.",
         "By default the file is truncated (overwrite mode). Pass `'WriteMode','append'` to add to an existing file.",
         "Encoding is optional. Provide either a positional encoding argument or the `'Encoding', value` keyword pair. Supported encodings mirror `fileread`: `auto` (default), `utf-8`, `ascii`, `latin1`, and `raw`.",
         "When writing text data with `filewrite` and `Encoding` set to `ascii` or `latin1`, an error is raised if any characters fall outside the permitted code page.",
         "When writing raw numeric bytes, encoding is ignored except to validate ASCII requests.",
-        "Returns the number of bytes written as a double scalar. Ignoring the output behaves like MATLAB (data is still written)."
+        "Returns the number of bytes written as a double scalar."
     ],
     "examples": [
         {
@@ -79,7 +79,7 @@ const builtinDoc = {
         },
         {
             "question": "How are string arrays written?",
-            "answer": "Each element of the string array is written sequentially (column-major order), separated by newline characters. This mirrors MATLAB’s `filewrite` behaviour and matches what most users expect when exporting string arrays."
+            "answer": "Each element of the string array is written sequentially in column-major order, separated by newline characters. This is RunMat-native behavior."
         },
         {
             "question": "Does `filewrite` add a newline automatically?",
@@ -145,7 +145,7 @@ const builtinDoc = {
         "url": "https://github.com/runmat-org/runmat/blob/main/crates/runmat-runtime/src/builtins/io/filetext/filewrite.rs"
     },
     "gpu_behavior": [
-        "`filewrite` performs synchronous host file I/O. If either the path or data reside on the GPU (for example through lazy residency), RunMat gathers those values before performing the write. No GPU kernels are launched and providers do not need to implement specialised hooks for this builtin."
+        "`filewrite` performs synchronous host file I/O. Provider-resident numeric data is gathered before writing. No GPU kernels are launched and providers do not need to implement specialised hooks for this RunMat-native builtin."
     ],
     "key": "filewrite",
     "slug": "filewrite",