@fabriktor/fx 0.0.104 → 0.0.106

package/dist/src/billable/billable.d.ts

@@ -26,7 +26,24 @@ type VendorInvoiceInsertOptions = Parameters<BillableOperator["insertOneVendorIn
 type VendorInvoiceReplaceOptions = Parameters<BillableOperator["replaceOneVendorInvoice"]>[0];
 type WarehouseInsertOptions = Parameters<BillableOperator["insertOneWarehouse"]>[0];
 type WarehouseReplaceOptions = Parameters<BillableOperator["replaceOneWarehouse"]>[0];
-export type SearchBillsOptions = OwnerSearchOptions & Partial<Pick<Bill, "is_estimate" | "is_canceled" | "type">>;
+export declare const BillFilter: {
+    readonly All: "all";
+    readonly NotCancelled: "not_cancelled";
+    readonly Fixed: "fixed";
+    readonly Dynamic: "dynamic";
+    readonly Cancelled: "cancelled";
+};
+export type BillFilter = (typeof BillFilter)[keyof typeof BillFilter];
+export declare function billFilterFields(value: BillFilter): Partial<Pick<Bill, "is_canceled" | "type">>;
+type ItemSearchFields = Partial<Pick<Item, "folder_id" | "is_archived" | "quantifier_id">> & {
+    warehouse_id?: Item["per_warehouse_quantity"][number]["warehouse_id"];
+};
+type EquipmentSearchFields = Partial<Pick<Equipment, "folder_id" | "is_archived" | "warehouse_id" | "rental_type">>;
+type ChargeSearchFields = Partial<Pick<Charge, "location_id" | "entity_id" | "warehouse_id" | "type" | "is_estimate" | "is_billed">>;
+type MeterReadingSearchFields = Partial<Pick<MeterReading, "location_id" | "equipment_id">>;
+export type SearchBillsOptions = OwnerSearchOptions & Partial<Pick<Bill, "is_estimate" | "is_canceled" | "type">> & {
+    filter?: BillFilter;
+};
 export type SearchBillsPage = SearchPage<Bill>;
 export type CreateBillableFolderOptions = BillableFolderInsertOptions;
 export type ReplaceBillableFolderOptions = BillableFolderReplaceOptions;
@@ -34,31 +51,31 @@ export type SearchBillableFoldersOptions = OwnerSearchOptions;
 export type SearchBillableFoldersPage = SearchPage<BillableFolder>;
 export type CreateChargeOptions = ChargeInsertOptions;
 export type ReplaceChargeOptions = ChargeReplaceOptions;
-export type SearchChargesOptions = OwnerSearchOptions;
+export type SearchChargesOptions = OwnerSearchOptions & ChargeSearchFields;
 export type SearchChargesPage = SearchPage<Charge>;
 export type CreateEquipmentOptions = EquipmentInsertOptions;
 export type ReplaceEquipmentOptions = EquipmentReplaceOptions;
-export type SearchEquipmentsOptions = OwnerSearchOptions;
+export type SearchEquipmentsOptions = OwnerSearchOptions & EquipmentSearchFields;
 export type SearchEquipmentsPage = SearchPage<Equipment>;
 export type CreateItemOptions = ItemInsertOptions;
 export type ReplaceItemOptions = ItemReplaceOptions;
-export type SearchItemsOptions = OwnerSearchOptions;
+export type SearchItemsOptions = OwnerSearchOptions & ItemSearchFields;
 export type SearchItemsPage = SearchPage<Item>;
 export type CreateLaborRateOptions = LaborRateInsertOptions;
 export type ReplaceLaborRateOptions = LaborRateReplaceOptions;
-export type SearchLaborRatesOptions = OwnerSearchOptions;
+export type SearchLaborRatesOptions = OwnerSearchOptions & Partial<Pick<LaborRate, "is_archived">>;
 export type SearchLaborRatesPage = SearchPage<LaborRate>;
 export type CreateMeterReadingOptions = MeterReadingInsertOptions;
 export type ReplaceMeterReadingOptions = MeterReadingReplaceOptions;
-export type SearchMeterReadingsOptions = OwnerSearchOptions;
+export type SearchMeterReadingsOptions = OwnerSearchOptions & MeterReadingSearchFields;
 export type SearchMeterReadingsPage = SearchPage<MeterReading>;
 export type CreateQuantifierOptions = QuantifierInsertOptions;
 export type ReplaceQuantifierOptions = QuantifierReplaceOptions;
-export type SearchQuantifiersOptions = OwnerSearchOptions;
+export type SearchQuantifiersOptions = OwnerSearchOptions & Partial<Pick<Quantifier, "is_archived">>;
 export type SearchQuantifiersPage = SearchPage<Quantifier>;
 export type CreateTaxOptions = TaxInsertOptions;
 export type ReplaceTaxOptions = TaxReplaceOptions;
-export type SearchTaxesOptions = OwnerSearchOptions;
+export type SearchTaxesOptions = OwnerSearchOptions & Partial<Pick<Tax, "is_archived">>;
 export type SearchTaxesPage = SearchPage<Tax>;
 export type SearchAllTaxesOptions = Omit<SearchTaxesOptions, "page">;
 export type CreateTmpBillNumberOptions = TmpBillNumberInsertOptions;
@@ -70,11 +87,11 @@ export type CreateVendorInvoiceOptions = VendorInvoiceInsertOptions & {
     allow_duplicate?: boolean;
 };
 export type ReplaceVendorInvoiceOptions = VendorInvoiceReplaceOptions;
-export type SearchVendorInvoicesOptions = OwnerSearchOptions;
+export type SearchVendorInvoicesOptions = OwnerSearchOptions & Partial<Pick<VendorInvoice, "is_archived">>;
 export type SearchVendorInvoicesPage = SearchPage<VendorInvoice>;
 export type CreateWarehouseOptions = WarehouseInsertOptions;
 export type ReplaceWarehouseOptions = WarehouseReplaceOptions;
-export type SearchWarehousesOptions = OwnerSearchOptions;
+export type SearchWarehousesOptions = OwnerSearchOptions & Partial<Pick<Warehouse, "is_archived">>;
 export type SearchWarehousesPage = SearchPage<Warehouse>;
 export type BillableFXOptions = {
     billable: BillableOperator;
@@ -111,14 +128,12 @@ export type BillableReadSearchOptions = SearchOptions & {
     employer_scope_ids?: Iterable<string>;
     query?: SearchQuery;
 };
-export type BillableItemReadSearchOptions = BillableReadSearchOptions & {
-    warehouse_id?: string;
-    quantifier_id?: string;
-};
-export type BillableEquipmentReadSearchOptions = BillableReadSearchOptions & {
-    warehouse_id?: string;
-    rental_type?: string;
-};
+export type BillableItemReadSearchOptions = BillableReadSearchOptions & ItemSearchFields;
+export type BillableEquipmentReadSearchOptions = BillableReadSearchOptions & EquipmentSearchFields;
+export type BillableChargeReadSearchOptions = BillableReadSearchOptions & ChargeSearchFields;
+export type BillableMeterReadingReadSearchOptions = BillableReadSearchOptions & MeterReadingSearchFields;
+export type BillableQuantifierReadSearchOptions = BillableReadSearchOptions & Partial<Pick<Quantifier, "is_archived">>;
+export type BillableWarehouseReadSearchOptions = BillableReadSearchOptions & Partial<Pick<Warehouse, "is_archived">>;
 export type GenerateFixedEstimateOptions = {
     in: GenerateBillPayload;
 };
@@ -150,7 +165,7 @@ export interface BillableFXOperator {
     createCharge(opts: CreateChargeOptions): Promise<Charge>;
     replaceCharge(opts: ReplaceChargeOptions): Promise<Charge>;
     searchCharges(opts: SearchChargesOptions): Promise<SearchChargesPage>;
-    searchReadableCharges(opts: BillableReadSearchOptions): Promise<SearchChargesPage>;
+    searchReadableCharges(opts: BillableChargeReadSearchOptions): Promise<SearchChargesPage>;
     createEquipment(opts: CreateEquipmentOptions): Promise<Equipment>;
     replaceEquipment(opts: ReplaceEquipmentOptions): Promise<Equipment>;
     searchEquipments(opts: SearchEquipmentsOptions): Promise<SearchEquipmentsPage>;
@@ -165,11 +180,11 @@ export interface BillableFXOperator {
     createMeterReading(opts: CreateMeterReadingOptions): Promise<MeterReading>;
     replaceMeterReading(opts: ReplaceMeterReadingOptions): Promise<MeterReading>;
     searchMeterReadings(opts: SearchMeterReadingsOptions): Promise<SearchMeterReadingsPage>;
-    searchReadableMeterReadings(opts: BillableReadSearchOptions): Promise<SearchMeterReadingsPage>;
+    searchReadableMeterReadings(opts: BillableMeterReadingReadSearchOptions): Promise<SearchMeterReadingsPage>;
     createQuantifier(opts: CreateQuantifierOptions): Promise<Quantifier>;
     replaceQuantifier(opts: ReplaceQuantifierOptions): Promise<Quantifier>;
     searchQuantifiers(opts: SearchQuantifiersOptions): Promise<SearchQuantifiersPage>;
-    searchReadableQuantifiers(opts: BillableReadSearchOptions): Promise<SearchQuantifiersPage>;
+    searchReadableQuantifiers(opts: BillableQuantifierReadSearchOptions): Promise<SearchQuantifiersPage>;
     createTax(opts: CreateTaxOptions): Promise<Tax>;
     replaceTax(opts: ReplaceTaxOptions): Promise<Tax>;
     searchTaxes(opts: SearchTaxesOptions): Promise<SearchTaxesPage>;
@@ -183,7 +198,7 @@ export interface BillableFXOperator {
     createWarehouse(opts: CreateWarehouseOptions): Promise<Warehouse>;
     replaceWarehouse(opts: ReplaceWarehouseOptions): Promise<Warehouse>;
     searchWarehouses(opts: SearchWarehousesOptions): Promise<SearchWarehousesPage>;
-    searchReadableWarehouses(opts: BillableReadSearchOptions): Promise<SearchWarehousesPage>;
+    searchReadableWarehouses(opts: BillableWarehouseReadSearchOptions): Promise<SearchWarehousesPage>;
     generateFixedEstimate(opts: GenerateFixedEstimateOptions): Promise<Bill>;
     acceptFixedEstimate(opts: AcceptFixedEstimateOptions): Promise<Bill>;
     generateDynamicEstimate(opts: GenerateDynamicEstimateOptions): Promise<Bill>;
@@ -205,7 +220,7 @@ export declare class BillableFX implements BillableFXOperator {
     createCharge(opts: CreateChargeOptions): Promise<Charge>;
     replaceCharge(opts: ReplaceChargeOptions): Promise<Charge>;
     searchCharges(opts: SearchChargesOptions): Promise<SearchChargesPage>;
-    searchReadableCharges(opts: BillableReadSearchOptions): Promise<SearchChargesPage>;
+    searchReadableCharges(opts: BillableChargeReadSearchOptions): Promise<SearchChargesPage>;
     createEquipment(opts: CreateEquipmentOptions): Promise<Equipment>;
     replaceEquipment(opts: ReplaceEquipmentOptions): Promise<Equipment>;
     searchEquipments(opts: SearchEquipmentsOptions): Promise<SearchEquipmentsPage>;
@@ -220,11 +235,11 @@ export declare class BillableFX implements BillableFXOperator {
     createMeterReading(opts: CreateMeterReadingOptions): Promise<MeterReading>;
     replaceMeterReading(opts: ReplaceMeterReadingOptions): Promise<MeterReading>;
     searchMeterReadings(opts: SearchMeterReadingsOptions): Promise<SearchMeterReadingsPage>;
-    searchReadableMeterReadings(opts: BillableReadSearchOptions): Promise<SearchMeterReadingsPage>;
+    searchReadableMeterReadings(opts: BillableMeterReadingReadSearchOptions): Promise<SearchMeterReadingsPage>;
     createQuantifier(opts: CreateQuantifierOptions): Promise<Quantifier>;
     replaceQuantifier(opts: ReplaceQuantifierOptions): Promise<Quantifier>;
     searchQuantifiers(opts: SearchQuantifiersOptions): Promise<SearchQuantifiersPage>;
-    searchReadableQuantifiers(opts: BillableReadSearchOptions): Promise<SearchQuantifiersPage>;
+    searchReadableQuantifiers(opts: BillableQuantifierReadSearchOptions): Promise<SearchQuantifiersPage>;
     createTax(opts: CreateTaxOptions): Promise<Tax>;
     replaceTax(opts: ReplaceTaxOptions): Promise<Tax>;
     searchTaxes(opts: SearchTaxesOptions): Promise<SearchTaxesPage>;
@@ -238,7 +253,7 @@ export declare class BillableFX implements BillableFXOperator {
     createWarehouse(opts: CreateWarehouseOptions): Promise<Warehouse>;
     replaceWarehouse(opts: ReplaceWarehouseOptions): Promise<Warehouse>;
     searchWarehouses(opts: SearchWarehousesOptions): Promise<SearchWarehousesPage>;
-    searchReadableWarehouses(opts: BillableReadSearchOptions): Promise<SearchWarehousesPage>;
+    searchReadableWarehouses(opts: BillableWarehouseReadSearchOptions): Promise<SearchWarehousesPage>;
     generateFixedEstimate(opts: GenerateFixedEstimateOptions): Promise<Bill>;
     acceptFixedEstimate(opts: AcceptFixedEstimateOptions): Promise<Bill>;
     generateDynamicEstimate(opts: GenerateDynamicEstimateOptions): Promise<Bill>;
@@ -249,7 +264,6 @@ export declare class BillableFX implements BillableFXOperator {
     vendorInvoiceFromBill(opts: VendorInvoiceFromBillOptions): Promise<VendorInvoice>;
     private generateBill;
     private checkVendorInvoiceNumber;
-    private searchReadableActivity;
     private searchReadable;
     private findBill;
     private findBillableFolder;

package/dist/src/billable/billable.js

@@ -3,13 +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 { queryParams } from "@fabriktor/client";
+import { mergeQueryOptions, queryNestedParam, queryParams, } from "@fabriktor/client";
 import { BillTypeDynamic, BillTypeFixed, UserTypeEmployee, UserTypeEmployer, } from "@fabriktor/schema";
 import { isZeroDateTime } from "../core/date.js";
 import { errRequired, errResolveFailed, errValidation } from "../core/err.js";
 import { requiredOperationID, resolvedID } from "../core/id.js";
 import { runPreActionCheck } from "../core/pre-action.js";
-import { collectSearchResults, runOwnerScopeFilteredSearch, runOwnerScopeSearch, runOwnerSearch, withOwnerQuery, } from "../core/search.js";
+import { collectSearchResults, runOwnerScopeSearch, runOwnerSearch, withOwnerQuery, } from "../core/search.js";
 const resourceBill = "bill";
 const msgCreatedBillIDMissing = "Created bill response did not contain an ID.";
 const msgBillMissing = "Bill could not be resolved after the mutation.";
@@ -56,6 +56,26 @@ const msgBillIDRequired = "Bill ID is required.";
 const msgBillIDMissing = "Bill response did not contain an ID.";
 const msgCompletableBillRequired = "Only an uncanceled invoice can be completed.";
 const msgAcceptedEstimateCancellation = "Cancel the accepted invoice instead of its estimate.";
+// Composite sidebar states belong with their backend query mapping.
+export const BillFilter = {
+    All: "all",
+    NotCancelled: "not_cancelled",
+    Fixed: BillTypeFixed,
+    Dynamic: BillTypeDynamic,
+    Cancelled: "cancelled",
+};
+export function billFilterFields(value) {
+    switch (value) {
+        case BillFilter.All:
+            return {};
+        case BillFilter.NotCancelled:
+            return { is_canceled: false };
+        case BillFilter.Cancelled:
+            return { is_canceled: true };
+        default:
+            return { is_canceled: false, type: value };
+    }
+}
 export const BillableReadResource = {
     Bill: "bill",
     BillableFolder: "billable_folder",
@@ -114,6 +134,7 @@ export class BillableFX {
                 is_estimate: opts.is_estimate,
                 is_canceled: opts.is_canceled,
                 type: opts.type,
+                ...(opts.filter === undefined ? {} : billFilterFields(opts.filter)),
             }),
             search: (searchOpts) => this.billable.searchManyBills(searchOpts),
         });
@@ -145,12 +166,20 @@ export class BillableFX {
     async searchCharges(opts) {
         return await runOwnerSearch({
             ...opts,
+            query: chargeSearchQuery(opts),
             search: (searchOpts) => this.billable.searchManyCharges(searchOpts),
         });
     }
     async searchReadableCharges(opts) {
-        return await this.searchReadableActivity({
+        const employer_ids = activityEmployerScopeIDs(opts);
+        return await this.searchReadable({
             ...opts,
+            // owner_id identifies the creator; employer_id identifies their employer.
+            // An explicitly empty authorized employer set must not become All.
+            allowed_owner_ids: employer_ids?.size === 0 ? [] : activityOwnerIDs(opts.context),
+            query: mergeQueryOptions(opts.query, chargeSearchQuery(opts), employer_ids === undefined ? undefined : queryParams({
+                employer_id: [...employer_ids],
+            })),
             search: (searchOpts) => this.billable.searchManyCharges(searchOpts),
         });
     }
@@ -166,18 +195,15 @@ export class BillableFX {
     async searchEquipments(opts) {
         return await runOwnerSearch({
             ...opts,
+            query: equipmentSearchQuery(opts),
             search: (searchOpts) => this.billable.searchManyEquipments(searchOpts),
         });
     }
     async searchReadableEquipments(opts) {
-        const { warehouse_id, rental_type, ...search_opts } = opts;
         return await this.searchReadable({
-            ...search_opts,
+            ...opts,
+            query: mergeQueryOptions(opts.query, equipmentSearchQuery(opts)),
             allowed_owner_ids: catalogOwnerIDs(opts.context, opts.employer_scope_ids),
-            filter: warehouse_id === undefined && rental_type === undefined
-                ? undefined
-                : (equipment) => (warehouse_id === undefined || equipment.warehouse_id === warehouse_id) &&
-                    (rental_type === undefined || equipment.rental_type === rental_type),
             search: (searchOpts) => this.billable.searchManyEquipments(searchOpts),
         });
     }
@@ -193,19 +219,15 @@ export class BillableFX {
     async searchItems(opts) {
         return await runOwnerSearch({
             ...opts,
+            query: itemSearchQuery(opts),
             search: (searchOpts) => this.billable.searchManyItems(searchOpts),
         });
     }
     async searchReadableItems(opts) {
-        const { warehouse_id, quantifier_id, ...search_opts } = opts;
         return await this.searchReadable({
-            ...search_opts,
+            ...opts,
+            query: mergeQueryOptions(opts.query, itemSearchQuery(opts)),
             allowed_owner_ids: catalogOwnerIDs(opts.context, opts.employer_scope_ids),
-            filter: warehouse_id === undefined && quantifier_id === undefined
-                ? undefined
-                : (item) => (warehouse_id === undefined ||
-                    item.per_warehouse_quantity.some((quantity) => quantity.warehouse_id === warehouse_id)) &&
-                    (quantifier_id === undefined || item.quantifier_id === quantifier_id),
             search: (searchOpts) => this.billable.searchManyItems(searchOpts),
         });
     }
@@ -221,6 +243,7 @@ export class BillableFX {
     async searchLaborRates(opts) {
         return await runOwnerSearch({
             ...opts,
+            query: queryParams({ is_archived: opts.is_archived }),
             search: (searchOpts) => this.billable.searchManyLaborRates(searchOpts),
         });
     }
@@ -236,12 +259,19 @@ export class BillableFX {
     async searchMeterReadings(opts) {
         return await runOwnerSearch({
             ...opts,
+            query: meterReadingSearchQuery(opts),
             search: (searchOpts) => this.billable.searchManyMeterReadings(searchOpts),
         });
     }
     async searchReadableMeterReadings(opts) {
-        return await this.searchReadableActivity({
+        const employer_ids = activityEmployerScopeIDs(opts);
+        return await this.searchReadable({
             ...opts,
+            // An explicitly empty authorized scope must stay empty, not become All.
+            allowed_owner_ids: employer_ids?.size === 0 ? [] : activityOwnerIDs(opts.context),
+            query: mergeQueryOptions(opts.query, meterReadingSearchQuery(opts), employer_ids === undefined ? undefined : queryParams({
+                employer_id: [...employer_ids],
+            })),
             search: (searchOpts) => this.billable.searchManyMeterReadings(searchOpts),
         });
     }
@@ -257,12 +287,16 @@ export class BillableFX {
     async searchQuantifiers(opts) {
         return await runOwnerSearch({
             ...opts,
+            query: queryParams({ is_archived: opts.is_archived }),
             search: (searchOpts) => this.billable.searchManyQuantifiers(searchOpts),
         });
     }
     async searchReadableQuantifiers(opts) {
         return await this.searchReadable({
             ...opts,
+            query: mergeQueryOptions(opts.query, queryParams({
+                ...(opts.is_archived === undefined ? {} : { is_archived: opts.is_archived }),
+            })),
             allowed_owner_ids: catalogOwnerIDs(opts.context, opts.employer_scope_ids),
             search: (searchOpts) => this.billable.searchManyQuantifiers(searchOpts),
         });
@@ -279,6 +313,7 @@ export class BillableFX {
     async searchTaxes(opts) {
         return await runOwnerSearch({
             ...opts,
+            query: queryParams({ is_archived: opts.is_archived }),
             search: (searchOpts) => this.billable.searchManyTaxes(searchOpts),
         });
     }
@@ -329,6 +364,7 @@ export class BillableFX {
     async searchVendorInvoices(opts) {
         return await runOwnerSearch({
             ...opts,
+            query: queryParams({ is_archived: opts.is_archived }),
             search: (searchOpts) => this.billable.searchManyVendorInvoices(searchOpts),
         });
     }
@@ -344,12 +380,16 @@ export class BillableFX {
     async searchWarehouses(opts) {
         return await runOwnerSearch({
             ...opts,
+            query: queryParams({ is_archived: opts.is_archived }),
             search: (searchOpts) => this.billable.searchManyWarehouses(searchOpts),
         });
     }
     async searchReadableWarehouses(opts) {
         return await this.searchReadable({
             ...opts,
+            query: mergeQueryOptions(opts.query, queryParams({
+                ...(opts.is_archived === undefined ? {} : { is_archived: opts.is_archived }),
+            })),
             allowed_owner_ids: catalogOwnerIDs(opts.context, opts.employer_scope_ids),
             search: (searchOpts) => this.billable.searchManyWarehouses(searchOpts),
         });
@@ -424,38 +464,12 @@ export class BillableFX {
             },
         });
     }
-    async searchReadableActivity(opts) {
-        const employer_scope_ids = activityEmployerScopeIDs(opts);
-        return await this.searchReadable({
-            ...opts,
-            allowed_owner_ids: activityOwnerIDs(opts.context),
-            filter: employer_scope_ids === undefined
-                ? undefined
-                : (value) => employer_scope_ids.has(value.employer_id),
-        });
-    }
     async searchReadable(opts) {
-        const { context: _context, owner_ids: requested_owner_ids, employer_scope_ids: _employer_scope_ids, allowed_owner_ids, search, filter, query, ...searchOpts } = opts;
+        const { context: _context, owner_ids: requested_owner_ids, employer_scope_ids: _employer_scope_ids, allowed_owner_ids, search, query, ...searchOpts } = opts;
         const owner_ids = restrictOwnerIDs(allowed_owner_ids, requested_owner_ids);
-        const page = filter === undefined
-            ? await runOwnerScopeSearch({
-                ...searchOpts,
-                owner_ids,
-                query,
-                search,
-            })
-            : await runOwnerScopeFilteredSearch({
-                ...searchOpts,
-                owner_ids,
-                query,
-                search,
-                filter,
-                compare: compareCreatedAtDescending,
-            });
-        return {
-            ...page,
-            results: [...page.results].sort(compareCreatedAtDescending),
-        };
+        // Keep each backend page in its returned order. The owner contract requires
+        // separate requests; do not manufacture a cross-owner sort in the frontend.
+        return await runOwnerScopeSearch({ ...searchOpts, owner_ids, query, search });
     }
     async findBill(id) {
         const out = await this.billable.findOneBill({
@@ -712,6 +726,55 @@ function catalogOwnerIDs(context, employer_scope_ids) {
     }
     return uniqueIDs([context.owner_id]);
 }
+function itemSearchQuery(opts) {
+    return mergeQueryOptions(queryParams({
+        ...(opts.folder_id === undefined
+            ? {}
+            : { folder_id: resolvedID(opts.folder_id) }),
+        ...(opts.is_archived === undefined ? {} : { is_archived: opts.is_archived }),
+        ...(opts.quantifier_id === undefined
+            ? {}
+            : { quantifier_id: resolvedID(opts.quantifier_id) }),
+    }), opts.warehouse_id === undefined ? undefined : queryNestedParam(["per_warehouse_quantity", "warehouse_id"], resolvedID(opts.warehouse_id)));
+}
+function equipmentSearchQuery(opts) {
+    return queryParams({
+        ...(opts.folder_id === undefined
+            ? {}
+            : { folder_id: resolvedID(opts.folder_id) }),
+        ...(opts.is_archived === undefined ? {} : { is_archived: opts.is_archived }),
+        ...(opts.warehouse_id === undefined
+            ? {}
+            : { warehouse_id: resolvedID(opts.warehouse_id) }),
+        ...(opts.rental_type === undefined ? {} : { rental_type: opts.rental_type }),
+    });
+}
+function chargeSearchQuery(opts) {
+    return queryParams({
+        ...(opts.location_id === undefined
+            ? {}
+            : { location_id: resolvedID(opts.location_id) }),
+        ...(opts.entity_id === undefined
+            ? {}
+            : { entity_id: resolvedID(opts.entity_id) }),
+        ...(opts.warehouse_id === undefined
+            ? {}
+            : { warehouse_id: resolvedID(opts.warehouse_id) }),
+        ...(opts.type === undefined ? {} : { type: opts.type }),
+        ...(opts.is_estimate === undefined ? {} : { is_estimate: opts.is_estimate }),
+        ...(opts.is_billed === undefined ? {} : { is_billed: opts.is_billed }),
+    });
+}
+function meterReadingSearchQuery(opts) {
+    return queryParams({
+        ...(opts.location_id === undefined
+            ? {}
+            : { location_id: resolvedID(opts.location_id) }),
+        ...(opts.equipment_id === undefined
+            ? {}
+            : { equipment_id: resolvedID(opts.equipment_id) }),
+    });
+}
 function activityEmployerScopeIDs(opts) {
     if (opts.context.active_mode === UserTypeEmployer) {
         return new Set([opts.context.owner_id]);
@@ -739,13 +802,6 @@ function restrictOwnerIDs(allowed, requested) {
 function uniqueIDs(ids) {
     return [...new Set([...ids].map((id) => id.trim()).filter((id) => id !== ""))];
 }
-function compareCreatedAtDescending(left, right) {
-    return timestamp(right.created_at) - timestamp(left.created_at);
-}
-function timestamp(value) {
-    const out = globalThis.Date.parse(value);
-    return Number.isFinite(out) ? out : 0;
-}
 export function newBillableFX(opts) {
     return new BillableFX(opts);
 }

package/dist/src/chat/send-queue.d.ts

@@ -1,6 +1,6 @@
 import type { ChatOperator } from "@fabriktor/client";
 import type { Chat, InChat } from "@fabriktor/schema";
-import { type QueueStore, type QueueLock } from "../core/queue.js";
+import { type QueueRetry, type QueueStore, type QueueLock } from "../core/queue.js";
 export declare const ChatSendStatus: {
     readonly Saving: "saving";
     readonly Queued: "queued";
@@ -28,6 +28,7 @@ export type QueuedChat = {
     chat?: Chat;
     attachments: ChatSendAttachments;
     attempted: boolean;
+    retry?: QueueRetry;
     upload_key: string;
     personal_box_key: string;
 };
@@ -64,6 +65,9 @@ export declare class ChatSendQueue {
     private error?;
     private enabled;
     private revision;
+    private readonly wakeup;
+    private storageRetry?;
+    private pendingCreates;
     constructor(opts: ChatSendQueueOptions);
     get hasUnsavedMessages(): boolean;
     get snapshot(): ChatSendSnapshot;
@@ -80,6 +84,9 @@ export declare class ChatSendQueue {
     private startConfirmation;
     private startUpload;
     private recoverUpload;
+    private waitForRetry;
+    private recoverStorage;
+    private scheduleRecovery;
     private uploadLock;
     private confirmationLock;
     private roomLock;

package/dist/src/chat/send-queue.js

@@ -4,7 +4,7 @@
 // not use this file except in compliance with the License. You may obtain
 // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
 import { requiredOperationID } from "../core/id.js";
-import { PersistentQueue, } from "../core/queue.js";
+import { PersistentQueue, QueueWakeup, nextQueueRetry, } from "../core/queue.js";
 import { newOptimisticChat } from "./optimistic.js";
 export const ChatSendStatus = {
     Saving: "saving",
@@ -17,7 +17,8 @@ export const ChatSendStatus = {
     UploadInterrupted: "upload_interrupted",
 };
 // Persistent creation FIFO per account and room. Creation never advances beyond
-// a failed/uncertain head. Retrieval, other rooms and other users are independent.
+// an uncertain head: it recovers automatically with its original request key.
+// Retrieval, attachments, other rooms and other users are independent.
 export class ChatSendQueue {
     opts;
     owner = "";
@@ -36,6 +37,9 @@ export class ChatSendQueue {
     error;
     enabled = false;
     revision = 0;
+    wakeup = new QueueWakeup();
+    storageRetry;
+    pendingCreates = new Map();
     constructor(opts) {
         this.opts = opts;
         this.queue = new PersistentQueue(opts.store, opts.lock);
@@ -58,7 +62,8 @@ export class ChatSendQueue {
     }
     async start(ownerID) {
         if (this.enabled && this.owner === ownerID) {
-            await this.refresh();
+            this.persist();
+            await this.writes;
             return;
         }
         this.pause();
@@ -72,11 +77,13 @@ export class ChatSendQueue {
         this.enabled = ownerID !== "";
         this.controller = new AbortController();
         this.publish();
-        await this.refresh();
+        this.persist();
+        await this.writes;
     }
     pause() {
         this.enabled = false;
         this.controller.abort();
+        this.wakeup.cancel();
     }
     enqueue(input, attachments) {
         if (!this.enabled || !this.owner) {
@@ -106,23 +113,28 @@ export class ChatSendQueue {
         this.writes = this.writes.then(async () => {
             const blocked = new Set();
             for (const entry of this.pendingSaves.values()) {
-                if (entry.status !== ChatSendStatus.Saving) {
+                if (!this.current(entry.owner_id, this.controller.signal))
+                    continue;
+                if (this.waitForRetry(entry) || blocked.has(entry.owner_id)) {
                     blocked.add(entry.owner_id);
-                }
-                if (blocked.has(entry.owner_id)) {
                     continue;
                 }
                 try {
                     const saved = await this.queue.enqueue({
                         ...entry,
                         status: ChatSendStatus.Queued,
+                        retry: undefined,
                     });
                     this.pendingSaves.delete(entry.id);
                     this.replace(saved);
                     this.opts.changed?.();
                 }
                 catch (err) {
-                    const failed = { ...entry, status: ChatSendStatus.Failed };
+                    const failed = {
+                        ...entry,
+                        status: ChatSendStatus.Failed,
+                        retry: nextQueueRetry(entry.retry),
+                    };
                     this.pendingSaves.set(entry.id, failed);
                     this.replace(failed);
                     if (entry.owner_id === this.owner) {
@@ -130,6 +142,7 @@ export class ChatSendQueue {
                         this.publish();
                     }
                     blocked.add(entry.owner_id);
+                    this.waitForRetry(failed);
                 }
             }
             await this.refresh();
@@ -166,7 +179,10 @@ export class ChatSendQueue {
                 }
             }
             this.error = undefined;
+            this.storageRetry = undefined;
             this.publish();
+            if (stored.length === 0 && this.pendingSaves.size === 0)
+                this.wakeup.cancel();
             for (const room of new Set(stored
                 .filter((entry) => !entry.chat && !entry.server_id)
                 .map((entry) => entry.input.chat_room_id))) {
@@ -185,6 +201,7 @@ export class ChatSendQueue {
             if (this.current(owner, signal)) {
                 this.error = err;
                 this.publish();
+                this.recoverStorage();
             }
         }
     }
@@ -197,7 +214,11 @@ export class ChatSendQueue {
             if (entry.status !== ChatSendStatus.Failed) {
                 return;
             }
-            const saving = { ...entry, status: ChatSendStatus.Saving };
+            const saving = {
+                ...entry,
+                status: ChatSendStatus.Saving,
+                retry: undefined,
+            };
             this.pendingSaves.set(id, saving);
             this.replace(saving);
             this.persist();
@@ -221,6 +242,7 @@ export class ChatSendQueue {
             else {
                 await this.save({
                     ...current,
+                    retry: undefined,
                     status: current.server_id
                         ? ChatSendStatus.Confirming
                         : ChatSendStatus.Queued,
@@ -266,6 +288,7 @@ export class ChatSendQueue {
                 if (stored && !chatSendCanRemove(stored))
                     return;
                 await this.opts.store.remove(id);
+                this.pendingCreates.delete(id);
                 this.entries = this.entries.filter((value) => value.id !== id);
                 this.publish();
                 this.opts.changed?.();
@@ -290,6 +313,7 @@ export class ChatSendQueue {
                 if (this.current(owner, signal)) {
                     this.error = err;
                     this.publish();
+                    this.recoverStorage();
                 }
             },
             on_idle: () => {
@@ -301,54 +325,65 @@ export class ChatSendQueue {
                 if (!this.current(owner, signal) || this.cancellations.has(entry.id)) {
                     return false;
                 }
-                if (entry.status === ChatSendStatus.Sending) {
-                    await this.save({ ...entry, status: ChatSendStatus.Interrupted });
+                // A persisted Sending marker is an interrupted request once we own
+                // the room lock. Reuse its key; never skip an unknown creation outcome.
+                let current = this.pendingCreates.get(entry.id) ?? entry;
+                if (this.waitForRetry(current))
                     return false;
-                }
-                else if (entry.status !== ChatSendStatus.Queued) {
-                    return false;
-                }
-                let current = entry;
                 const request = new AbortController();
                 const requestSignal = AbortSignal.any([signal, request.signal]);
                 this.sends.set(entry.id, request);
                 try {
-                    current = {
-                        ...entry,
-                        status: ChatSendStatus.Sending,
-                        attempted: true,
-                    };
-                    await this.save(current);
-                    if (!this.current(owner, signal)) {
-                        return false;
+                    if (!current.server_id) {
+                        current = {
+                            ...current,
+                            status: ChatSendStatus.Sending,
+                            attempted: true,
+                        };
+                        await this.save(current);
+                        if (!this.current(owner, signal))
+                            return false;
+                        requestSignal.throwIfAborted();
+                        const out = await this.opts.chat.insertOneChat({
+                            in: current.input,
+                            signal: requestSignal,
+                            idempotency_key: current.id,
+                        });
+                        current = {
+                            ...current,
+                            server_id: requiredOperationID(out, "Created chat response did not contain an ID."),
+                        };
+                        this.pendingCreates.set(current.id, current);
                     }
-                    requestSignal.throwIfAborted();
-                    const out = await this.opts.chat.insertOneChat({
-                        in: current.input,
-                        signal: requestSignal,
-                        idempotency_key: current.id,
-                    });
                     current = {
                         ...current,
                         status: ChatSendStatus.Confirming,
-                        server_id: requiredOperationID(out, "Created chat response did not contain an ID."),
+                        retry: undefined,
                     };
                     // Persist successful creation before advancing the room's FIFO. A
                     // later retrieval failure must never cause this POST to be repeated.
                     await this.save(current);
+                    this.pendingCreates.delete(current.id);
                     if (!this.current(owner, signal)) {
                         return false;
                     }
                     this.startConfirmation(current, owner, signal);
                 }
                 catch (err) {
+                    current = {
+                        ...current,
+                        status: requestSignal.aborted
+                            ? ChatSendStatus.Interrupted
+                            : ChatSendStatus.Failed,
+                        retry: requestSignal.aborted
+                            ? undefined
+                            : nextQueueRetry(current.retry),
+                    };
+                    if (current.server_id)
+                        this.pendingCreates.set(current.id, current);
                     try {
-                        await this.save({
-                            ...current,
-                            status: requestSignal.aborted
-                                ? ChatSendStatus.Interrupted
-                                : ChatSendStatus.Failed,
-                        });
+                        await this.save(current);
+                        this.pendingCreates.delete(current.id);
                     }
                     catch (storageError) {
                         this.error = storageError;
@@ -356,6 +391,8 @@ export class ChatSendQueue {
                     if (this.current(owner, signal) && !request.signal.aborted) {
                         this.error = err;
                         this.publish();
+                        if (current.retry)
+                            this.scheduleRecovery(current.retry.after);
                     }
                     return false;
                 }
@@ -369,7 +406,7 @@ export class ChatSendQueue {
     // Retrieval is independent of the room's creation lock. Its per-message
     // lock coordinates retries/recovery across tabs without holding later POSTs.
     startConfirmation(entry, owner, signal) {
-        if (this.confirmations.has(entry.id)) {
+        if (this.confirmations.has(entry.id) || this.waitForRetry(entry)) {
             return;
         }
         this.confirmations.add(entry.id);
@@ -379,7 +416,9 @@ export class ChatSendQueue {
                 return;
             }
             const stored = (await this.opts.store.list(owner)).find((value) => value.id === entry.id);
-            if (!stored || !chatSendCanConfirm(stored)) {
+            if (!stored ||
+                !chatSendCanConfirm(stored) ||
+                this.waitForRetry(stored)) {
                 return;
             }
             let current = stored;
@@ -406,6 +445,7 @@ export class ChatSendQueue {
                         ...current,
                         chat,
                         status: ChatSendStatus.UploadInterrupted,
+                        retry: undefined,
                     };
                     await this.save(current);
                     this.startUpload(current, owner, signal);
@@ -418,8 +458,15 @@ export class ChatSendQueue {
                 }
             }
             catch (err) {
+                const retry = signal.aborted
+                    ? undefined
+                    : nextQueueRetry(current.retry);
+                if (retry && !current.chat && this.current(owner, signal)) {
+                    this.scheduleRecovery(retry.after);
+                }
                 await this.save({
                     ...current,
+                    retry,
                     status: current.chat
                         ? ChatSendStatus.UploadInterrupted
                         : signal.aborted
@@ -436,6 +483,7 @@ export class ChatSendQueue {
             if (this.current(owner, signal)) {
                 this.error = err;
                 this.publish();
+                this.recoverStorage();
             }
         })
             .finally(() => {
@@ -563,6 +611,25 @@ export class ChatSendQueue {
         })
             .finally(() => this.uploads.delete(entry.id));
     }
+    waitForRetry(entry) {
+        if (!entry.retry || entry.retry.after <= Date.now())
+            return false;
+        this.scheduleRecovery(entry.retry.after);
+        return true;
+    }
+    recoverStorage() {
+        this.storageRetry = nextQueueRetry(this.storageRetry);
+        this.scheduleRecovery(this.storageRetry.after);
+    }
+    scheduleRecovery(after) {
+        if (!this.enabled)
+            return;
+        this.wakeup.schedule(after, this.controller.signal, () => {
+            // Persist also refreshes the durable queue. It is app-owned, never
+            // dependent on a mounted chat tool or a presentation subscription.
+            this.persist();
+        });
+    }
     uploadLock(entry) {
         return `chat-upload:${entry.owner_id}:${entry.id}`;
     }
@@ -614,7 +681,8 @@ function chatSendCanConfirm(entry) {
         (entry.status === ChatSendStatus.Confirming ||
             entry.status === ChatSendStatus.Sending ||
             entry.status === ChatSendStatus.Queued ||
-            entry.status === ChatSendStatus.Interrupted));
+            entry.status === ChatSendStatus.Interrupted ||
+            entry.status === ChatSendStatus.Failed));
 }
 export function chatSendNeedsRetry(entry) {
     return (entry.status === ChatSendStatus.Failed ||

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

@@ -1,4 +1,5 @@
 import type { Date as SchemaDate, InDate } from "@fabriktor/schema";
+export declare const utcTimezone = "UTC";
 export type LocalDateParts = {
     y: number;
     m: number;
@@ -12,3 +13,6 @@ export declare function zeroDate(): SchemaDate;
 export declare function isZeroDate(v: LocalDateParts): boolean;
 export declare function isZeroDateTime(value: string | null | undefined): boolean;
 export declare function isZeroSchemaDate(value: SchemaDate | null | undefined): boolean;
+export declare function dateTimezone(timezone: string): string;
+export declare function inDateAtTimestamp(timestamp: string, timezone?: string): InDate | null;
+export declare function timestampDate(timestamp: string): globalThis.Date | null;

package/dist/src/core/date.js

@@ -16,7 +16,7 @@ const zeroDatePrefix = [
     String(zeroDateParts.d).padStart(2, "0"),
 ].join("-");
 const zeroUTC = `${zeroDatePrefix}T00:00:00Z`;
-const utcTimezone = "UTC";
+export const utcTimezone = "UTC";
 export function normalizeInputDate(v) {
     if (isZeroDate(v)) {
         return zeroInputDate();
@@ -53,3 +53,48 @@ export function isZeroSchemaDate(value) {
         value === undefined ||
         (isZeroDate(value) && isZeroDateTime(value.utc)));
 }
+// Use the account/location timezone explicitly; never consult the browser's
+// timezone when interpreting a persisted UTC timestamp.
+export function dateTimezone(timezone) {
+    const value = timezone.trim();
+    if (!value)
+        return utcTimezone;
+    try {
+        new Intl.DateTimeFormat("en", { timeZone: value });
+        return value;
+    }
+    catch {
+        return utcTimezone;
+    }
+}
+export function inDateAtTimestamp(timestamp, timezone = utcTimezone) {
+    const instant = timestampDate(timestamp);
+    if (!instant)
+        return null;
+    const tz = dateTimezone(timezone);
+    const parts = new Intl.DateTimeFormat("en-CA", {
+        timeZone: tz,
+        year: "numeric",
+        month: "2-digit",
+        day: "2-digit",
+        hour: "2-digit",
+        minute: "2-digit",
+        hourCycle: "h23",
+    }).formatToParts(instant);
+    const part = (type) => Number(parts.find((value) => value.type === type)?.value);
+    return {
+        y: part("year"),
+        m: part("month"),
+        d: part("day"),
+        h: part("hour"),
+        min: part("minute"),
+        tz,
+    };
+}
+export function timestampDate(timestamp) {
+    if (isZeroDateTime(timestamp) || !/(?:Z|[+-]\d{2}:\d{2})$/i.test(timestamp)) {
+        return null;
+    }
+    const instant = new globalThis.Date(timestamp);
+    return Number.isFinite(instant.getTime()) ? instant : null;
+}

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

@@ -3,6 +3,16 @@ export type QueueRecord = {
     owner_id: string;
     sequence?: number;
 };
+export type QueueRetry = {
+    attempts: number;
+    after: number;
+};
+export declare function nextQueueRetry(previous?: QueueRetry): QueueRetry;
+export declare class QueueWakeup {
+    private pending?;
+    schedule(after: number, signal: AbortSignal, run: () => void): void;
+    cancel(): void;
+}
 export interface QueueStore<T extends QueueRecord> {
     add(entry: T): Promise<T>;
     put(entry: T): Promise<void>;

package/dist/src/core/queue.js

@@ -3,6 +3,39 @@
 // 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
+const queueRetryInitialMilliseconds = 1_000;
+const queueRetryMaximumMilliseconds = 30_000;
+// Durable deadlines prevent refreshes and other tabs from bypassing backoff.
+export function nextQueueRetry(previous) {
+    const attempts = (previous?.attempts ?? 0) + 1;
+    const delay = Math.min(queueRetryMaximumMilliseconds, queueRetryInitialMilliseconds * 2 ** (attempts - 1));
+    return { attempts, after: Date.now() + delay };
+}
+// One wakeup for the earliest pending recovery. A paused account must never
+// be restarted by an old timer. The caller re-reads durable state on wakeup.
+export class QueueWakeup {
+    pending;
+    schedule(after, signal, run) {
+        if (signal.aborted || (this.pending && this.pending.after <= after))
+            return;
+        this.cancel();
+        const cancel = () => {
+            clearTimeout(timer);
+            signal.removeEventListener("abort", cancel);
+            this.pending = undefined;
+        };
+        const timer = setTimeout(() => {
+            cancel();
+            if (!signal.aborted)
+                run();
+        }, Math.max(0, after - Date.now()));
+        this.pending = { after, cancel };
+        signal.addEventListener("abort", cancel, { once: true });
+    }
+    cancel() {
+        this.pending?.cancel();
+    }
+}
 // Store order is authoritative across views/tabs. Each scope has one worker;
 // run must durably retire the head before returning true. False pauses the
 // lane without blocking other scopes. Storage/transport failures never skip it.

package/dist/src/core/search-controller.d.ts

@@ -0,0 +1,30 @@
+import { type SearchOptions, type SearchPage, type SearchResultWithID } from "./search.js";
+export type SearchState<T> = {
+    readonly results: readonly T[];
+    readonly ready: boolean;
+    readonly loading: boolean;
+    readonly loading_more: boolean;
+    readonly error: unknown;
+    readonly has_more: boolean;
+    readonly total_count?: number;
+};
+export type SearchControllerOptions<T, Options extends SearchOptions> = {
+    search: (opts: Options) => Promise<SearchPage<T>>;
+    on_change: (state: SearchState<T>) => void;
+};
+export declare class SearchController<T extends SearchResultWithID, Options extends SearchOptions> {
+    private readonly options;
+    private selection?;
+    private request?;
+    private next_page;
+    private current;
+    constructor(options: SearchControllerOptions<T, Options>);
+    get state(): SearchState<T>;
+    clear(): void;
+    replace(selection: Options): Promise<boolean>;
+    loadMore(): Promise<boolean>;
+    retry(): Promise<boolean>;
+    private load;
+    private emptyState;
+    private publish;
+}

package/dist/src/core/search-controller.js

@@ -0,0 +1,111 @@
+// Copyright (C) Fabriktor, Inc. 2025-present.
+//
+// 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 { appendUniqueSearchResults, normalizeSearchPage, } from "./search.js";
+import { errUnknown } from "./err.js";
+// Holds only the current selection and its displayed pages. Previous queries
+// are discarded, and revisiting a selection always makes a backend request.
+export class SearchController {
+    options;
+    selection;
+    request;
+    next_page = normalizeSearchPage();
+    current = this.emptyState();
+    constructor(options) {
+        this.options = options;
+    }
+    get state() {
+        return this.current;
+    }
+    // Invalidate immediately, including during text-search debounce or teardown.
+    clear() {
+        this.request?.abort();
+        this.request = undefined;
+        this.selection = undefined;
+        this.next_page = normalizeSearchPage();
+        this.publish(this.emptyState());
+    }
+    async replace(selection) {
+        this.clear();
+        this.selection = { ...selection };
+        return await this.load(false);
+    }
+    async loadMore() {
+        if (!this.current.has_more || this.current.error !== undefined) {
+            return false;
+        }
+        return await this.load(true);
+    }
+    async retry() {
+        return await this.load(this.next_page > normalizeSearchPage());
+    }
+    async load(append) {
+        if (!this.selection || this.current.loading || this.current.loading_more) {
+            return false;
+        }
+        const request = new AbortController();
+        this.request = request;
+        this.publish({
+            ...this.current,
+            loading: !append,
+            loading_more: append,
+            error: undefined,
+        });
+        try {
+            const page = await this.options.search({
+                ...this.selection,
+                page: this.next_page,
+                signal: request.signal,
+            });
+            if (this.request !== request || request.signal.aborted) {
+                return false;
+            }
+            this.next_page = page.next_page;
+            this.publish({
+                results: append
+                    ? appendUniqueSearchResults(this.current.results, page.results)
+                    : page.results,
+                ready: true,
+                loading: false,
+                loading_more: false,
+                error: undefined,
+                has_more: page.has_more,
+                total_count: page.total_count,
+            });
+            return true;
+        }
+        catch (error) {
+            if (this.request !== request || request.signal.aborted) {
+                return false;
+            }
+            this.publish({
+                ...this.current,
+                loading: false,
+                loading_more: false,
+                error: errUnknown(error),
+            });
+            return false;
+        }
+        finally {
+            if (this.request === request) {
+                this.request = undefined;
+            }
+        }
+    }
+    emptyState() {
+        return {
+            results: [],
+            ready: false,
+            loading: false,
+            loading_more: false,
+            error: undefined,
+            has_more: false,
+        };
+    }
+    publish(state) {
+        this.current = state;
+        this.options.on_change(state);
+    }
+}

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

@@ -4,7 +4,7 @@ export type SearchPaginationOptions = {
     page?: number;
     per_page?: number;
 };
-export type SearchOptions = SearchPaginationOptions & {
+export type SearchOptions = SearchPaginationOptions & Pick<SearchManyOptionsCRUD, "signal"> & {
     q?: string;
 };
 export type RequiredSearchOptions = SearchPaginationOptions & {
@@ -54,3 +54,7 @@ export declare function runSearch<T>(opts: RunSearchOptions<T>): Promise<SearchP
 export declare function normalizeSearchPage(value?: number): number;
 export declare function normalizeSearchPerPage(value?: number): number;
 export declare function normalizeSearchQuery(value?: string): string | undefined;
+export type SearchResultWithID = {
+    readonly id: string;
+};
+export declare function appendUniqueSearchResults<T extends SearchResultWithID>(current: readonly T[], next: readonly T[]): T[];

package/dist/src/core/search.js

@@ -48,6 +48,7 @@ export async function runOwnerScopeSearch(opts) {
         per_page,
         query: opts.query,
         search: opts.search,
+        signal: opts.signal,
     })));
     const results = new Map();
     for (const ownerPage of pages) {
@@ -94,6 +95,7 @@ export async function runOwnerScopeFilteredSearch(opts) {
                 per_page,
                 query: opts.query,
                 search: opts.search,
+                signal: opts.signal,
             }),
         })));
         for (const owner_page of pages) {
@@ -147,6 +149,7 @@ export async function runSearch(opts) {
         };
     const raw = await opts.search({
         query,
+        signal: opts.signal,
     });
     return resolveSearchPage({
         raw,
@@ -236,3 +239,17 @@ function maxDefined(values) {
     }
     return Math.max(...values.map((value) => value ?? 0));
 }
+export function appendUniqueSearchResults(current, next) {
+    const out = [...current];
+    const indexes = new Map(out.map((item, index) => [item.id, index]));
+    for (const item of next) {
+        const index = indexes.get(item.id);
+        if (index === undefined) {
+            indexes.set(item.id, out.length);
+            out.push(item);
+            continue;
+        }
+        out[index] = item;
+    }
+    return out;
+}

package/dist/src/index.d.ts

@@ -12,6 +12,7 @@ export * from "./core/pre-action.js";
 export * from "./core/pull.js";
 export * from "./core/queue-store.js";
 export * from "./core/queue.js";
+export * from "./core/search-controller.js";
 export * from "./core/search.js";
 export * from "./feed/feed.js";
 export * from "./fulfillments/fulfillments.js";

package/dist/src/index.js

@@ -12,6 +12,7 @@ export * from "./core/pre-action.js";
 export * from "./core/pull.js";
 export * from "./core/queue-store.js";
 export * from "./core/queue.js";
+export * from "./core/search-controller.js";
 export * from "./core/search.js";
 export * from "./feed/feed.js";
 export * from "./fulfillments/fulfillments.js";

package/dist/src/memos/memos.d.ts

@@ -1,5 +1,5 @@
-import type { MemosOperator } from "@fabriktor/client";
-import type { Memo, MemoFolder } from "@fabriktor/schema";
+import { type MemosOperator } from "@fabriktor/client";
+import { type Memo, type MemoFolder } from "@fabriktor/schema";
 import { type OwnerSearchOptions, type SearchPage } from "../core/search.js";
 type MemoInsertOptions = Parameters<MemosOperator["insertOneMemo"]>[0];
 type MemoReplaceOptions = Parameters<MemosOperator["replaceOneMemo"]>[0];
@@ -9,7 +9,7 @@ export type CreateMemoOptions = MemoInsertOptions;
 export type ReplaceMemoOptions = MemoReplaceOptions;
 export type CreateMemoFolderOptions = MemoFolderInsertOptions;
 export type ReplaceMemoFolderOptions = MemoFolderReplaceOptions;
-export type SearchMemosOptions = OwnerSearchOptions;
+export type SearchMemosOptions = OwnerSearchOptions & Partial<Pick<Memo, "is_archived" | "folder_id">>;
 export type SearchMemoFoldersOptions = OwnerSearchOptions;
 export type SearchMemosPage = SearchPage<Memo>;
 export type SearchMemoFoldersPage = SearchPage<MemoFolder>;

package/dist/src/memos/memos.js

@@ -3,13 +3,16 @@
 // 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 { errResolveFailed } from "../core/err.js";
-import { requiredOperationID } from "../core/id.js";
+import { queryParams } from "@fabriktor/client";
+import { OwnerIDKey } from "@fabriktor/schema";
+import { errRequired, errResolveFailed } from "../core/err.js";
+import { requiredOperationID, resolvedID } from "../core/id.js";
 import { runOwnerSearch, } from "../core/search.js";
 const resourceMemo = "memo";
 const resourceMemoFolder = "memo_folder";
 const msgCreatedMemoIDMissing = "Created memo response did not contain an ID.";
 const msgMemoMissing = "Memo could not be resolved after the mutation.";
+const msgMemoOwnerRequired = "Memo owner is required.";
 const msgCreatedMemoFolderIDMissing = "Created memo folder response did not contain an ID.";
 const msgMemoFolderMissing = "Memo folder could not be resolved after the mutation.";
 export class MemosFX {
@@ -36,8 +39,18 @@ export class MemosFX {
         return await this.findMemoFolder(opts.id);
     }
     async searchMemos(opts) {
+        const { is_archived, folder_id, ...searchOpts } = opts;
+        const owner_id = resolvedID(opts.owner_id);
+        if (owner_id === undefined) {
+            throw errRequired({ field: OwnerIDKey, msg: msgMemoOwnerRequired });
+        }
         return await runOwnerSearch({
-            ...opts,
+            ...searchOpts,
+            owner_id,
+            query: queryParams({
+                is_archived,
+                folder_id: resolvedID(folder_id),
+            }),
             search: (searchOpts) => this.memos.searchManyMemos(searchOpts),
         });
     }

package/package.json

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