Rutba Office 1.13.0

You are told when a release is waiting, in the window you are working in.

Updates: found, announced, one click away

An installed copy has looked for a newer release since 1.7 — shortly after
it starts and every six hours, one request to GitHub's release feed carrying
nothing about you — and downloaded it in the background to install when you
quit. What it did not do was say so anywhere you would see: a small chip in
the launcher, and nothing in the window you actually work in. A copy that
updates in silence is a copy whose owner never learns what changed.

• A release the check finds is announced at once, in every window: a
  card at the bottom right saying which version is available and how far the
  download has got. When it is downloaded the card says the release is ready
  to install and offers Restart and update, which quits, installs and
  comes back — the only way an update is ever applied while you are working,
  and only when you ask. If you carry on, it still installs when you quit.
• Not now puts that version away — in the window at once, and everywhere
  for a day, after which it asks again, because a copy that is never quit
  never installs on quit. A newer release is a new question, whatever was put
  away before; and asking for a check yourself (About → Check now) always
  gets an answer.
• The launcher's chip and the About panel say the same thing in the same
  words, so nothing on the screen contradicts anything else.

Proven, not promised

• Five application checks drive the prompt in a Rutba Word window with the
  states the service publishes: found and downloading with the percentage,
  ready with its button, put away and staying away, a newer release asked
  about anyway, and the prompt measured on screen rather than only found in
  the tree. RUTBA_VERIFY_ONLY=update runs them alone.
• tools/update-test.ps1 — the fourth check before a release is called
  done — installs the previous release, launches it, waits for its own
  updater to find and download this one, reads the prompt through UI
  Automation and reads the version the installer leaves behind. 1.11.0
  updated itself to 1.12.0 this way on the day 1.12.0 was published; 1.12.0
  is proved against this release the same way.

Under the hood

• The update service publishes snoozed and snoozedVersion with its state
  and gained snooze({ version }); a manual check clears a snooze. The
  snooze itself (apps/desktop/main/update-snooze.js) is one version for one
  day, and is unit-tested.
• The shared frame (renderer/shell.js) carries the prompt, so every app has
  it without knowing; the check harness receives the shell's broadcast and
  the update service so it can publish states without a network.

Rutba Office 1.12.0

The ruler, and a table's borders, in Rutba Word — moved by hand.

Rutba Word: a ruler that moves things

The ruler above the page was a picture of the margins. It is now the one in
Word: centimetres counted from the left margin, the margins shaded, and on it
every marker a hand reaches for.

• The paragraph at the caret shows its first-line indent (the top
  marker), its hanging indent (the bottom one), the left-indent box under
  it that moves both together, and the right indent. Drag any of them and a
  dashed guide runs down the page with a readout in centimetres; let go and
  the paragraph — or every paragraph in the selection — is written that
  way. The first line dragged left of the rest becomes a hanging indent, as
  it does in Word, and a left indent dragged to the margin is written as an
  explicit zero, so it beats a style that indents.
• Tab stops. The paragraph's own stops, or its style's, sit on the ruler
  as the small left, centre, right and decimal marks. Click the ruler to
  add one of the type the box at the far left shows (click the box to
  change it); drag a stop to move it; drag it off the ruler to remove it.
  The last one removed cancels the style's stops too, so they do not come
  back.
• The margins. Drag the edge of either shaded margin and the section's
  page margin follows — the same setting the Layout tab's Margins menu
  writes, to the pixel of where it was dropped.
• Table columns. With the caret in a table the ruler shows its column
  edges as grey boxes; drag one and the two columns either side of it
  change, the table keeping its width — Word's own rule for an inside
  border — and the last edge widens the last column and the table with it.
  The file keeps the grid and every cell's width together, so Word, Excel
  and this suite measure the table the same.

The ruler is on by default; the View tab's Ruler button puts it away.

Rutba Word: tables drawn as the file draws them, and resized on the page

• A table's columns were drawn as the browser saw fit, every table
  stretched to the text width. Each column now takes the share of the
  table the file's grid gives it, and the table the width the file gives
  it: a share of the text width, a fixed width, or the grid's own sum. A
  merged cell spans the columns it merges; a row the file sizes is drawn
  that tall.
• Grips on the borders. With the caret in a table, rest on any column
  edge or row bottom and the pointer says it can be dragged. A column edge
  moves the two columns beside it as the ruler does; a row's bottom edge
  sets the row's height, written as a floor the way Word writes it, so a
  cell that needs more still gets it.

Under the hood

• The document reader hands the page each top-level table's grid, width,
  cell spans and row heights, carried by the paragraphs in it; the writer
  gained setTableColumnWidths (several columns at once, and a fixed table
  width brought up to date with the grid) and setTableRowHeight.
• Paragraph formatting takes four absolute indents (leftTwips,
  firstLineTwips, hangingTwips, rightTwips) and the paragraph's
  tabs, each written into its schema slot; a paragraph that only clears
  stops reads back an empty list rather than its style's.
