@quario/viewer 0.5.0 → 0.6.0

package/CHANGELOG.md

@@ -7,6 +7,28 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.6.0] - 2026-09-07
+
+### Changed
+
+- **Numbers presented through `format` now show a fixed two fraction digits**,
+  the same as every other target: `1,000.00` where the preview showed `1,000`,
+  `21.00%` where it showed `21%`, and a currency's own minor units in place of
+  a universal two. The digits come from the engine, so a page on screen and
+  the PDF of it agree. A formatted cell is also up to three characters wider,
+  so a line that just fitted can wrap and move a page break.
+
+### Fixed
+
+- **A page the browser cannot fully paint no longer fails the render.** An
+  image whose pixel data is corrupt past the size in its header left that page
+  blank _and_ rejected `renderComplete`, so a host awaiting it saw an unhandled
+  rejection instead of an answer, and every page after it on screen went
+  unpainted too. Such an image is now drawn as nothing and the page is drawn
+  around it, marking and all; `renderComplete` resolves `true`, `rendered`
+  fires, and no `error` event is raised. It never rejects for this reason
+  again: a page that cannot be drawn is blank, not a failed render.
+
 ## [0.5.0] - 2026-09-05
 
 ### Changed

package/README.md

@@ -97,13 +97,20 @@ non-bubbling, like `<img>`'s. Listen on the element. (Because the event is named
 inline `onerror` attribute on the element would fire too; `window.onerror` never sees it.)
 
 `renderComplete` awaits the newest render settling: `true` when it landed on the sheet with the pages
-on screen painted, `false` when it failed or there was nothing to render. It never rejects; failures
-arrive on the `error` event. `rendered` fires at that same moment. Like every outcome here, it
-answers for the newest render only. A superseded render's failure is reported to no one.
+on screen finished trying to paint, `false` when it failed or there was nothing to render. It never
+rejects; failures arrive on the `error` event. `rendered` fires at that same moment. Like every
+outcome here, it answers for the newest render only. A superseded render's failure is reported to no
+one.
 
