@fabriktor/fx 0.0.149 → 0.0.151

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/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,39 @@ 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>;
+type AvailabilityWindow = Pick<InClientAvailability, "from" | "to" | "timezone">;
+export declare function isValidAvailabilityWindow(window: AvailabilityWindow): boolean;
+export declare function availabilityWindowConflicts(inputs: readonly AvailabilityWindow[]): number[];
 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[];
 }>;
+export {};

package/dist/src/routes/availability.js

@@ -1,11 +1,11 @@
 import { UserTypeClient, UserTypeEmployer, } from "@fabriktor/schema";
 import { isFabriktorUser } from "../users/users.js";
 import { addressTimezone } from "../core/address.js";
-import { hoursPerDay, minutesOfDay, minutesPerHour, sameCalendarDay, } from "../core/date.js";
+import { hoursPerDay, isValidInputDate, minutesOfDay, minutesPerHour, sameCalendarDay, } from "../core/date.js";
 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,37 @@ 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 msgAvailabilityMinimumWindows = "Choose at least {count} possible visit times.";
+const msgAvailabilityWindows = "Some visit times overlap. Choose another day or change their hours.";
+const msgAvailabilityOutsideHours = "Choose visit times within the working hours shown.";
 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 +96,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 +130,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 +153,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,41 +170,77 @@ 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 isValidAvailabilityWindow(window) {
+    return (isValidInputDate(window.from) &&
+        isValidInputDate(window.to) &&
+        window.from.tz === window.timezone &&
+        window.to.tz === window.timezone &&
+        sameCalendarDay(window.from, window.to) &&
+        minutesOfDay(window.from) < minutesOfDay(window.to));
+}
+// Return every affected row, including duplicates. Incomplete rows are handled
+// by the inputs' required/date/time rules, not by the overlap rule.
+export function availabilityWindowConflicts(inputs) {
+    const conflicts = new Set();
+    inputs.forEach((input, index) => {
+        if (!isValidAvailabilityWindow(input))
+            return;
+        inputs.slice(0, index).forEach((other, previous) => {
+            if (isValidAvailabilityWindow(other) &&
+                input.timezone === other.timezone &&
+                sameCalendarDay(input.from, other.from) &&
+                minutesOfDay(input.from) < minutesOfDay(other.to) &&
+                minutesOfDay(input.to) > minutesOfDay(other.from)) {
+                conflicts.add(previous);
+                conflicts.add(index);
+            }
+        });
+    });
+    return inputs.flatMap((_, index) => (conflicts.has(index) ? [index] : []));
 }
 export function validateAvailabilityWindows(inputs, context, minimum = clientAvailabilityMinimumWindows) {
     if (inputs.length < minimum)
-        throw errValidation({ msg: msgAvailabilityWindows });
-    for (const [index, input] of inputs.entries()) {
+        throw errValidation({
+            msg: msgAvailabilityMinimumWindows.replace("{count}", String(minimum)),
+        });
+    for (const input of inputs) {
         validateClientAvailabilityInput(input);
         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 ||
-            inputs
-                .slice(0, index)
-                .some((other) => sameCalendarDay(input.from, other.from) &&
-                minutesOfDay(input.from) < minutesOfDay(other.to) &&
-                minutesOfDay(input.to) > minutesOfDay(other.from)))
-            throw errValidation({ msg: msgAvailabilityWindows });
+            input.timezone !== context.timezone)
+            throw errValidation({ msg: msgAvailabilityAccess });
+        if (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))
+            throw errValidation({ msg: msgAvailabilityOutsideHours });
     }
+    if (availabilityWindowConflicts(inputs).length)
+        throw errValidation({ msg: msgAvailabilityWindows });
 }
 // 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/dist/src/routes/planning.d.ts

@@ -30,5 +30,12 @@ export type RouteAvailabilityWindow = {
     start: number;
     end: number;
 };