• The fixture builder makes a table with columns of a given width.
• Twelve application checks drive the ruler and the grips with real
  pointer events: the first-line marker dragged and the drawn text indent
  read back, a stop added by a click and removed by a drag off the ruler,
  a column border and a row border dragged on the page and the cell
  measured, the margin edge dragged and the page's padding read, and the
  file reopened with all of it. RUTBA_VERIFY_ONLY knows the block as
  ruler. Four engine tests cover the writers and the reader.

Rutba Office 1.11.0

Shapes you move by hand, pictures the words wrap round, tooltips of our own and a zoom slider.

Presentation: shapes move, resize and recolour by hand

• Every shape on the slide can be taken hold of. A click selects it and
  shows eight handles; a drag moves it; a handle resizes it — a corner keeps
  a picture's proportions, and Shift keeps any shape's; the arrow keys nudge
  it a pixel (ten with Shift) and Delete removes it. The box follows the
  pointer as a dashed outline and the engine is told once, on release, so
  the drawing never lags the hand. Until now only shapes with words had a
  hit area, and nothing moved except through the Arrange menu.
• A Format pane on the right — from Shape Fill, Shape Outline, the
  right-click menu or the View tab — sets the fill from the theme's ten
  colours, a standard row or any colour, or takes it away; and the outline's
  colour, weight and dashes, or takes that away. Each press is one write into
  the shape's own properties, in the order the file format wants, so
  PowerPoint reads it back exactly.
• Quick Styles on the Home tab: filled in an accent, outlined in the
  same accent darkened — the theme's own looks, six of them.
• The right-click menu on a shape now offers Format, Bring to front and
  Send to back beside Edit text and Delete.

Rutba Word: a picture floats where the file puts it

A picture or a text box in the file's anchor sat in a paragraph of its own
whatever the file said. It now floats where the file puts it and the words
wrap round it: square, tight and through wrap at the left or right become a
float inside the paragraph, top-and-bottom and centred sit between the
words, behind and in front sit under or over them. The page layout counts a
float that hangs below its paragraph. Click a picture to pick it, then on
the Layout tab Wrap Text (in line, square, top and bottom, behind, in
front) and Position (left, centre, right) move it, and the file keeps
the answer — the picture itself is untouched.

Print and PDF still draw a floating picture as a block under its paragraph;
the engine's paginator wraps to one width. That is next.

Rutba Word: pictures resize by hand

Click a picture and it wears four corner handles; drag one and the picture
grows or shrinks, keeping its proportions, the words re-wrapping round it
as it goes. The engine writes the size into the file on release; the
picture stays picked, so the next drag or Wrap Text choice needs no second
click.

Worksheets: the fill handle

The small square at the bottom-right corner of the selection, as in Excel:
drag it down or across and a dashed box follows; on release the cells it
passed over are filled from the selection — a value copied, a formula's
references moved — and become the selection. Ctrl+D and Ctrl+R did this
already; the handle is how most people reach for it.

The frame

• Tooltips of our own. Rest on any ribbon button and a small chip says
  what it does and its shortcut, in the suite's look, in both themes. The
  browser's grey box no longer appears.
• A zoom slider at the right of the status bar in Rutba Word,
  Worksheets and Presentation: minus, slider, plus, and the level as a
  button that puts it back to 100% — or, for a deck, fits the slide to the
  window again.

Under the hood

• The deck engine gained setShapeStyle; the document reader reads a
  wp:anchor in full (anchorLayout) and the writer moves a picture between
  wp:inline and wp:anchor (setImageLayout).
• Twenty-five application checks were added: the first line measured against
  a floating picture after each move; a shape dragged, resized and nudged with
  real pointer and keyboard events and its geometry read back; the Format
  pane's swatches, No outline and a 3 pt weight read back and seen in the
  drawing; a picture's corner handle dragged and its size read from the file;
  the fill handle dragged two rows; a tooltip shown and hidden; the slider
  zooming the window and the slide. The harness reads a button's tip as well
  as its title. RUTBA_VERIFY_ONLY knows the new blocks: float, polish,
  shapes, fill, pics.

Rutba Office 1.10.0

Pages on screen in Rutba Word, layers and designs in Presentation, and a worksheet's columns you can drag.

Rutba Word lays its pages out

A document was one endless sheet. A report of ten pages ran off the bottom
of the first page and kept going over the desk, and a page break — the
paragraph property, the Ctrl+Enter — did nothing anyone could see. That was
the difference between a viewer and a word processor, and it is closed.

• The flow is laid onto sheets. After every edit the drawn page is
  measured, and each block that would cross a page's bottom is moved to the
  top of the next page. A paragraph of many lines is split at the line that
  no longer fits and continues on the next page — with at least two lines on
  each side, which is Word's widow and orphan control. A table splits at a
  row. A heading goes over with the paragraph that follows it. An explicit
  page break heads a fresh page.
