@fabriktor/fx 0.0.148 → 0.0.150

package/dist/src/chat/data.js

@@ -14,19 +14,24 @@ export function newChatData(type, payload) {
         type,
         payload,
     };
-    if (!validChatData(data))
-        throw errValidation({ msg: msgChatData });
-    return structuredClone(data);
+    // JSON snapshots also accept reactive UI objects without structuredClone's
+    // Proxy failure. Validation and size limits are shared with sending.
+    return JSON.parse(serializeChatData(data));
 }
 export function encodeChatContent(text, data) {
     if (!data)
         return text;
-    if (!text.trim() || text.includes(chatDataMarker) || !validChatData(data))
+    if (!text.trim() || text.includes(chatDataMarker))
+        throw errValidation({ msg: msgChatData });
+    return text.trim() + chatDataMarker + serializeChatData(data);
+}
+function serializeChatData(data) {
+    if (!validChatData(data))
         throw errValidation({ msg: msgChatData });
     const value = JSON.stringify(data);
     if (new TextEncoder().encode(value).length > chatDataMaximumBytes)
         throw errValidation({ msg: msgChatData });
-    return text.trim() + chatDataMarker + value;
+    return value;
 }
 export function decodeChatContent(value) {
     const boundary = value.indexOf(chatDataMarker);

package/dist/src/chat/forms.d.ts

@@ -1,9 +1,16 @@
 import type { User } from "@fabriktor/schema";
 import type { EmploymentActor } from "../contacts/scope.js";
+import { type ChatData, type ChatJSON } from "./data.js";
 export type ChatFormRecipient = Pick<User, "id" | "account_identity">;
 export type ChatFormPolicy = {
     readonly sender_modes: readonly User["active_mode"][];
     readonly recipient_modes: readonly User["active_mode"][];
     readonly allow_group: boolean;
 };
+export type ChatFormContextDefinition<T extends ChatJSON> = {
+    readonly version: number;
+    readonly read: (value: ChatJSON | undefined) => T | undefined;
+};
+export declare function newChatFormData<T extends ChatJSON>(type: string, payload: ChatData["payload"], definition: ChatFormContextDefinition<T>, context: T): ChatData;
+export declare function readChatFormContext<T extends ChatJSON>(data: ChatData, definition: ChatFormContextDefinition<T>): T;
 export declare function canSendChatForm(policy: ChatFormPolicy, actor: EmploymentActor, recipients: readonly ChatFormRecipient[]): boolean;

package/dist/src/chat/forms.js

@@ -1,5 +1,29 @@
+import { errValidation } from "../core/err.js";
 import { normalizeIDs, resolvedID } from "../core/id.js";
+import { newChatData } from "./data.js";
 import { isFabriktorUser, isOtherUserID, userSupportsMode, } from "../users/users.js";
+const msgFormContext = "The form details are missing or unsupported. Ask the sender to send a new form.";
+export function newChatFormData(type, payload, definition, context) {
+    const value = definition.read(context);
+    if (value === undefined)
+        throw errValidation({ msg: msgFormContext });
+    return newChatData(type, {
+        ...payload,
+        form_context: { version: definition.version, data: value },
+    });
+}
+export function readChatFormContext(data, definition) {
+    const context = data.payload.form_context;
+    if (context &&
+        typeof context === "object" &&
+        !Array.isArray(context) &&
+        context.version === definition.version) {
+        const value = definition.read(context.data);
+        if (value !== undefined)
+            return value;
+    }
+    throw errValidation({ msg: msgFormContext });
+}
 // 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.

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/jobs/jobs.js

@@ -12,6 +12,7 @@ import { runPreActionCheck } from "../core/pre-action.js";
 import { runOwnerSearch, runSearch, withOwnerQuery, } from "../core/search.js";
 const msgJobIDRequired = "Job ID is required.";
 const msgLocationIDRequired = "Location ID is required.";
+const msgLocationClientRequired = "Choose a client for this location.";
 const msgOwnerIDRequired = "Owner ID is required.";
 const msgMemberIDRequired = "Member ID is required.";
 const msgJobLocationMismatch = "Job location does not match the provided parent location.";
@@ -59,9 +60,11 @@ export class JobsFX {
         this.now = opts.now ?? (() => new globalThis.Date());
     }
     async createLocation(opts) {
+        const client_id = requiredID(opts.in.client_id, "client_id", msgLocationClientRequired);
         const out = await this.jobs.insertOneLocation({
             in: {
                 ...opts.in,
+                client_id,
                 is_archived: false,
                 current_members: normalizeIDs(opts.in.current_members),
             },
@@ -72,8 +75,12 @@ export class JobsFX {
     async updateLocation(opts) {
         const owner_id = requiredID(opts.owner_id, "owner_id", msgOwnerIDRequired);
         const id = requiredID(opts.location.id, "location", msgLocationIDRequired);
+        const client_id = requiredID(opts.in.client_id === undefined
+            ? opts.location.client_id
+            : opts.in.client_id, "client_id", msgLocationClientRequired);
         const input = {
             ...opts.in,
+            client_id,
             ...locationAddressInput(opts.location),
         };
         if (opts.in.current_members !== undefined) {

package/dist/src/routes/availability.d.ts

@@ -2,7 +2,7 @@ import type { JobsOperator, RoutesOperator, UsersOperator } from "@fabriktor/cli
 import { type ClientAvailability, type InClientAvailability, type Location, type PrefCompany, type User } from "@fabriktor/schema";
 import type { PreferencesFXOperator } from "../preferences/preferences.js";
 import { type ChatData } from "../chat/data.js";
-import { type ChatFormRecipient } from "../chat/forms.js";
+import { type ChatFormContextDefinition, type ChatFormRecipient } from "../chat/forms.js";
 import { type RoutesActor } from "./workspace.js";
 export declare const clientAvailabilityMinimumWindows = 3;
 export declare const availabilityRequestPolicy: {
@@ -21,23 +21,35 @@ export type AvailabilityContext = {
     location: Location;
     employer: User;
     client: User;
-    company: PrefCompany;
+    working_hours?: AvailabilityWorkingHours;
     timezone: string;
 };
 export type AvailabilityReaders = {
     jobs: Pick<JobsOperator, "findOneLocation">;
     users: Pick<UsersOperator, "findOneUser">;
-    preferences: Pick<PreferencesFXOperator, "getPrefCompany">;
+};
+export type AvailabilityWorkingHours = Pick<PrefCompany, "work_day_start_hour" | "work_day_end_hour">;
+export type AvailabilityFormContext = {
+    working_hours: AvailabilityWorkingHours;
+    timezone: Location["address_timezone"];
+};
+export declare const availabilityFormContextDefinition: ChatFormContextDefinition<AvailabilityFormContext>;
+export type AvailabilityContextOptions = {
+    request?: ChatData;
+    signal?: AbortSignal;
 };
 export declare function availabilityReference(data: ChatData): AvailabilityReference | undefined;
 export declare function availabilityRequest(location: Location, actor: RoutesActor): ChatData;
 export declare function canSendAvailabilityRequest(data: ChatData, actor: RoutesActor, recipients: readonly ChatFormRecipient[]): boolean;
+export declare function loadAvailabilityRequestContext(readers: AvailabilityReaders & {
+    preferences: Pick<PreferencesFXOperator, "getPrefCompany">;
+}, actor: RoutesActor, data: ChatData): Promise<AvailabilityFormContext>;
 export declare function availabilitySubmission(reference: AvailabilityReference, request_id: string, ids: readonly string[]): ChatData;
-export declare function loadAvailabilityContext(readers: AvailabilityReaders, actor: RoutesActor, reference: AvailabilityReference, signal?: AbortSignal): Promise<AvailabilityContext>;
+export declare function loadAvailabilityContext(readers: AvailabilityReaders, actor: RoutesActor, reference: AvailabilityReference, { request, signal }?: AvailabilityContextOptions): Promise<AvailabilityContext>;
 export declare function validateAvailabilityWindows(inputs: readonly InClientAvailability[], context: AvailabilityContext, minimum?: number): void;
 export declare function loadAvailabilitySelection(readers: AvailabilityReaders & {
     routes: Pick<RoutesOperator, "findOneClientAvailability">;
-}, actor: RoutesActor, reference: AvailabilityReference, ids: readonly string[], signal?: AbortSignal): Promise<{
+}, actor: RoutesActor, reference: AvailabilityReference, ids: readonly string[], options?: AvailabilityContextOptions): Promise<{
     context: AvailabilityContext;
     windows: ClientAvailability[];
 }>;

package/dist/src/routes/availability.js

@@ -5,7 +5,7 @@ import { hoursPerDay, minutesOfDay, minutesPerHour, sameCalendarDay, } from "../
 import { errValidation } from "../core/err.js";
 import { normalizeIDs, resolvedID } from "../core/id.js";
 import { newChatData } from "../chat/data.js";
-import { canSendChatForm, } from "../chat/forms.js";
+import { canSendChatForm, readChatFormContext, } from "../chat/forms.js";
 import { routeCanPlan } from "./workspace.js";
 import { validateClientAvailabilityInput } from "./validation.js";
 export const clientAvailabilityMinimumWindows = 3;
@@ -18,10 +18,35 @@ export const RoutesChatDataType = {
     AvailabilityRequest: "routes.availability.request",
     AvailabilitySubmitted: "routes.availability.submitted",
 };
+export const availabilityFormContextDefinition = {
+    version: 1,
+    read: (value) => {
+        if (!value || typeof value !== "object" || Array.isArray(value))
+            return;
+        const { working_hours, timezone } = value;
+        if (!working_hours ||
+            typeof working_hours !== "object" ||
+            Array.isArray(working_hours) ||
+            typeof timezone !== "string" ||
+            !timezone.trim())
+            return;
+        const { work_day_start_hour: start, work_day_end_hour: end } = working_hours;
+        if (typeof start !== "number" ||
+            typeof end !== "number" ||
+            ![start, end].every((hour) => Number.isInteger(hour) && hour >= 0 && hour < hoursPerDay) ||
+            start >= end)
+            return;
+        return {
+            timezone,
+            working_hours: { work_day_start_hour: start, work_day_end_hour: end },
+        };
+    },
+};
 const msgAvailabilityAccess = "This availability does not match the client and employer of the location.";
 const msgAvailabilityTimezone = "The location needs a valid saved address timezone.";
+const msgAvailabilityTimezoneChanged = "The location timezone has changed. Ask the sender to send a new form.";
 const msgAvailabilityHours = "The employer's working hours must form a valid same-day window.";
-const msgAvailabilityWindows = "Provide enough distinct, non-overlapping availability windows within the employer's working hours.";
+const msgAvailabilityWindows = "Provide enough distinct, non-overlapping availability windows and respect the hours supplied with the request.";
 const msgAvailabilityClient = "Visit times can only be requested from clients with a Fabriktor account. Arrange external contacts’ visit times directly.";
 const msgAvailabilityData = "The availability request is invalid.";
 export function availabilityReference(data) {
@@ -69,6 +94,30 @@ export function canSendAvailabilityRequest(data, actor, recipients) {
         canSendChatForm(availabilityRequestPolicy, actor, recipients) &&
         reference.client_id === recipients[0].id);
 }
+// Registry pre-action: only the employer preparing the request reads their
+// preferences. Transfer the two hours, never the complete preferences record.
+export async function loadAvailabilityRequestContext(readers, actor, data) {
+    const reference = availabilityReference(data);
+    if (data.type !== RoutesChatDataType.AvailabilityRequest ||
+        !reference ||
+        !routeCanPlan(actor) ||
+        reference.employer_id !== actor.owner_id)
+        throw errValidation({ msg: msgAvailabilityAccess });
+    const [context, company] = await Promise.all([
+        loadAvailabilityContext(readers, actor, reference),
+        readers.preferences.getPrefCompany({ owner_id: actor.owner_id }),
+    ]);
+    const supplied = availabilityFormContextDefinition.read({
+        timezone: context.timezone,
+        working_hours: {
+            work_day_start_hour: company.work_day_start_hour,
+            work_day_end_hour: company.work_day_end_hour,
+        },
+    });
+    if (!supplied)
+        throw errValidation({ msg: msgAvailabilityHours });
+    return supplied;
+}
 export function availabilitySubmission(reference, request_id, ids) {
     const data = newChatData(RoutesChatDataType.AvailabilitySubmitted, {
         ...reference,
@@ -79,7 +128,19 @@ export function availabilitySubmission(reference, request_id, ids) {
         throw errValidation({ msg: msgAvailabilityData });
     return data;
 }
-export async function loadAvailabilityContext(readers, actor, reference, signal) {
+export async function loadAvailabilityContext(readers, actor, reference, { request, signal } = {}) {
+    const supplied = request
+        ? readChatFormContext(request, availabilityFormContextDefinition)
+        : undefined;
+    if (request) {
+        const requestReference = availabilityReference(request);
+        if (request.type !== RoutesChatDataType.AvailabilityRequest ||
+            !requestReference ||
+            requestReference.employer_id !== reference.employer_id ||
+            requestReference.client_id !== reference.client_id ||
+            requestReference.location_id !== reference.location_id)
+            throw errValidation({ msg: msgAvailabilityAccess });
+    }
     const location = (await readers.jobs.findOneLocation({ id: reference.location_id, signal })).value;
     if (!location ||
         location.id !== reference.location_id ||
@@ -90,10 +151,9 @@ export async function loadAvailabilityContext(readers, actor, reference, signal)
             ? actor.owner_id !== reference.client_id
             : !routeCanPlan(actor) || actor.owner_id !== reference.employer_id))
         throw errValidation({ msg: msgAvailabilityAccess });
-    const [result, clientResult, company] = await Promise.all([
+    const [result, clientResult] = await Promise.all([
         readers.users.findOneUser({ id: reference.employer_id, signal }),
         readers.users.findOneUser({ id: reference.client_id, signal }),
-        readers.preferences.getPrefCompany({ owner_id: reference.employer_id }),
     ]);
     const employer = result.value;
     if (!employer ||
@@ -108,11 +168,15 @@ export async function loadAvailabilityContext(readers, actor, reference, signal)
     const timezone = addressTimezone(location);
     if (!timezone)
         throw errValidation({ msg: msgAvailabilityTimezone });
-    const { work_day_start_hour: start, work_day_end_hour: end } = company;
-    if (![start, end].every((hour) => Number.isInteger(hour) && hour >= 0 && hour < hoursPerDay) ||
-        start >= end)
-        throw errValidation({ msg: msgAvailabilityHours });
-    return { location, employer, client, company, timezone };
+    if (supplied && supplied.timezone !== timezone)
+        throw errValidation({ msg: msgAvailabilityTimezoneChanged });
+    return {
+        location,
+        employer,
+        client,
+        working_hours: supplied?.working_hours,
+        timezone,
+    };
 }
 export function validateAvailabilityWindows(inputs, context, minimum = clientAvailabilityMinimumWindows) {
     if (inputs.length < minimum)
@@ -122,10 +186,11 @@ export function validateAvailabilityWindows(inputs, context, minimum = clientAva
         if (input.employer_id !== context.employer.id ||
             input.location_id !== context.location.id ||
             input.timezone !== context.timezone ||
-            minutesOfDay(input.from) <
-                context.company.work_day_start_hour * minutesPerHour ||
-            minutesOfDay(input.to) >
-                context.company.work_day_end_hour * minutesPerHour ||
+            (context.working_hours &&
+                (minutesOfDay(input.from) <
+                    context.working_hours.work_day_start_hour * minutesPerHour ||
+                    minutesOfDay(input.to) >
+                        context.working_hours.work_day_end_hour * minutesPerHour)) ||
             inputs
                 .slice(0, index)
                 .some((other) => sameCalendarDay(input.from, other.from) &&
@@ -136,13 +201,16 @@ export function validateAvailabilityWindows(inputs, context, minimum = clientAva
 }
 // A chat response contains references, never authority or an appointment confirmation.
 // Reload each chosen record before preparing the response, including after a resumed batch.
-export async function loadAvailabilitySelection(readers, actor, reference, ids, signal) {
+export async function loadAvailabilitySelection(readers, actor, reference, ids, options = {}) {
     if (ids.length < clientAvailabilityMinimumWindows ||
         normalizeIDs(ids).length !== ids.length)
         throw errValidation({ msg: msgAvailabilityData });
-    const context = await loadAvailabilityContext(readers, actor, reference, signal);
+    const context = await loadAvailabilityContext(readers, actor, reference, options);
     const windows = await Promise.all(ids.map(async (id) => {
-        const window = (await readers.routes.findOneClientAvailability({ id, signal })).value;
+        const window = (await readers.routes.findOneClientAvailability({
+            id,
+            signal: options.signal,
+        })).value;
         if (!window ||
             window.id !== id ||
             window.owner_id !== reference.client_id)

package/package.json

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