@fabriktor/fx 0.0.104 → 0.0.105

package/dist/src/chat/send-queue.d.ts

@@ -1,6 +1,6 @@
 import type { ChatOperator } from "@fabriktor/client";
 import type { Chat, InChat } from "@fabriktor/schema";
-import { type QueueStore, type QueueLock } from "../core/queue.js";
+import { type QueueRetry, type QueueStore, type QueueLock } from "../core/queue.js";
 export declare const ChatSendStatus: {
     readonly Saving: "saving";
     readonly Queued: "queued";
@@ -28,6 +28,7 @@ export type QueuedChat = {
     chat?: Chat;
     attachments: ChatSendAttachments;
     attempted: boolean;
+    retry?: QueueRetry;
     upload_key: string;
     personal_box_key: string;
 };
@@ -64,6 +65,9 @@ export declare class ChatSendQueue {
     private error?;
     private enabled;
     private revision;
+    private readonly wakeup;
+    private storageRetry?;
+    private pendingCreates;
     constructor(opts: ChatSendQueueOptions);
     get hasUnsavedMessages(): boolean;
     get snapshot(): ChatSendSnapshot;
@@ -80,6 +84,9 @@ export declare class ChatSendQueue {
     private startConfirmation;
     private startUpload;
     private recoverUpload;
+    private waitForRetry;
+    private recoverStorage;
+    private scheduleRecovery;
     private uploadLock;
     private confirmationLock;
     private roomLock;

package/dist/src/chat/send-queue.js

@@ -4,7 +4,7 @@
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 import { requiredOperationID } from "../core/id.js";
-import { PersistentQueue, } from "../core/queue.js";
+import { PersistentQueue, QueueWakeup, nextQueueRetry, } from "../core/queue.js";
 import { newOptimisticChat } from "./optimistic.js";
 export const ChatSendStatus = {
     Saving: "saving",
@@ -17,7 +17,8 @@ export const ChatSendStatus = {
     UploadInterrupted: "upload_interrupted",
 };
 // Persistent creation FIFO per account and room. Creation never advances beyond
-// a failed/uncertain head. Retrieval, other rooms and other users are independent.
+// an uncertain head: it recovers automatically with its original request key.
+// Retrieval, attachments, other rooms and other users are independent.
 export class ChatSendQueue {
     opts;
     owner = "";
@@ -36,6 +37,9 @@ export class ChatSendQueue {
     error;
     enabled = false;
     revision = 0;
+    wakeup = new QueueWakeup();
+    storageRetry;
+    pendingCreates = new Map();
     constructor(opts) {
         this.opts = opts;
         this.queue = new PersistentQueue(opts.store, opts.lock);
@@ -58,7 +62,8 @@ export class ChatSendQueue {
     }
     async start(ownerID) {
         if (this.enabled && this.owner === ownerID) {
-            await this.refresh();
+            this.persist();
+            await this.writes;
             return;
         }
         this.pause();
@@ -72,11 +77,13 @@ export class ChatSendQueue {
         this.enabled = ownerID !== "";
         this.controller = new AbortController();
         this.publish();
-        await this.refresh();
+        this.persist();
+        await this.writes;
     }
     pause() {
         this.enabled = false;
         this.controller.abort();
+        this.wakeup.cancel();
     }
     enqueue(input, attachments) {
         if (!this.enabled || !this.owner) {
@@ -106,23 +113,28 @@ export class ChatSendQueue {
         this.writes = this.writes.then(async () => {
             const blocked = new Set();
             for (const entry of this.pendingSaves.values()) {
-                if (entry.status !== ChatSendStatus.Saving) {
+                if (!this.current(entry.owner_id, this.controller.signal))
+                    continue;
+                if (this.waitForRetry(entry) || blocked.has(entry.owner_id)) {
                     blocked.add(entry.owner_id);
-                }
-                if (blocked.has(entry.owner_id)) {
                     continue;
                 }
                 try {
                     const saved = await this.queue.enqueue({
                         ...entry,
                         status: ChatSendStatus.Queued,
+                        retry: undefined,
                     });
                     this.pendingSaves.delete(entry.id);
                     this.replace(saved);
                     this.opts.changed?.();
                 }
                 catch (err) {
-                    const failed = { ...entry, status: ChatSendStatus.Failed };
+                    const failed = {
+                        ...entry,
+                        status: ChatSendStatus.Failed,
+                        retry: nextQueueRetry(entry.retry),
+                    };
                     this.pendingSaves.set(entry.id, failed);
                     this.replace(failed);
                     if (entry.owner_id === this.owner) {
@@ -130,6 +142,7 @@ export class ChatSendQueue {
                         this.publish();
                     }
                     blocked.add(entry.owner_id);
+                    this.waitForRetry(failed);
                 }
             }
             await this.refresh();
@@ -166,7 +179,10 @@ export class ChatSendQueue {
                 }
             }
             this.error = undefined;
+            this.storageRetry = undefined;
             this.publish();
+            if (stored.length === 0 && this.pendingSaves.size === 0)
+                this.wakeup.cancel();
             for (const room of new Set(stored
                 .filter((entry) => !entry.chat && !entry.server_id)
                 .map((entry) => entry.input.chat_room_id))) {
@@ -185,6 +201,7 @@ export class ChatSendQueue {
             if (this.current(owner, signal)) {
                 this.error = err;
                 this.publish();
+                this.recoverStorage();
             }
         }
     }
@@ -197,7 +214,11 @@ export class ChatSendQueue {
             if (entry.status !== ChatSendStatus.Failed) {
                 return;
             }
-            const saving = { ...entry, status: ChatSendStatus.Saving };
+            const saving = {
+                ...entry,
+                status: ChatSendStatus.Saving,
+                retry: undefined,
+            };
             this.pendingSaves.set(id, saving);
             this.replace(saving);
             this.persist();
@@ -221,6 +242,7 @@ export class ChatSendQueue {
             else {
                 await this.save({
                     ...current,
+                    retry: undefined,
                     status: current.server_id
                         ? ChatSendStatus.Confirming
                         : ChatSendStatus.Queued,
@@ -266,6 +288,7 @@ export class ChatSendQueue {
                 if (stored && !chatSendCanRemove(stored))
                     return;
                 await this.opts.store.remove(id);
+                this.pendingCreates.delete(id);
                 this.entries = this.entries.filter((value) => value.id !== id);
                 this.publish();
                 this.opts.changed?.();
@@ -290,6 +313,7 @@ export class ChatSendQueue {
                 if (this.current(owner, signal)) {
                     this.error = err;
                     this.publish();
+                    this.recoverStorage();
                 }
             },
             on_idle: () => {
@@ -301,54 +325,65 @@ export class ChatSendQueue {
                 if (!this.current(owner, signal) || this.cancellations.has(entry.id)) {
                     return false;
                 }
-                if (entry.status === ChatSendStatus.Sending) {
-                    await this.save({ ...entry, status: ChatSendStatus.Interrupted });
+                // A persisted Sending marker is an interrupted request once we own
+                // the room lock. Reuse its key; never skip an unknown creation outcome.
+                let current = this.pendingCreates.get(entry.id) ?? entry;
+                if (this.waitForRetry(current))
                     return false;
-                }
-                else if (entry.status !== ChatSendStatus.Queued) {
-                    return false;
-                }
-                let current = entry;
                 const request = new AbortController();
                 const requestSignal = AbortSignal.any([signal, request.signal]);
                 this.sends.set(entry.id, request);
                 try {
-                    current = {
-                        ...entry,
-                        status: ChatSendStatus.Sending,
-                        attempted: true,
-                    };
-                    await this.save(current);
-                    if (!this.current(owner, signal)) {
-                        return false;
+                    if (!current.server_id) {
+                        current = {
+                            ...current,
+                            status: ChatSendStatus.Sending,
+                            attempted: true,
+                        };
+                        await this.save(current);
+                        if (!this.current(owner, signal))
+                            return false;
+                        requestSignal.throwIfAborted();
+                        const out = await this.opts.chat.insertOneChat({
+                            in: current.input,
+                            signal: requestSignal,
+                            idempotency_key: current.id,
+                        });
+                        current = {
+                            ...current,
+                            server_id: requiredOperationID(out, "Created chat response did not contain an ID."),
+                        };
+                        this.pendingCreates.set(current.id, current);
                     }
-                    requestSignal.throwIfAborted();
-                    const out = await this.opts.chat.insertOneChat({
-                        in: current.input,
-                        signal: requestSignal,
-                        idempotency_key: current.id,
-                    });
                     current = {
                         ...current,
                         status: ChatSendStatus.Confirming,
-                        server_id: requiredOperationID(out, "Created chat response did not contain an ID."),
+                        retry: undefined,
                     };
                     // Persist successful creation before advancing the room's FIFO. A
                     // later retrieval failure must never cause this POST to be repeated.
                     await this.save(current);
+                    this.pendingCreates.delete(current.id);
                     if (!this.current(owner, signal)) {
                         return false;
                     }
                     this.startConfirmation(current, owner, signal);
                 }
                 catch (err) {
+                    current = {
+                        ...current,
+                        status: requestSignal.aborted
+                            ? ChatSendStatus.Interrupted
+                            : ChatSendStatus.Failed,
+                        retry: requestSignal.aborted
+                            ? undefined
+                            : nextQueueRetry(current.retry),
+                    };
+                    if (current.server_id)
+                        this.pendingCreates.set(current.id, current);
                     try {
-                        await this.save({
-                            ...current,
-                            status: requestSignal.aborted
-                                ? ChatSendStatus.Interrupted
-                                : ChatSendStatus.Failed,
-                        });
+                        await this.save(current);
+                        this.pendingCreates.delete(current.id);
                     }
                     catch (storageError) {
                         this.error = storageError;
@@ -356,6 +391,8 @@ export class ChatSendQueue {
                     if (this.current(owner, signal) && !request.signal.aborted) {
                         this.error = err;
                         this.publish();
+                        if (current.retry)
+                            this.scheduleRecovery(current.retry.after);
                     }
                     return false;
                 }
@@ -369,7 +406,7 @@ export class ChatSendQueue {
     // Retrieval is independent of the room's creation lock. Its per-message
     // lock coordinates retries/recovery across tabs without holding later POSTs.
     startConfirmation(entry, owner, signal) {
-        if (this.confirmations.has(entry.id)) {
+        if (this.confirmations.has(entry.id) || this.waitForRetry(entry)) {
             return;
         }
         this.confirmations.add(entry.id);
@@ -379,7 +416,9 @@ export class ChatSendQueue {
                 return;
             }
             const stored = (await this.opts.store.list(owner)).find((value) => value.id === entry.id);
-            if (!stored || !chatSendCanConfirm(stored)) {
+            if (!stored ||
+                !chatSendCanConfirm(stored) ||
+                this.waitForRetry(stored)) {
                 return;
             }
             let current = stored;
@@ -406,6 +445,7 @@ export class ChatSendQueue {
                         ...current,
                         chat,
                         status: ChatSendStatus.UploadInterrupted,
+                        retry: undefined,
                     };
                     await this.save(current);
                     this.startUpload(current, owner, signal);
@@ -418,8 +458,15 @@ export class ChatSendQueue {
                 }
             }
             catch (err) {
+                const retry = signal.aborted
+                    ? undefined
+                    : nextQueueRetry(current.retry);
+                if (retry && !current.chat && this.current(owner, signal)) {
+                    this.scheduleRecovery(retry.after);
+                }
                 await this.save({
                     ...current,
+                    retry,
                     status: current.chat
                         ? ChatSendStatus.UploadInterrupted
                         : signal.aborted
@@ -436,6 +483,7 @@ export class ChatSendQueue {
             if (this.current(owner, signal)) {
                 this.error = err;
                 this.publish();
+                this.recoverStorage();
             }
         })
             .finally(() => {
@@ -563,6 +611,25 @@ export class ChatSendQueue {
         })
             .finally(() => this.uploads.delete(entry.id));
     }
+    waitForRetry(entry) {
+        if (!entry.retry || entry.retry.after <= Date.now())
+            return false;
+        this.scheduleRecovery(entry.retry.after);
+        return true;
+    }
+    recoverStorage() {
+        this.storageRetry = nextQueueRetry(this.storageRetry);
+        this.scheduleRecovery(this.storageRetry.after);
+    }
+    scheduleRecovery(after) {
+        if (!this.enabled)
+            return;
+        this.wakeup.schedule(after, this.controller.signal, () => {
+            // Persist also refreshes the durable queue. It is app-owned, never
+            // dependent on a mounted chat tool or a presentation subscription.
+            this.persist();
+        });
+    }
     uploadLock(entry) {
         return `chat-upload:${entry.owner_id}:${entry.id}`;
     }
@@ -614,7 +681,8 @@ function chatSendCanConfirm(entry) {
         (entry.status === ChatSendStatus.Confirming ||
             entry.status === ChatSendStatus.Sending ||
             entry.status === ChatSendStatus.Queued ||
-            entry.status === ChatSendStatus.Interrupted));
+            entry.status === ChatSendStatus.Interrupted ||
+            entry.status === ChatSendStatus.Failed));
 }
 export function chatSendNeedsRetry(entry) {
     return (entry.status === ChatSendStatus.Failed ||

package/dist/src/core/date.d.ts

@@ -1,4 +1,5 @@
 import type { Date as SchemaDate, InDate } from "@fabriktor/schema";
+export declare const utcTimezone = "UTC";
 export type LocalDateParts = {
     y: number;
     m: number;
@@ -12,3 +13,6 @@ export declare function zeroDate(): SchemaDate;
 export declare function isZeroDate(v: LocalDateParts): boolean;
 export declare function isZeroDateTime(value: string | null | undefined): boolean;
 export declare function isZeroSchemaDate(value: SchemaDate | null | undefined): boolean;
+export declare function dateTimezone(timezone: string): string;
+export declare function inDateAtTimestamp(timestamp: string, timezone?: string): InDate | null;
+export declare function timestampDate(timestamp: string): globalThis.Date | null;

package/dist/src/core/date.js

@@ -16,7 +16,7 @@ const zeroDatePrefix = [
     String(zeroDateParts.d).padStart(2, "0"),
 ].join("-");
 const zeroUTC = `${zeroDatePrefix}T00:00:00Z`;
-const utcTimezone = "UTC";
+export const utcTimezone = "UTC";
 export function normalizeInputDate(v) {
     if (isZeroDate(v)) {
         return zeroInputDate();
@@ -53,3 +53,48 @@ export function isZeroSchemaDate(value) {
         value === undefined ||
         (isZeroDate(value) && isZeroDateTime(value.utc)));
 }
+// Use the account/location timezone explicitly; never consult the browser's
+// timezone when interpreting a persisted UTC timestamp.
+export function dateTimezone(timezone) {
+    const value = timezone.trim();
+    if (!value)
+        return utcTimezone;
+    try {
+        new Intl.DateTimeFormat("en", { timeZone: value });
+        return value;
+    }
+    catch {
+        return utcTimezone;
+    }
+}
+export function inDateAtTimestamp(timestamp, timezone = utcTimezone) {
+    const instant = timestampDate(timestamp);
+    if (!instant)
+        return null;
+    const tz = dateTimezone(timezone);
+    const parts = new Intl.DateTimeFormat("en-CA", {
+        timeZone: tz,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hourCycle: "h23",
+    }).formatToParts(instant);
+    const part = (type) => Number(parts.find((value) => value.type === type)?.value);
+    return {
+        y: part("year"),
+        m: part("month"),
+        d: part("day"),
+        h: part("hour"),
+        min: part("minute"),
+        tz,
+    };
+}
+export function timestampDate(timestamp) {
+    if (isZeroDateTime(timestamp) || !/(?:Z|[+-]\d{2}:\d{2})$/i.test(timestamp)) {
+        return null;
+    }
+    const instant = new globalThis.Date(timestamp);
+    return Number.isFinite(instant.getTime()) ? instant : null;
+}

package/dist/src/core/queue.d.ts

@@ -3,6 +3,16 @@ export type QueueRecord = {
     owner_id: string;
     sequence?: number;
 };
+export type QueueRetry = {
+    attempts: number;
+    after: number;
+};
+export declare function nextQueueRetry(previous?: QueueRetry): QueueRetry;
+export declare class QueueWakeup {
+    private pending?;
+    schedule(after: number, signal: AbortSignal, run: () => void): void;
+    cancel(): void;
+}
 export interface QueueStore<T extends QueueRecord> {
     add(entry: T): Promise<T>;
     put(entry: T): Promise<void>;

package/dist/src/core/queue.js

@@ -3,6 +3,39 @@
 // Licensed under the Apache License, Version 2.0 (the "License"); you may
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+const queueRetryInitialMilliseconds = 1_000;
+const queueRetryMaximumMilliseconds = 30_000;
+// Durable deadlines prevent refreshes and other tabs from bypassing backoff.
+export function nextQueueRetry(previous) {
+    const attempts = (previous?.attempts ?? 0) + 1;
+    const delay = Math.min(queueRetryMaximumMilliseconds, queueRetryInitialMilliseconds * 2 ** (attempts - 1));
+    return { attempts, after: Date.now() + delay };
+}
+// One wakeup for the earliest pending recovery. A paused account must never
+// be restarted by an old timer. The caller re-reads durable state on wakeup.
+export class QueueWakeup {
+    pending;
+    schedule(after, signal, run) {
+        if (signal.aborted || (this.pending && this.pending.after <= after))
+            return;
+        this.cancel();
+        const cancel = () => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", cancel);
+            this.pending = undefined;
+        };
+        const timer = setTimeout(() => {
+            cancel();
+            if (!signal.aborted)
+                run();
+        }, Math.max(0, after - Date.now()));
+        this.pending = { after, cancel };
+        signal.addEventListener("abort", cancel, { once: true });
+    }
+    cancel() {
+        this.pending?.cancel();
+    }
+}
 // Store order is authoritative across views/tabs. Each scope has one worker;
 // run must durably retire the head before returning true. False pauses the
 // lane without blocking other scopes. Storage/transport failures never skip it.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabriktor/fx",
-  "version": "0.0.104",
+  "version": "0.0.105",
   "description": "![Fabriktor Logo](./img/fabriktor-character.gif)",
   "type": "module",
   "exports": {