• Each sheet carries its own header and footer, with its own page number:
  a PAGE field says which sheet it is on, and the count is the count. The
  first-page and even-page bands of a section go where the section says.
• The status bar says "Page 3 of 10", following the caret.
• The browser lays the lines out, so the browser is asked where they fell.
  That is the one answer that agrees with what is drawn; the engine's own
  paginator, which measures with a width table, still lays out print and
  PDF. A split paragraph is still one paragraph with one index; typing at
  the head of its second part lands where it should.

This is the app the owner asked to be called by its full name: it is
Rutba Word in the launcher, the title bar, the Apps menu and the
messages, so nobody mistakes it for the other one.

Presentation has a Layers pane and a Designs pane

Two panes on the right, opened from the View tab (and from Arrange on the
Home tab, and Layouts on the Design tab), closed with their own cross.

• Layers lists the slide's shapes top-most first, the way a selection
  pane does. A click selects the shape on the stage; the arrows bring it
  forward or send it backward, Front and Back take it all the way; the eye
  hides it (it stays in the file, undrawn, as PowerPoint keeps hidden
  shapes); a double-click renames it, and the name is the one PowerPoint
  shows. The drawing order is the file's own: the shape's XML moves among
  its siblings and nothing else changes.
• Designs shows the deck's own layouts as a gallery, each drawn as the
  boxes its placeholders make, with the current slide's layout marked. A
  click puts the slide on that layout — its placeholders then inherit that
  layout's geometry and text style wherever they state none of their own —
  and + New starts a slide on it, after the current one.

Worksheets: drag a heading's edge

Column resizing "did not work" because there was nothing to drag. The edge
of a column heading is now a handle: drag it and a guide line follows the
pointer, release and the column is that wide. Row headings likewise. A
double-click on a column's edge fits it to its widest text; on a row's,
puts the row back to the default height.

Under the hood

• The document engine's frame carries pageBreakBefore, keepNext and
  keepLines, read from the file; the builder can write all three.
• The deck engine gained reorderShape, setShapeHidden, renameShape,
  layoutList, layoutOf and applyLayout, and insertSlide takes the
  layout it should use. A scene built on a slide's old layout is dropped
  when the layout changes.
• The application checks grew by seventeen: six open a ten-page report and
  read the layout back (every block inside a page, the break heading a
  page, a paragraph split at a line and a table at a row, the page count,
  the caret in a split paragraph, a page break typed at the front adding a
  page); four drag headings with real pointer events; seven drive the two
  panes and read the deck back. RUTBA_VERIFY_ONLY=pages,grips,panes runs
  named blocks alone; RUTBA_VERIFY_CAPTURE=<dir> photographs them.

Known limits

• A block taller than a page's text area — one table row, one picture —
  runs into the gap between sheets rather than being cut.
• Footnotes are drawn at the end of the document on screen; print and PDF
  put them at the foot of the page that refers to them.
• The pages on screen and the pages in print can differ by a line here and
  there: two measurers, two answers. Print is the engine's.

Rutba Office 1.9.0

The look: a header in the app's colour, a ribbon that fits, and a frame that reads as one product.

The frame

Every window is drawn by the suite, not the platform, and the frame has
been redrawn so that the nine apps read as one product and are told apart
at a glance.

• The header wears the app's colour. A wash of the accent — blue for
  Word, green for Worksheets, red for Presentation — sits behind the title
  bar and fades out by the middle, the way it does in the windows people
  spend their day in, without the saturated band. The app mark is a small
  tile of the same colour with a sheen and a shadow; the document's name
  is centred and weighted; the window controls are rounded chips.
• Tabs are pills. The active tab is a raised white pill in the app's
  colour; the rest are quiet text. No underline, no box.
• The ribbon is a card. The groups float in a rounded card under the
  tabs, with a hairline and a shadow, and nothing else on the row.
• The ribbon fits. Word's Home tab was 2,372 pixels of groups laid out
  in a single row, with a scrollbar under it that read as a fault. The
  small buttons now stack in two rows beside the tall ones — Cut and Copy
  over Format Painter, the font boxes over Bold, Italic and Underline,
  bullets over alignment — as Office lays them out, and the Home tabs of
  Word, Worksheets and Presentation fit a normal window. Where a tab is
  still wider than the window, a chevron on that side says so and the
  wheel scrolls it sideways; there is no bar.
• Calendar and Contacts have their colour. The theme had never named
  one for either, so their launcher tiles were blank and their windows
  wore Word's blue. Every app's colour is now named in one place, and the
  launcher tiles, template chips and recent-file marks all take it from
  there rather than from a list of their own.

The rest of the window

• A worksheet's formula bar is a bar: the name box and the formula field
  are boxes on the chrome, and the field lights up when it has the focus.
