@fabriktor/fx 0.0.147 → 0.0.149

package/dist/src/chat/forms.js

@@ -1,5 +1,5 @@
 import { normalizeIDs, resolvedID } from "../core/id.js";
-import { isFabriktorUser, userSupportsMode } from "../users/users.js";
+import { isFabriktorUser, isOtherUserID, userSupportsMode, } from "../users/users.js";
 // Recipients are all other members of the conversation, resolved before use.
 // Sender modes apply now; recipient modes describe what their identity supports.
 // Do not depend on the recipient's current mode, which Public() omits.
@@ -10,7 +10,7 @@ export function canSendChatForm(policy, actor, recipients) {
         (policy.allow_group || recipients.length === 1) &&
         normalizeIDs(recipients.map((recipient) => recipient.id)).length ===
             recipients.length &&
-        recipients.every((recipient) => recipient.id !== actor.owner_id &&
+        recipients.every((recipient) => isOtherUserID(recipient.id, actor.owner_id) &&
             isFabriktorUser(recipient) &&
             policy.recipient_modes.some((mode) => userSupportsMode(recipient, mode))));
 }

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

@@ -48,6 +48,7 @@ export type ChatSendQueueOptions = {
     upload: (entry: QueuedChat, signal: AbortSignal) => Promise<boolean>;
     changed?: (chat?: Chat) => void;
     online?: () => boolean;
+    on_error?: (error: unknown) => void;
 };
 export declare class ChatSendQueue {
     private readonly opts;
@@ -87,6 +88,7 @@ export declare class ChatSendQueue {
     private startConfirmation;
     private startUpload;
     private recoverUpload;
+    private report;
     private waitForRetry;
     private recoverStorage;
     private scheduleRecovery;

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 { createEvent, EventBus } from "../core/events.js";
+import { createEvent, EventBus, notifyObserver, } from "../core/events.js";
 import { PersistentQueue, QueueWakeup, nextQueueRetry, } from "../core/queue.js";
 import { newOptimisticChat } from "./optimistic.js";
 export const ChatSendStatus = {
@@ -141,6 +141,7 @@ export class ChatSendQueue {
                     this.pendingSaves.set(entry.id, failed);
                     this.replace(failed);
                     if (entry.owner_id === this.owner) {
+                        this.report(err);
                         this.error = err;
                         this.publish();
                     }
@@ -198,7 +199,9 @@ export class ChatSendQueue {
             }
             for (const entry of stored) {
                 if (chatSendCanConfirm(entry) ||
-                    (!entry.chat && entry.server_id && this.confirmed.has(entry.server_id))) {
+                    (!entry.chat &&
+                        entry.server_id &&
+                        this.confirmed.has(entry.server_id))) {
                     this.startConfirmation(entry, owner, signal);
                 }
                 if (entry.chat && entry.status === ChatSendStatus.Uploading) {
@@ -208,6 +211,7 @@ export class ChatSendQueue {
         }
         catch (err) {
             if (this.current(owner, signal)) {
+                this.report(err);
                 this.error = err;
                 this.publish();
                 this.recoverStorage();
@@ -321,6 +325,7 @@ export class ChatSendQueue {
             select: (entry) => entry.input.chat_room_id === room && chatSendCanCreate(entry),
             on_error: (err) => {
                 if (this.current(owner, signal)) {
+                    this.report(err);
                     this.error = err;
                     this.publish();
                     this.recoverStorage();
@@ -390,12 +395,14 @@ export class ChatSendQueue {
                     }
                     this.startConfirmation(current, owner, signal);
                 }
-                catch {
+                catch (error) {
                     // remove() owns deliberate cancellation and removes the durable entry
                     // under this same room lock. Do not publish a transient send failure.
                     if (this.cancellations.has(entry.id) && !current.server_id) {
                         return false;
                     }
+                    if (this.current(owner, signal))
+                        this.report(error);
                     current = {
                         ...current,
                         attempted: current.attempted && (requestStarted || !!current.server_id),
@@ -409,6 +416,7 @@ export class ChatSendQueue {
                         this.pendingCreates.delete(current.id);
                     }
                     catch (storageError) {
+                        this.report(storageError);
                         this.error = storageError;
                         this.publish();
                         this.recoverStorage();
@@ -487,7 +495,9 @@ export class ChatSendQueue {
                     this.opts.changed?.(chat);
                 }
             }
-            catch {
+            catch (error) {
+                if (this.current(owner, signal))
+                    this.report(error);
                 await this.save({
                     ...current,
                     retry: undefined,
@@ -501,6 +511,7 @@ export class ChatSendQueue {
         })
             .catch((err) => {
             if (this.current(owner, signal)) {
+                this.report(err);
                 this.error = err;
                 this.publish();
                 this.recoverStorage();
@@ -563,7 +574,9 @@ export class ChatSendQueue {
                 this.publish();
                 this.opts.changed?.(this.confirmed.get(entry.server_id));
             }
-            catch {
+            catch (error) {
+                if (this.current(owner, signal))
+                    this.report(error);
                 await this.save({
                     ...entry,
                     status: ChatSendStatus.UploadInterrupted,
@@ -572,6 +585,7 @@ export class ChatSendQueue {
         })
             .catch((err) => {
             if (this.current(owner, signal)) {
+                this.report(err);
                 this.error = err;
                 this.publish();
             }
@@ -616,6 +630,7 @@ export class ChatSendQueue {
                 if (!this.current(owner, signal)) {
                     return;
                 }
+                this.report(err);
                 this.error = err;
             }
             await this.save({
@@ -625,12 +640,17 @@ export class ChatSendQueue {
         })
             .catch((err) => {
             if (this.current(owner, signal)) {
+                this.report(err);
                 this.error = err;
                 this.publish();
             }
         })
             .finally(() => this.uploads.delete(entry.id));
     }
+    report(error) {
+        if (this.opts.on_error)
+            notifyObserver(() => this.opts.on_error?.(error));
+    }
     waitForRetry(entry) {
         if (!entry.retry || entry.retry.after <= Date.now())
             return false;

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

@@ -5,6 +5,8 @@ export type EventKey<T> = symbol & {
 export type EventListener<T> = (value: T) => void | Promise<void>;
 export declare function createEvent<T>(): EventKey<T>;
 export declare function notifyObserver(run: () => unknown): void;
+type ObserverErrorHandler = (error: unknown) => void;
+export declare function setObserverErrorHandler(handler: ObserverErrorHandler): () => void;
 export declare class EventBus {
     private readonly listeners;
     subscribe<T>(event: EventKey<T>, listener: EventListener<NoInfer<T>>, initial?: () => T): () => void;

package/dist/src/core/events.js

@@ -14,9 +14,28 @@ export function notifyObserver(run) {
         observerError(err);
     }
 }
-function observerError(err) {
+function defaultObserverError(err) {
     console.error("Event observer failed.", err);
 }
+let observerErrorHandler = defaultObserverError;
+// Apps own diagnostic presentation; independent FX consumers keep the existing
+// console fallback. Observer failures must never break a completed mutation.
+export function setObserverErrorHandler(handler) {
+    const previous = observerErrorHandler;
+    observerErrorHandler = handler;
+    return () => {
+        if (observerErrorHandler === handler)
+            observerErrorHandler = previous;
+    };
+}
+function observerError(err) {
+    try {
+        observerErrorHandler(err);
+    }
+    catch {
+        defaultObserverError(err);
+    }
+}
 export class EventBus {
     listeners = new Map();
     subscribe(event, listener, initial) {

package/dist/src/core/search-controller.d.ts

@@ -11,6 +11,7 @@ export type SearchState<T> = {
 export type SearchControllerOptions<T, Options extends SearchOptions> = {
     search: (opts: Options) => Promise<SearchPage<T>>;
     on_change: (state: SearchState<T>) => void;
+    on_error?: (error: unknown) => void;
 };
 export declare class SearchController<T extends SearchResultWithID, Options extends SearchOptions> {
     private readonly options;

package/dist/src/core/search-controller.js

@@ -5,6 +5,7 @@
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 import { appendUniqueSearchResults, normalizeSearchPage, } from "./search.js";
 import { errUnknown } from "./err.js";
+import { notifyObserver } from "./events.js";
 // Holds only the current selection and its displayed pages. Previous queries
 // are discarded, and revisiting a selection always makes a backend request.
 export class SearchController {
@@ -96,6 +97,8 @@ export class SearchController {
                 loading_more: false,
                 error: errUnknown(error),
             });
+            if (this.options.on_error)
+                notifyObserver(() => this.options.on_error?.(error));
             return false;
         }
         finally {

package/dist/src/users/users.d.ts

@@ -17,6 +17,7 @@ export type UpdateExternalUserOptions = {
 };
 export declare function userSupportsMode(user: Pick<User, "account_identity"> | null | undefined, mode: User["active_mode"]): boolean;
 export declare function isFabriktorUser(user: Pick<User, "account_identity"> | null | undefined): boolean;
+export declare function isOtherUserID(user_id: string | null | undefined, owner_id: string | null | undefined): boolean;
 export declare function canManageExternalUser(user: User | null | undefined, owner_id: string): boolean;
 export type SearchExternalUsersOptions = SearchUsersOptions;
 export type SearchExternalUsersPage = SearchUsersPage;

package/dist/src/users/users.js

@@ -44,6 +44,13 @@ export function userSupportsMode(user, mode) {
 export function isFabriktorUser(user) {
     return userSupportsMode(user, UserTypeClient);
 }
+// Client capability and being a different party are separate requirements.
+// Apply this to counterparties, not to ownership or employee scope filters.
+export function isOtherUserID(user_id, owner_id) {
+    const userID = resolvedID(user_id ?? undefined);
+    const ownerID = resolvedID(owner_id ?? undefined);
+    return !!userID && !!ownerID && userID !== ownerID;
+}
 export function canManageExternalUser(user, owner_id) {
     return (!!resolvedID(owner_id) &&
         user?.account_identity === UserTypeExternal &&

package/package.json

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