-Your own mistakes surface on the same channel: a report that is not compiled, a missing
-`"html"` target, or a malformed option property becomes a `TypeError` naming the property, on
-the `error` event and the [error panel](#errors).
+An image the browser cannot decode — pixel data corrupt past the size in its header, which is all
+the engine reads — is drawn as nothing, and the page is drawn around it. That is not a render
+failure: `renderComplete` answers `true`, `rendered` fires, and no `error` event is raised. A face in
+`fonts` is a different story: it is parsed while the report is measured, so bytes that will not parse
+are a render error with a panel.
+
+Your own mistakes surface on the same channel: a report that is not compiled, or a malformed
+option property, becomes a `TypeError` naming the property, on the `error` event and the
+[error panel](#errors). No particular target is required — the sheet is the layout's own.
 
 ## Lifecycle
 
@@ -250,7 +257,8 @@ export marks every page: it rides on the layout, so what you see is what the doc
 licensed render carries none.
 
 While a render is in flight a thin indeterminate bar sits on the toolbar's bottom edge, and the
-viewer reads `aria-busy="true"`. It reports that the viewer is working, not how far along. The
+viewer's inner container — the `.qv-viewer` div in its shadow root, not the element itself —
+reads `aria-busy="true"`. It reports that the viewer is working, not how far along. The
 engine streams events and cannot know how many are still coming.
 
 There is no Print button, because the sheet is the wrong thing to print. Your page's stylesheets do
@@ -261,9 +269,9 @@ document, the same bytes the PDF export hands over. A host that wants its own Pr
 two lines:
 
 ```js
-// `pdfTarget` is the pdf() from the quick start above, and `data` whatever you
-// last rendered — so what prints is exactly what the PDF export would produce.
-const bytes = await rpt.render(pdfTarget, data);
+// The same compiled report and data the element holds, through the pdf()
+// target from the quick start — so what prints is exactly the PDF export.
+const bytes = await view.report.render(pdf(), view.data);
 window.open(URL.createObjectURL(new Blob([bytes], { type: "application/pdf" })));
 ```
 
@@ -273,7 +281,7 @@ the export is, watermark and all.
 ## Errors
 
 When a render or an export fails, the viewer says so on the **error panel**, a strip across the top
-of the sheet carrying a short label and the error's own message. It replaces rather than stacks, is
+of the sheet carrying a short label — "Could not render the report", "Could not update the report — showing the previous version", or "Could not export PDF" — and the error's own message. It replaces rather than stacks, is
 dismissed by its own button, and is cleared by the next render that lands on the sheet. A successful
 export leaves it up, because the panel describes what you are looking at and a download says
 nothing about that.

package/lib/index.d.ts

@@ -97,10 +97,11 @@ export class QuarioViewer extends LitElement {
   colorScheme: "light" | "dark" | "auto" | undefined;
   /**
    * The newest render settling: `true` when it landed on the sheet with the
-   * pages on screen painted, `false` when it failed or there was nothing to
-   * render. Never rejects — failures are the `error` event's — and like every
-   * outcome here it answers for the newest render only. `rendered` fires at
-   * that same moment.
+   * pages on screen finished trying to paint, `false` when it failed or there
+   * was nothing to render. A page the browser could not draw is blank and the
+   * render still landed. Never rejects — failures are the
+   * `error` event's — and like every outcome here it answers for the newest
+   * render only. `rendered` fires at that same moment.
    */
   get renderComplete(): Promise<boolean>;
 

package/lib/index.js

@@ -112,7 +112,13 @@ export class QuarioViewer extends LitElement {
   #exporting = new Set();
   /** @type {(() => void) | undefined} */
   #unwatch;
-  /** @type {Promise<void>} The newest swap's paint, which `renderComplete` waits behind. */
+  /**
+   * The newest swap's paint, which `renderComplete` waits behind. Bare, with
+   * no catch of its own: the stage settles a page it cannot draw rather than
+   * rejecting, so the chain below is reached whatever the pixels did.
+   *
+   * @type {Promise<void>}
+   */
   #painting = Promise.resolve();
 
   // The whole async pipeline: keyed on the render properties, re-run when one
@@ -186,10 +192,13 @@ export class QuarioViewer extends LitElement {
   }
 
   /**
-   * The newest render settling: `true` when it landed on the sheet, `false`
-   * when it failed or there was nothing to render. It never rejects — a
-   * failed render is handled, on the panel and through the error event — and
-   * like every outcome here it answers for the newest render only.
+   * The newest render settling: `true` when it landed on the sheet — after
+   * its pages have finished trying to paint — `false` when it failed or there
+   * was nothing to render. A page the browser could not draw is blank and the
+   * render still landed, so `true` promises the sheet is done changing, not
+   * that every page carries pixels. It never rejects — a failed
+   * render is handled, on the panel and through the error event — and like
+   * every outcome here it answers for the newest render only.
    *
    * @returns {Promise<boolean>}
    */

package/lib/stage.js

@@ -21,6 +21,19 @@
  * asked a thousand-page report for gigabytes of backing store, and past what
  * the browser would grant the pages simply came up blank.
  *
+ * **A page the browser will not paint is blank, not a failure.** `start`
+ * swallows and nothing here rejects: the report laid out and the list reached
+ * the sheet, which is all a render promised, so the surfaces have no channel
+ * for it and deliberately grow none.
+ *
+ * Little reaches it. An image that will not decode is the layout's own to
+ * absorb — `paint` draws it as nothing and draws the page around it — and a
+ * face is parsed with fontkit while the report is measured, so bytes that will
+ * not parse are a render error long before the sheet. What is left is the face
+ * fontkit accepted and the browser refuses, which the browser suite drives by
+ * making `FontFace.prototype.load` reject under a record handed straight to
+ * `swap`.
+ *
  * **A canvas on the sheet is never re-pointed at a second paint.** `paint()`
  * awaits before it draws, so a canvas whose paint is still in flight is
  * *retired* rather than painted over or emptied: it comes off the sheet, its
@@ -287,6 +300,20 @@ export let stage = () => {
    * the next pass over the reach tries again instead of counting the page as
    * painted; one that settles joins `settled`.
    *
+   * **The paint this answers with never rejects**, which is the whole of why
+   * `swap` does not either. A page that could not be drawn is not a render
+   * that failed: the report laid out and the list reached the sheet, so there
+   * is nothing for the error panel to say and nothing to report through the
+   * error event. Swallowed here, the one place a paint begins, so no caller
+   * has to remember to; one bad page then costs its own pixels rather than
+   * every page after it in the reach, which this loop awaits one at a time.
+   *
+   * See the header for how little can still reach it — the layout absorbs a
+   * bad image and refuses a bad face while measuring — and why it stays
+   * anyway. A paint that failed is forgotten so the next pass over the reach
+   * tries again, which is what makes a failure for a passing reason
+   * recoverable.
+   *
    * @type {(i: number) => Promise<void>}
    */
   let start = (i) => {
@@ -302,9 +329,8 @@ export let stage = () => {
       () => {
         settled.add(canvas);
       },
-      (failure) => {
+      () => {
         backed.delete(canvas);
-        throw failure;
       },
     );
     backed.set(canvas, { scale, painted });
@@ -422,9 +448,8 @@ export let stage = () => {
    * keeps no epoch of its own, so a swap painting behind it is never cut off
    * part-painted, and a page it starts is one a swap arriving at the same page
    * waits behind rather than skips. Nothing awaits these paints here: a scroll
-   * is not a render and has no failure channel of its own, and a paint that
-   * failed is forgotten, so the next pass over the reach reports it the way
-   * any other paint does.
+   * is not a render, and a page that will not paint is blank whoever asked for
+   * it — `start` settles either way, so there is nothing here to catch.
    */
   let pending = false;
   let follow = () => {
@@ -433,7 +458,7 @@ export let stage = () => {
     requestAnimationFrame(() => {
       pending = false;
       if (!list) return;
-      for (let i of keep()) paintPage(i).catch(() => {});
+      for (let i of keep()) void paintPage(i);
     });
   };
   scroll.addEventListener("scroll", follow);
@@ -510,7 +535,9 @@ export let stage = () => {
      * — and the reach is read from those offsets, so it is chosen after they
      * are in. What the
      * returned promise settles behind is the reach, which is what the caller's
-     * `renderComplete` means by "the pages on screen are painted".
+     * `renderComplete` means by "the pages on screen have finished trying to
+     * paint" — and **it never rejects**, because `start` swallows a page the
+     * browser will not draw and the reach walks on past it.
      */
     swap: async (next, faces) => {
       // Reading the offsets flushes layout, so only an actual reswap pays for

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@quario/viewer",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "The embeddable report viewer shell for quario — in the makings, not yet released",
   "homepage": "https://getquario.com",
   "license": "SEE LICENSE IN LICENSE",
@@ -44,7 +44,7 @@
   },
   "dependencies": {
     "@lit/task": "^1.0.3",
-    "@quario/layout": "^0.2.0",
+    "@quario/layout": "^0.3.0",
     "lit": "^3.3.3"
   },
   "devDependencies": {
@@ -53,12 +53,12 @@
     "@size-limit/preset-small-lib": "^13.0.3",
     "esbuild": "^0.28.2",
     "exceljs": "^4.4.0",
-    "quario": "^0.5.0",
+    "quario": "^0.6.0",
     "size-limit": "^13.0.3",
     "typescript": "^7.0.2"
   },
   "peerDependencies": {
-    "quario": "^0.5.0"
+    "quario": "^0.6.0"
   },
   "size-limit": [
     {