• A document's page sits on a desk — a close shadow for the edge, a wide
  one for the lift.
• Dialogs have a foot that reads as a foot, with the secondary buttons
  bordered and the primary one raised; menus have roomier rows and an
  accent tint under the pointer; the selected row of a list carries a
  short accent mark; empty states have a softer tile.
• The launcher opens on a wash of the accent behind the welcome; the app
  tiles lift a little under the pointer.
• All of it in the dark theme too, with the wash, the card and the pills
  tuned for it. RUTBA_SMOKE_THEME=dark npm run smoke photographs every
  window in the dark theme, which is how it was checked.

Verified

• 165 application checks unchanged: the buttons the checks press are the
  same buttons in the same groups, in rows.
• 10 window captures, light and dark, read by eye before the release.

Rutba Office 1.8.1

Files Office itself wrote, opened and judged; charts on slides; an .ods that keeps its names, merges and formats; the installer proven before it is published.

Judged against what Office writes

The suite's fixtures were small and well formed. This release adds the
other kind: a workbook, a document and a deck written by Excel, Word and
PowerPoint themselves, through tools/make-rich-fixtures.ps1, as OOXML
and as OpenDocument from the same content — charts, shapes, gradients,
pictures, cross-sheet formulas, named ranges, every number format,
conditional formats, sparklines, a table with a total row, a table of
contents, three kinds of list, footnotes, endnotes, comments, fields,
tracked changes, an equation, a landscape section, a watermark, WordArt,
animations, speaker notes. tests/rich-fixtures.test.js opens each through
the same service the windows use and holds the engine to Excel's own
cached results. Eighty-one real files from two public sample sites went
through the real windows as well: 84 of 87 shown, three refused in a
sentence, none with a console error. What all that found is below.

Worksheets

• SUBTOTAL. Every table Excel writes ends in SUBTOTAL(109, …), and
  every such total row read #NAME? here. Function numbers 1–11 and
  101–111 are all answered.
• An .ods keeps what it says. A named range — $$GrandTotal in the
  file — reached the engine as #VALUE!; merged cells and number formats
  were dropped, so 7,518 showed as 7518 and 11.4% as 0.1138. Named ranges,
  merges, the number, percentage, currency, date and time styles, dates,
  times and booleans now all arrive.
• Dates in the machine's order. Excel's built-in date format 14 is
  documented as mm-dd-yy and shows the system's short date; a British
  workbook's 10 September read as 09-10-26 here. It follows the machine
  now, as does format 22.
• The Worksheets checks wait for a menu to open rather than pausing a fixed
  fifth of a second, which under load was not always enough.

Presentation

• Charts on slides are drawn. A chart frame was an unsupported graphic;
  a corpus deck with six chart slides showed six empty frames. The frame's
  chart part is read the way a worksheet's is and drawn by the same chart
  kit, on the slide and in its thumbnail.

Opening files

• A password-protected file is refused as one. An encrypted .docx
  opened as an empty page, and an encrypted .pptx was refused as "a
  document, not a presentation" — both are compound files holding the
  encrypted package, whatever their name. Each now says it is
  password-protected and what to do. A compound file that is none of Word,
  Excel or PowerPoint 97-2003 is refused too rather than shown empty.

The installer, proven

1.8.0's installer opened with "Cannot find package '@rutba/contacts'": the
two new packages were not declared as the desktop application's
dependencies, so the archive left them out, and every check passed because
every check ran inside the repository, where Node finds them anyway. Both
are declared, a test reads every import and requires a declaration, the
install test lives in the repository and reads what an installed copy shows
when it fails to open, and TESTING.md says the order — the packaged smoke
from outside the repository, the install test, then the tag and the
publish. The published 1.8.0 was rebuilt and proven before it went out.

Mail

• A file of accounts sets them up at once — from the Add account and
  Import mail dialogs, or --import-accounts=<file> on the command line
  with --accounts=a,b, --sync and --quit. Set up against five real
  mailboxes on three domains, every one signed in on both servers and
  fetched its inbox.

Known, and named in docs/GAPS.md

The fixtures also showed what is still not read: an .ods's charts and
shapes and an .odp's pictures, shapes and tables (OpenDocument drawings),
Office Math equations, and tracked changes shown as changes rather than in
their accepted form.

Verified

• 696 engine tests, with the rich fixtures, SUBTOTAL, the OpenDocument
  names and formats, the machine's short date and the encrypted-file
  refusal pinned.
• 165 application checks, 9 editing checks, 10 window captures; the gate in
  under three minutes, run alone.
• The packaged smoke from a copy outside the repository, and the install
  test, before publishing.

Rutba Office 1.8.0

Calendar and Contacts, two more apps on the shell; a meeting in a message answered from the message; twenty accounts set up from one file.

Calendar

Mail was here and a calendar was not: a meeting arrived as an attachment
nothing opened, and there was nowhere to keep it. There is a Calendar now,
on the same shell as the rest, with its own tile, its own window and its
own icon on .ics.

