@fabriktor/fx 0.0.138 → 0.0.140

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

@@ -0,0 +1,23 @@
+export declare const chatDataProtocol = "fabriktor.chat.data";
+export declare const chatDataVersion = 1;
+export declare const chatDataMarker = "\n\n[Fabriktor data]\n";
+export declare const chatDataMaximumBytes = 16384;
+export type ChatJSON = null | boolean | number | string | ChatJSON[] | {
+    [key: string]: ChatJSON;
+};
+export type ChatData = {
+    protocol: typeof chatDataProtocol;
+    version: typeof chatDataVersion;
+    type: string;
+    payload: {
+        [key: string]: ChatJSON;
+    };
+};
+export type ChatContent = {
+    text: string;
+    data?: ChatData;
+    unsupported: boolean;
+};
+export declare function newChatData(type: string, payload: ChatData["payload"]): ChatData;
+export declare function encodeChatContent(text: string, data?: ChatData): string;
+export declare function decodeChatContent(value: string): ChatContent;

package/dist/src/chat/data.js

@@ -0,0 +1,76 @@
+import { errValidation } from "../core/err.js";
+// Frontend message framing over the existing Chat.text contract. No executable
+// templates, URLs, component names, or permissions are accepted from messages.
+export const chatDataProtocol = "fabriktor.chat.data";
+export const chatDataVersion = 1;
+export const chatDataMarker = "\n\n[Fabriktor data]\n";
+export const chatDataMaximumBytes = 16_384;
+const chatDataMaximumDepth = 8;
+const msgChatData = "The structured chat message is invalid or too large.";
+export function newChatData(type, payload) {
+    const data = {
+        protocol: chatDataProtocol,
+        version: chatDataVersion,
+        type,
+        payload,
+    };
+    if (!validChatData(data))
+        throw errValidation({ msg: msgChatData });
+    return structuredClone(data);
+}
+export function encodeChatContent(text, data) {
+    if (!data)
+        return text;
+    if (!text.trim() || text.includes(chatDataMarker) || !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;
+}
+export function decodeChatContent(value) {
+    const boundary = value.indexOf(chatDataMarker);
+    if (boundary < 0)
+        return { text: value, unsupported: false };
+    const text = value.slice(0, boundary).trimEnd();
+    const raw = value.slice(boundary + chatDataMarker.length);
+    if (raw.length > chatDataMaximumBytes ||
+        new TextEncoder().encode(raw).length > chatDataMaximumBytes)
+        return { text, unsupported: true };
+    try {
+        const data = JSON.parse(raw);
+        return validChatData(data)
+            ? { text, data, unsupported: false }
+            : { text, unsupported: true };
+    }
+    catch {
+        return { text, unsupported: true };
+    }
+}
+function validChatData(value) {
+    return (jsonObject(value) &&
+        value.protocol === chatDataProtocol &&
+        value.version === chatDataVersion &&
+        typeof value.type === "string" &&
+        /^[a-z][a-z0-9_.-]{0,95}$/.test(value.type) &&
+        jsonObject(value.payload) &&
+        validJSON(value.payload, chatDataMaximumDepth));
+}
+function jsonObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function validJSON(value, depth) {
+    if (value === null || typeof value === "string" || typeof value === "boolean")
+        return true;
+    if (typeof value === "number")
+        return Number.isFinite(value);
+    if (depth <= 0)
+        return false;
+    if (Array.isArray(value))
+        return value.every((child) => validJSON(child, depth - 1));
+    return (jsonObject(value) &&
+        Object.entries(value).every(([key, child]) => key !== "__proto__" &&
+            key !== "constructor" &&
+            key !== "prototype" &&
+            validJSON(child, depth - 1)));
+}

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

@@ -1,5 +1,8 @@
 import type { Date as SchemaDate, InDate } from "@fabriktor/schema";
 export declare const utcTimezone = "UTC";
+export declare const minutesPerHour = 60;
+export declare const hoursPerDay = 24;
+export declare const minutesPerDay: number;
 export type LocalDateParts = {
     y: number;
     m: number;
@@ -7,6 +10,9 @@ export type LocalDateParts = {
     h: number;
     min: number;
 };
+export declare function sameCalendarDay(a: LocalDateParts, b: LocalDateParts): boolean;
+export declare function minutesOfDay(v: LocalDateParts): number;
+export declare function isValidInputDate(v: InDate): boolean;
 export declare function normalizeInputDate(v: InDate): InDate;
 export declare function zeroInputDate(): InDate;
 export declare function zeroDate(): SchemaDate;

package/dist/src/core/date.js

@@ -17,6 +17,33 @@ const zeroDatePrefix = [
 ].join("-");
 const zeroUTC = `${zeroDatePrefix}T00:00:00Z`;
 export const utcTimezone = "UTC";
+export const minutesPerHour = 60;
+export const hoursPerDay = 24;
+export const minutesPerDay = hoursPerDay * minutesPerHour;
+export function sameCalendarDay(a, b) {
+    return a.y === b.y && a.m === b.m && a.d === b.d;
+}
+export function minutesOfDay(v) {
+    return v.h * minutesPerHour + v.min;
+}
+// Civil input checks only. The backend remains responsible for resolving the
+// supplied operational timezone to an instant, including daylight-saving rules.
+export function isValidInputDate(v) {
+    if (![v.y, v.m, v.d, v.h, v.min].every(Number.isInteger) ||
+        v.y <= 0 ||
+        v.h < 0 ||
+        v.h >= hoursPerDay ||
+        v.min < 0 ||
+        v.min >= minutesPerHour ||
+        !v.tz ||
+        dateTimezone(v.tz) !== v.tz)
+        return false;
+    const day = new globalThis.Date(0);
+    day.setUTCFullYear(v.y, v.m - 1, v.d);
+    return (day.getUTCFullYear() === v.y &&
+        day.getUTCMonth() + 1 === v.m &&
+        day.getUTCDate() === v.d);
+}
 export function normalizeInputDate(v) {
     if (isZeroDate(v)) {
         return zeroInputDate();

package/dist/src/core/server-clock.d.ts

@@ -0,0 +1,10 @@
+export type NowProvider = () => globalThis.Date | Promise<globalThis.Date>;
+export declare const serverClockMaximumAgeMS = 60000;
+export declare class ServerClock {
+    private readonly elapsedNow;
+    private sample?;
+    constructor(elapsedNow: () => number);
+    observeHTTPDate(value: string | null): void;
+    now(): number | null;
+    requireNow(): number;
+}

package/dist/src/core/server-clock.js

@@ -0,0 +1,36 @@
+import { errValidation } from "./err.js";
+export const serverClockMaximumAgeMS = 60_000;
+const msgServerTime = "Server time is unavailable. Refresh and try again.";
+// Wall time comes only from the API. The injected monotonic timer measures
+// elapsed duration; browser timezone and device wall-clock changes are irrelevant.
+export class ServerClock {
+    elapsedNow;
+    sample;
+    constructor(elapsedNow) {
+        this.elapsedNow = elapsedNow;
+    }
+    observeHTTPDate(value) {
+        if (!value || !value.endsWith(" GMT"))
+            return;
+        const epoch = globalThis.Date.parse(value);
+        if (!Number.isFinite(epoch))
+            return;
+        this.sample = { epoch, elapsed: this.elapsedNow() };
+    }
+    now() {
+        if (!this.sample)
+            return null;
+        const elapsed = this.elapsedNow() - this.sample.elapsed;
+        if (!Number.isFinite(elapsed) ||
+            elapsed < 0 ||
+            elapsed > serverClockMaximumAgeMS)
+            return null;
+        return this.sample.epoch + elapsed;
+    }
+    requireNow() {
+        const value = this.now();
+        if (value === null)
+            throw errValidation({ msg: msgServerTime });
+        return value;
+    }
+}

package/dist/src/fx.d.ts

@@ -1,4 +1,5 @@
-import type { BillableOperator, CallsOperator, ChatOperator, ConnectionsOperator, ContactsOperator, FeedOperator, FulfillmentsOperator, JobsOperator, MarketplaceOperator, MemosOperator, NotificationsOperator, PaymentsOperator, PayrollsOperator, PreferencesOperator, PrivacyOperator, ProcessesOperator, RoutesOperator, StorageOperator, TimesheetsOperator, TmpPhonesOperator, TmpUsernamesOperator, UsersOperator } from "@fabriktor/client";
+import type { HTTPDoer, BillableOperator, CallsOperator, ChatOperator, ConnectionsOperator, ContactsOperator, FeedOperator, FulfillmentsOperator, JobsOperator, MarketplaceOperator, MemosOperator, NotificationsOperator, PaymentsOperator, PayrollsOperator, PreferencesOperator, PrivacyOperator, ProcessesOperator, RoutesOperator, StorageOperator, TimesheetsOperator, TmpPhonesOperator, TmpUsernamesOperator, UsersOperator } from "@fabriktor/client";
+import type { NowProvider } from "./core/server-clock.js";
 import type { AuthOperator } from "./auth/auth.js";
 import type { BillableFX, BillableFXOperator } from "./billable/billable.js";
 import type { CallsFX, CallsFXOperator } from "./calls/calls.js";
@@ -22,6 +23,7 @@ import type { StorageFX, StorageFXOperator } from "./storage/storage.js";
 import type { TimesheetsFX, TimesheetsFXOperator } from "./timesheets/timesheets.js";
 import type { UsersFX, UsersFXOperator } from "./users/users.js";
 export type FXOptions = {
+    timesheets_now?: NowProvider;
     auth: AuthOperator;
     billable: BillableOperator;
     calls: CallsOperator;
@@ -50,6 +52,8 @@ export type FXOptions = {
     marketplace_keep_alive_interval_ms: number;
 };
 export type DefaultFXOptions = {
+    http?: HTTPDoer;
+    timesheets_now?: NowProvider;
     base_url: string;
     auth: AuthOperator;
     get_device_token: DeviceTokenProvider;

package/dist/src/fx.js

@@ -117,6 +117,7 @@ export class FX {
             timesheets: opts.timesheets,
             contacts_fx: this.contacts,
             billable: opts.billable,
+            now: opts.timesheets_now,
         });
         this.users = newUsersFX({
             users: opts.users,
@@ -135,10 +136,11 @@ export function newFX(opts) {
     return new FX(opts);
 }
 export function newDefaultFX(opts) {
-    const http = newHTTPClient();
+    const http = opts.http ?? newHTTPClient();
     const get_token = () => opts.auth.getToken();
     return newFX({
         auth: opts.auth,
+        timesheets_now: opts.timesheets_now,
         billable: newBillableClient({
             http,
             base_url: opts.base_url,

package/dist/src/index.d.ts

@@ -2,6 +2,7 @@ export * from "./auth/auth.js";
 export * from "./billable/billable.js";
 export * from "./calls/calls.js";
 export * from "./chat/chat.js";
+export * from "./chat/data.js";
 export * from "./chat/optimistic.js";
 export * from "./chat/send-queue.js";
 export * from "./contacts/contacts.js";
@@ -19,6 +20,7 @@ export * from "./core/queue.js";
 export * from "./core/scope.js";
 export * from "./core/search-controller.js";
 export * from "./core/search.js";
+export * from "./core/server-clock.js";
 export * from "./feed/feed.js";
 export * from "./fulfillments/fulfillments.js";
 export * from "./fx.js";
@@ -32,7 +34,14 @@ export * from "./payrolls/workspace.js";
 export * from "./preferences/preferences.js";
 export * from "./privacy/privacy.js";
 export * from "./processes/processes.js";
+export * from "./routes/arrival.js";
+export * from "./routes/availability.js";
+export * from "./routes/planning.js";
+export * from "./routes/punch.js";
 export * from "./routes/routes.js";
+export * from "./routes/tracking.js";
+export * from "./routes/validation.js";
+export * from "./routes/workspace.js";
 export * from "./session/session.js";
 export * from "./storage/storage.js";
 export * from "./timesheets/access.js";

package/dist/src/index.js

@@ -2,6 +2,7 @@ export * from "./auth/auth.js";
 export * from "./billable/billable.js";
 export * from "./calls/calls.js";
 export * from "./chat/chat.js";
+export * from "./chat/data.js";
 export * from "./chat/optimistic.js";
 export * from "./chat/send-queue.js";
 export * from "./contacts/contacts.js";
@@ -19,6 +20,7 @@ export * from "./core/queue.js";
 export * from "./core/scope.js";
 export * from "./core/search-controller.js";
 export * from "./core/search.js";
+export * from "./core/server-clock.js";
 export * from "./feed/feed.js";
 export * from "./fulfillments/fulfillments.js";
 export * from "./fx.js";
@@ -32,7 +34,14 @@ export * from "./payrolls/workspace.js";
 export * from "./preferences/preferences.js";
 export * from "./privacy/privacy.js";
 export * from "./processes/processes.js";
+export * from "./routes/arrival.js";
+export * from "./routes/availability.js";
+export * from "./routes/planning.js";
+export * from "./routes/punch.js";
 export * from "./routes/routes.js";
+export * from "./routes/tracking.js";
+export * from "./routes/validation.js";
+export * from "./routes/workspace.js";
 export * from "./session/session.js";
 export * from "./storage/storage.js";
 export * from "./timesheets/access.js";

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

@@ -0,0 +1,16 @@
+import { type Route } from "@fabriktor/schema";
+import type { TimesheetPunchState } from "../timesheets/workspace.js";
+import type { RoutesActor } from "./workspace.js";
+export declare const routeArrivalRadiusMeters = 150;
+export declare const routeArrivalMaximumAccuracyMeters = 75;
+export type RouteStopDistance = {
+    location_id: string;
+    distance_meters: number;
+};
+export declare class RouteArrivalCue {
+    private candidate;
+    private samples;
+    reset(): void;
+    observe(distances: readonly RouteStopDistance[], accuracy: number): string | null;
+}
+export declare function routeHasActiveTransport(actor: RoutesActor, route: Route, vehicle_id: string, state: TimesheetPunchState, location_id?: string): boolean;

package/dist/src/routes/arrival.js

@@ -0,0 +1,50 @@
+import { PunchStatusWorking, UserTypeEmployee, } from "@fabriktor/schema";
+import { routeCanTrack } from "./workspace.js";
+export const routeArrivalRadiusMeters = 150;
+export const routeArrivalMaximumAccuracyMeters = 75;
+const requiredSamples = 2;
+// Only a visual cue. Two accurate, consecutive foreground samples prevent a
+// passing or imprecise GPS fix from immediately highlighting a destination.
+export class RouteArrivalCue {
+    candidate = "";
+    samples = 0;
+    reset() {
+        this.candidate = "";
+        this.samples = 0;
+    }
+    observe(distances, accuracy) {
+        if (!Number.isFinite(accuracy) ||
+            accuracy < 0 ||
+            accuracy > routeArrivalMaximumAccuracyMeters) {
+            this.reset();
+            return null;
+        }
+        const nearest = distances.reduce((best, value) => {
+            if (!Number.isFinite(value.distance_meters) ||
+                value.distance_meters < 0 ||
+                value.distance_meters + accuracy > routeArrivalRadiusMeters)
+                return best;
+            return !best || value.distance_meters < best.distance_meters
+                ? value
+                : best;
+        }, undefined);
+        if (!nearest) {
+            this.reset();
+            return null;
+        }
+        this.samples =
+            this.candidate === nearest.location_id ? this.samples + 1 : 1;
+        this.candidate = nearest.location_id;
+        return this.samples >= requiredSamples ? this.candidate : null;
+    }
+}
+export function routeHasActiveTransport(actor, route, vehicle_id, state, location_id) {
+    return (actor.active_mode === UserTypeEmployee &&
+        routeCanTrack(actor, route, vehicle_id, actor.owner_id) &&
+        !state.stale_day &&
+        !state.week_sheet?.is_archived &&
+        state.punch?.employer_id === route.owner_id &&
+        state.punch.punch_status === PunchStatusWorking &&
+        (location_id === undefined || state.punch.location_id === location_id) &&
+        state.punch.rides.at(-1)?.is_active === true);
+}

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

@@ -0,0 +1,35 @@
+import type { JobsOperator, RoutesOperator, UsersOperator } from "@fabriktor/client";
+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 RoutesActor } from "./workspace.js";
+export declare const clientAvailabilityMinimumWindows = 3;
+export declare const RoutesChatDataType: {
+    readonly AvailabilityRequest: "routes.availability.request";
+    readonly AvailabilitySubmitted: "routes.availability.submitted";
+};
+export type AvailabilityReference = Pick<InClientAvailability, "employer_id" | "location_id"> & {
+    client_id: string;
+};
+export type AvailabilityContext = {
+    location: Location;
+    employer: User;
+    company: PrefCompany;
+    timezone: string;
+};
+export type AvailabilityReaders = {
+    jobs: Pick<JobsOperator, "findOneLocation">;
+    users: Pick<UsersOperator, "findOneUser">;
+    preferences: Pick<PreferencesFXOperator, "getPrefCompany">;
+};
+export declare function availabilityReference(data: ChatData): AvailabilityReference | undefined;
+export declare function availabilityRequest(location: Location, actor: RoutesActor): ChatData;
+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 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<{
+    context: AvailabilityContext;
+    windows: ClientAvailability[];
+}>;

package/dist/src/routes/availability.js

@@ -0,0 +1,131 @@
+import { UserTypeClient, UserTypeEmployer, } from "@fabriktor/schema";
+import { dateTimezone, hoursPerDay, 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 { routeCanPlan } from "./workspace.js";
+import { validateClientAvailabilityInput } from "./validation.js";
+export const clientAvailabilityMinimumWindows = 3;
+export const RoutesChatDataType = {
+    AvailabilityRequest: "routes.availability.request",
+    AvailabilitySubmitted: "routes.availability.submitted",
+};
+const msgAvailabilityAccess = "This availability does not match the client and employer of the location.";
+const msgAvailabilityTimezone = "The employer needs a valid saved address timezone.";
+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 msgAvailabilityData = "The availability request is invalid.";
+export function availabilityReference(data) {
+    if (data.type !== RoutesChatDataType.AvailabilityRequest &&
+        data.type !== RoutesChatDataType.AvailabilitySubmitted)
+        return;
+    const { employer_id, client_id, location_id } = data.payload;
+    if (typeof employer_id !== "string" ||
+        !resolvedID(employer_id) ||
+        typeof client_id !== "string" ||
+        !resolvedID(client_id) ||
+        typeof location_id !== "string" ||
+        !resolvedID(location_id))
+        return;
+    if (data.type === RoutesChatDataType.AvailabilitySubmitted) {
+        const { request_id, availability_ids } = data.payload;
+        if (typeof request_id !== "string" ||
+            !resolvedID(request_id) ||
+            !Array.isArray(availability_ids) ||
+            !availability_ids.every((id) => typeof id === "string") ||
+            availability_ids.length < clientAvailabilityMinimumWindows ||
+            normalizeIDs(availability_ids).length !== availability_ids.length)
+            return;
+    }
+    return { employer_id, client_id, location_id };
+}
+export function availabilityRequest(location, actor) {
+    if (!routeCanPlan(actor) ||
+        location.owner_id !== actor.owner_id ||
+        location.is_archived ||
+        !resolvedID(location.client_id) ||
+        !resolvedID(location.id))
+        throw errValidation({ msg: msgAvailabilityAccess });
+    return newChatData(RoutesChatDataType.AvailabilityRequest, {
+        employer_id: actor.owner_id,
+        client_id: location.client_id,
+        location_id: location.id,
+    });
+}
+export function availabilitySubmission(reference, request_id, ids) {
+    const data = newChatData(RoutesChatDataType.AvailabilitySubmitted, {
+        ...reference,
+        request_id,
+        availability_ids: [...ids],
+    });
+    if (!availabilityReference(data))
+        throw errValidation({ msg: msgAvailabilityData });
+    return data;
+}
+export async function loadAvailabilityContext(readers, actor, reference, signal) {
+    const location = (await readers.jobs.findOneLocation({ id: reference.location_id, signal })).value;
+    if (!location ||
+        location.id !== reference.location_id ||
+        location.is_archived ||
+        location.owner_id !== reference.employer_id ||
+        location.client_id !== reference.client_id ||
+        (actor.active_mode === UserTypeClient
+            ? actor.owner_id !== reference.client_id
+            : !routeCanPlan(actor) || actor.owner_id !== reference.employer_id))
+        throw errValidation({ msg: msgAvailabilityAccess });
+    const [result, company] = await Promise.all([
+        readers.users.findOneUser({ id: reference.employer_id, signal }),
+        readers.preferences.getPrefCompany({ owner_id: reference.employer_id }),
+    ]);
+    const employer = result.value;
+    if (!employer ||
+        employer.id !== reference.employer_id ||
+        employer.account_identity !== UserTypeEmployer)
+        throw errValidation({ msg: msgAvailabilityAccess });
+    const timezone = employer.address_timezone.trim();
+    if (!timezone || dateTimezone(timezone) !== 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, company, timezone };
+}
+export function validateAvailabilityWindows(inputs, context, minimum = clientAvailabilityMinimumWindows) {
+    if (inputs.length < minimum)
+        throw errValidation({ msg: msgAvailabilityWindows });
+    for (const [index, input] of inputs.entries()) {
+        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 });
+    }
+}
+// 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) {
+    if (ids.length < clientAvailabilityMinimumWindows ||
+        normalizeIDs(ids).length !== ids.length)
+        throw errValidation({ msg: msgAvailabilityData });
+    const context = await loadAvailabilityContext(readers, actor, reference, signal);
+    const windows = await Promise.all(ids.map(async (id) => {
+        const window = (await readers.routes.findOneClientAvailability({ id, signal })).value;
+        if (!window ||
+            window.id !== id ||
+            window.owner_id !== reference.client_id)
+            throw errValidation({ msg: msgAvailabilityAccess });
+        return window;
+    }));
+    validateAvailabilityWindows(windows, context);
+    return { context, windows };
+}

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

@@ -0,0 +1,34 @@
+import type { ClientAvailability, InDate, InRoute, Location, PrefCompany, RPRoutesAvailability, Route } from "@fabriktor/schema";
+import { PreActionBlocked } from "../core/pre-action.js";
+declare const routePreparationBlocked = "route_preparation";
+export declare const RouteMutationBlock: {
+    readonly Busy: "route_mutation_busy";
+    readonly Changed: "route_mutation_changed";
+    readonly Unconfirmed: "route_mutation_unconfirmed";
+};
+export declare function routePlanChanged(current: Route, input: InRoute): boolean;
+export declare class RoutePreparationBlocked extends PreActionBlocked<typeof routePreparationBlocked> {
+    readonly cause: unknown;
+    constructor(cause: unknown);
+}
+export declare const routePlanningDefaults: {
+    readonly days_ago: 0;
+    readonly duration_in_minutes: 0;
+    readonly consider_traffic: false;
+    readonly start_early: false;
+    readonly override_itinerary: false;
+};
+export declare function newRoutePlan(opts: {
+    day: InDate;
+    company: Pick<PrefCompany, "work_day_start_hour" | "work_day_end_hour">;
+    start_place_id: string;
+}): InRoute;
+export declare function routeDestination(location: Location, owner_id: string): InRoute["destinations"][number];
+export declare function validateRouteEmployees(ids: readonly string[], allowed: readonly string[], occupied?: readonly string[]): void;
+export type RouteAvailabilityWindow = {
+    availability: ClientAvailability;
+    start: number;
+    end: number;
+};
+export declare function routeAvailabilityWindows(input: Pick<InRoute, "from" | "to" | "timezone">, availability: RPRoutesAvailability, location_id: string, client_id: string): RouteAvailabilityWindow[];
+export {};