@fabriktor/fx 0.0.128 → 0.0.129

package/dist/src/fx.js

@@ -79,6 +79,9 @@ export class FX {
         });
         this.payments = newPaymentsFX({
             payments: opts.payments,
+            billable: opts.billable,
+            payrolls: opts.payrolls,
+            events: this.events,
         });
         this.payrolls = newPayrollsFX({
             payrolls: opts.payrolls,

package/dist/src/payments/payments.d.ts

@@ -1,6 +1,8 @@
-import { type CreditLedgerEntry, type Payment, type PmtAccount, type PmtBankAccount, type PmtCard, type PmtCustomer, type PmtPublicSession, type PmtRefund } from "@fabriktor/schema";
-import { type PaymentsOperator } from "@fabriktor/client";
-import { type OwnerSearchOptions, type SearchPage } from "../core/search.js";
+import { PaymentEntityTypeBill, PaymentEntityTypePayroll, type Bill, type Payroll, PSPPaymentStatusPending, PSPPaymentStatusPartial, PSPPaymentStatusFull, type CreditLedgerEntry, type Payment, type PmtAccount, type PmtBankAccount, type PmtCard, type PmtCustomer, type PmtPublicSession, type PmtRefund } from "@fabriktor/schema";
+import { type PaymentsOperator, type BillableOperator, type PayrollsOperator } from "@fabriktor/client";
+import { type SearchOptions, type OwnerSearchOptions, type SearchPage } from "../core/search.js";
+import { EventBus } from "../core/events.js";
+import type { MultiCreateAttempt, MultiCreateCheckpoint } from "../core/multi-create.js";
 type PurchaseCreditsPayload = Parameters<PaymentsOperator["purchaseCredits"]>[0];
 type OpenPublicSessionPayload = Parameters<PaymentsOperator["openPmtPublicSession"]>[0];
 type PaymentFromPublicSessionPayload = Parameters<PaymentsOperator["paymentFromPublicSession"]>[0];
@@ -21,16 +23,73 @@ type PmtPublicSessionInsertOptions = Parameters<PaymentsOperator["insertOnePmtPu
 type PmtPublicSessionReplaceOptions = Parameters<PaymentsOperator["replaceOnePmtPublicSession"]>[0];
 type CreditLedgerEntryInsertOptions = Parameters<PaymentsOperator["insertOneCreditLedgerEntry"]>[0];
 type CreditLedgerEntryReplaceOptions = Parameters<PaymentsOperator["replaceOneCreditLedgerEntry"]>[0];
-export type EntityPaymentHistoryOptions = {
+export type EntityPaymentScope = {
     owner_id: string;
-    entity_id: string;
-    type: Payment["type"];
     recipient_id?: string;
+} | {
+    owner_id?: string;
+    recipient_id: string;
+};
+export type EntityPaymentStatus = typeof PSPPaymentStatusPending | typeof PSPPaymentStatusPartial | typeof PSPPaymentStatusFull;
+export type EntityPaymentHistoryOptions = EntityPaymentScope & {
+    entity_id: string | readonly string[];
+    type: Payment["type"];
+    psp_payment_status?: EntityPaymentStatus | readonly EntityPaymentStatus[];
     signal?: AbortSignal;
 };
-export type CreatePaymentOptions = PaymentInsertOptions;
+export type PaymentEntity = {
+    id: string;
+    currency: string;
+    original_amount: number;
+};
+export type ResolveEntityPaymentsOptions = EntityPaymentScope & Pick<EntityPaymentHistoryOptions, "type" | "psp_payment_status" | "signal"> & {
+    entities: readonly PaymentEntity[];
+};
+export type EntityPayments = {
+    entity: PaymentEntity;
+    payments: Payment[];
+    matching_payments: Payment[];
+    paid_amount: number;
+    remaining_amount: number;
+    status: EntityPaymentStatus;
+    has_pending: boolean;
+};
+export declare const PaymentsEvents: {
+    Changed: import("../index.js").EventKey<Payment>;
+};
+export type PayableEntityType = typeof PaymentEntityTypeBill | typeof PaymentEntityTypePayroll;
+export type PayableEntity = PaymentEntity & {
+    type: PayableEntityType;
+    recipient_id: string;
+    record: Bill | Payroll;
+};
+export type PayableEntityBalance = EntityPayments & {
+    entity: PayableEntity;
+};
+export type SearchPayableEntitiesOptions = SearchOptions & {
+    owner_id: string;
+    type: PayableEntityType;
+};
+export type ResolvePayableEntityOptions = {
+    owner_id: string;
+    entity_id: string;
+    type: PayableEntityType;
+    signal?: AbortSignal;
+};
+export type CreateEntityPaymentOptions = {
+    owner_id: string;
+    entity_id: string;
+    type: PayableEntityType;
+    remaining_amount: number;
+    payer_payment_method_psp_id: string;
+    return_url: string;
+};
+export type CreatePaymentOptions = PaymentInsertOptions & MultiCreateCheckpoint;
 export type ReplacePaymentOptions = PaymentReplaceOptions;
-export type SearchPaymentsOptions = OwnerSearchOptions;
+export type SearchPaymentsOptions = OwnerSearchOptions & {
+    type?: Payment["type"] | Payment["type"][];
+    kind?: Payment["kind"];
+};
 export type SearchPaymentsPage = SearchPage<Payment>;
 export type CreatePmtAccountOptions = PmtAccountInsertOptions;
 export type ContinuePmtAccountOnboardingOptions = PmtAccountOnboardingOptions;
@@ -110,9 +169,16 @@ export type OpenPublicPaymentSessionResult = {
 };
 export type PaymentsFXOptions = {
     payments: PaymentsOperator;
+    billable?: Pick<BillableOperator, "searchManyBills" | "findOneBill">;
+    payrolls?: Pick<PayrollsOperator, "searchManyPayrolls" | "findOnePayroll">;
+    events?: EventBus;
 };
 export interface PaymentsFXOperator {
+    resolvePayableEntity(opts: ResolvePayableEntityOptions): Promise<PayableEntityBalance>;
+    searchPayableEntities(opts: SearchPayableEntitiesOptions): Promise<SearchPage<PayableEntityBalance>>;
+    createEntityPayment(opts: CreateEntityPaymentOptions, attempt: MultiCreateAttempt): Promise<Payment>;
     entityPaymentHistory(opts: EntityPaymentHistoryOptions): Promise<Payment[]>;
+    resolveEntityPayments(opts: ResolveEntityPaymentsOptions): Promise<EntityPayments[]>;
     createPayment(opts: CreatePaymentOptions): Promise<Payment>;
     replacePayment(opts: ReplacePaymentOptions): Promise<Payment>;
     searchPayments(opts: SearchPaymentsOptions): Promise<SearchPaymentsPage>;
@@ -149,9 +215,16 @@ export interface PaymentsFXOperator {
 }
 export declare class PaymentsFX implements PaymentsFXOperator {
     private payments;
+    private billable;
+    private payrolls;
+    private readonly events;
     private submittedPublicSessionIDs;
     constructor(opts: PaymentsFXOptions);
     entityPaymentHistory(opts: EntityPaymentHistoryOptions): Promise<Payment[]>;
+    resolveEntityPayments(opts: ResolveEntityPaymentsOptions): Promise<EntityPayments[]>;
+    searchPayableEntities(opts: SearchPayableEntitiesOptions): Promise<SearchPage<PayableEntityBalance>>;
+    resolvePayableEntity(opts: ResolvePayableEntityOptions): Promise<PayableEntityBalance>;
+    createEntityPayment(opts: CreateEntityPaymentOptions, attempt: MultiCreateAttempt): Promise<Payment>;
     createPayment(opts: CreatePaymentOptions): Promise<Payment>;
     replacePayment(opts: ReplacePaymentOptions): Promise<Payment>;
     searchPayments(opts: SearchPaymentsOptions): Promise<SearchPaymentsPage>;
@@ -196,4 +269,5 @@ export declare class PaymentsFX implements PaymentsFXOperator {
     private openPublicPaymentSession;
 }
 export declare function newPaymentsFX(opts: PaymentsFXOptions): PaymentsFX;
+export declare function isPaymentPending(payment: Payment): boolean;
 export {};

package/dist/src/payments/payments.js

@@ -3,11 +3,13 @@
 // Licensed under the Apache License, Version 2.0 (the "License"); you may
 // 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 { CreditLedgerSourceAndroidIAP, CreditLedgerSourceAppleIAP, CreditLedgerSourceStripe, ZeroID, PaymentKindMain, } from "@fabriktor/schema";
-import { queryParams } from "@fabriktor/client";
+import { CreditLedgerSourceAndroidIAP, CreditLedgerSourceAppleIAP, CreditLedgerSourceStripe, ZeroID, PaymentKindMain, PaymentEntityTypeBill, PaymentEntityTypePayroll, PSPActionableStatusSucceeded, PSPActionableStatusFailed, PSPActionableStatusCanceled, PSPPaymentStatusPending, PSPPaymentStatusPartial, PSPPaymentStatusFull, } from "@fabriktor/schema";
+import { queryParams, } from "@fabriktor/client";
 import { errResolveFailed, errValidation } from "../core/err.js";
-import { requiredOperationID, resolvedID } from "../core/id.js";
-import { runOwnerSearch, } from "../core/search.js";
+import { normalizeIDs, requiredOperationID, resolvedID } from "../core/id.js";
+import { runOwnerSearch, runSearch, } from "../core/search.js";
+import { createEvent, EventBus } from "../core/events.js";
+const entityPaymentQuerySize = 30;
 const publicAmountPattern = /^\d+$/;
 const resourcePayment = "payment";
 const resourcePmtAccount = "pmt_account";
@@ -20,6 +22,17 @@ const resourcePmtPublicSession = "pmt_public_session";
 const resourceCreditLedgerEntry = "credit_ledger_entry";
 const resourceStripeCreditPayment = "stripe credit payment";
 const resourcePublicPaymentSession = "public payment session";
+const msgPayableSourceMissing = "Payable entity source is unavailable.";
+const msgPayableBalanceChanged = "Payment balance changed or a payment is still pending. Refresh before paying.";
+const msgPaymentMethodRequired = "A payment method is required.";
+const msgPayableUnavailable = "This entity is not available for payment.";
+const msgPaymentScopeMissing = "Payment history requires a payer or recipient scope and an entity type.";
+const msgPaymentHistoryIncomplete = "Payment history response is incomplete.";
+const msgPaymentEntityInvalid = "Payment resolution requires a valid entity, currency, and amount.";
+const msgPaymentEntityConflict = "Payment resolution received conflicting entity amounts.";
+const msgPaymentCurrencyMismatch = "Payment currency differs from the entity currency.";
+const msgPaymentAmountInvalid = "Payment amount is invalid.";
+const msgPaymentStatusesInvalid = "Select at least one valid payment status, or omit the status filter.";
 const msgCreatedPaymentIDMissing = "Created payment response did not contain an ID.";
 const msgPaymentMissing = "Payment could not be resolved after the mutation.";
 const msgCreatedPmtAccountIDMissing = "Created payment account response did not contain an ID.";
@@ -47,6 +60,9 @@ const msgPublicSessionConsumed = "Public payment session has already been consum
 const msgPublicAmountInvalid = "Public payment amount must be a positive integer.";
 const msgPublicBalanceInvalid = "Public payment session balance is invalid.";
 const msgPublicAmountExceedsBalance = "Public payment amount cannot exceed the session balance.";
+export const PaymentsEvents = {
+    Changed: createEvent(),
+};
 export const PmtAccountAccessStatus = {
     Missing: "missing",
     OnboardingRequired: "onboarding_required",
@@ -71,8 +87,7 @@ export function pmtAccountAccess(account) {
     if (account === null) {
         return { account, status: PmtAccountAccessStatus.Missing, ready: false };
     }
-    if (account.is_currently_due ||
-        account.is_external_account_due) {
+    if (account.is_currently_due || account.is_external_account_due) {
         return {
             account,
             status: PmtAccountAccessStatus.RequirementsDue,
@@ -96,34 +111,289 @@ export const PublicPaymentSessionStatus = {
 };
 export class PaymentsFX {
     payments;
+    billable;
+    payrolls;
+    events;
     submittedPublicSessionIDs;
     constructor(opts) {
         this.payments = opts.payments;
+        this.billable = opts.billable;
+        this.payrolls = opts.payrolls;
+        this.events = opts.events ?? new EventBus();
         this.submittedPublicSessionIDs = new Set();
     }
     async entityPaymentHistory(opts) {
-        if (!resolvedID(opts.owner_id) || !resolvedID(opts.entity_id) || !opts.type.trim()) {
-            throw errValidation({ field: "entity_id", msg: "Payment history requires an owner, entity, and type." });
+        const owner_id = resolvedID(opts.owner_id);
+        const recipient_id = resolvedID(opts.recipient_id);
+        if ((!owner_id && !recipient_id) || !opts.type.trim()) {
+            throw errValidation({ msg: msgPaymentScopeMissing });
+        }
+        const ids = normalizeIDs(typeof opts.entity_id === "string" ? [opts.entity_id] : opts.entity_id);
+        const statuses = entityPaymentStatuses(opts.psp_payment_status);
+        const records = new Map();
+        for (let offset = 0; offset < ids.length; offset += entityPaymentQuerySize) {
+            opts.signal?.throwIfAborted();
+            const response = await this.payments.queryPayments({
+                signal: opts.signal,
+                query: queryParams({
+                    owner_id,
+                    recipient_id,
+                    entity_id: ids.length === 1
+                        ? ids[0]
+                        : ids.slice(offset, offset + entityPaymentQuerySize),
+                    type: opts.type,
+                    kind: PaymentKindMain,
+                    ...(statuses === undefined ? {} : { psp_payment_status: statuses }),
+                }),
+            });
+            opts.signal?.throwIfAborted();
+            if (!Array.isArray(response.value)) {
+                throw errResolveFailed({
+                    resource: resourcePayment,
+                    msg: msgPaymentHistoryIncomplete,
+                });
+            }
+            // Retain each entity's backend order and ignore duplicate documents.
+            for (const payment of response.value)
+                records.set(payment.id, payment);
+        }
+        return [...records.values()];
+    }
+    async resolveEntityPayments(opts) {
+        const { entities, psp_payment_status, ...scope } = opts;
+        const statuses = entityPaymentStatuses(psp_payment_status);
+        const unique = new Map();
+        for (const entity of entities) {
+            if (!resolvedID(entity.id) ||
+                !entity.currency.trim() ||
+                !Number.isSafeInteger(entity.original_amount) ||
+                entity.original_amount < 0) {
+                throw errValidation({ msg: msgPaymentEntityInvalid });
+            }
+            const previous = unique.get(entity.id);
+            if (previous &&
+                (previous.currency !== entity.currency ||
+                    previous.original_amount !== entity.original_amount)) {
+                throw errValidation({ msg: msgPaymentEntityConflict });
+            }
+            unique.set(entity.id, entity);
+        }
+        // Never infer unpaid from a filtered history: resolve coverage from all statuses.
+        const payments = await this.entityPaymentHistory({
+            ...scope,
+            entity_id: [...unique.keys()],
+        });
+        const grouped = new Map();
+        for (const payment of payments) {
+            if (payment.kind !== PaymentKindMain ||
+                payment.type !== opts.type ||
+                !unique.has(payment.entity_id))
+                continue;
+            const group = grouped.get(payment.entity_id) ?? [];
+            group.push(payment);
+            grouped.set(payment.entity_id, group);
+        }
+        return [...unique.values()].map((entity) => {
+            const records = grouped.get(entity.id) ?? [];
+            let paid_amount = 0;
+            for (const payment of records) {
+                if (payment.currency.toUpperCase() !== entity.currency.toUpperCase()) {
+                    throw errResolveFailed({
+                        resource: resourcePayment,
+                        msg: msgPaymentCurrencyMismatch,
+                    });
+                }
+                if (payment.psp_actionable_status !== PSPActionableStatusSucceeded)
+                    continue;
+                const amount = payment.gross_amount.raw;
+                if (!Number.isSafeInteger(amount) ||
+                    amount < 0 ||
+                    !Number.isSafeInteger(paid_amount + amount)) {
+                    throw errResolveFailed({
+                        resource: resourcePayment,
+                        msg: msgPaymentAmountInvalid,
+                    });
+                }
+                paid_amount += amount;
+            }
+            const remaining_amount = Math.max(0, entity.original_amount - paid_amount);
+            return {
+                entity,
+                payments: records,
+                matching_payments: statuses === undefined
+                    ? records
+                    : records.filter((payment) => statuses.includes(payment.psp_payment_status)),
+                paid_amount,
+                remaining_amount,
+                status: remaining_amount === 0
+                    ? PSPPaymentStatusFull
+                    : paid_amount > 0
+                        ? PSPPaymentStatusPartial
+                        : PSPPaymentStatusPending,
+                has_pending: records.some(isPaymentPending),
+            };
+        });
+    }
+    // Scan real source pages until there are payable results or the source is exhausted.
+    // Settlement is a cross-service resolution, not a fabricated backend unpaid filter.
+    async searchPayableEntities(opts) {
+        if (!resolvedID(opts.owner_id))
+            throw errValidation({ msg: msgPaymentScopeMissing });
+        let page = opts.page;
+        while (true) {
+            opts.signal?.throwIfAborted();
+            let source;
+            if (opts.type === PaymentEntityTypeBill && this.billable) {
+                source = await runSearch({
+                    ...opts,
+                    page,
+                    query: queryParams({
+                        client_id: opts.owner_id,
+                        is_internal_client: true,
+                        is_estimate: false,
+                        is_canceled: false,
+                    }),
+                    search: (request) => this.billable.searchManyBills(request),
+                });
+            }
+            else if (opts.type === PaymentEntityTypePayroll && this.payrolls) {
+                source = await runOwnerSearch({
+                    ...opts,
+                    page,
+                    query: queryParams({
+                        is_banked: false,
+                        is_problematic: false,
+                    }),
+                    search: (request) => this.payrolls.searchManyPayrolls(request),
+                });
+            }
+            else
+                throw errValidation({ msg: msgPayableSourceMissing });
+            const entities = source.results.map((record) => payableEntity(record, opts.type, opts.owner_id));
+            const balances = await this.resolveEntityPayments({
+                owner_id: opts.owner_id,
+                type: opts.type,
+                entities,
+                signal: opts.signal,
+            });
+            const results = balances.flatMap((balance, index) => balance.remaining_amount > 0 && !balance.has_pending
+                ? [{ ...balance, entity: entities[index] }]
+                : []);
+            if (results.length || source.done) {
+                // Source counts include paid records and cannot describe the filtered result.
+                return {
+                    ...source,
+                    results,
+                    total_count: undefined,
+                    last_page: undefined,
+                };
+            }
+            if (source.next_page <= source.page)
+                throw errResolveFailed({
+                    resource: resourcePayment,
+                    msg: msgPaymentHistoryIncomplete,
+                });
+            page = source.next_page;
         }
-        const response = await this.payments.queryPayments({
+    }
+    async resolvePayableEntity(opts) {
+        opts.signal?.throwIfAborted();
+        const record = opts.type === PaymentEntityTypeBill
+            ? (await this.billable?.findOneBill({
+                id: opts.entity_id,
+                signal: opts.signal,
+            }))?.value
+            : opts.type === PaymentEntityTypePayroll
+                ? (await this.payrolls?.findOnePayroll({
+                    id: opts.entity_id,
+                    signal: opts.signal,
+                }))?.value
+                : undefined;
+        if (!record)
+            throw errResolveFailed({
+                resource: resourcePayment,
+                msg: msgPaymentMissing,
+            });
+        const entity = payableEntity(record, opts.type, opts.owner_id);
+        const [balance] = await this.resolveEntityPayments({
+            owner_id: opts.owner_id,
+            type: opts.type,
+            entities: [entity],
             signal: opts.signal,
-            query: queryParams({ owner_id: opts.owner_id, entity_id: opts.entity_id, type: opts.type, kind: PaymentKindMain, recipient_id: opts.recipient_id }),
         });
-        // Preserve the backend's chronological order; do not infer settlement from PSP payment balance flags.
-        return response.value ?? [];
+        if (!balance)
+            throw errResolveFailed({
+                resource: resourcePayment,
+                msg: msgPaymentHistoryIncomplete,
+            });
+        return { ...balance, entity };
+    }
+    async createEntityPayment(opts, attempt) {
+        if (attempt.created_id)
+            return this.findPayment(attempt.created_id, attempt.signal);
+        const balance = await this.resolvePayableEntity({
+            ...opts,
+            signal: attempt.signal,
+        });
+        const { entity } = balance;
+        if (!balance ||
+            balance.has_pending ||
+            balance.remaining_amount <= 0 ||
+            balance.remaining_amount !== opts.remaining_amount) {
+            throw errValidation({
+                msg: msgPayableBalanceChanged,
+            });
+        }
+        if (!resolvedID(opts.payer_payment_method_psp_id))
+            throw errValidation({ msg: msgPaymentMethodRequired });
+        const amount = {
+            raw: balance.remaining_amount,
+            text: String(balance.remaining_amount),
+        };
+        return this.createPayment({
+            ...attempt,
+            in: {
+                psp_confirm: true,
+                is_manual: false,
+                currency: entity.currency,
+                entity_id: entity.id,
+                type: entity.type,
+                recipient_id: entity.recipient_id,
+                payer_payment_method_psp_id: opts.payer_payment_method_psp_id,
+                return_url: opts.return_url,
+                use_psp_sdk: true,
+                original_amount: {
+                    raw: entity.original_amount,
+                    text: String(entity.original_amount),
+                },
+                original_balance_amount: amount,
+                gross_amount: amount,
+                is_off_session: false,
+            },
+        });
     }
     async createPayment(opts) {
+        if (opts.created_id)
+            return this.findPayment(opts.created_id, opts.signal);
+        opts.signal?.throwIfAborted();
+        opts.before_request?.();
         const out = await this.payments.insertOnePayment(opts);
         const id = requiredOperationID(out, msgCreatedPaymentIDMissing);
-        return await this.findPayment(id);
+        opts.on_created?.(id);
+        const payment = await this.findPayment(id, opts.signal);
+        this.events.publish(PaymentsEvents.Changed, payment);
+        return payment;
     }
     async replacePayment(opts) {
         await this.payments.replaceOnePayment(opts);
-        return await this.findPayment(opts.id);
+        const payment = await this.findPayment(opts.id);
+        this.events.publish(PaymentsEvents.Changed, payment);
+        return payment;
     }
     async searchPayments(opts) {
         return await runOwnerSearch({
             ...opts,
+            query: queryParams({ type: opts.type, kind: opts.kind }),
             search: (searchOpts) => this.payments.searchManyPayments(searchOpts),
         });
     }
@@ -388,9 +658,10 @@ export class PaymentsFX {
             throw err;
         }
     }
-    async findPayment(id) {
+    async findPayment(id, signal) {
         const out = await this.payments.findOnePayment({
             id,
+            signal,
         });
         const payment = out.value;
         if (payment === undefined) {
@@ -597,3 +868,45 @@ function zeroGoogleIAP() {
         kind: "",
     };
 }
+// A coverage flag alone does not establish the provider outcome.
+export function isPaymentPending(payment) {
+    return (payment.psp_actionable_status !== PSPActionableStatusSucceeded &&
+        payment.psp_actionable_status !== PSPActionableStatusFailed &&
+        payment.psp_actionable_status !== PSPActionableStatusCanceled);
+}
+function entityPaymentStatuses(value) {
+    if (value === undefined)
+        return undefined;
+    const values = [...new Set(typeof value === "string" ? [value] : value)];
+    if (!values.length ||
+        values.some((status) => status !== PSPPaymentStatusPending &&
+            status !== PSPPaymentStatusPartial &&
+            status !== PSPPaymentStatusFull)) {
+        throw errValidation({ msg: msgPaymentStatusesInvalid });
+    }
+    return values;
+}
+function payableEntity(record, type, ownerID) {
+    const bill = "is_estimate" in record;
+    if (!resolvedID(ownerID) ||
+        (type === PaymentEntityTypeBill
+            ? !bill ||
+                !record.is_internal_client ||
+                record.client_id !== ownerID ||
+                record.is_estimate ||
+                record.is_canceled
+            : bill ||
+                record.owner_id !== ownerID ||
+                record.is_banked ||
+                record.is_problematic)) {
+        throw errValidation({ msg: msgPayableUnavailable });
+    }
+    return {
+        id: record.id,
+        type,
+        recipient_id: bill ? record.owner_id : record.employee_id,
+        currency: record.currency,
+        original_amount: bill ? record.total.total.raw : record.net_amount.raw,
+        record,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fabriktor/fx",
-  "version": "0.0.128",
+  "version": "0.0.129",
   "description": "![Fabriktor Logo](./img/fabriktor-character.gif)",
   "type": "module",
   "exports": {
@@ -17,8 +17,8 @@
     "typescript": "^6.0.3"
   },
   "dependencies": {
-    "@fabriktor/client": "0.0.91",
+    "@fabriktor/client": "0.0.92",
     "@fabriktor/fx": "0.0.94",
-    "@fabriktor/schema": "0.0.65"
+    "@fabriktor/schema": "0.0.66"
   }
 }