• Month, week, day and agenda, a small month beside them for moving
  about, and the calendars in the sidebar with a colour each, shown or
  hidden. An event is a title, a start and an end or an all-day date, a
  place, a repeat and notes; an edit to a repeating event says whether it
  means this one or all of them.
• .ics in and out. A file opened in the app shows its events and
  offers to keep them — nothing is added until it is asked — and a calendar
  is exported as one. An invitation (METHOD:REQUEST) is recognised as
  one, kept as an event, and answered with a reply in the file's own form.
• @rutba/calendar, the engine behind it: iCalendar read and written —
  folding, escaping, durations, date-times with and without a zone;
  recurrence rules expanded into occurrences — daily, weekly, monthly and
  yearly with INTERVAL, COUNT and UNTIL, BYDAY with and without
  ordinals, BYMONTHDAY, BYMONTH and BYSETPOS, EXDATE removing
  instances, RDATE adding them and a RECURRENCE-ID replacing one — with
  a sentence that says what a rule means; and time zones, including the
  Windows names Outlook writes, resolved to offsets.

Contacts

• A book, kept in the profile: a list, a card, an editor, search. A
  .vcf or a CSV opened in the app shows its cards and offers them; Add
  keeps them, and an address already in the book is merged rather than
  doubled. Export writes vCards.
• @rutba/contacts: vCard 2.1, 3.0 and 4.0 read and written —
  quoted-printable soft breaks joined only where the property says so, so a
  base64 photo no longer swallows the line after it — and the CSV shapes
  Outlook and Google export.

Mail, with both

• An invitation in a message is answered from it. A message carrying a
  calendar part shows the meeting in the reading pane — the title, when,
  who is asking — with Accept, Tentative and Decline. The answer keeps the
  event and opens a reply to the organizer with the answer attached, so the
  sender's calendar learns it the way it would from any other client. A
  reply that arrives shows what the attendee said; any other calendar part
  offers Add to calendar.
• Addresses complete from the book. To, Cc and Bcc complete from
  Contacts first and then from the people mail has seen, with the keyboard.
• A sender is kept in one click, from the reading pane.
• Mail opens with a message to write when Contacts or the calendar asks
  it to: Send mail on a card, or the reply to an invitation with the file
  attached.

Accounts from a file

Adding an account has been an address and a password since 1.7.1. Adding
twenty is a file now. A JSON file of accounts, the loose way other clients
write one — address, password, host and ports, or imap and smtp
objects — is read by the app: each entry is tried before it is kept, as the
dialog does; an address already set up is left alone; the ports decide the
security when nothing says. Add account and Import mail both offer the
file. On the command line, --import-accounts=<file> sets them up before
the first window, --accounts=a,b picks addresses from it, --sync
fetches each new inbox and --quit leaves without opening a window — how
an administrator's file becomes a working Mail without a dialog per
address. The answer names addresses and outcomes and never a password, and
the file is not changed.

Set up this way against five real mailboxes on three domains, every one
signed in on both servers and fetched its inbox.

The shell

• .ics opens in Calendar and .vcf in Contacts — from the launcher, from
  a double-click, from the command line — each with an icon of its own; the
  installer registers both.
• Two more tiles on the launcher, two more windows the smoke photographs,
  two more taskbar identities.
• A check run's mail seed used to be imported into the developer's own
  profile by an early runner; fifteen copies were found there this release
  and taken out. Every run has had a profile of its own since 1.7.0.

Verified

• 688 engine tests, with iCalendar, recurrence, time zones, vCard and CSV
  pinned.
• 165 application checks, off the desktop, now including a .vcf opened as
  its cards and kept, a card typed in and shown, an invitation shown and
  accepted with the reply addressed and attached, Compose completing an
  address, a sender kept, and a file of accounts set up once and not twice.
• 10 window captures, Calendar and Contacts among them. The whole gate in
  about two and a half minutes.

Rutba Office 1.7.1

Adding a mail account is an address and a password; OpenDocument written back; a grid that keeps up with the keys, and more than one selection.

Mail: an address and a password

Adding an account asked for the incoming server, the outgoing server and
two ports, and guessed them from the domain when it could. Now it asks for
the address and the password, and finds the rest the way every mail program
people find easy does — in every way there is, at once, in a few seconds:

• a table of the providers most people use;
• the domain's MX records, which name Google, Microsoft 365, Yahoo, Zoho,
  Fastmail or iCloud when a company's mail is hosted there;
• the SRV records a domain publishes for its own servers (RFC 6186);
• autoconfig — the domain's own, its .well-known path, then Mozilla's
  public database;
• Microsoft's autodiscover, which answers for any mailbox on Microsoft 365;
• and a knock on the conventional names — imap., mail., smtp., the bare
  domain — on each port that matters, to hear whether something answers
  and says IMAP or SMTP. A name that answers outranks a name that is
  guessed, whatever its source; nothing is sent to any of them but the one
  line that asks for an upgrade, so no server sees a password from here.

