Skip to content

Merge every open view branch and check them as one - #114

Merged
ww-mw merged 221 commits into
mainfrom
integration/all
Nov 9, 2026
Merged

ww-mw merged 221 commits into
mainfrom
integration/all

Conversation

@ww-mw

@ww-mw ww-mw commented Nov 7, 2026

Copy link
Copy Markdown
Member

Every open view branch merged and checked together: shell/parity (#105), open-at (#106), the Folder view (#107), the command line's model (#108), the hierarchy and menu fixes (#109, #110), share links (#111), the MATLAB shell (#112) and compare (#113). It's the commit the desktop app pins to check everything as one (ww-mw/data-explorer-app #44). Merge it after those PRs, when its diff shrinks to the merge resolutions, or in their place.

Merge resolutions

  • cli/model: only dist/ conflicted (compareRows.js on both sides). Rebuilt, and the build matched compare's file.
  • fix/menu-and-ink: dex-tree-table.ts's styles keep compare's diff-mark block, then the hovered row's 78% muted ink. compare's first-height (ResizeObserver), gap rows, _entryCount and the focus ring come through unchanged.
  • matlab/shell:
    • ShellCommand lists compare's three commands, then the seven matlab-*.
    • The Explorer's file menu has Compare With… and, with a MATLAB connected, its commands after Close.
    • A row's menu: Copy Link to Entry, Show in Graph, then the MATLAB items.
    • The status bar's MATLAB button comes before a comparison's kind.
    • The palette adds the MATLAB group on top of compare's commands. A compare tab offers no MATLAB command, since it has no file.
    • README: the ShellHost table lists all 23 members once, checked against the interface by script.
  • Test changes:
    • three matlab.test file-menu expectations now include Compare With…;
    • one new statusBar test: the MATLAB button before a comparison's kind;
    • typedApi counts 65 events from 36 widgets.

Checks

  • npm run verify passes: 7441 tests, plus check:leak. The build reproduces dist/.
  • check:api shows additions only, apart from the two known "type changed" lines from Bring the app shell level with the app it is modelled on #105: optional parameters on buildPropertyGroups and <dex-context-menu>.show().
  • Gallery: 317 tests in Chromium, Firefox, WebKit and the dev server, headless.
  • The VS Code extension's unit tests (564) and typecheck pass against this build.

ww-mw added 30 commits November 6, 2026 04:49
…ar and the bars

The prototype drew its toolbar, its Back/Forward/Up and its activity bars as
single-colour glyphs; the shell drew every icon in its file's colours. A
<dex-icon mono> now draws the same file in the element's currentColor: an SVG
<image> of it through a filter that keeps the strokes and dark shapes as ink
and drops the light fills. It follows the theme and forced colours with no
dark-set filter, and no second icon set ships.

Not a CSS mask: a mask image is fetched in CORS mode, which a file:// page
(the Electron app's) is refused, so every icon vanished there, and an alpha
mask filled each white tile solid. The <image> loads as an <img> does, under
img-src 'self'.

<dex-toolbar>, <dex-location-bar> (its three buttons, not the segments) and
<dex-app-shell> (the activity bars' and the status bar's buttons) gain a
reflected mono property, off by default, so a page that does not set it
draws as before.
…olbar's labels kept

ShellSettings gains iconStyle (minimal, the prototype's default, or colorful)
and tableStyle (grid, the table's own default, or rows). A record an earlier
version kept, with the theme and the toolbar alone, reads back on the new
defaults. The popover's rows are Theme (Auto now first), Toolbar, Icons and
Table, and the compact toolbar's tooltip no longer says "Icons alone": its
labels stay, beside smaller icons.

connectShell applies them: Minimal sets mono on the toolbar, the location bar
and the shell, and the table style goes to every open table and to each one
it makes later (Rows is the tree table's light style), the banner table of a
file that could not be read included.

docs/widgets/settings-panel.md's generated half prints ShellSettings from the
source; the next build writes it.
…ok disabled

The cut icon is a tile drawn in light greys with a dotted cut line, and
beside Copy's solid tile an enabled Cut read as a disabled one in the
colourful style. The toolbar's Cut now draws scissorToolUI, the MathWorks
set's scissors in the dark grey of the other enabled glyphs, in both icon
styles. The table's context menu keeps the cut icon, so the menu is as it
was.

src/widgets/icon-assets/assets.ts and dist/ name the new icon once the next
build writes them.
… glyphs

The review's minors. The ink filter's comment names the two colours the
icons draw between the bands, the gear's middle disc (#A6A6A6, half ink) and
Delete's red tile (#FF9D9A, a faint fill), and the test pins both. mono's
doc and the icon page say each mono icon runs a filter of its own, so it is
for the handful of glyphs an app's chrome draws, not a long list, and that a
missing file draws nothing in mono where the <img> draws a broken image. The
dark-filter test also holds the host free of --dex-icon-filter. The prose
added to the README, the Settings page and the Settings test is rewrapped.
… its Usage

A JSON dictionary's edit paints its entry at once, writes the text, and on the
text's change repaints the entry once its Usage column is filled. With a usage
source that fill is awaited, so an undo pressed straight after the edit (which
repaints the entry at once) landed first, and the echo's older rows then came
in over it: the table showed the edited value while the text, and every save,
held the undone one.

A narrow repaint that waited on the Usage column is now dropped when a newer
paint of the same entry, or a wide repaint, went out meanwhile. The race was
there with a folder shown, and in the VS Code extension's dictionary editor,
which runs the same engine with its usage graph; the shell met it on every
dictionary once the open tabs fill the column.
With only files open (dropped, or picked one by one), a dictionary's or a
MAT-file's table hid its Usage column, and a model's blocks named no source
file: the column was answered only by a shown folder's usage graphs. The
prototype answered it from its open files.

The shell's workspace now takes a usage source over the open tabs
(createOpenFilesUsage): the same UsageGraphs a folder session gives, over the
bytes each tab holds as last read or saved, so a dictionary's entries name the
blocks of the open models that read them, and a model's parameters resolve to
an open dictionary by its uri (unresolved until it is open, as a folder
without the dictionary answers). A tab opened, closed, saved or reloaded
repaints, once the burst is over, each table whose column was answered over
other tabs than are open now. A folder shown still wins: its session fills
the column from then on, and a file outside it shows none, as before.

An editable .slx now repaints when a usage source comes later (setUsage), as
the read-only model and the data files did; its refill did nothing before.
…each is

The Search view matched entry names alone, as a substring, in alphabetical
order, and its rows did not say what an entry is. The prototype ranked its
open files' entries by name, value and data type, a prefix before a
substring before a fuzzy match, and showed the type.

searchRanked does that: each field by its strongest match (a prefix, a
substring, or for the name its letters in order), the strength first, then
the name before the value before the type, and where an entry is (a block's
path, its file's name) last, as a substring, as before; the cap applies after
the ranking, so a broad query keeps its best matches. The open files' records
carry their rows' Value, Data Type and Class cells (namesOfRows with
`cells`); a folder's index reads names alone, so its entries rank by name.
Each row ends with the entry's class, else its data type (SearchItem's
`type`), as the prototype showed it.

The extension's search is untouched: searchEntries keeps its rule and order,
namesOfRows its records without `cells`, and a record with no cells makes the
item it always did. The folder part's own search box still uses searchEntries.
…iable's value for json

`add Parameter x` was refused: the window took a class only by its full name
(Simulink.Parameter), in any case. It now takes the last part of the dotted
name too, as the prototype did, and where two classes end in it asks which.

`json` on a MAT-file's variable, or a Model Workspace's, printed only how many
bytes it holds, since its raw form is the bytes it was read from (the Raw
pane's dump). It now asks for the record (TableSource.raw's new `record`
option), the JSON a save writes and the prototype printed, and gets it for a
variable of up to HEX_LIMIT bytes; a larger one, or one core will not write,
still answers its bytes. Without the option every answer is as before, and
a source across a channel has no raw at all.
…illing first

The guard against a stale narrow repaint compared with the entry's last paint
sent, so of two repaints waiting on the Usage column the older one, landing
first, won and dropped the newer. With the graph cold (fillNow cannot fill,
as the extension's is after any editor opens or closes), an edit's own
repaint and the take-back of its refused write both wait: the edit's landed
first, the take-back was dropped, and the table showed the refused value
while the text held the old one.

Each narrow repaint now takes its entry's turn as it begins, and a paint sent
at once takes one too; a repaint lands only if it still holds its entry's
latest turn and no wide repaint began since. The undo race of the last fix
still holds, and the refused edit is a test of its own.
With only a model open, a block parameter its dictionary would answer was
unresolved over the open files, so its Usage cell named no file and linked
nothing, where the file alone had linked the dictionary by name. A page of
open files is not a folder that lacks the dictionary: it is most likely
beside the model, unopened.

Over the open files only, a parameter left unresolved (not the workspace's,
not a mask's) in a model that links a dictionary now names that dictionary
as the model records it, `Value=Uo (params.sldd)`, linked `Uo@params.sldd`,
which opens it beside the model, as the prototype linked it. Once it is open
the parameter resolves to it by its uri, and a parameter the workspace
shadows still names the workspace. The folder's and the extension's graphs
are untouched: the name is the open files' cell, not the graph's. The link
tests read DictOnly's link again.
…efore its fill

RawOptions (TableSource.raw's `record`) and NamesOfRowsOptions (namesOfRows'
`cells`) are named in the model entry's signatures, so the entry exports
them as types. A document asked to repaint over the open files counts as
filled over the files of the ask, and a test now holds that: a second burst
that puts the files back as they were asks it again. connectShell says what
a Close Folder would hand back, and the Search pane's head comment is
wrapped as the rest are.
…y it

A table offered Undo and Redo wherever its document could be edited, so a
file just opened had both enabled with nothing to take back. An editable
source may now say where its stack stands: EditableTableSource.history
(EditHistory: canUndo, canRedo, and onChange when either moves). The page's
own stacks are histories (EditStack, and the JSON dictionary's text store),
the engines hand on the one they are given (a new `history` option), and
every document a workspace edits gives its table its stack's. A listener's
throw goes to the workspace's notify, never back into the edit.

Optional throughout: a source across a channel, as the VS Code extension's,
and an engine given no history (the extension's host gives none) have none,
and a table keeps offering both as before.
…enu key

Rows take no focus (the grid does, and the arrows move a cursor over it), so
the browser's own menu event for those keys reached the grid as a right-click
on no row, which a dictionary's table answers with no menu, and Chromium on
macOS sends none at all: a keyboard user had no row menu. With the new
`keyboardMenu` (attribute `keyboard-menu`), both keys on the grid send
dex-table-context-menu for the keyboard's row (the row the arrows moved to,
else the selection's last), under it and inside the grid, or for the space
under the rows when there is none. The keys are spent, the ContextMenu key's
keyup too (Windows sends the browser's event then), so no second menu event
follows. A cell editor's keys and a header filter button's stay theirs.

Off by default, so a table that does not ask (the VS Code extension's) keeps
both keys the browser's, as they were. A right-click sends what it sent.
The toolbar's Save always drew the grey floppy. As in the prototype it is now
the blue one (unsaved.svg, added from the MathWorks icon set the others come
from) while the active document holds edits its file does not, and the grey
one again once they are saved. The icon assets' generated list takes the new
file at the next build.
…gesture it ran

The editing menu's Undo and Redo, the handle's can() and run() for them (an
app's toolbar and palette) and handle.undo()/redo() follow the source's
`history` where it has one: each is offered only where there is a step, and a
greyed one says "Nothing to undo" as Paste says its clipboard is empty. A
source without one keeps both offered wherever the document may be edited,
as the VS Code extension's does. The Undo chords are still the table's, and
send nothing where there is nothing to undo.

The handle's new `ran` says each editing menu item's gesture the table handed
its source, from the menu, a chord, run() or undo()/redo(): its actionId, the
rows it carried and how many it acted on, as the item's label counts them
(entries copied or cut, items deleted, the clipboard's entries pasted). It is
told a task later, and not where the source refused it, said an error or
threw meanwhile, which a source in the page does before then: an app's
"Copied to clipboard" is said only of what was done.

The toolbar test whose Undo commits an open cell editor first makes an edit
before it, since a file just opened now has nothing to undo.
…ables the keyboard menu

As the prototype said them, the shell toasts (and logs) "Copied to
clipboard", "Cut to clipboard", "Pasted" and "Entry deleted" or "N entries
deleted" after each of those gestures, from the toolbar, a chord, the palette
or the menu alike: from the table handle's `ran`, so a gesture the document
refused or a press with nothing selected says nothing. The toolbar is drawn
again whenever the active document's undo history moves, so Undo and Redo
follow it even where no repaint does (a reload of the text a JSON dictionary
already held). The shell's tables open their row menu on Shift+F10 and the
ContextMenu key (keyboardMenu). The README says where a document's undo
stack stands, what `ran` tells, and the new keys.
…s it closes

A menu opened by Shift+F10 left the keyboard on the table's grid. The first
ArrowDown entered the menu and moved the selection too, so Enter then copied
(or deleted) the next row, and when the menu closed the focus was on the
page's body. The context menu's show() takes `focusFirst` now: the keyboard
is on the first item at once, and goes back to the element that had it,
inside a shadow root too, on Escape or a choice (before the choice is sent,
so a dialog it opens keeps the focus). A click outside leaves the focus
where it put it. The table marks a menu its keys opened (`keyboard: true` in
dex-table-context-menu's detail), and connectTable shows that one with
`focusFirst`. A right-click's menu, and every caller that does not ask, is
as it was, so the VS Code extension's tables are unchanged.

The menu keys also named a row the table no longer showed: the arrows' row
outlives a delete. They take it only while the table shows it, else the
selection's last shown row, else none. And the grid names the keys for
assistive tech (aria-keyshortcuts) where keyboardMenu is on.
…t follows the history

What the shell says of Copy, Cut, Paste and Delete (ranNote) moves out of
documents.ts into connect/editingNotes.ts, with tests of its own. The shell
test now holds the toolbar to the document's undo history where no table
change follows it (a reload of the text a JSON dictionary already held
drops its Redo), and to a keyboard-opened menu taking the keyboard and
giving it back to the grid. The editing wire's comment says that a refusal
arriving late can silence an unrelated gesture handed in the same task.
… the keyboard back however it closes

Chromium on Windows opens its own menu on the ContextMenu key's keyup unless
the keyup is spent. Now that a menu a key opened takes the keyboard during
that keydown, the keyup lands in the menu, where nothing spent it, so Chrome
and Edge on Windows would open their menu over ours. While such a menu is
open it spends that key's keyup (heard from show() on, as the keyup can come
before the menu's first frame) and any contextmenu event on it. A menu a
right-click opened leaves both to the browser, as before.

And a menu opened with focusFirst gives the keyboard back to where it was
whenever it closes holding it: Escape, a scroll, a right-click outside, or
close(), as well as a choice. A click outside still moves the focus where it
goes.
…ows that edit

A table's inspector showed one row's properties, read-only, and nothing for
no row or a section heading. A document's table now answers more where it is
asked (inspect's new options): with `pages`, the file's own page while no row
is selected (its name, kind, core's facts of it, where it is, whether it holds
edits, and the open files it references and is referenced by, as links), a
section heading's (its entries counted by type), and "N selected" for several
rows; with `editable`, a row's properties editable where core offers an
editor of them, keyed by the property an edit names, a choice listing its
options and a description its lines. Every document answers through one rule
(inspectTree), as the Raw pane's do through rawOfRow.

connectTable asks for them with two new options, `inspectorPages` (which also
adds a row's Usage links as a group) and `inspectorEditing`; the handle writes
an inspector's change back as a cell edit is, a refusal in the table's dialog
and the page sent again, and refreshInspector() asks again for what the table
does not hear (the file's unsaved state). connectInspector hands a change of
an editable row to a feed that takes edits. The inspector draws a choice as a
list and a text of lines as a field of several lines, and names the row's key
in dex-property-changed.

Every default is as before: asked without options a source answers exactly
as it did, and buildPropertyGroups, InspectorSelection and InspectorPage,
which the VS Code extension's inspector is built from, are unchanged without
them. A section's page is drawn here, since core's section nodes have no
property layout; a file's root name is the uri core registers it under, so
the page names the file itself.
…t Root

The shell's tables ask for the inspector's pages and editable rows: the
Properties view shows the active file's page while no row is selected (so a
tab shown or a selection cleared no longer leaves the empty text), a section
heading's and several rows' pages, a row's Usage links, and edits a row as a
cell edit is. A link on it goes where a table's link goes, through the folder
shown. The file's page says whether it holds edits again on every change of
the tab's unsaved state, a save among them.

At Root, a box clicked in the relationship graph (or an item, for its box's
file) shows that file's page, drawn from what the graph knows of it, open or
not, and the location bar a dimmed "Root › file" after Root, which opens the
file when pressed; a click on the graph's background clears both. The graph
pane says when its selection changes, and opens the selected file or a file
its page links as a double-click on its box would. The location bar's
segments take `preview`, drawn dimmed (still 4.5:1) after the current place.
…still there

A field's text was its row's value, put back (live) whenever the page was
pushed again. A change of one field is answered by the page pushed again up to
three times (its repaint, the resend after the edit settles, the shell's
refresh for the unsaved state), so what the user was typing meanwhile in the
next field was wiped. A field typed in now keeps its text until it is changed
or left; every other field follows its row, a refused one put back as before.

A Save chord given with the focus still in a field saved without what was
typed there, since the field commits only on its change. The inspector's new
commit() sends the focused field's change as leaving it would (once: the
change its blur fires after is the one already sent), connectInspector's
handle has it, and the shell calls it before the table's commitEdit() on a
save, a tab's or the window's close, and the Gallery's add.

Each field is named for a screen reader by its property (aria-label), and a
choice with no value, for which core names no default, shows empty and offers
only the choices rather than a blank one.
…e dimmed segment

A file's page listed core's root facts as they came, so a .mdl showed a blank
Release. A fact with no value is left out now.

The location bar's segments take a `description`, what a screen reader hears
past the label, and the shell gives the dimmed file at Root "selected in the
graph", so it is not heard as a place the user is in.

Tests pin three more cases: an inspector edit undone as a cell edit is, one
step, the page following; an edit landing on its row while the selection has
moved on, the next row's page shown; and a Value shown as a summary staying
read-only though core offers an editor of its whole text.
…d a dimmed segment

The hand-written halves of three pages. The property inspector's says what a
table connected with inspectorPages shows (the file's, a section's and several
rows' pages, a row's Usage links), how a row edits (its key, a list for
options, several lines for multiline, the change handed to a feed's edit), the
commit() an app's Save calls, and inspect's options. The tree table's says what
inspectorPages and inspectorEditing send, handle.edit(), and when to call
handle.refreshInspector(). The location bar's says what `preview` and
`description` draw.

The generated half of the inspector's page waits for the build, which writes
the event detail's new key into it.
…fore the page moves on

What was typed in a field was kept by the field's place in the page, not its
row's. A selection moved with no blur (a native menu's Back, a command, a
host's select) left the text in the next row's field, where a Save's commit()
or the later blur wrote it to that row; and a field drawn anew at the same place
(the inspector following another feed and back) was left blank.

connectInspector now commits the focused field before it shows another row's
page or follows another feed, while it still names the row and the feed the
text was typed in, so the edit goes to that row. And the widget keeps typed
text only in the field the focus is in: any other, a new one among them,
shows its row's value. The memo that keeps a commit from being sent twice
names the row it was sent for, so a change of the next row's field is its own.
The graph listed a model's blocks only where a usage of them was drawn, so a
model opened without its data had no items, no + on its box, and nothing to
show of what its blocks read. The prototype listed every block a parameter of
which names something. Each such block is now an item, built from core's own
block key, label and path as its usage index builds a usage's, so the item is
the same one, id included, whether or not the data it reads is open.
…the pointer is on

As the prototype's graph did. A box newly in `expanded` (its + pressed, the
app answering) is what is lit: the view moves onto it and the files it
reaches along data links, dictionary references and usages, and every other
box and edge is dimmed, until the box is closed, Escape is pressed or the
background clicked. A selection lights over it. The boxes a graph comes with
are not taken as opened. A double-click on the background asks to close every
open box and fits the graph.

The pointer on an item lights what it is joined to, as a selection of it
would, and gives back what was lit when it leaves; on an edge under the
boxes, the other edges fade. A data link is drawn in the border colour of
the file it links, a dictionary's green or a MAT-file's sand, with no token
of its own, and a usage is labelled as the block's property (".Gain").

zoomToReach(id) moves the view onto a box or an item and what a selection of
it lights, keeping the thing itself in view where they do not fit. The
shell's Show in Graph uses it in place of reveal(), and opens the file's own
box onto its items as the prototype opened a model; a file a reference row
names is shown as it is.
…g it focused

A click on a box's + leaves the toggle focused, and the graph left every key
on a button to the button, so Escape after opening a box did nothing until
the canvas was clicked. A button has no use for Escape: it now clears the
selection and the dimming from there too.
… need

The complex_dataflow set (eight models one tree five leaves wide, five
dictionaries one tree three wide, two MAT-files) drew 2170 pixels wide: every
file had a slot as wide as its column's widest box, and the gap between the
columns was the prototype's 300. In the app shell at 1440 by 900 the graph
gets about 900 by 610, so at the 0.6 fit floor a label was 6.6 pixels and the
data files were off the screen, and a model opened was zoomed to at 0.65.

The look stays the prototype's two columns of top-down trees. A file now
takes the width it needs and its subtree its children's side by side, the
file centred over them within its own span; trees still wrap at three (models)
and two (data files) of the column's widest boxes. The gap is as wide as the
data links' lanes need, 8 pixels apart over 60% of it, between 120 and 300.
Both are decided by the graph, so opening a box moves nothing sideways. The
same files draw 1890 wide.

The fit floor is 0.7, where a label is near 8 pixels, and the fit no longer
takes a tenth off the scale (the layout has its margin). PowerTrain opened is
now zoomed to with its three data files at 0.77, both columns on the screen;
Show in Graph zooms the same way. layout.ts and the widget's doc say what
fits at 1440 by 900, and why.
…aying the default

`layout` on <dex-relationship-graph> (attribute and property) chooses how the
columns are drawn: 'tree', the default, the prototype's top-down trees; or
'indented', each column a file tree, one box a row, what a file references in
the rows under it a step to the right with a line down the referrer's left
side, and a reference to a file drawn under another referrer round the
outside of its column. A column too long for a 900 by 600 canvas is dealt
into columns side by side, whole trees each, when that draws it at least a
fifth larger, decided with every box closed. layoutGraph takes the style;
the gap between the columns is sized from the lanes in both.

For the complex_dataflow set in the shell at 1440 by 900 the trees draw 1890
by 390, fitted at 0.7 with the data files off the screen, PowerTrain opened at
0.77; indented they draw 740 by 540, fitted at 1.0 with both columns on the
screen, PowerTrain opened at 0.87. A change of layout fits the graph afresh
and keeps what is open and selected. The graph pane's setLayout(layout) sets
it, for a setting to choose; the shell passes nothing yet.

The arrows move only to a box wholly past the selected one's side, so in an
indented column of unlike widths Left and Right leave the column. Every
layout test's invariants now run over both layouts.
ww-mw added 17 commits November 6, 2026 21:31
… with each other

The Folder view is where files are before any is open, so it compares them too. A data file's
row menu gains Compare With… after Open to the Side: the file opens in a tab kept, and the shell
asks which file to compare it with. With two data files' rows taken into the selection, the menu
of either begins with Compare Selected, which opens both, kept, and compares the first with the
second in the tree's order. A row of a file the app does not open, or a project's, offers neither.

For that the folder tree takes several rows at once, opt in: with `multiSelect`, Cmd+click on
macOS or Ctrl+click elsewhere takes a row into the selection or out of it without opening it,
`selectedKeys` and `selectedItems` say which are selected, and dex-hierarchy-selection-changed says
when that changes. A plain click and Enter select one row and send what they always sent. A
screen reader hears the tree as multi-selectable, each row's selection with it; the keyboard
reaches the compare through the row menu. A tree without multiSelect is as it was.
…inks) into the compare's shell work

share/links brings share V5: Open from URL…, Copy Link, and a tab's menu (connect/tabMenu.ts),
which the compare's Compare With… and its Next and Previous Change are added to, one module for
both; and the web addresses' code without the forge's name, which clears check:leak.

# Conflicts:
#	custom-elements.json
#	dist/browser/urls.d.ts
#	dist/browser/urls.js
#	dist/widgets/app-shell/connect/types.d.ts
#	dist/widgets/app-shell/index.d.ts
#	src/widgets/app-shell/connect/carryOut.ts
#	src/widgets/app-shell/connect/connectShell.ts
#	src/widgets/app-shell/connect/documents.ts
#	src/widgets/app-shell/connect/fileMenu.ts
#	src/widgets/app-shell/connect/paletteItems.ts
#	src/widgets/app-shell/connect/requests.ts
#	src/widgets/app-shell/connect/tabMenu.ts
#	test/checkApi.test.ts
#	test/typedApi.test.ts
…links merged

The compare tab in the shell (Compare With…, F7, the tab, Explorer and line menus, Copy to Left
and Right, the Folder view's Compare Selected) and share's Open from URL, Copy Link and tab menu,
merged above: dist/, the widgets' manifest and the generated half of their docs pages.
…ws from the keyboard too

Copy Link listed every tab as an open file, so a compare tab went to the host as a file of no
path named "a.sldd ↔ b.sldd", and its link was at it. The open files are the files' tabs now:
from a compare tab's menu, Copy Link links both compared files with the rest, at none of them,
as Root's does.

A Folder tree that says it selects several rows (aria-multiselectable) now lets the keyboard do
it: Cmd+Space on macOS, Ctrl+Space elsewhere, takes the focused row into the selection or out of
it, as the tree pattern's Control+Space does.

Smaller: a tab's first paint is waited for by one helper, open-at's, which also settles when the
table's source could not open its file, so a compare of such a file says it could not be read. A
copy whose source will not lend its entries, or whose drop throws, is said and the next section
tried, the drag still ended. The compare tests also hold that a refused copy leaves the target
clean with nothing to undo, and that an added numeric array is one step of F7.
Copy Link from a compare tab, the Folder tree's Cmd/Ctrl+Space and the one wait for a tab's first
paint, above: dist/, the widgets' manifest and the generated half of their docs pages.
…light and dark

The app page opens object_props_text.sldd before object_props_binary.sldd, so the two
dictionaries that differ in the zip one's fleetObject Notes are open side by side. A new
gallery test right-clicks the text dictionary's tab, picks Compare With… and the zip
dictionary in the palette, and checks the compare tab, the header's "1 changed" and the two
captions. F7 then selects the one change in both tables. The compare is kept as a light and a
dark screenshot, for a person to look at. The app test counts five tabs now.

Screenshots go through one helper that takes none in WebKit. Playwright's WebKit screenshot
first adds a style element to the page to line up its animations. The page's policy refuses
it, and the refusal is a console error that fails the test. The Folder view's screenshot,
which failed in WebKit for that reason, uses the helper too.
…ight from its observer

A gap row stands for a row only the other file has, so it holds nothing to open. Its
twisty, its aria-expanded and Space on it now go, through the table's one rule for whether
a row can open. Its indent and its hatching stay, so the lines still meet the other side's.
The gaps under it still show and hide as the other side's row is opened and closed, since
the compare view hands both tables the same open lines.

A table given its rows before its first render draws its grid in that render. It measured
the grid's height in firstUpdated, which set state inside the update: a second render at
once, and Lit's change-in-update warning in an app's dev console. Each of a compare's two
tables did this. The resize observer, which already kept the height up to date, now takes
the first one as well. Its first callback comes before the first paint, so no frame is drawn
with the default height's window.

The gallery's dev-mode warning test now opens the app page's compare too, and failed on the
warning before the change. The compare test checks the gaps' missing twisty in a browser.
The tree table's build, its declarations, custom-elements.json and the generated part of its widget docs, for the gap rows that open nothing and the first height taken from the resize observer.
…focused table's cell, and refuse Compare With… on a compare tab at once

A compare's heading counted the lines under it, the other file's gaps among them. So
rt_bin.sldd's side read "Design Data (3)" for params.sldd's three entries, though rt_bin.sldd
has none there. Each side's heading row now carries its own file's count, the entries of that
section the side has (`_entryCount`, a new optional field of TreeTableRow). The table draws
that count in place of the rows under the heading. That reads as the file's own table reads it:
an empty section is "(0)", and "Show only differences" narrows the lines, not the count. A
heading only the other file has stays a gap, with no count. A table given no `_entryCount`
counts the rows under a section as before.

Both of a compare's tables select the same line, and both drew the focused cell's ring on it,
though only one has the keyboard. With diffMarks, a table now rings the cell only while the
keyboard is in its grid. The selection stays drawn on both, and a table with no marks rings its
cell as it always has.

Compare With… on a compare tab now says at once that a comparison can't be compared with
another file. The shell's own menus never offer it there, but a host's native menu has the
item on every tab, and the shell used to ask for a file and refuse only after the pick.
The layout's heading counts, the row field that carries them, the tree table that draws them and rings only the focused table's cell, the shell's at-once answer to Compare With… on a compare tab, custom-elements.json, and the generated part of the tree table's docs.
A host's native menu has Compare With… on every tab. On a project's tab the shell asked for a
file and refused only after the pick, since a project has no table to compare. It now says at
once that the project has no table and that only data files are compared, as it does on a
compare tab. The shell's own menus still offer no Compare With… there.

The focus ring the reviewer asked for went in with the section counts (c57975b): with
diffMarks, a table rings its focused cell only while it has the keyboard.
The shell's at-once answer to Compare With… on a project's tab.
Comment thread src/model/compare/cellText.ts Fixed
ww-mw added 4 commits November 7, 2026 15:11
…pace does

In a dex-hierarchy with multiSelect, plain Space on the focused row now takes it into the
selection or out of it, as the multi-select tree pattern's Space does. Mod+Space still does
the same. On macOS, Cmd+Space is Spotlight's and Ctrl+Space switches the input source, so
Mod+Space rarely reached the page there; Space alone does. Shift+Space, Alt+Space and, on
macOS, Ctrl+Space are left alone, and a tree without multiSelect leaves Space alone as before.
The JSDoc and the widget docs say so.

The tree table's comment on read-only ink over a wash gave the dark set's muted ink as
4.32:1 on the plain surface. That was #888; the token is #8c8c8c now, which gives 4.55:1 on the
lightest surface (#252526) and 3.4 to 3.7:1 on a wash, and the comment says so.
On a loaded machine (load averages of 14 to 58) a few tests ran past the 5 s default and the
10 s hook default, then passed alone. Each now does its work once, or is given the time that
work takes, with a comment saying what the work is. The global timeouts are unchanged.

- checkApiSurface: each case builds a TypeScript program for its small package, and most of
  what that program parsed was TypeScript's own lib files. api-surface.mjs now parses those once
  a process; the surface it reads is the same (checked on this package's own build: 1871 items,
  the same). The cases' folders are taken away with each case, not all in one afterAll hook,
  which is the hook that timed out. The cases get 20 s each.
- iconSet: core's dist was scanned twice, once for each case that reads its ids. It is now
  scanned once, in a hook given 20 s, and the scan helper keeps its answer. The SVG check reads
  every icon with one assertion over all of them, not one per file. The widget-source case gets
  20 s.
- dexIcon: the two plain-Node cases each started Node, happy-dom and the built module. One
  process now draws both icons, once, in a hook given 45 s. execFileSync kills it at 30 s, so a
  process that hangs fails the hook rather than holding the worker.
- usageScopeEquality: the exhaustive case planned the whole corpus twice, for the unscoped graph
  and for the probes. It plans it once now, and gets 20 s; each file's scoped graph is still
  built from nothing.
- widgetDocs: the generator check runs gen-widget-docs in its own process. It gets 45 s and the
  process is killed at 30 s. The case that parses every source file gets 20 s. Both failed under
  two suites at once.
- folder.test's Search view case: a folder change re-lists the folder and rebuilds the index,
  past the harness's 3 s waits under load. Its waits get 15 s and the case 45 s.

folderGraphSources needed no change here: on this branch it waits for the tree's hierarchy
build rather than a quiet spell, and it took 62 to 138 ms alone and under load.
The hierarchy's Space toggle in a multi-select tree, its JSDoc in custom-elements.json and the generated part of its widget docs, and the tree table's corrected comment on the dark set's muted ink.
…ed, word Space plainly, and drop dist files with no source

api-surface.mjs keys its cache of TypeScript's lib files by the compiler target as well as the
file, so a program with other options would not take a lib file parsed for another target.

The plain-Node icon run draws from a base set before defineIcon again, beside the base set
after it. A second instance of the built module, whose base nothing has set yet, gets
setIconBase first and is then defined under a tag of its own. The run checks it is a module of
its own, so the case cannot pass by drawing the first module's base.

The docs say Space on the focused row toggles it, Ctrl+Space too outside macOS, and the JSDoc
says "Space (or Mod+Space)".

dist/widgets/app-shell/connect/folderSearch.js and .d.ts have had no source since 0c311ae
but still shipped. Nothing imports them (source, tests, gallery, scripts, package.json's
exports and custom-elements.json name neither), and a fresh build makes neither, so they go.
@ww-mw
ww-mw marked this pull request as ready for review November 9, 2026 01:57
ww-mw added 3 commits November 8, 2026 21:17
… not by a regex that backtracks

CodeQL flagged both as polynomial regular expressions on library input: /[.\s]+$/ over a source's reason and /0+$/ over a literal's mantissa backtrack over a long run that something else follows, so their time grows with its square (40k characters already took 1.5 s and 0.8 s). Both now scan from the end by index. Two tests read 200,000-character inputs, which the old patterns could not finish inside a test's timeout.
…ift before Ctrl

toolbarItems.ts says its editing buttons' chords are the table's, as the menu labels them, and a test holds the two to it. On macOS both say ⇧⌘Z, but off it the menu says Shift+Ctrl+Z, as VS Code's own webview did (editing-trace.json), and chordLabel said Ctrl+Shift+Z: so the test failed on Linux CI only, and no PR into main had run it there before. The table chords are now written through tableChordLabel, which puts Shift first off macOS; the platform-words test pins Shift+Ctrl+Z.
@ww-mw
ww-mw merged commit 1e26646 into main Nov 9, 2026
5 of 6 checks passed
@ww-mw
ww-mw deleted the integration/all branch November 9, 2026 02:45
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment

Labels

None yet

Projects

None yet

Development

Successfully merging this pull request may close these issues.

2 participants