@fabriktor/fx 0.0.113 → 0.0.115

package/dist/src/fx.js

@@ -108,6 +108,7 @@ export class FX {
         });
         this.timesheets = newTimesheetsFX({
             timesheets: opts.timesheets,
+            billable: opts.billable,
         });
         this.users = newUsersFX({
             users: opts.users,

package/dist/src/index.d.ts

@@ -31,6 +31,7 @@ export * from "./routes/routes.js";
 export * from "./session/session.js";
 export * from "./storage/storage.js";
 export * from "./timesheets/timesheets.js";
+export * from "./timesheets/workspace.js";
 export * from "./users/email.js";
 export * from "./users/phone.js";
 export * from "./users/username.js";

package/dist/src/index.js

@@ -31,6 +31,7 @@ export * from "./routes/routes.js";
 export * from "./session/session.js";
 export * from "./storage/storage.js";
 export * from "./timesheets/timesheets.js";
+export * from "./timesheets/workspace.js";
 export * from "./users/email.js";
 export * from "./users/phone.js";
 export * from "./users/username.js";

package/dist/src/timesheets/timesheets.d.ts

@@ -1,5 +1,6 @@
 import { type Date as SchemaDate, type OperationResult, type Summary, type WeekSheet } from "@fabriktor/schema";
-import type { TimesheetsOperator } from "@fabriktor/client";
+import type { BillableOperator, TimesheetsOperator } from "@fabriktor/client";
+import { TimesheetsWorkspace } from "./workspace.js";
 type PunchPayload = Parameters<TimesheetsOperator["punch"]>[0];
 type WeekSheetReplaceOptions = Parameters<TimesheetsOperator["replaceOneWeekSheet"]>[0];
 type SummaryReplaceOptions = Parameters<TimesheetsOperator["replaceOneSummary"]>[0];
@@ -7,6 +8,8 @@ export type ReplaceWeekSheetOptions = WeekSheetReplaceOptions;
 export type ReplaceSummaryOptions = SummaryReplaceOptions;
 export type TimesheetsFXOptions = {
     timesheets: TimesheetsOperator;
+    billable?: BillableOperator;
+    now?: () => globalThis.Date;
 };
 export type PunchContext = Pick<PunchPayload, "timezone" | "location_id" | "employer_id">;
 export type PunchInOptions = PunchContext & {
@@ -61,6 +64,7 @@ export type ApproveWeekSheetsOptions = {
     week_sheets: WeekSheet[];
 };
 export interface TimesheetsFXOperator {
+    readonly workspace: TimesheetsWorkspace;
     replaceWeekSheet(opts: ReplaceWeekSheetOptions): Promise<WeekSheet>;
     replaceSummary(opts: ReplaceSummaryOptions): Promise<Summary>;
     punchControls(opts: PunchControlsOptions): PunchControls;
@@ -76,6 +80,7 @@ export interface TimesheetsFXOperator {
     approveWeekSheets(opts: ApproveWeekSheetsOptions): Promise<void>;
 }
 export declare class TimesheetsFX implements TimesheetsFXOperator {
+    readonly workspace: TimesheetsWorkspace;
     private timesheets;
     private punch_in_progress;
     constructor(opts: TimesheetsFXOptions);

package/dist/src/timesheets/timesheets.js

@@ -6,6 +6,8 @@
 import { PunchModeDefault, PunchModeDelete, PunchModeReplace, PunchModeWeekSheet, PunchStatusPending, PunchStatusWorking, PunchTypeIn, PunchTypeOut, PunchTypeRideIn, PunchTypeRideOut, ZeroID, } from "@fabriktor/schema";
 import { zeroDate } from "../core/date.js";
 import { errRequired, errResolveFailed, errValidation, } from "../core/err.js";
+import { PreActionBlocked } from "../core/pre-action.js";
+import { TimesheetsWorkspace, TimesheetsBlock, timesheetCanApprove, timesheetIsMutable, timesheetPunches, } from "./workspace.js";
 const allWeekDays = [0, 1, 2, 3, 4, 5, 6];
 const minuteStep = 15;
 const msgPunchInProgress = "A punch action is already in progress.";
@@ -27,11 +29,13 @@ const resourceSummary = "summary";
 const msgWeekSheetMissing = "Week sheet could not be resolved after the mutation.";
 const msgSummaryMissing = "Summary could not be resolved after the mutation.";
 export class TimesheetsFX {
+    workspace;
     timesheets;
     punch_in_progress;
     constructor(opts) {
         this.timesheets = opts.timesheets;
         this.punch_in_progress = false;
+        this.workspace = new TimesheetsWorkspace(opts.timesheets, this, opts.billable, opts.now);
     }
     async replaceWeekSheet(opts) {
         await this.timesheets.replaceOneWeekSheet(opts);
@@ -43,7 +47,7 @@ export class TimesheetsFX {
     }
     punchControls(opts) {
         validateWeekDay(opts.week_day, "week_day");
-        if (opts.week_sheet?.is_archived) {
+        if (opts.week_sheet && !timesheetIsMutable(opts.week_sheet)) {
             return disabledPunchControls();
         }
         const day = opts.week_sheet?.sheets.find((sheet) => sheet.week_day === opts.week_day);
@@ -207,7 +211,13 @@ export class TimesheetsFX {
             });
         }
         const ids = [];
-        for (const week_sheet of opts.week_sheets) {
+        for (const expected of opts.week_sheets) {
+            // Query cleaners can return partial days. Always authorize the whole fresh record.
+            const week_sheet = await this.findWeekSheet(expected.id);
+            if (week_sheet.updated_at !== expected.updated_at)
+                throw new PreActionBlocked(TimesheetsBlock.Changed);
+            if (!timesheetCanApprove(week_sheet))
+                throw new PreActionBlocked(TimesheetsBlock.Locked);
             const id = requiredID(week_sheet.id, "week_sheets", msgWeekSheetIDRequired);
             if (week_sheet.employer_id !== employer_id) {
                 throw errValidation({
@@ -266,6 +276,12 @@ export class TimesheetsFX {
         return summary;
     }
     async syncSheets(opts) {
+        const source = await this.findWeekSheet(opts.from.id);
+        if (source.updated_at !== opts.from.updated_at)
+            throw new PreActionBlocked(TimesheetsBlock.Changed);
+        if (!timesheetCanApprove(source))
+            throw new PreActionBlocked(TimesheetsBlock.InvalidSync);
+        opts = { ...opts, from: source };
         const from_id = requiredID(opts.from.id, "from", msgWeekSheetIDRequired);
         if (opts.to.length === 0) {
             throw errRequired({
@@ -274,7 +290,16 @@ export class TimesheetsFX {
             });
         }
         const to_ids = [];
-        for (const week_sheet of opts.to) {
+        for (const expected of opts.to) {
+            const week_sheet = await this.findWeekSheet(expected.id);
+            if (week_sheet.updated_at !== expected.updated_at)
+                throw new PreActionBlocked(TimesheetsBlock.Changed);
+            if (!timesheetIsMutable(week_sheet) ||
+                timesheetPunches(week_sheet).some((p) => p.punch_status === PunchStatusWorking) ||
+                week_sheet.id === opts.from.id ||
+                week_sheet.period_index !== opts.from.period_index ||
+                week_sheet.timezone !== opts.from.timezone)
+                throw new PreActionBlocked(TimesheetsBlock.InvalidSync);
             const id = requiredID(week_sheet.id, "to", msgWeekSheetIDRequired);
             if (week_sheet.is_archived) {
                 throw errValidation({

package/dist/src/timesheets/workspace.d.ts

@@ -0,0 +1,76 @@
+import type { BillableOperator, TimesheetsOperator } from "@fabriktor/client";
+import { PunchTypeIn, PunchTypeOut, PunchTypeRideIn, PunchTypeRideOut, type InDate, type Punch, type Summary, type WeekSheet } from "@fabriktor/schema";
+import type { TimesheetsFXOperator } from "./timesheets.js";
+export type TimesheetFilters = {
+    owner_ids?: string[];
+    employer_ids?: string[];
+    period_indexes?: number[];
+    location_ids?: string[];
+    is_archived?: boolean;
+    punch_status?: string;
+    signal?: AbortSignal;
+};
+export type PunchStateOptions = {
+    owner_id: string;
+    employer_id: string;
+    timezone: string;
+    date?: InDate;
+};
+export type TimesheetPunchState = {
+    week_sheet?: WeekSheet;
+    punch?: Punch;
+    week_day: number;
+    stale_day: boolean;
+};
+export type TimesheetPunchAction = typeof PunchTypeIn | typeof PunchTypeOut | typeof PunchTypeRideIn | typeof PunchTypeRideOut;
+export type CheckedPunchOptions = PunchStateOptions & {
+    location_id: string;
+    action: TimesheetPunchAction;
+    expected: TimesheetPunchState;
+    total_pause_minutes?: number;
+    total_meal_minutes?: number;
+};
+export type SaveTimesheetDayOptions = PunchStateOptions & {
+    location_id: string;
+    start: InDate;
+    end: InDate;
+    total_pause_minutes: number;
+    total_meal_minutes: number;
+    replace?: WeekSheet;
+};
+export declare const TimesheetsBlock: {
+    readonly Changed: "timesheets_changed";
+    readonly Locked: "timesheets_locked";
+    readonly Active: "timesheets_active";
+    readonly InvalidDay: "timesheets_invalid_day";
+    readonly InvalidSync: "timesheets_invalid_sync";
+    readonly Unconfirmed: "timesheets_unconfirmed";
+};
+export declare function timesheetPunches(sheet: WeekSheet): Punch[];
+export declare function timesheetIsMutable(sheet: WeekSheet): boolean;
+export declare function timesheetCanApprove(sheet: WeekSheet): boolean;
+export declare function timesheetStateKey(state: TimesheetPunchState): string;
+export declare function timesheetWeekDay(date: InDate): number;
+export declare class TimesheetsWorkspace {
+    private readonly client;
+    private readonly actions;
+    private readonly billable?;
+    private readonly now;
+    constructor(client: TimesheetsOperator, actions: TimesheetsFXOperator, billable?: BillableOperator | undefined, now?: () => Date);
+    weeks(opts: TimesheetFilters): Promise<WeekSheet[]>;
+    summaries(opts: TimesheetFilters): Promise<Summary[]>;
+    week(id: string, signal?: AbortSignal): Promise<WeekSheet>;
+    summary(id: string, signal?: AbortSignal): Promise<Summary>;
+    periods(employer_id: string, start: InDate, end?: InDate): Promise<number[]>;
+    punchState(opts: PunchStateOptions): Promise<TimesheetPunchState>;
+    punch(opts: CheckedPunchOptions): Promise<WeekSheet>;
+    saveDay(opts: SaveTimesheetDayOptions): Promise<WeekSheet>;
+    removeDay(owner_id: string, expected: WeekSheet, date: InDate): Promise<void>;
+    removeWeek(actor_id: string, expected: WeekSheet): Promise<void>;
+    blankWeek(opts: PunchStateOptions & {
+        location_id: string;
+        date: InDate;
+    }): Promise<WeekSheet>;
+    private checkedWeek;
+    private validateDay;
+}

package/dist/src/timesheets/workspace.js

@@ -0,0 +1,322 @@
+import { PunchStatusApproved, PunchStatusPending, PunchStatusWorking, PunchTypeIn, PunchTypeOut, PunchTypeRideIn, PunchTypeRideOut, } from "@fabriktor/schema";
+import { inDateAtTimestamp, zeroDate } from "../core/date.js";
+import { PreActionBlocked } from "../core/pre-action.js";
+export const TimesheetsBlock = {
+    Changed: "timesheets_changed",
+    Locked: "timesheets_locked",
+    Active: "timesheets_active",
+    InvalidDay: "timesheets_invalid_day",
+    InvalidSync: "timesheets_invalid_sync",
+    Unconfirmed: "timesheets_unconfirmed",
+};
+function requireState(allowed, reason) {
+    if (!allowed)
+        throw new PreActionBlocked(reason);
+}
+export function timesheetPunches(sheet) {
+    return sheet.sheets.flatMap((day) => day.punches);
+}
+export function timesheetIsMutable(sheet) {
+    return (!sheet.is_archived &&
+        !timesheetPunches(sheet).some((p) => p.punch_status === PunchStatusApproved));
+}
+export function timesheetCanApprove(sheet) {
+    const punches = timesheetPunches(sheet);
+    return (timesheetIsMutable(sheet) &&
+        punches.length > 0 &&
+        punches.every((p) => p.punch_status === PunchStatusPending));
+}
+export function timesheetStateKey(state) {
+    return JSON.stringify([
+        state.week_sheet?.id,
+        state.week_sheet?.updated_at,
+        state.week_sheet?.is_archived,
+        state.week_day,
+        state.punch,
+    ]);
+}
+export function timesheetWeekDay(date) {
+    // Calendar arithmetic on explicit date parts; never the device timezone.
+    return new Date(Date.UTC(date.y, date.m - 1, date.d)).getUTCDay();
+}
+function sameDay(a, b) {
+    return a.y === b.y && a.m === b.m && a.d === b.d;
+}
+function wallTime(date) {
+    return Date.UTC(date.y, date.m - 1, date.d, date.h, date.min);
+}
+function schemaDate(date) {
+    // The backend computes UTC from the supplied wall-clock fields and tz.
+    return { ...zeroDate(), ...date };
+}
+export class TimesheetsWorkspace {
+    client;
+    actions;
+    billable;
+    now;
+    constructor(client, actions, billable, now = () => new Date()) {
+        this.client = client;
+        this.actions = actions;
+        this.billable = billable;
+        this.now = now;
+    }
+    async weeks(opts) {
+        if (emptyScope(opts))
+            return [];
+        const result = await this.client.queryWeekSheets({
+            signal: opts.signal,
+            query: {
+                ...query(opts),
+                is_archived: opts.is_archived,
+                "sheets.punches.location_id": opts.location_ids,
+                "sheets.punches.punch_status": opts.punch_status,
+            },
+        });
+        return result.value ?? [];
+    }
+    async summaries(opts) {
+        if (emptyScope(opts))
+            return [];
+        const result = await this.client.querySummaries({
+            signal: opts.signal,
+            query: {
+                ...query(opts),
+                "location_records.location_id": opts.location_ids,
+            },
+        });
+        return result.value ?? [];
+    }
+    async week(id, signal) {
+        const { value } = await this.client.findOneWeekSheet({ id, signal });
+        requireState(!!value, TimesheetsBlock.Changed);
+        return value;
+    }
+    async summary(id, signal) {
+        const { value } = await this.client.findOneSummary({ id, signal });
+        requireState(!!value, TimesheetsBlock.Changed);
+        return value;
+    }
+    async periods(employer_id, start, end = start) {
+        requireState(!!this.billable && !!employer_id, TimesheetsBlock.InvalidDay);
+        const result = await this.billable.periodsFromDates({
+            employer_id,
+            start,
+            end,
+        });
+        requireState(!!result.value?.ints.length, TimesheetsBlock.InvalidDay);
+        return result.value.ints;
+    }
+    async punchState(opts) {
+        requireState(!!opts.owner_id && !!opts.timezone, TimesheetsBlock.InvalidDay);
+        const today = opts.date ?? inDateAtTimestamp(this.now().toISOString(), opts.timezone);
+        const week_day = timesheetWeekDay(today);
+        // Check every open work punch, including other employers/locations/weeks.
+        // A scope selection must never hide an already open shift.
+        const active = await this.weeks({
+            owner_ids: [opts.owner_id],
+            is_archived: false,
+            punch_status: PunchStatusWorking,
+        });
+        const open = active.flatMap((week_sheet) => week_sheet.sheets.flatMap((day) => day.punches
+            .filter((p) => p.punch_status === PunchStatusWorking)
+            .map((punch) => ({ week_sheet, punch, week_day: day.week_day }))));
+        requireState(open.length <= 1, TimesheetsBlock.Active);
+        if (open[0]) {
+            const current = open[0];
+            const date = inDateAtTimestamp(this.now().toISOString(), current.punch.timezone);
+            return {
+                ...current,
+                stale_day: !sameDay(current.punch.punch_in_time, opts.date ?? date),
+            };
+        }
+        if (!opts.employer_id)
+            return { week_day, stale_day: false };
+        const indexes = await this.periods(opts.employer_id, today);
+        const weeks = await this.weeks({
+            owner_ids: [opts.owner_id],
+            employer_ids: [opts.employer_id],
+            period_indexes: indexes,
+        });
+        requireState(weeks.length <= 1, TimesheetsBlock.Changed);
+        const week_sheet = weeks[0];
+        const punch = week_sheet?.sheets
+            .find((day) => day.week_day === week_day)
+            ?.punches.at(-1);
+        return { week_sheet, punch, week_day, stale_day: false };
+    }
+    async punch(opts) {
+        if (opts.date)
+            this.validateDay(opts.date, opts.timezone);
+        const current = await this.punchState(opts);
+        requireState(timesheetStateKey(current) === timesheetStateKey(opts.expected), TimesheetsBlock.Changed);
+        requireState(!current.stale_day, TimesheetsBlock.InvalidDay);
+        requireState(!current.week_sheet || timesheetIsMutable(current.week_sheet), TimesheetsBlock.Locked);
+        const controls = this.actions.punchControls(current);
+        const allowed = {
+            [PunchTypeIn]: controls.can_punch_in,
+            [PunchTypeOut]: controls.can_punch_out,
+            [PunchTypeRideIn]: controls.can_ride_in,
+            [PunchTypeRideOut]: controls.can_ride_out,
+        };
+        requireState(allowed[opts.action], TimesheetsBlock.Changed);
+        if (opts.action !== PunchTypeIn) {
+            requireState(current.punch?.location_id === opts.location_id &&
+                current.punch.employer_id === opts.employer_id &&
+                current.punch.timezone === opts.timezone, TimesheetsBlock.Changed);
+        }
+        if (opts.date && current.punch && opts.action !== PunchTypeIn) {
+            requireState(sameDay(opts.date, current.punch.punch_in_time) &&
+                wallTime(opts.date) >= wallTime(current.punch.punch_in_time), TimesheetsBlock.InvalidDay);
+        }
+        const context = {
+            employer_id: opts.employer_id,
+            location_id: opts.location_id,
+            timezone: opts.timezone,
+            explicit_date: opts.date ? schemaDate(opts.date) : undefined,
+        };
+        const result = opts.action === PunchTypeIn
+            ? await this.actions.punchIn(context)
+            : opts.action === PunchTypeOut
+                ? await this.actions.punchOut({
+                    ...context,
+                    total_pause_minutes: opts.total_pause_minutes ?? 0,
+                    total_meal_minutes: opts.total_meal_minutes ?? 0,
+                })
+                : opts.action === PunchTypeRideIn
+                    ? await this.actions.rideIn(context)
+                    : await this.actions.rideOut(context);
+        requireState(!!result.id, TimesheetsBlock.Unconfirmed);
+        const sheet = await this.week(result.id);
+        const last = sheet.sheets
+            .find((day) => day.week_day === current.week_day)
+            ?.punches.at(-1);
+        requireState(!!last &&
+            last.location_id === opts.location_id &&
+            !sheet.is_archived &&
+            (opts.action === PunchTypeOut
+                ? last.punch_status === PunchStatusPending
+                : last.punch_status === PunchStatusWorking) &&
+            (opts.action !== PunchTypeRideIn ||
+                last.rides.at(-1)?.is_active === true) &&
+            (opts.action !== PunchTypeRideOut ||
+                last.rides.at(-1)?.is_active === false), TimesheetsBlock.Unconfirmed);
+        return sheet;
+    }
+    async saveDay(opts) {
+        this.validateDay(opts.start, opts.timezone);
+        this.validateDay(opts.end, opts.timezone);
+        requireState(sameDay(opts.start, opts.end) &&
+            wallTime(opts.end) > wallTime(opts.start), TimesheetsBlock.InvalidDay);
+        const indexes = await this.periods(opts.employer_id, opts.start);
+        const matches = await this.weeks({
+            owner_ids: [opts.owner_id],
+            employer_ids: [opts.employer_id],
+            period_indexes: indexes,
+        });
+        requireState(matches.length <= 1, TimesheetsBlock.Changed);
+        const sheet = matches[0];
+        const day = sheet?.sheets.find((d) => d.week_day === timesheetWeekDay(opts.start));
+        if (opts.replace) {
+            requireState(sheet?.id === opts.replace.id &&
+                sheet.updated_at === opts.replace.updated_at, TimesheetsBlock.Changed);
+        }
+        else {
+            // A new manual entry must not silently replace an existing day.
+            requireState(!day?.punches.length, TimesheetsBlock.Changed);
+        }
+        requireState(!sheet || timesheetIsMutable(sheet), TimesheetsBlock.Locked);
+        requireState(!day?.punches.some((p) => p.punch_status === PunchStatusWorking), TimesheetsBlock.Active);
+        const open = await this.weeks({
+            owner_ids: [opts.owner_id],
+            is_archived: false,
+            punch_status: PunchStatusWorking,
+        });
+        requireState(open.length === 0, TimesheetsBlock.Active);
+        const result = await this.actions.replaceDay({
+            employer_id: opts.employer_id,
+            location_id: opts.location_id,
+            timezone: opts.timezone,
+            punch_in_date: schemaDate(opts.start),
+            punch_out_date: schemaDate(opts.end),
+            total_pause_minutes: opts.total_pause_minutes,
+            total_meal_minutes: opts.total_meal_minutes,
+        });
+        requireState(!!result.punch_out.id, TimesheetsBlock.Unconfirmed);
+        return this.week(result.punch_out.id);
+    }
+    async removeDay(owner_id, expected, date) {
+        const sheet = await this.checkedWeek(expected);
+        requireState(sheet.owner_id === owner_id, TimesheetsBlock.Locked);
+        const day = sheet.sheets.find((d) => d.week_day === timesheetWeekDay(date));
+        requireState(!!day?.punches.length &&
+            !day.punches.some((p) => p.punch_status === PunchStatusWorking), TimesheetsBlock.Active);
+        const punch = day.punches[0];
+        requireState(sameDay(date, punch.punch_in_time), TimesheetsBlock.InvalidDay);
+        await this.actions.deleteDay({
+            employer_id: sheet.employer_id,
+            location_id: punch.location_id,
+            timezone: punch.timezone,
+            explicit_date: schemaDate(date),
+        });
+    }
+    async removeWeek(actor_id, expected) {
+        const sheet = await this.checkedWeek(expected);
+        requireState(sheet.owner_id === actor_id || sheet.employer_id === actor_id, TimesheetsBlock.Locked);
+        requireState(!timesheetPunches(sheet).some((p) => p.punch_status === PunchStatusWorking), TimesheetsBlock.Active);
+        await this.client.deleteOneWeekSheet({ id: sheet.id });
+    }
+    async blankWeek(opts) {
+        this.validateDay(opts.date, opts.timezone);
+        const indexes = await this.periods(opts.employer_id, opts.date);
+        const matches = await this.weeks({
+            owner_ids: [opts.owner_id],
+            employer_ids: [opts.employer_id],
+            period_indexes: indexes,
+        });
+        requireState(matches.length === 0, TimesheetsBlock.Changed);
+        const result = await this.actions.createBlankWeekSheet({
+            ...opts,
+            explicit_date: schemaDate(opts.date),
+        });
+        requireState(!!result.id, TimesheetsBlock.Unconfirmed);
+        return this.week(result.id);
+    }
+    async checkedWeek(expected) {
+        const sheet = await this.week(expected.id);
+        requireState(sheet.updated_at === expected.updated_at, TimesheetsBlock.Changed);
+        requireState(timesheetIsMutable(sheet), TimesheetsBlock.Locked);
+        return sheet;
+    }
+    validateDay(date, timezone) {
+        const now = inDateAtTimestamp(this.now().toISOString(), timezone);
+        const calendar = new Date(Date.UTC(date.y, date.m - 1, date.d));
+        requireState(!!now &&
+            date.tz === timezone &&
+            date.y > 1 &&
+            date.m >= 1 &&
+            date.m <= 12 &&
+            calendar.getUTCDate() === date.d &&
+            Number.isInteger(date.h) &&
+            date.h >= 0 &&
+            date.h < 24 &&
+            Number.isInteger(date.min) &&
+            date.min >= 0 &&
+            date.min < 60 &&
+            wallTime(date) <= wallTime(now), TimesheetsBlock.InvalidDay);
+    }
+}
+function emptyScope(opts) {
+    return [
+        opts.owner_ids,
+        opts.employer_ids,
+        opts.period_indexes,
+        opts.location_ids,
+    ].some((ids) => ids?.length === 0);
+}
+function query(opts) {
+    return {
+        owner_id: opts.owner_ids,
+        employer_id: opts.employer_ids,
+        period_index: opts.period_indexes,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabriktor/fx",
-  "version": "0.0.113",
+  "version": "0.0.115",
   "description": "![Fabriktor Logo](./img/fabriktor-character.gif)",
   "type": "module",
   "exports": {
@@ -17,7 +17,7 @@
     "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@fabriktor/client": "0.0.85",
+    "@fabriktor/client": "0.0.87",
     "@fabriktor/fx": "0.0.94",
     "@fabriktor/schema": "0.0.63"
   }