The dialog shows what it found and whether it answered, opens "What was
checked" to the step-by-step account, and offers the browser sign-in when
the provider wants one — the moment a Gmail or Outlook.com address is typed,
before the search has run — including a company domain hosted at Google or
Microsoft 365, which no address pattern can know. Advanced is always one
click away, never the only way in, and its fields carry the answer: the
username when it is not the address, the two servers, the ports, and the
security of each as TLS, STARTTLS or none, so a wrong guess is a correction
rather than a form from scratch. Add account signs in before it keeps
anything; an account that cannot sign in is not added, and the failure
opens the fields it needs. An account imported from another program on the
computer goes through the same checks, so what was carried over is
confirmed rather than trusted. A check run asks only the table, never the
network; the search is pinned with every lookup injected.

A plain port is upgraded with STARTTLS before a password is sent, on the
test and on every message sent, or not used.

OpenDocument, written

The installer had told Windows for a year that this suite was the editor of
.odt, .ods and .odp, and Ctrl+S on any of them refused. They are
written now. A file that came in as OpenDocument goes out as OpenDocument,
holding what this suite models: a document's headings, paragraphs, lists,
tables and run formatting; a workbook's values, formulas and the value types
a cell needs to stay a date, a percentage or a boolean; a deck's text boxes,
pictures and speaker notes, in place. Formulas cross into the file's own
spelling and back — =SUM(Sheet2!A1:B2, 3) is of:=SUM([$Sheet2.A1:.B2]; 3)
on disk — and a formula read from somebody else's .ods now reaches the
engine in the engine's dialect rather than the file's. The archive starts with
a stored mimetype, as readers check. Save as offers all three.

Worksheets

• Every open Worksheets window kept the main process busy, for as long
  as it lived. The grid stretched to its own canvas, the canvas was sized
  to cover the grid plus a margin, and the size observer asked for a wider
  frame each time — eight times a second, 1,088 pixels wider every time,
  with an idle window and nobody touching it. Each frame drew more columns
  than the last. With several sheets open the main process was never idle
  again, every window's replies queued behind it, and the whole suite
  felt slow; a profile of the main process over a full check run showed
  ninety-nine percent of its time drawing Worksheets frames. Two words of
  CSS — a zero minimum width on the flex items — end it: an idle window
  now makes no request at all. A check opens a workbook, waits, and
  requires the grid to stay inside the window and stop growing.
• More than one selection. Ctrl+click adds a cell, a range, a column or a
  row to what is selected; Shift grows the current rectangle and keeps the
  others; a plain click or arrow drops them, as a spreadsheet does. The name
  box reads A1:B2,D4:D5, the status strip counts across all of them,
  formatting and clearing apply to all of them, and typing goes where the
  last click was. Ctrl+A selects everything.
• The selection keeps up with the keys. An arrow key used to be its own
  round trip and its own full frame — a hundred milliseconds and a quarter of
  a megabyte on an eighteen-million-cell workbook — and a held key queued
  one per repeat, so the grid fell behind the key and caught up seconds after
  it was released. Two changes: a move that scrolls nothing is answered with
  the selection and the active cell's fields, not the frame (3 ms and a
  kilobyte on the same workbook); and moves that arrive while a frame is on
  its way are sent together when it lands, one frame per reply however fast
  the keys.

The formula language

• TEXT() speaks every format code the grid does. It handled thousands
  separators and fixed decimals and gave anything else back as a plain
  number, so TEXT(A1,"dd/mm/yyyy") — one of the most common formulas in
  a real workbook — showed a serial. The grid's formatter moved in beside
  the engine, where TEXT can reach it: dates, times, percentages,
  fractions, currency, exponents, colour and sign sections. Two of those
  the grid itself had never drawn: a cell formatted as a fraction showed
  digits round a slash, and one in scientific notation showed the number
  twice round a literal E. Both draw as Excel draws them now, padding
  spaces and engineering exponents included.
• 29 February 1900. Excel's calendar has a day that never happened —
  serial 60 — and every file Excel wrote counts it. DATE(1900,2,29)
  answered 61 here and DAY(60) answered 1; they answer 60 and 29 now,
  and WEEKDAY uses Excel's arithmetic rather than the almanac, so a
  workbook's weekdays agree with Excel's for every serial, not only from
  March 1900 on.

Verified

• 673 engine tests, with the OpenDocument round trips, the multi-range
  selection, the selection-only reply, the mail-server search, the phantom
  day and every format code pinned.
• 151 application checks, off the desktop, now including Ctrl+click adding
  a selection with Bold painting both, the account dialog finding a
  provider and carrying it into Advanced, a Save as .odt that reopens as
  OpenDocument, and an idle Worksheets window that settles.