+export declare function routeAvailabilityMatch(input: Pick<InRoute, "from" | "to" | "timezone">, availability: ClientAvailability): RouteAvailabilityWindow | undefined;
+export type RouteAvailabilityOverview = {
+    saved: ClientAvailability[];
+    matching: RouteAvailabilityWindow[];
+    on_day: number;
+};
+export declare function routeAvailabilityOverview(input: Pick<InRoute, "from" | "to" | "timezone">, availability: RPRoutesAvailability, location_id: string, client_id: string): RouteAvailabilityOverview;
 export declare function routeAvailabilityWindows(input: Pick<InRoute, "from" | "to" | "timezone">, availability: RPRoutesAvailability, location_id: string, client_id: string): RouteAvailabilityWindow[];
 export {};

package/dist/src/routes/planning.js

@@ -1,8 +1,9 @@
-import { isValidInputDate, minutesOfDay, sameCalendarDay, } from "../core/date.js";
+import { minutesOfDay, sameCalendarDay } from "../core/date.js";
 import { errValidation } from "../core/err.js";
 import { normalizeIDs } from "../core/id.js";
 import { routeInput, validateRouteTimeWindow } from "./validation.js";
 import { validateRoutePlanLocation } from "./departure.js";
+import { isValidAvailabilityWindow } from "./availability.js";
 import { PreActionBlocked } from "../core/pre-action.js";
 const routePreparationBlocked = "route_preparation";
 const msgPlanningEmployees = "Choose available employees who are not already in another vehicle.";
@@ -71,25 +72,37 @@ export function validateRouteEmployees(ids, allowed, occupied = []) {
             msg: msgPlanningEmployees,
         });
 }
-// Suggestions are child data in an availability response. Intersect the client's
-// window with the route window; never widen the hours offered by either party.
-export function routeAvailabilityWindows(input, availability, location_id, client_id) {
+// Intersect the client's window with the route hours; never widen either.
+export function routeAvailabilityMatch(input, availability) {
+    if (!isValidAvailabilityWindow(availability) ||
+        availability.timezone !== input.timezone ||
+        !sameCalendarDay(availability.from, input.from))
+        return;
+    const start = Math.max(minutesOfDay(availability.from), minutesOfDay(input.from));
+    const end = Math.min(minutesOfDay(availability.to), minutesOfDay(input.to));
+    return start < end ? { availability, start, end } : undefined;
+}
+// These are child windows returned by get_availability, not a filtered parent
+// query. Keep other days visible and preserve the backend's order.
+export function routeAvailabilityOverview(input, availability, location_id, client_id) {
     validateRouteTimeWindow(input);
-    return availability.client_availabilities
+    const saved = availability.client_availabilities
         .flatMap((group) => group.location_id === location_id ? group.availabilities : [])
-        .flatMap((window) => {
-        if (window.owner_id !== client_id ||
-            window.location_id !== location_id ||
-            window.timezone !== input.timezone ||
-            window.from.tz !== input.timezone ||
-            window.to.tz !== input.timezone ||
-            !isValidInputDate(window.from) ||
-            !isValidInputDate(window.to) ||
-            !sameCalendarDay(window.from, input.from) ||
-            !sameCalendarDay(window.to, input.to))
-            return [];
-        const start = Math.max(minutesOfDay(window.from), minutesOfDay(input.from));
-        const end = Math.min(minutesOfDay(window.to), minutesOfDay(input.to));
-        return start < end ? [{ availability: window, start, end }] : [];
-    });
+        .filter((window) => window.owner_id === client_id &&
+        window.location_id === location_id &&
+        window.timezone === input.timezone &&
+        isValidAvailabilityWindow(window));
+    return {
+        saved,
+        matching: saved.flatMap((window) => {
+            const match = routeAvailabilityMatch(input, window);
+            return match ? [match] : [];
+        }),
+        on_day: saved.filter((window) => sameCalendarDay(window.from, input.from))
+            .length,
+    };
+}
+export function routeAvailabilityWindows(input, availability, location_id, client_id) {
+    return routeAvailabilityOverview(input, availability, location_id, client_id)
+        .matching;
 }

package/package.json

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