@steve31415/baselib 3.33.2 → 3.34.0

package/dist/email.d.ts

@@ -15,6 +15,10 @@ export interface EmailMessage {
     text?: string;
     html?: string;
     attachments?: EmailAttachment[];
+    /** Extra message headers (`X-Coder-Task`, `In-Reply-To`, …), passed to
+     *  Resend's `headers` field as given. Coder uses them so Radar can
+     *  recognise and thread its task mail (2026-10-11). */
+    headers?: Record<string, string>;
 }
 export interface SendEmailResult {
     ok: boolean;

package/dist/email.js

@@ -54,6 +54,7 @@ export async function sendEmail(msg, deps) {
                 subject: msg.subject,
                 ...(msg.text !== undefined ? { text: msg.text } : {}),
                 ...(msg.html !== undefined ? { html: msg.html } : {}),
+                ...(msg.headers && Object.keys(msg.headers).length ? { headers: msg.headers } : {}),
                 ...(msg.attachments?.length
                     ? {
                         attachments: msg.attachments.map((attachment) => ({

package/dist/sync-browser/client.d.ts

@@ -217,12 +217,6 @@ export declare class SyncClient<B, C extends EventBody, S extends EventBody, Sum
      * the page counted as visible is counted (hidden pages are throttled by
      * design and their time is `hiddenMs`). */
     private observeStall;
-    /** The sleep half of `observeStall`, also run by every event-driven entry
-     * that starts, ends or splits the accounting (outage start and end, an
-     * `online` event, a hide): a wake can reach the page as one of those
-     * events before any timer runs, and the sleep must land on the right side
-     * of it (reader, 2026-10-11). */
-    private observeClockJump;
     private setTimer;
     private setRepeating;
     private isHidden;

package/dist/sync-browser/client.js

@@ -382,27 +382,20 @@ export class SyncClient {
      * the page counted as visible is counted (hidden pages are throttled by
      * design and their time is `hiddenMs`). */
     observeStall(dueMono) {
-        this.observeClockJump();
         const mono = this.monoNow();
-        if (!this.isHidden() && mono - dueMono >= STALL_MIN_MS) {
+        const offset = this.now() - mono;
+        const visible = !this.isHidden();
+        if (visible && this.clockOffset !== null && offset - this.clockOffset >= STALL_MIN_MS) {
+            this.counters.stalledMs += offset - this.clockOffset;
+        }
+        this.clockOffset = offset;
+        if (visible && mono - dueMono >= STALL_MIN_MS) {
             const from = Math.max(dueMono, this.stallCoveredUntil, this.visibleSinceMono);
             if (mono > from)
                 this.counters.stalledMs += mono - from;
             this.stallCoveredUntil = mono;
         }
     }
-    /** The sleep half of `observeStall`, also run by every event-driven entry
-     * that starts, ends or splits the accounting (outage start and end, an
-     * `online` event, a hide): a wake can reach the page as one of those
-     * events before any timer runs, and the sleep must land on the right side
-     * of it (reader, 2026-10-11). */
-    observeClockJump() {
-        const offset = this.now() - this.monoNow();
-        if (!this.isHidden() && this.clockOffset !== null && offset - this.clockOffset >= STALL_MIN_MS) {
-            this.counters.stalledMs += offset - this.clockOffset;
-        }
-        this.clockOffset = offset;
-    }
     setTimer(callback, delayMs) {
         const dueMono = this.monoNow() + delayMs;
         return this.options.runtime.setTimeout(() => {
@@ -446,9 +439,8 @@ export class SyncClient {
         if (this.halted || this.disposed || this.hiddenSince !== null)
             return;
         this.finishReturnWindow();
-        // A device that slept with the page visible and hid it on waking: the
-        // sleep counts as stalled, before the hidden spell starts.
-        this.observeClockJump();
+        // A device that slept and then hid the page: the sleep counts as hidden.
+        this.rebaselineClocks();
         this.hiddenSince = this.now();
         this.spellCounters = this.snapshot();
         this.hiddenSocketFailed = false;
@@ -491,7 +483,6 @@ export class SyncClient {
     onOnline() {
         if (this.halted || this.disposed)
             return;
-        this.observeClockJump();
         if (this.isHidden()) {
             if (this.socket === null) {
                 this.cancelBackgroundTick();
@@ -975,10 +966,6 @@ export class SyncClient {
     startOutage(closeCode, wasClean = false) {
         if (this.outageStartedAt !== null)
             return;
-        // A sleep or freeze that ended in this close happened before the outage
-        // began (durationMs starts now): keep it out of the outage's stalledMs.
-        this.observeClockJump();
-        this.stallCoveredUntil = Math.max(this.stallCoveredUntil, this.monoNow());
         this.outageStartedAt = this.options.runtime.now();
         this.outageEscalated = false;
         this.outageCloseCode = closeCode;
@@ -1313,7 +1300,6 @@ export class SyncClient {
     }
     onSyncEstablished() {
         if (this.outageStartedAt !== null) {
-            this.observeClockJump();
             const durationMs = Math.max(0, this.options.runtime.now() - this.outageStartedAt);
             // Failures are only counted (and the ladder only runs) while visible,
             // and the count restarts on each return, so `attempts` is what the

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@steve31415/baselib",
-  "version": "3.33.2",
+  "version": "3.34.0",
   "description": "Plasticine new-world shared platform library: logging, auth, service-to-service auth, db, HTTP, sync, app updates",
   "type": "module",
   "license": "MIT",