• The whole gate in two minutes; the same gate took thirty-one minutes
  before the frame loop was found, and the main process is now idle
  ninety-four percent of the time through the checks.

Rutba Office 1.7.0

Beta, said plainly; every real file opened for real; and the opening problems that found.

The owner used the suite on their own files and found problems opening
documents and problems of usability that none of the checks had caught. This
release is the answer to that: the suite is marked beta, a new check opens
every file in a folder in the real application, and what that check found
in the first two hundred files is fixed here.

Beta

Every release is now published as a pre-release, the window title says
"(beta)", the launcher says so beside the version, and the README says so
above the downloads. An installed copy follows the beta releases. Nothing
about the software changed by being called beta; what changed is that the
name now matches the state.

The corpus check

npm run verify:corpus opens every file in the folders it is pointed at in
the real application, one window at a time — the same main process, the
same service, the same bundle — and records for each: shown (and how long it
took), refused with the application's own reason, hung, crashed, or skipped.
Console errors are kept with the file even when it opened. The report names
the failures, the files that opened but complained, the slowest twenty, and
the numbers per format. It runs in a profile of its own, so a thousand files
do not become a thousand recent entries. TESTING.md says
where it sits among the other checks and what each can and cannot see.

The first run, over 1,532 files of public tenders, found the following.

What it found, and what was done

• Every document ever opened stayed in memory. Nothing closed a document
  session when its window closed, so a session of many files grew without
  end; a hundred and forty files in, the main process stalled for two
  minutes on a small JPEG. A session now belongs to the window that opened
  it and goes when the window does.
• A truncated deck showed a blank window for as long as you waited. The
  Presentation window's error return sat above one of its hooks, so a file
  the engine refused made React throw instead of drawing the message. The
  return is below the last hook now, and a check opens a file of junk in
  each document app and expects the sentence.
• A tender with 274 tabs took seven seconds to answer. Each tab stop was
  measured on its own, and each measurement forced the browser to lay the
  thousand-paragraph page out again. The measurements are batched: one
  reset, one layout, one write per commit. 1.8 seconds, and typing no
  longer re-measures the page.
• A fifteen-megabyte deck took five seconds to show its first slide. The
  outline parsed every slide with its layout and master to find the titles,
  then every thumbnail was drawn, all before the window could paint. The
  outline now reads titles off the XML; the open model draws the five
  thumbnails nearest the slide shown and the window asks for the rest after
  its first paint; and a thumbnail leaves out a vector map with a hundred
  thousand points. One second.
• A refusal said "not a zip archive: no end-of-central-directory record".
  It now says the file is not a complete .pptx and may be a download that
  stopped early, with the engine's message in brackets for a bug report.
• An Office owner file was called a stopped download. Word, Excel and
  PowerPoint keep a 162-byte file beside every open document, named after
  it with ~$ in front, and leave it behind after a crash; a Downloads
  folder began with four. Opening one now says what it is and names the
  document to open instead.
• Closing a deck's editor left its presenter window up, failing every
  call it made. The presenter shows the deck its editor holds open; with
  the editor gone, so is the deck. The show now ends with its editor.
• The photo viewer read a whole picture to learn its size. It reads the
  first quarter megabyte, where the size and the EXIF live.

Across the first two hundred files of the second run the median time to
first paint fell from three seconds to one, and the slowest file from 7.6
seconds to 2.5. The full run — 1,532 files — then showed 1,390 of 1,394
opening, the four that did not being one zero-byte document, one text file
sniffed as an email (fixed below), and two copies of the workbook below.

The big files, which the owner asked for by name

• A 46 MB workbook of eighteen million plain values took 135 seconds and
  2.7 GB, and then gave up. Two causes. The calculation model copied every
  cell into itself for a sheet with not one formula; a formula-free sheet
  past twenty thousand rows now stays in its part and is read through on
  demand (an edit overlays it, a cleared cell stays cleared, a formula on
  another sheet still sums it). And the sheet view kept a map of every
  cell's style — which a JavaScript map cannot hold past 16.7 million
  entries; past a size the styles are read as cells are asked for. The
  workbook opens in eight seconds.
• A specification of 3,200 paragraphs and 2,400 table cells took eight
  seconds to paint though the engine had it in half a second: the window
  mounted every block before the first paint. The first screens mount at
  once and the rest follows in idle slices while the person reads.
• The 31.8 MB manual, the 20 MB decks and the 6.5 MB Barbican workbook open
  in one to six seconds; the many-page documents in the corpus (up to 3,211
  blocks) in under two.
• A second corpus, the owner's own Downloads folder of 1,008 files — 278
  PDFs, 605 photographs, 52 workbooks, 32 CSVs, decks, documents, videos
  and sound — showed every file but the four owner files above, with no
  console error: a median of 0.9 seconds, nine in ten inside 1.5, and the
  slowest, a workbook, in 4.2.

