Follow-up to #2113. A window loading `file://localhost/ui/index.html` was looked up as `localhost/ui/index.html`, which could match the wrong page; `localhost` and an empty host both mean this computer now. And a page reference ending in a `.` or `..` part (`./boot.js/.`) names a folder, so it is no longer matched to the file before it.
Follow-up to #2116. A result with thousands of lists at its top level was still gone through in full, though its first 64 already decide what is listed. The top level is read first and the work stops at the 64th list; nested lists are only looked for when there is room left. What is listed doesn't change.
Follow-up to #2119, which stopped a load being shown after a store that may have changed the memory it read, but still let it through in several cases: on 64-bit ARM, where the size of an access wasn't known and a 16-byte pair store looked clear of a load 8 bytes on; when a stack address had an index, or the two addresses used different segments; after an instruction the decompiler doesn't model, such as a byte store on 32-bit ARM or an x86 string operation; and for a value loaded from a fixed address. A Win64 argument passed on the stack is also no longer shown with the value stored before a later write to its slot. Where it can't tell, the decompiler now keeps the load as its own statement.
Follow-up to #2108. A column added later to a SQLite table fills older rows with its default. Two kinds of default were read as empty: a blob written with a plus sign in front (`DEFAULT+X'41'`), which #2108's splitting broke, and a bare word containing accented or other non-ASCII letters or a `$` (`DEFAULT été`, `DEFAULT a$b`). Both are read as SQLite reads them. A test table that SQLite itself would refuse to create is replaced by one it accepts.
Follow-up to #2107. Listing a result's pageable lists looked each list name up from the top of the result again, so a large result with many names took one full walk per name (about 150 ms for 5,000 names in the author's measurement, under 1 ms now). The result is walked once, recording what each name reaches first, in the same order as before. What is listed doesn't change.
Follow-up to #2114. An argument loaded from memory was written into the call that follows it, also when a store in between could have changed that memory: `ldr r0, [r4]; str r1, [r4]; puts(...)` printed `puts(*r4)`, which reads the value after the store. Such a load now stays where it is and the call is shown taking the register, unless the two places can be told apart (the same base with offsets far enough apart, or a stack slot and a fixed address). A store instruction was also recorded as setting the register it reads, which could make the store's own line disappear. And the object of a method-table call is still passed when it was saved to the stack before the call.
Follow-up to #2100. A page script written as a `data:` or `blob:` URL was read as a local path, so `data:text/javascript,0//../../boot.js` became a dependency on the app's own `boot.js`. Anything with a URL scheme is now left alone, while a local path whose query holds a URL stays local. A path written with a `./` in the middle reaches the same file as one without. A dependency's file under `node_modules/` no longer wins over the app's own file of the same name. These lookups now use one index built once per app, where each used to scan every file.
Settings ends with an About tab that shows "Craft Anything" and its version on every system, not
only in macOS's menu bar. A Copy the version button, which the keyboard reaches, copies it. "About"
and "Copy the version" are in all 16 catalogs. The roadmap ticks the item and adds an open line:
Settings doesn't fit a small window at high zoom.
Closes#1300.
Only STR lifted as a store, so the other plain stores recorded the stored register as written, which dropped it from entry-block parameters and other dataflow. Their kind is unchanged.
Follow-up to #2105. While the rebuild ledger was being built, the same piece of evidence was looked up several times. A check result saved in between could fail the first lookup and pass a later one, which left an entry marked proven with no result behind it. Each piece of evidence is now looked up once per build, and an entry is proven only when a passing check's result was actually selected. Two checks that tie no longer give a different explanation depending on the order they were recorded in.
A memory-indirect call's base assigned in the block stays an argument after an earlier read of it. A folded load stays in place when a store before the call may overwrite what it read. A store's source register is no longer recorded as an assignment, which folded the store's statement away.
HTML refs lose interior tabs and newlines before the scheme check, file: is stripped case-insensitively, and a path ending in / resolves to no file in resolve_path or a modulepreload.
A unary plus before X'..' keeps the blob, as SQLite drops the plus. Bare default words take non-ASCII characters and a later dollar sign, as SQLite identifiers do. The comment-after-e fixture uses 0x1e--, which SQLite creates.
Follow-up to #2096 and #2084. A call through a table reached from a register (`mov rdi, obj; call [rdi + 16]`) is usually a method call on that object, with the object as its first argument; since #2096 the pseudo-C showed it with no arguments. The register is passed by name again and its assignment stays visible. A jump to an imported function through its slot (`jmp [slot]`, `ldr pc, …`) is a tail call: it now shows the arguments set up before it and is listed among the function's calls, where it read `return puts();`. And a 32-bit ARM store relative to the program counter keeps its fixed address.
result_lists looked each array name up from the root. It now builds the first match for every name once, in find_result_key's order, and keeps the level-order cap.
Follow-up to #2104. `craft-anything-cli uninstall` named the app whose config blocked it and nothing more; it now prints the reason and what to do. The advice also fits the problem: a folder where the config file should be is called that (Windows reports it as "access denied", which sent people to check permissions), only a real permission error points at permissions, and a config that is badly encoded or malformed is to be backed up and fixed where it is, since moving it aside would also take the other servers it lists out of use. Setup, doctor and uninstall share the wording.
Spaced HTML refs are classified as a browser reads them, only a whole node_modules directory segment marks dependency code, and remote loadURL targets stay URL nodes.
A memory-indirect call's base argument register is passed by name, valid A32 PC-relative stores keep their static address without becoming literal references, and import tail calls through ldr pc or jmp [slot] pass their register arguments and are recorded in Pseudo.calls.
data: HTML refs no longer resolve to local files, equivalent tail spellings reach the same file, node_modules listing entries never win a tail, and tails come from one index per analysis.
SQLite accepts a `CREATE TABLE` with no spaces between its parts, and reading one went wrong in three ways. A constraint written straight after a type (`REAL(8)CHECK(...)`) became part of the type, which changed how the column's values were read (REAL as INTEGER, BLOB as TEXT). A quoted type straight after a column name (`id"INTEGER" PRIMARY KEY`) became part of the name, so the column wasn't seen as the row's key. And `DEFAULT-5`, `STRICT;` or `WITHOUT ROWID;` weren't recognised. Names, types and clauses are now split wherever SQLite splits them, and only its five whitespace characters count as space.
A result that starts to verify mid-build can no longer prove a row with no selected result, proven needs a selected verifier result, and tied verifiers report the same gap in either order.
A tool's result says which of its lists can be paged through, up to 64 of them. Names were gathered depth first and counted before checking that each really led to a list, so 64 names that turned out to be counts, or the sub-lists of one nested object, could use up the limit and leave a real top-level list unlisted. A name now counts only when it leads to a list, and each level of the result is gone through before the one below it.
The ledger of what a rebuilt JavaScript app must do names, for each entry, the place in the app's map it came from. For storage uses, requests with no method and native modules listed as files, that name didn't match any node in the map, so those entries led nowhere; they now use the map's own ids. The same entry could also be listed twice, and no longer is. And when one owner in the rebuild had several records for an entry, only the first was read: test cases in the later ones were lost, and a failed check after a passing one went unnoticed. All of an owner's records are now read together, and one failed check is enough to mark the entry disproved.
Follow-up to #2087. In a `.gitignore` pattern such as `a/**\/b.js`, the slash after `**` is written with a backslash, and `**` was then read as a single `*`, so `a/x/y/b.js` wasn't ignored. `**` followed by an escaped slash now crosses folders as git reads it, and still needs at least one folder in between.
A folder at the config path gets folder advice instead of permissions, other I/O errors keep their text, and malformed or non-UTF-8 configs are fixed where they are. The CLI prints each uninstall blocker's reason and remediation.
Follow-up to #2093. A conversion to `List<IntPtr>` or `List<UIntPtr>` is to the built-in `nint` or `nuint`, but when the program also imported a type of its own named `nint`, the conversion could be matched to that one. A name that was read as a built-in now matches only the built-in.
When uninstall couldn't safely take our entry out of another app's config file, it reported the wording of setup: "Can't add our entry…" and "run setup again". It now says what it found (the file can't be read, isn't valid, or our entry can't be removed in place) and what to do, ending in "run uninstall again". A config file that isn't UTF-8 text is also reported as that, with "save it as UTF-8", in setup, doctor and uninstall, where it used to say to check the file's permissions.
Follow-up to #2097. A path written in code, such as a preload of `bridge.js`, was matched to a `bridge.ts` beside the code before a file really named `bridge.js` elsewhere in the app was looked for, and two files of that name no longer counted as ambiguous; the exact name is looked for first again. A path with `?v=2` or `#part` after it is found without them. A page's `<script src="//cdn.example/boot.js">` is an address on another site and is no longer joined into a local path, and a page script that can't be found is listed as unresolved, not as a package.
* Claim Simple / Advanced and Clean room / Deep on the Make screen (R2.9)
* Offer Simple / Advanced on the Make screen, and always show Clean room / Deep there (R2.9)
Simple mode's title bar leaves the mode switch out, so someone starting on
New project never saw that Advanced exists. The ways in now end with a
Simple / Advanced switch (on a line of its own when the window is too
narrow), using set_mode like Settings and the title bar; switching from
there stays on New project instead of opening the workbench, so the draft
stays in view.
The Clean room / Deep tiles appeared only once an original was picked. They
are now always in view: with nothing to recreate they are dimmed, can't be
picked, and say the choice applies once there is something to recreate.
Choice tiles report whether they are enabled to accessibility.
* Put back this PR's roadmap line, dropped by a merge of main, worded as review asked (R2.9)
A merge of main made in GitHub's conflict editor dropped the R2.9 line this
PR ticks. It's back, now saying Simple's title bar had no mode switch (only
Settings had one) rather than that Simple hid it everywhere but Settings.
* Describe #1286's two new tests in doc comments (R2.9)
* Measure the room Make's Simple / Advanced switch needs instead of assuming 240 points (R2.9)
Review of #1286: the row beside the ways in fitted the switch by a fixed 240-point width, set
for English. It's now measured from the switch and its name in the language shown
(widgets::segmented_width, from main's design system), so a longer translation moves the switch
under the ways in sooner. The narrow-window test also sweeps five window widths and checks the
switch and its name never overlap the ways in and stay inside the window.
The walk kept only as many names of a folder as its entry limit allowed, but read the folder to its end to pick the first names in order: 100,000 entries read for a limit of 2. Entries that failed to read were skipped in silence, and 64 failures in a row came back as an empty folder listed in full.
- A folder is read at most as far as the remaining entry limit, and one entry more that says the folder holds more; a name over the path-byte limit ends it the same way. Cancel is checked before every read.
- A cut listing holds the entries the system returned first, sorted by name; the comments and the roadmap no longer promise the same cut every time.
- Entries that couldn't be read mark the walk as cut short and put their folder in `unlisted` with a count and the first reason ("." for the root).
In a TypeScript project that hasn't been built, `import "./util.js"` means the file `util.ts`: the import names what the file will be called after building. Mapping such a folder left those imports unresolved, so the app's modules looked unconnected. An import or preload path ending in `.js`, `.mjs`, `.cjs` or `.jsx` now falls back to the TypeScript file beside it when no file of that exact name exists, and `.mts`/`.cts` files and more kinds of `index` file are found. The declaration files `.d.mts` and `.d.cts` are no longer taken for code, as `.d.ts` already wasn't.
Follow-up to #2083, which stopped an unawaited `import("x")` being taken for the module itself. Bundled code often writes the awaited form as `await (0, import("x"))`, and that shape was no longer recognised, so calls on the module it loads weren't recorded. An awaited comma sequence that ends in a dynamic import is the module again; the same sequence without `await` still isn't.
A call through a register (`blx r3`, `call rcx`, `call [rdi + 16]`) reads that register to find its target. The pseudo-C treated the register's assignment as an argument being set up: it removed the statement and passed the function's address as a parameter, so `r3 = table[2]; (*r3)(1, 2)` came out as `(*r3)(1, 2, r2, table[2])`. An assignment the call itself reads is now kept as a statement and isn't folded into the arguments.