Usability, from the owner's own report

• In Worksheets, after Enter in the formula bar the arrow keys moved the
  caret in the bar and the selection did not move. Enter, Tab and Escape
  now finish with the bar and hand the keys back to the grid, as Excel does.
• In Word, typing faster than the engine answered put the letters out of
  order. Every keystroke is cancelled in the browser and sent to the
  engine with the caret read from the page. Until the engine's answer was
  painted, that caret was stale — the browser never made the insertion — so
  the next letter landed before the last: "Typed." came back "ye.dpT" at
  sixty milliseconds a letter on a loaded machine, and in a long document
  a slower pace does it. That is what "the editor did not respond
  properly" looks like from the keyboard. A caret exactly where the editor
  last sent or placed it is not resent now; the engine's own caret, already
  past whatever is in flight, is used. tests/word-caret.test.js pins the
  rule and the reversal it prevents.
• The application checks now drive the windows with real mouse and keyboard
  input — a click aimed by the column and row headers, a drag across text,
  a click on a ribbon button — and read the engine to see where it landed,
  instead of clicking elements from inside the page. That is how the
  formula-bar fault was found, and it is what will find the next one.
• A text file that begins like an email opens as a text file.
• A refusal from the engine itself is now the plain sentence too.

Every kind of file wears its own icon

After "make Rutba Office the default", every document, workbook and deck
wore the suite's one mark, and a folder of mixed files read as one kind of
file. Each family now has its own icon — the app's colour and the app's own
glyph on a page, the arrangement people know from Office — so a document
looks like a document and a workbook like a grid before the name is read.
Word, Worksheets, Presentation, Pictures, Video and Mail each have one, and
PDF has its own.

The windows follow. On Windows every app window now carries its app's tile
and its own taskbar identity, so a Word window and a Worksheets window sit
under different icons, each app can be pinned to the taskbar on its own,
and a pinned entry opens that app. Before, every window wore the suite's
one mark and they all grouped together. The launcher keeps the suite's
mark.

The application checks, broadened

• A broken file in each document app: the sentence, the reason, no spinner,
  no exception.
• Journeys: Escape closes the Go To dialog and moves nothing; Escape closes
  the Speaker Notes dialog and keeps the notes; Ctrl+F1 folds the ribbon
  and folds it back; each window at its minimum size shows its content
  without a sideways scroll and keeps its status bar; the launcher lists
  the files the run opened.
• Real input, in Worksheets: a click selects the cell it lands on, the
  arrows move the selection, typing fills the cell, Enter moves down, Bold
  from the ribbon paints the cell, and Enter in the formula bar hands the
  keys back to the grid. In Word: a click into the page and typing, Ctrl+B
  on a selection, a real drag across a paragraph and a real click on
  Italic, each read back from the engine.
• The run's windows sit off the desktop: to the right of every display,
  out of the taskbar, never activated. Two runs had been ended by hand,
  and a run must never take the keyboard from whoever is working. A window
  closed by anything but the run is reported as such, with the time.
• A ribbon button is waited for rather than expected after a fixed pause,
  and the mail strip likewise; both had missed on a loaded machine.
• The Bold check clicks a shape that has text; the border check accepts any
  border on a scaled display; the mail block waits for its rows.

Built alongside: printing, page setup, rich text, recovery

The gap list (GAPS.md) was written from the code the same day,
and its first entries were built before this release closed.

• Printing. Nothing here could print: Word's button called a command
  that was never defined, Worksheets' asked for a PDF and was refused. Now
  every window has Ctrl+...

Rutba Office 1.6.1

One copy of Rutba Office on a machine, whichever way it was installed.

The installer replaces, never sits beside

The Windows installer now keeps one copy of the suite on a machine. Before
it installs, it finds every registered copy — installed for this user or
for all users, in whichever directory it went to — and runs that copy's own
uninstaller silently, keeping documents and settings where they are. Then
it installs. The same happens when an installed copy updates itself.

Before this, the installer replaced the previous copy in the scope it was
installing to and only that one: a per-user install could land beside an
all-users install from an earlier day, and Windows listed two.

Two smaller things came with it:

• An entry whose uninstaller has gone — the folder deleted by hand — is
  removed from Apps & Features rather than left there, in either scope.

• A copy that cannot be removed (the suite still running, a cancelled
  elevation) stops the install with a message, rather than installing
  beside it. The one promise is that it never ends with two.

The portable build installs nothing and is not counted.

Verified

• On a machine with 1.4.0 installed for this user, the 1.6.1 installer run
  silently left one entry in Apps & Features, 1.6.1, in the same directory,
  and the installed copy opened all eight windows clean.
• With the installed folder removed by hand and the entry left behind, the
  installer forgot the entry and installed afresh into the same directory.
• Engine tests and application checks unchanged from 1.6.0 (609 and 119);
  the release gate was run again before this went out.