kaafil-react-uikit 0.1.0-beta.1

package/dist/chunk-UYJ6LIWP.js

@@ -0,0 +1,2154 @@
+import { OfflineEngineContext, KaafilClientContext, useCapabilityRows, UNKNOWN_CAPABILITY_TRIPLE, deriveCapabilityTriple, darkReasonFor, useKaafilClient, useOfflineMutation, usePersona, isDevelopment, useOfflineEvent } from './chunk-6FPAGGFL.js';
+import { UnsatisfiableSchemeError, isKaafilError, SyncOpMethod } from 'kaafil-js/client';
+export { FALLBACK_GLYPH, SHADES_PER_FAMILY, TONE_FAMILIES, parseRoomingTone, roomingHeuristicSeverity } from 'kaafil-js/client';
+import { useContext, useState, useRef, useCallback, useEffect } from 'react';
+
+// src/core/errors/catalog.ts
+var ERROR_HANDLING_PATH = {
+  // re-auth
+  UNAUTHENTICATED: "re-auth",
+  // retryable (TRANSIENT, `06-offline-first.md §7`)
+  RATE_LIMITED: "retryable",
+  INTERNAL_ERROR: "retryable",
+  TENANT_SCOPE_MISSING: "retryable",
+  // parked (the closed never-retried set, `07-offline-and-sync.md §10`)
+  PLAN_FEATURE_DISABLED: "parked",
+  FILE_PURGED: "parked",
+  LOCKED: "parked",
+  // surface-to-user (everything else in the 24-code catalog)
+  VALIDATION_ERROR: "surface-to-user",
+  RESOURCE_NOT_FOUND: "surface-to-user",
+  CONFLICT_VERSION: "surface-to-user",
+  STOP_HAS_PENDING: "surface-to-user",
+  RESPONSE_CLOSED: "surface-to-user",
+  BUSINESS_RULE_VIOLATION: "surface-to-user",
+  OUT_OF_TRIP_WINDOW: "surface-to-user",
+  UPLOAD_MISMATCH: "surface-to-user",
+  FILE_ORPHANED: "surface-to-user",
+  CAPABILITY_UNAVAILABLE: "surface-to-user",
+  READ_ONLY_ROLE: "surface-to-user",
+  SUBJECT_REQUIRED: "surface-to-user",
+  IDEMPOTENCY_KEY_REUSED: "surface-to-user",
+  SECRET_NOT_REPLAYABLE: "surface-to-user",
+  NOT_IMPLEMENTED: "surface-to-user",
+  SHARE_TOKEN_EXPIRED: "surface-to-user",
+  SHARE_TOKEN_REVOKED: "surface-to-user"
+};
+function pathForStatusOnly(status) {
+  if (status === void 0 || status === null) {
+    return "retryable";
+  }
+  if (status === 401) {
+    return "re-auth";
+  }
+  if (status === 429 || status >= 500) {
+    return "retryable";
+  }
+  if (status === 402 || status === 410 || status === 423) {
+    return "parked";
+  }
+  return "surface-to-user";
+}
+function classifyError(error) {
+  if (error instanceof UnsatisfiableSchemeError) {
+    return {
+      path: "parked",
+      code: void 0,
+      status: void 0,
+      unsatisfiableScheme: true,
+      cause: error
+    };
+  }
+  if (isKaafilError(error)) {
+    const catalogPath = error.code !== void 0 ? ERROR_HANDLING_PATH[error.code] : void 0;
+    const path = catalogPath ?? pathForStatusOnly(error.status);
+    return {
+      path,
+      code: error.code,
+      status: error.status,
+      unsatisfiableScheme: false,
+      cause: error
+    };
+  }
+  return {
+    path: "surface-to-user",
+    code: void 0,
+    status: void 0,
+    unsatisfiableScheme: false,
+    cause: error
+  };
+}
+
+// src/core/internal/ensureTripPulled.ts
+var pulledTrips = /* @__PURE__ */ new WeakMap();
+function ensureTripPulled(engine, tripRef) {
+  let seen = pulledTrips.get(engine);
+  if (seen === void 0) {
+    seen = /* @__PURE__ */ new Set();
+    pulledTrips.set(engine, seen);
+  }
+  if (seen.has(tripRef)) {
+    return;
+  }
+  seen.add(tripRef);
+  void engine.pull.pullTrip({ tripRef }).catch(() => {
+    seen?.delete(tripRef);
+  });
+}
+
+// src/core/hooks/useSnapshotList.ts
+function useSnapshotList(tripRef, listName, options) {
+  const engine = useContext(OfflineEngineContext);
+  const client = useContext(KaafilClientContext);
+  const [rows, setRows] = useState(
+    () => engine === null ? [] : engine.snapshot.list(tripRef, listName)
+  );
+  const [liveRows, setLiveRows] = useState(void 0);
+  const [liveSyncedAt, setLiveSyncedAt] = useState(void 0);
+  const liveRef = useRef(options?.live);
+  liveRef.current = options?.live;
+  const hasLive = options?.live !== void 0;
+  const readLive = useCallback(async () => {
+    const live = liveRef.current;
+    if (engine !== null || live === void 0 || client === null) {
+      return;
+    }
+    try {
+      const result = await live(client, tripRef);
+      setLiveRows(result.rows);
+      setLiveSyncedAt(result.syncedAt);
+    } catch {
+    }
+  }, [engine, client, tripRef, hasLive]);
+  useEffect(() => {
+    void readLive();
+  }, [readLive]);
+  useEffect(() => {
+    if (engine === null) {
+      setRows([]);
+      return;
+    }
+    ensureTripPulled(engine, tripRef);
+    setRows(engine.snapshot.list(tripRef, listName));
+    const unsubscribe = engine.events.on("snapshot.updated", (event) => {
+      if (event.tripRef === tripRef && event.lists.includes(listName)) {
+        setRows(engine.snapshot.list(tripRef, listName));
+      }
+    });
+    return unsubscribe;
+  }, [engine, tripRef, listName]);
+  if (engine === null) {
+    return {
+      rows: liveRows ?? rows,
+      syncedAt: liveSyncedAt,
+      refreshLive: readLive
+    };
+  }
+  let syncedAt;
+  for (const row of rows) {
+    const stamp = engine.snapshot.syncedAt(tripRef, listName, row.id);
+    if (stamp !== void 0 && (syncedAt === void 0 || stamp > syncedAt)) {
+      syncedAt = stamp;
+    }
+  }
+  if (syncedAt === void 0 && rows.length === 0) {
+    syncedAt = engine.snapshot.cursor(tripRef, listName);
+  }
+  return { rows, syncedAt, refreshLive: readLive };
+}
+
+// src/core/internal/createDomainHook.ts
+function createDomainHook(moduleKey, build) {
+  return function useDomainHook(tripRef) {
+    const { rows, loaded } = useCapabilityRows(tripRef);
+    const ready = build(tripRef);
+    if (!loaded) {
+      return { status: "loading" };
+    }
+    const row = rows.find((candidate) => candidate.capability === moduleKey);
+    const triple = row === void 0 ? UNKNOWN_CAPABILITY_TRIPLE : deriveCapabilityTriple(row);
+    if (triple.status !== "lit") {
+      const reason = darkReasonFor(triple);
+      return { status: "dark", reason };
+    }
+    return { status: "ready", ...ready };
+  };
+}
+
+// src/core/hooks/useChecklists.ts
+var useChecklistsInternal = createDomainHook("checklists", (tripRef) => {
+  const client = useKaafilClient();
+  const engine = useContext(OfflineEngineContext);
+  const { rows: snapshotItems, syncedAt } = useSnapshotList(
+    tripRef,
+    "checklist"
+  );
+  const [aggregate, setAggregate] = useState({
+    title: void 0,
+    subtitle: void 0,
+    progress: void 0,
+    hasOpenMandatoryByPhase: void 0,
+    sections: [],
+    items: [],
+    availableTemplates: [],
+    loaded: false,
+    lastFetchFailed: false,
+    fetchedAt: void 0
+  });
+  const refreshAggregate = useCallback(async () => {
+    try {
+      const response = await client.checklists.read({ tripRef });
+      setAggregate({
+        title: response.title,
+        subtitle: response.subtitle,
+        progress: response.progress,
+        hasOpenMandatoryByPhase: response.hasOpenMandatoryByPhase,
+        sections: response.sections,
+        items: response.items,
+        availableTemplates: response.availableTemplates,
+        loaded: true,
+        lastFetchFailed: false,
+        fetchedAt: response.meta.serverTime
+      });
+    } catch {
+      setAggregate((previous) => ({ ...previous, lastFetchFailed: true }));
+    }
+  }, [client, tripRef]);
+  useEffect(() => {
+    void refreshAggregate();
+  }, [refreshAggregate]);
+  const refreshAggregateAfterDrain = useCallback(() => {
+    if (engine === null) {
+      return;
+    }
+    const unsubscribe = engine.events.on("sync.drained", () => {
+      unsubscribe();
+      void refreshAggregate();
+    });
+  }, [engine, refreshAggregate]);
+  const addItemMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine2, input) => engine2.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/checklist/items`,
+      operationId: "addChecklistItem",
+      body: input
+    }),
+    // ── THE DESK LANE ─────────────────────────────────────────────────
+    // All five checklist writes take the admin triple, and a desk console
+    // mounts no `OfflineShell` — without this the write has no transport
+    // at all and every attempt fails as an unclassified error.
+    // `idempotencyKey` is OPTIONAL on these SDK options, so no lane here
+    // mints one (hard rule #4); `linkExpenseReceipt`, whose key is
+    // required, is the one write in this package that CANNOT have a desk
+    // lane for exactly that reason.
+    direct: (liveClient, input) => liveClient.checklists.items.add({ tripRef, ...input })
+  });
+  const patchItemMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine2, input) => {
+      const { itemId, version, ...body } = input;
+      return engine2.enqueue({
+        tripRef,
+        method: SyncOpMethod.Patch,
+        path: `/api/v1/trips/${tripRef}/checklist/items/${itemId}`,
+        operationId: "patchChecklistItem",
+        body,
+        ifMatch: version
+      });
+    },
+    direct: (liveClient, input) => liveClient.checklists.items.patch({ tripRef, ...input })
+  });
+  const removeItemMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine2, input) => {
+      const { itemId, version } = input;
+      return engine2.enqueue({
+        tripRef,
+        method: SyncOpMethod.Delete,
+        path: `/api/v1/trips/${tripRef}/checklist/items/${itemId}`,
+        operationId: "deleteChecklistItem",
+        ifMatch: version
+      });
+    },
+    direct: (liveClient, input) => liveClient.checklists.items.remove({ tripRef, ...input })
+  });
+  const toggleItemMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine2, input) => {
+      const { itemId, ...body } = input;
+      return engine2.enqueue({
+        tripRef,
+        method: SyncOpMethod.Post,
+        path: `/api/v1/trips/${tripRef}/checklist/items/${itemId}/toggle`,
+        // `expectedStatus`, not `version`/`ifMatch` — this file's header,
+        // quirk 1.
+        operationId: "toggleChecklistItem",
+        body
+      });
+    },
+    direct: (liveClient, input) => liveClient.checklists.items.toggle({ tripRef, ...input })
+  });
+  const pullTemplateMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine2, input) => engine2.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/checklist/templates/pull`,
+      operationId: "pullChecklistTemplate",
+      body: input
+    }),
+    direct: (liveClient, input) => liveClient.checklists.templates.pull({ tripRef, ...input })
+  });
+  const addItemMutate = addItemMutation.mutate;
+  const addItem = useCallback(
+    async (input) => {
+      const op = await addItemMutate(input);
+      void refreshAggregate();
+      refreshAggregateAfterDrain();
+      return op;
+    },
+    [addItemMutate, refreshAggregate, refreshAggregateAfterDrain]
+  );
+  const patchItemMutate = patchItemMutation.mutate;
+  const patchItem = useCallback(
+    async (input) => {
+      const op = await patchItemMutate(input);
+      void refreshAggregate();
+      refreshAggregateAfterDrain();
+      return op;
+    },
+    [patchItemMutate, refreshAggregate, refreshAggregateAfterDrain]
+  );
+  const removeItemMutate = removeItemMutation.mutate;
+  const removeItem = useCallback(
+    async (input) => {
+      const op = await removeItemMutate(input);
+      void refreshAggregate();
+      refreshAggregateAfterDrain();
+      return op;
+    },
+    [removeItemMutate, refreshAggregate, refreshAggregateAfterDrain]
+  );
+  const toggleItemMutate = toggleItemMutation.mutate;
+  const toggleItem = useCallback(
+    async (input) => {
+      const op = await toggleItemMutate(input);
+      void refreshAggregate();
+      refreshAggregateAfterDrain();
+      return op;
+    },
+    [toggleItemMutate, refreshAggregate, refreshAggregateAfterDrain]
+  );
+  const pullTemplateMutate = pullTemplateMutation.mutate;
+  const pullTemplate = useCallback(
+    async (input) => {
+      const op = await pullTemplateMutate(input);
+      void refreshAggregate();
+      refreshAggregateAfterDrain();
+      return op;
+    },
+    [pullTemplateMutate, refreshAggregate, refreshAggregateAfterDrain]
+  );
+  const listTemplates = useCallback(
+    (input) => client.checklists.templates.list({ tripRef, ...input }),
+    [client, tripRef]
+  );
+  const listAgencyTemplates = useCallback(
+    (input) => client.checklists.agencyTemplates.list(input),
+    [client]
+  );
+  const createAgencyTemplate = useCallback(
+    (input) => client.checklists.agencyTemplates.create(input),
+    [client]
+  );
+  const patchAgencyTemplate = useCallback(
+    (input) => client.checklists.agencyTemplates.patch(input),
+    [client]
+  );
+  const removeAgencyTemplate = useCallback(
+    (input) => client.checklists.agencyTemplates.remove(input),
+    [client]
+  );
+  const publishAgencyTemplate = useCallback(
+    (input) => client.checklists.agencyTemplates.publish(input),
+    [client]
+  );
+  const items = syncedAt === void 0 ? aggregate.items : snapshotItems;
+  return {
+    items,
+    syncedAt,
+    aggregate: { ...aggregate, refresh: refreshAggregate },
+    addItem,
+    patchItem,
+    removeItem,
+    toggleItem,
+    listTemplates,
+    pullTemplate,
+    listAgencyTemplates,
+    createAgencyTemplate,
+    patchAgencyTemplate,
+    removeAgencyTemplate,
+    publishAgencyTemplate
+  };
+});
+function useChecklists(tripRef) {
+  return useChecklistsInternal(tripRef);
+}
+var useCloseoutInternal = createDomainHook("closing-day", (tripRef) => {
+  const client = useKaafilClient();
+  const [aggregate, setAggregate] = useState(void 0);
+  const [loaded, setLoaded] = useState(false);
+  const [lastFetchFailed, setLastFetchFailed] = useState(false);
+  const [syncedAt, setSyncedAt] = useState(void 0);
+  const refresh = useCallback(async () => {
+    try {
+      const response = await client.closeout.get({ tripRef });
+      setAggregate(response);
+      setLoaded(true);
+      setLastFetchFailed(false);
+      setSyncedAt(response.meta.serverTime);
+    } catch {
+      setLastFetchFailed(true);
+    }
+  }, [client, tripRef]);
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  const saveHandover = useCallback(
+    async (input) => {
+      const response = await client.closeout.saveHandover({ tripRef, ...input });
+      setAggregate(response);
+      setLoaded(true);
+      setLastFetchFailed(false);
+      setSyncedAt(response.meta.serverTime);
+      return response;
+    },
+    [client, tripRef]
+  );
+  const lock = useCallback(
+    async (input = {}) => {
+      const response = await client.closeout.lock({ tripRef, ...input });
+      setAggregate(response);
+      setLoaded(true);
+      setLastFetchFailed(false);
+      setSyncedAt(response.meta.serverTime);
+      return response;
+    },
+    [client, tripRef]
+  );
+  const unlock = useCallback(
+    async (input) => {
+      const response = await client.closeout.unlock({ tripRef, ...input });
+      setAggregate(response);
+      setLoaded(true);
+      setLastFetchFailed(false);
+      setSyncedAt(response.meta.serverTime);
+      return response;
+    },
+    [client, tripRef]
+  );
+  const exportPdf = useCallback(
+    (input = {}) => client.closeout.exportPdf({ tripRef, ...input }),
+    [client, tripRef]
+  );
+  return {
+    aggregate,
+    loaded,
+    lastFetchFailed,
+    syncedAt,
+    refresh,
+    saveHandover,
+    lock,
+    unlock,
+    exportPdf
+  };
+});
+function useCloseout(tripRef) {
+  return useCloseoutInternal(tripRef);
+}
+var useCollectionsInternal = createDomainHook("collections", (tripRef) => {
+  const client = useKaafilClient();
+  const {
+    rows: collections,
+    syncedAt,
+    refreshLive
+  } = useSnapshotList(tripRef, "collections", {
+    live: async (liveClient, ref) => {
+      const response = await liveClient.collections.list({ tripRef: ref });
+      return { rows: response, syncedAt: response.meta.serverTime };
+    }
+  });
+  const [eligibleStatus, setEligibleStatus] = useState("due");
+  const [eligibleRows, setEligibleRows] = useState([]);
+  const [eligibleLoaded, setEligibleLoaded] = useState(false);
+  const [eligibleFetchFailed, setEligibleFetchFailed] = useState(false);
+  const [eligibleFetchedAt, setEligibleFetchedAt] = useState(void 0);
+  const refreshEligible = useCallback(
+    async (status) => {
+      const nextStatus = status ?? eligibleStatus;
+      if (status !== void 0 && status !== eligibleStatus) {
+        setEligibleStatus(status);
+      }
+      try {
+        const response = await client.collections.eligible({ tripRef, status: nextStatus });
+        setEligibleRows(response);
+        setEligibleLoaded(true);
+        setEligibleFetchFailed(false);
+        setEligibleFetchedAt(response.meta.serverTime);
+      } catch {
+        setEligibleFetchFailed(true);
+      }
+    },
+    [client, tripRef, eligibleStatus]
+  );
+  useEffect(() => {
+    void refreshEligible(eligibleStatus);
+  }, [refreshEligible, eligibleStatus]);
+  const recordMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/collections`,
+      // `OperationId` is not exported from `kaafil-js/client`'s public
+      // surface (the same gap `useRooming()`'s own comment names) —
+      // hardcoded literal, verified against
+      // `kaafil-js/src/generated/security.ts` this session.
+      operationId: "recordCollection",
+      body: input
+    }),
+    // The desk lane. `recordCollection` takes the admin triple, and a desk
+    // console mounts no `OfflineShell` — without this the write has no
+    // transport at all and every attempt fails as an unclassified error.
+    direct: (liveClient, input) => liveClient.collections.record({ tripRef, ...input })
+  });
+  const recordMutate = recordMutation.mutate;
+  const record = useCallback(
+    async (input) => {
+      const op = await recordMutate(input);
+      void refreshEligible();
+      return op;
+    },
+    [recordMutate, refreshEligible]
+  );
+  const voidMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { collectionId, version, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Delete,
+        path: `/api/v1/trips/${tripRef}/collections/${collectionId}/void`,
+        operationId: "voidCollection",
+        body,
+        ifMatch: version
+      });
+    },
+    direct: (liveClient, input) => liveClient.collections.void({ tripRef, ...input })
+  });
+  const voidMutate = voidMutation.mutate;
+  const voidCollection = useCallback(
+    async (input) => {
+      const op = await voidMutate(input);
+      void refreshEligible();
+      return op;
+    },
+    [voidMutate, refreshEligible]
+  );
+  return {
+    collections,
+    syncedAt,
+    refreshLive,
+    eligible: {
+      rows: eligibleRows,
+      status: eligibleStatus,
+      loaded: eligibleLoaded,
+      lastFetchFailed: eligibleFetchFailed,
+      fetchedAt: eligibleFetchedAt,
+      refresh: refreshEligible
+    },
+    record,
+    void: voidCollection
+  };
+});
+function useCollections(tripRef) {
+  return useCollectionsInternal(tripRef);
+}
+var useExpensesInternal = createDomainHook("expenses", (tripRef) => {
+  const client = useKaafilClient();
+  const {
+    rows: expenses,
+    syncedAt,
+    refreshLive
+  } = useSnapshotList(tripRef, "expenses", {
+    live: async (liveClient, ref) => {
+      const response = await liveClient.expenses.list({ tripRef: ref });
+      return { rows: response.items, syncedAt: response.meta.serverTime };
+    }
+  });
+  const [spendTotalMinor, setSpendTotalMinor] = useState(void 0);
+  const [categoryTotals, setCategoryTotals] = useState(void 0);
+  const [totalsLoaded, setTotalsLoaded] = useState(false);
+  const [totalsFailed, setTotalsFailed] = useState(false);
+  const refreshTotals = useCallback(async () => {
+    try {
+      const response = await client.expenses.list({ tripRef });
+      setSpendTotalMinor(response.spendTotalMinor);
+      setCategoryTotals(response.categoryTotals);
+      setTotalsLoaded(true);
+      setTotalsFailed(false);
+    } catch {
+      setTotalsFailed(true);
+    }
+  }, [client, tripRef]);
+  useEffect(() => {
+    void refreshTotals();
+  }, [refreshTotals]);
+  const logMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/expenses`,
+      // Hardcoded literal, not imported: `OperationId` is not exported
+      // from `kaafil-js/client`'s public surface (verified — same gap
+      // `useRooming.ts` documents). Value verified against
+      // `kaafil-js/src/generated/security.ts` this session.
+      operationId: "logExpense",
+      body: input
+    }),
+    // The desk lane. `log`, `linkReceipt` and `void` each additionally
+    // accept an agency-admin session (the SDK's own header says so), and a
+    // desk console mounts no `OfflineShell` — without these the writes have
+    // no transport at all. `submitClaim`/`withdrawClaim` deliberately get
+    // NONE: those are `['manager', 'apiKey']`, a manager claiming their own
+    // reimbursement, and an admin has no business standing in for them.
+    direct: (liveClient, input) => liveClient.expenses.log({ tripRef, ...input })
+  });
+  const linkReceiptMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { expenseId, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Patch,
+        path: `/api/v1/trips/${tripRef}/expenses/${expenseId}/receipt`,
+        operationId: "linkExpenseReceipt",
+        body
+      });
+    }
+    // NO DESK LANE, AND IT CANNOT HAVE ONE. `LinkExpenseReceiptOptions`
+    // declares `idempotencyKey` as REQUIRED — the route "addresses no
+    // client-held version", so the key is its only replay guard — and hard
+    // rule #4 forbids any hook here from minting one or accepting one in its
+    // signature. The outbox path is unaffected: `OfflineEngine.enqueue()`
+    // mints the key itself, which is exactly the arrangement rule #4 exists
+    // to preserve. So this write is FIELD-ONLY in practice, and a desk
+    // surface must not offer it rather than offering a control that throws.
+    // Widening it would mean either breaking rule #4 or making the key
+    // optional on the wire, neither of which belongs in a UIKit pass.
+  });
+  const voidMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { expenseId, version, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Delete,
+        path: `/api/v1/trips/${tripRef}/expenses/${expenseId}/void`,
+        operationId: "voidExpense",
+        body,
+        ifMatch: version
+      });
+    },
+    direct: (liveClient, input) => liveClient.expenses.void({ tripRef, ...input })
+  });
+  const submitClaimMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { expenseId } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Post,
+        path: `/api/v1/trips/${tripRef}/expenses/${expenseId}/claim`,
+        operationId: "submitExpenseClaim",
+        body: {}
+      });
+    }
+  });
+  const withdrawClaimMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { expenseId, version } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Delete,
+        path: `/api/v1/trips/${tripRef}/expenses/${expenseId}/claim/withdraw`,
+        operationId: "withdrawExpenseClaim",
+        body: {},
+        ifMatch: version
+      });
+    }
+  });
+  const read = useCallback(
+    (expenseId) => client.expenses.read({ tripRef, expenseId }),
+    [client, tripRef]
+  );
+  return {
+    expenses,
+    syncedAt,
+    refreshLive,
+    totals: {
+      spendTotalMinor,
+      categoryTotals,
+      loaded: totalsLoaded,
+      lastFetchFailed: totalsFailed,
+      refresh: refreshTotals
+    },
+    read,
+    log: logMutation.mutate,
+    linkReceipt: linkReceiptMutation.mutate,
+    void: voidMutation.mutate,
+    submitClaim: submitClaimMutation.mutate,
+    withdrawClaim: withdrawClaimMutation.mutate
+  };
+});
+function useExpenses(tripRef) {
+  return useExpensesInternal(tripRef);
+}
+var DEFAULT_MAX_ATTEMPTS = 3;
+function useFiles(context) {
+  const client = useKaafilClient();
+  const { tripRef } = context;
+  const request = useCallback(
+    (input) => client.files.request({ ...input, tripRef }),
+    [client, tripRef]
+  );
+  const confirm = useCallback((input) => client.files.confirm(input), [client]);
+  const meta = useCallback((fileId) => client.files.meta({ fileId }), [client]);
+  const url = useCallback((fileId) => client.files.url({ fileId }), [client]);
+  const list = useCallback(
+    async (query) => (await client.files.list({ ...query, tripRef })).items,
+    [client, tripRef]
+  );
+  const managerView = useCallback(
+    (fileId) => client.files.managerView({ fileId }),
+    [client]
+  );
+  const upload = useCallback(
+    async ({
+      file,
+      purpose,
+      title,
+      travellerRef,
+      maxAttempts = DEFAULT_MAX_ATTEMPTS,
+      signal
+    }) => {
+      let lastError;
+      for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        const created = await client.files.request({
+          tripRef,
+          purpose,
+          contentType: file.type,
+          sizeBytes: file.size,
+          // Conditional spreads, not `title: title` — the engine rejects a
+          // present-but-undefined key on the wrong purpose the same way it
+          // rejects a real one, and "absent" is the only thing that means
+          // "no title"/"the whole trip".
+          ...title !== void 0 ? { title } : {},
+          ...travellerRef !== void 0 ? { travellerRef } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+        try {
+          const put = await fetch(created.uploadUrl, {
+            method: "PUT",
+            headers: { "Content-Type": file.type },
+            body: file,
+            ...signal !== void 0 ? { signal } : {}
+          });
+          if (!put.ok) {
+            lastError = new Error(`Upload PUT failed with status ${put.status}`);
+            continue;
+          }
+        } catch (putError) {
+          lastError = putError;
+          continue;
+        }
+        try {
+          return await client.files.confirm({
+            fileId: created.fileId,
+            ...signal !== void 0 ? { signal } : {}
+          });
+        } catch (confirmError) {
+          lastError = confirmError;
+        }
+      }
+      throw lastError instanceof Error ? lastError : new Error("File upload did not confirm after retrying.");
+    },
+    [client, tripRef]
+  );
+  return { request, confirm, meta, url, list, managerView, upload };
+}
+var useFloatInternal = createDomainHook("float", (tripRef) => {
+  const client = useKaafilClient();
+  const { rows: movements, syncedAt } = useSnapshotList(tripRef, "float");
+  const [summaryRows, setSummaryRows] = useState([]);
+  const [summaryLoaded, setSummaryLoaded] = useState(false);
+  const [summaryFetchFailed, setSummaryFetchFailed] = useState(false);
+  const [summaryFetchedAt, setSummaryFetchedAt] = useState(void 0);
+  const refreshSummary = useCallback(async () => {
+    try {
+      const response = await client.float.readSummary({ tripRef });
+      setSummaryRows(response.data);
+      setSummaryLoaded(true);
+      setSummaryFetchFailed(false);
+      setSummaryFetchedAt(response.meta.serverTime);
+    } catch {
+      setSummaryFetchFailed(true);
+    }
+  }, [client, tripRef]);
+  useEffect(() => {
+    void refreshSummary();
+  }, [refreshSummary]);
+  const issueMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/float/issue`,
+      // `OperationId` is not exported from `kaafil-js/client`'s public
+      // surface (verified, same gap `useRooming.ts` documents for its own
+      // literal operationId casts).
+      operationId: "issueFloat",
+      body: input
+    }),
+    // The desk lane. All three float writes take the admin triple — `return`
+    // included, contrary to what this file used to claim — and a desk
+    // console mounts no `OfflineShell`, so without these the writes have no
+    // transport at all.
+    direct: (liveClient, input) => liveClient.float.issue({ tripRef, ...input })
+  });
+  const returnMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/float/return`,
+      operationId: "returnFloat",
+      body: input
+    }),
+    direct: (liveClient, input) => liveClient.float.return({ tripRef, ...input })
+  });
+  const adjustMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/float/adjust`,
+      operationId: "adjustFloat",
+      body: input
+    }),
+    direct: (liveClient, input) => liveClient.float.adjust({ tripRef, ...input })
+  });
+  const issueMutate = issueMutation.mutate;
+  const issue = useCallback(
+    async (input) => {
+      const op = await issueMutate(input);
+      void refreshSummary();
+      return op;
+    },
+    [issueMutate, refreshSummary]
+  );
+  const returnMutate = returnMutation.mutate;
+  const returnFloat = useCallback(
+    async (input) => {
+      const op = await returnMutate(input);
+      void refreshSummary();
+      return op;
+    },
+    [returnMutate, refreshSummary]
+  );
+  const adjustMutate = adjustMutation.mutate;
+  const adjust = useCallback(
+    async (input) => {
+      const op = await adjustMutate(input);
+      void refreshSummary();
+      return op;
+    },
+    [adjustMutate, refreshSummary]
+  );
+  const readLedger = useCallback(
+    (managerId) => client.float.readLedger({ tripRef, managerId }),
+    [client, tripRef]
+  );
+  return {
+    movements,
+    syncedAt,
+    readLedger,
+    summary: {
+      rows: summaryRows,
+      loaded: summaryLoaded,
+      lastFetchFailed: summaryFetchFailed,
+      fetchedAt: summaryFetchedAt,
+      refresh: refreshSummary
+    },
+    issue,
+    return: returnFloat,
+    adjust
+  };
+});
+function useFloat(tripRef) {
+  return useFloatInternal(tripRef);
+}
+var FORM_FIELD_KIND_SINGLE_BOOLEAN = "CHECKBOX";
+var useFormsInternal = createDomainHook("forms", (tripRef) => {
+  const client = useKaafilClient();
+  const engine = useContext(OfflineEngineContext);
+  const [forms, setForms] = useState([]);
+  const [syncedAt, setSyncedAt] = useState(void 0);
+  const refreshForms = useCallback(async () => {
+    try {
+      const response = await client.forms.trip.list({ tripRef });
+      setForms(response.items);
+      setSyncedAt(response.meta.serverTime);
+    } catch {
+    }
+  }, [client, tripRef]);
+  useEffect(() => {
+    void refreshForms();
+  }, [refreshForms]);
+  const refreshFormsAfterDrain = useCallback(() => {
+    if (engine === null) {
+      return;
+    }
+    const unsubscribe = engine.events.on("sync.drained", () => {
+      unsubscribe();
+      void refreshForms();
+    });
+  }, [engine, refreshForms]);
+  const getDefinition = useCallback(
+    async (formId) => client.forms.get({ formId }),
+    [client]
+  );
+  const getResponse = useCallback(
+    async (formId, responseId) => client.forms.responses.get({ formId, responseId }),
+    [client]
+  );
+  const travellerResponses = useCallback(
+    async (travellerRef) => {
+      const response = await client.forms.trip.travellerResponses.list({ tripRef, travellerRef });
+      return response.items;
+    },
+    [client, tripRef]
+  );
+  const formResponses = useCallback(
+    async (formId) => {
+      const response = await client.forms.trip.responses.list({ tripRef, formId });
+      return response.items;
+    },
+    [client, tripRef]
+  );
+  const submitMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine2, input) => {
+      const { formId, ...body } = input;
+      return engine2.enqueue({
+        tripRef,
+        method: SyncOpMethod.Post,
+        path: `/api/v1/trips/${tripRef}/forms/${formId}/responses`,
+        // Hardcoded literal, not imported: `OperationId` is not exported
+        // from `kaafil-js/client`'s public surface (same reasoning
+        // `useRooming.ts` documents). Verified against
+        // `kaafil-js/src/generated/security.ts` this session:
+        // `OperationId.ManagerCreateFormResponse === 'managerCreateFormResponse'`.
+        operationId: "managerCreateFormResponse",
+        body
+      });
+    },
+    // THE DESK LANE. On-behalf capture is exactly what an office does when
+    // a traveller phones in an answer, and a desk console mounts no
+    // `OfflineShell` — without this the write has no transport at all.
+    // `idempotencyKey` is OPTIONAL on `ManagerCreateFormResponseOptions`,
+    // so nothing here mints one (hard rule #4).
+    direct: (liveClient, input) => {
+      const { formId, ...body } = input;
+      return liveClient.forms.trip.responses.create({ tripRef, formId, ...body });
+    }
+  });
+  const submitMutate = submitMutation.mutate;
+  const submitResponse = useCallback(
+    async (input) => {
+      const op = await submitMutate(input);
+      void refreshForms();
+      refreshFormsAfterDrain();
+      return op;
+    },
+    [submitMutate, refreshForms, refreshFormsAfterDrain]
+  );
+  const completion = useCallback(async () => {
+    const response = await client.forms.trip.completion({ tripRef });
+    return response.items;
+  }, [client, tripRef]);
+  const dispatch = useCallback(
+    async (input) => {
+      const { formId, ...body } = input;
+      await client.forms.trip.dispatch({ tripRef, formId, ...body });
+      void refreshForms();
+    },
+    [client, tripRef, refreshForms]
+  );
+  const exportResponses = useCallback(
+    (input) => client.forms.responses.export(input),
+    [client]
+  );
+  const consentReceipt = useCallback(
+    (input) => client.forms.responses.consentReceipt(input),
+    [client]
+  );
+  const listAgencyForms = useCallback(async () => {
+    const response = await client.forms.list({});
+    return response.items;
+  }, [client]);
+  const createForm = useCallback(
+    async (input) => client.forms.create(input),
+    [client]
+  );
+  const patchForm = useCallback(
+    async (input) => client.forms.patch(input),
+    [client]
+  );
+  const publishForm = useCallback(
+    async (formId) => client.forms.publish({ formId }),
+    [client]
+  );
+  const closeForm = useCallback(
+    async (formId) => client.forms.close({ formId }),
+    [client]
+  );
+  const reopenForm = useCallback(
+    async (formId) => client.forms.reopen({ formId }),
+    [client]
+  );
+  const archiveForm = useCallback(
+    async (formId) => client.forms.archive({ formId }),
+    [client]
+  );
+  const unarchiveForm = useCallback(
+    async (formId) => client.forms.unarchive({ formId }),
+    [client]
+  );
+  const cloneForm = useCallback(
+    async (input) => client.forms.clone(input),
+    [client]
+  );
+  const reorderForm = useCallback(
+    async (input) => {
+      await client.forms.reorder(input);
+    },
+    [client]
+  );
+  const createSection = useCallback(
+    async (input) => client.forms.sections.create(input),
+    [client]
+  );
+  const patchSection = useCallback(
+    async (input) => client.forms.sections.patch(input),
+    [client]
+  );
+  const deleteSection = useCallback(
+    async (input) => {
+      await client.forms.sections.delete(input);
+    },
+    [client]
+  );
+  const createField = useCallback(
+    async (input) => client.forms.fields.create(input),
+    [client]
+  );
+  const patchField = useCallback(
+    async (input) => client.forms.fields.patch(input),
+    [client]
+  );
+  const deleteField = useCallback(
+    async (input) => {
+      await client.forms.fields.delete(input);
+    },
+    [client]
+  );
+  const listBindings = useCallback(async () => {
+    const response = await client.forms.bindings.list();
+    return response.items;
+  }, [client]);
+  return {
+    forms,
+    syncedAt,
+    getDefinition,
+    getResponse,
+    travellerResponses,
+    formResponses,
+    submitResponse,
+    refresh: refreshForms,
+    completion,
+    dispatch,
+    exportResponses,
+    consentReceipt,
+    listAgencyForms,
+    createForm,
+    patchForm,
+    publishForm,
+    closeForm,
+    reopenForm,
+    archiveForm,
+    unarchiveForm,
+    cloneForm,
+    reorderForm,
+    createSection,
+    patchSection,
+    deleteSection,
+    createField,
+    patchField,
+    deleteField,
+    listBindings
+  };
+});
+function useForms(tripRef) {
+  return useFormsInternal(tripRef);
+}
+function isLiveItineraryItem(row) {
+  return !("_tombstone" in row);
+}
+function useItinerary(tripRef) {
+  const client = useKaafilClient();
+  const [trip, setTrip] = useState(void 0);
+  const [initialDayIso, setInitialDayIso] = useState(void 0);
+  const [canAddItems, setCanAddItems] = useState(false);
+  const [canAddItemsReason, setCanAddItemsReason] = useState(null);
+  const [days, setDays] = useState([]);
+  const [items, setItems] = useState([]);
+  const [loaded, setLoaded] = useState(false);
+  const [lastFetchFailed, setLastFetchFailed] = useState(false);
+  const [syncedAt, setSyncedAt] = useState(void 0);
+  const refresh = useCallback(async () => {
+    try {
+      const response = await client.itinerary.read({ tripRef });
+      setTrip(response.trip);
+      setInitialDayIso(response.initialDayIso);
+      setCanAddItems(response.canAddItems);
+      setCanAddItemsReason(response.canAddItemsReason);
+      setDays(response.days);
+      setItems(response.items.filter(isLiveItineraryItem));
+      setLoaded(true);
+      setLastFetchFailed(false);
+      setSyncedAt(response.meta.serverTime);
+    } catch {
+      setLastFetchFailed(true);
+    }
+  }, [client, tripRef]);
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  const [changeLog, setChangeLog] = useState([]);
+  const [changeLogLoaded, setChangeLogLoaded] = useState(false);
+  const [changeLogFetchFailed, setChangeLogFetchFailed] = useState(false);
+  const loadChangeLog = useCallback(
+    async (input) => {
+      try {
+        const response = await client.itinerary.changeLog.list({ tripRef, ...input });
+        setChangeLog(response);
+        setChangeLogLoaded(true);
+        setChangeLogFetchFailed(false);
+      } catch {
+        setChangeLogFetchFailed(true);
+      }
+    },
+    [client, tripRef]
+  );
+  const patchDayMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { dayIndex, version, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Patch,
+        path: `/api/v1/trips/${tripRef}/itinerary/days/${dayIndex}`,
+        operationId: "patchItineraryDay",
+        body,
+        ifMatch: version
+      });
+    },
+    direct: (client2, input) => client2.itinerary.days.patch({ tripRef, ...input })
+  });
+  const patchDayMutate = patchDayMutation.mutate;
+  const patchDay = useCallback(
+    async (input) => {
+      const op = await patchDayMutate(input);
+      void refresh();
+      return op;
+    },
+    [patchDayMutate, refresh]
+  );
+  const addItemMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/itinerary/items`,
+      operationId: "addItineraryItem",
+      body: input
+    }),
+    direct: (client2, input) => client2.itinerary.items.add({ tripRef, ...input })
+  });
+  const addItemMutate = addItemMutation.mutate;
+  const addItem = useCallback(
+    async (input) => {
+      const op = await addItemMutate(input);
+      void refresh();
+      return op;
+    },
+    [addItemMutate, refresh]
+  );
+  const patchItemMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { itemId, version, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Patch,
+        path: `/api/v1/trips/${tripRef}/itinerary/items/${itemId}`,
+        operationId: "patchItineraryItem",
+        body,
+        ifMatch: version
+      });
+    },
+    direct: (client2, input) => client2.itinerary.items.patch({ tripRef, ...input })
+  });
+  const patchItemMutate = patchItemMutation.mutate;
+  const patchItem = useCallback(
+    async (input) => {
+      const op = await patchItemMutate(input);
+      void refresh();
+      return op;
+    },
+    [patchItemMutate, refresh]
+  );
+  const removeItemMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { itemId, version } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Delete,
+        path: `/api/v1/trips/${tripRef}/itinerary/items/${itemId}`,
+        operationId: "deleteItineraryItem",
+        ifMatch: version
+      });
+    },
+    direct: (client2, input) => client2.itinerary.items.remove({ tripRef, ...input })
+  });
+  const removeItemMutate = removeItemMutation.mutate;
+  const removeItem = useCallback(
+    async (input) => {
+      const op = await removeItemMutate(input);
+      void refresh();
+      return op;
+    },
+    [removeItemMutate, refresh]
+  );
+  const reorderItemMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { itemId, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Post,
+        path: `/api/v1/trips/${tripRef}/itinerary/items/${itemId}/reorder`,
+        operationId: "reorderItineraryItem",
+        body
+      });
+    },
+    direct: (client2, input) => client2.itinerary.items.reorder({ tripRef, ...input })
+  });
+  const reorderItemMutate = reorderItemMutation.mutate;
+  const reorderItem = useCallback(
+    async (input) => {
+      const op = await reorderItemMutate(input);
+      void refresh();
+      return op;
+    },
+    [reorderItemMutate, refresh]
+  );
+  if (!loaded && !lastFetchFailed) {
+    return { status: "loading" };
+  }
+  if (!loaded && lastFetchFailed) {
+    return { status: "error" };
+  }
+  return {
+    status: "ready",
+    trip,
+    initialDayIso,
+    canAddItems,
+    canAddItemsReason,
+    days,
+    items,
+    loaded,
+    lastFetchFailed,
+    syncedAt,
+    refresh,
+    changeLog,
+    changeLogLoaded,
+    changeLogFetchFailed,
+    loadChangeLog,
+    patchDay,
+    addItem,
+    patchItem,
+    removeItem,
+    reorderItem
+  };
+}
+function useManagers(tripRef) {
+  const client = useKaafilClient();
+  const persona = usePersona();
+  const [result, setResult] = useState({ status: "loading" });
+  useEffect(() => {
+    if (persona === "share") {
+      if (isDevelopment()) {
+        throw new Error(
+          "useManagers() was called from a share session \u2014 it is manager/agencyAdmin only."
+        );
+      }
+      return;
+    }
+    let cancelled = false;
+    setResult({ status: "loading" });
+    void Promise.resolve().then(() => client.trips.managers.list({ tripRef })).then((managers) => {
+      if (!cancelled) {
+        setResult({ status: "ready", managers });
+      }
+    }).catch((error) => {
+      if (!cancelled) {
+        setResult({ status: "error", error: classifyError(error) });
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [client, persona, tripRef]);
+  return result;
+}
+function useManagerToday(tripRef) {
+  const client = useKaafilClient();
+  const [result, setResult] = useState({ status: "loading" });
+  useEffect(() => {
+    let cancelled = false;
+    setResult({ status: "loading" });
+    client.managerToday.read({ tripRef }).then((response) => {
+      if (cancelled) {
+        return;
+      }
+      const { meta, ...data } = response;
+      setResult({ status: "ready", ...data, syncedAt: meta.serverTime });
+    }).catch(() => {
+      if (!cancelled) {
+        setResult({ status: "error" });
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [client, tripRef]);
+  return result;
+}
+function isLiveParty(row) {
+  return !("_tombstone" in row);
+}
+function useParties(tripRef) {
+  const client = useKaafilClient();
+  const [rows, setRows] = useState([]);
+  const [listLoaded, setListLoaded] = useState(false);
+  const [listFetchFailed, setListFetchFailed] = useState(false);
+  const [listFetchedAt, setListFetchedAt] = useState(void 0);
+  const [firstLoadError, setFirstLoadError] = useState(void 0);
+  const refreshList = useCallback(async () => {
+    try {
+      const response = await client.trips.parties.list({ tripRef });
+      setRows(response.filter(isLiveParty));
+      setListLoaded(true);
+      setListFetchFailed(false);
+      setListFetchedAt(response.meta.serverTime);
+      setFirstLoadError(void 0);
+    } catch (error) {
+      setListFetchFailed(true);
+      setFirstLoadError((previous) => previous ?? classifyError(error));
+    }
+  }, [client, tripRef]);
+  useEffect(() => {
+    void refreshList();
+  }, [refreshList]);
+  const [rosterRows, setRosterRows] = useState([]);
+  const [rosterLoaded, setRosterLoaded] = useState(false);
+  const [rosterFetchFailed, setRosterFetchFailed] = useState(false);
+  const [rosterFetchedAt, setRosterFetchedAt] = useState(void 0);
+  const refreshRoster = useCallback(async () => {
+    try {
+      const response = await client.travellers.listForTrip({ tripRef });
+      setRosterRows(response);
+      setRosterLoaded(true);
+      setRosterFetchFailed(false);
+      setRosterFetchedAt(response.meta.serverTime);
+    } catch {
+      setRosterFetchFailed(true);
+    }
+  }, [client, tripRef]);
+  useEffect(() => {
+    void refreshRoster();
+  }, [refreshRoster]);
+  const addMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/parties`,
+      operationId: "createParty",
+      body: input
+    })
+  });
+  const patchMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { partyId, version, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Patch,
+        path: `/api/v1/trips/${tripRef}/parties/${partyId}`,
+        operationId: "patchParty",
+        body,
+        ifMatch: version
+      });
+    }
+  });
+  const removeMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { partyId } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Delete,
+        path: `/api/v1/trips/${tripRef}/parties/${partyId}`,
+        operationId: "deleteParty"
+      });
+    }
+  });
+  const addMutate = addMutation.mutate;
+  const add = useCallback(
+    async (input) => {
+      const op = await addMutate(input);
+      void refreshList();
+      return op;
+    },
+    [addMutate, refreshList]
+  );
+  const patchMutate = patchMutation.mutate;
+  const patch = useCallback(
+    async (input) => {
+      const op = await patchMutate(input);
+      void refreshList();
+      return op;
+    },
+    [patchMutate, refreshList]
+  );
+  const removeMutate = removeMutation.mutate;
+  const remove = useCallback(
+    async (input) => {
+      const op = await removeMutate(input);
+      void refreshList();
+      return op;
+    },
+    [removeMutate, refreshList]
+  );
+  if (!listLoaded && !listFetchFailed) {
+    return { status: "loading" };
+  }
+  if (!listLoaded && listFetchFailed) {
+    return {
+      status: "error",
+      error: firstLoadError ?? {
+        path: "surface-to-user",
+        code: void 0,
+        status: void 0,
+        unsatisfiableScheme: false,
+        cause: void 0
+      },
+      retry: refreshList
+    };
+  }
+  return {
+    status: "ready",
+    list: {
+      rows,
+      loaded: listLoaded,
+      lastFetchFailed: listFetchFailed,
+      fetchedAt: listFetchedAt,
+      refresh: refreshList
+    },
+    tripRoster: {
+      rows: rosterRows,
+      loaded: rosterLoaded,
+      lastFetchFailed: rosterFetchFailed,
+      fetchedAt: rosterFetchedAt,
+      refresh: refreshRoster
+    },
+    add,
+    patch,
+    remove
+  };
+}
+var usePickupsInternal = createDomainHook("pickup-points", (tripRef) => {
+  const client = useKaafilClient();
+  const {
+    rows: stops,
+    syncedAt,
+    refreshLive
+  } = useSnapshotList(tripRef, "pickups", {
+    live: async (liveClient, ref) => {
+      const response = await liveClient.pickups.list({ tripRef: ref });
+      return { rows: response, syncedAt: response.meta.serverTime };
+    }
+  });
+  const createMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/pickups`,
+      // `OperationId` is not exported from `kaafil-js/client`'s public
+      // surface (verified, same gap `useRooming.ts` documents) — every
+      // literal below is checked against `kaafil-js/src/generated/
+      // security.ts`'s own operation-id table.
+      operationId: "createPickupStop",
+      body: input
+    }),
+    // The desk lane. `board`, `close` and `reopen` below deliberately get
+    // NONE — they are `managerAuth`-only on the wire, so a direct call from
+    // an agency-admin session would be refused by `CredentialResolver`
+    // before it left the process. See this file's own persona note.
+    direct: (liveClient, input) => liveClient.pickups.create({ tripRef, ...input })
+  });
+  const patchMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { pointId, version, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Patch,
+        path: `/api/v1/trips/${tripRef}/pickups/${pointId}`,
+        operationId: "patchPickupStop",
+        body,
+        ifMatch: version
+      });
+    },
+    direct: (liveClient, input) => liveClient.pickups.patch({ tripRef, ...input })
+  });
+  const removeMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { pointId, version, force } = input;
+      const query = force === true ? "?force=true" : "";
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Delete,
+        path: `/api/v1/trips/${tripRef}/pickups/${pointId}${query}`,
+        operationId: "deletePickupStop",
+        ifMatch: version
+      });
+    },
+    direct: (liveClient, input) => liveClient.pickups.remove({ tripRef, ...input })
+  });
+  const reorderMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/pickups/reorder`,
+      operationId: "reorderPickupStops",
+      body: input
+    }),
+    direct: (liveClient, input) => liveClient.pickups.reorder({ tripRef, ...input })
+  });
+  const assignMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { pointId, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Post,
+        path: `/api/v1/trips/${tripRef}/pickups/${pointId}/assign`,
+        operationId: "assignPickupTraveller",
+        body
+      });
+    },
+    direct: (liveClient, input) => liveClient.pickups.assign({ tripRef, ...input })
+  });
+  const boardMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { pointId, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Post,
+        path: `/api/v1/trips/${tripRef}/pickups/${pointId}/board`,
+        operationId: "boardPickupTraveller",
+        body
+      });
+    }
+  });
+  const correctBoardStatusMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { pointId, travellerId, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Patch,
+        path: `/api/v1/trips/${tripRef}/pickups/${pointId}/board/${travellerId}`,
+        operationId: "correctPickupBoardStatus",
+        body
+      });
+    },
+    // The office's ONE door onto the board table, so it needs the desk lane
+    // as much as the five stop writes do — `board`/`close`/`reopen` below
+    // still get none, because they are `managerAuth`-only.
+    direct: (liveClient, input) => liveClient.pickups.correctBoardStatus({ tripRef, ...input })
+  });
+  const closeMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { pointId, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Post,
+        path: `/api/v1/trips/${tripRef}/pickups/${pointId}/close`,
+        operationId: "closePickupStop",
+        body
+      });
+    }
+  });
+  const reopenMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { pointId } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Post,
+        path: `/api/v1/trips/${tripRef}/pickups/${pointId}/reopen`,
+        operationId: "reopenPickupStop"
+      });
+    }
+  });
+  const reassign = useCallback(
+    (input) => client.pickups.reassign({ tripRef, ...input }),
+    [client, tripRef]
+  );
+  const manifestByPickup = useCallback(
+    (input) => client.pickups.manifestByPickup({ tripRef, ...input }),
+    [client, tripRef]
+  );
+  return {
+    stops,
+    syncedAt,
+    refreshLive,
+    create: createMutation.mutate,
+    patch: patchMutation.mutate,
+    remove: removeMutation.mutate,
+    reorder: reorderMutation.mutate,
+    assign: assignMutation.mutate,
+    reassign,
+    board: boardMutation.mutate,
+    correctBoardStatus: correctBoardStatusMutation.mutate,
+    close: closeMutation.mutate,
+    reopen: reopenMutation.mutate,
+    manifestByPickup
+  };
+});
+function usePickups(tripRef) {
+  return usePickupsInternal(tripRef);
+}
+var useRoomingInternal = createDomainHook("rooming", (tripRef) => {
+  const client = useKaafilClient();
+  const {
+    rows: rooms,
+    syncedAt: roomsSyncedAt,
+    refreshLive: refreshRoomsLive
+  } = useSnapshotList(tripRef, "rooming", {
+    live: async (liveClient, ref) => {
+      const response = await liveClient.rooming.read({ tripRef: ref });
+      return { rows: response.rooms, syncedAt: response.meta.serverTime };
+    }
+  });
+  const {
+    rows: stayWindows,
+    syncedAt: windowsSyncedAt,
+    refreshLive: refreshWindowsLive
+  } = useSnapshotList(tripRef, "stayWindows", {
+    live: async (liveClient, ref) => {
+      const response = await liveClient.rooming.stayWindows.list({ tripRef: ref });
+      return { rows: response, syncedAt: response.meta.serverTime };
+    }
+  });
+  const refreshLive = useCallback(async () => {
+    await Promise.all([refreshRoomsLive(), refreshWindowsLive()]);
+  }, [refreshRoomsLive, refreshWindowsLive]);
+  const assignMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/rooming/assign`,
+      // Hardcoded literal, not imported: `OperationId` is not exported from
+      // `kaafil-js/client`'s public surface (verified — see this worker's
+      // final report). Value verified against
+      // `kaafil-js/src/generated/security.ts` this session.
+      operationId: "assignRoomingBed",
+      body: input,
+      // `RoomingAssignDto.rooms` is every room this write touched, whole —
+      // up to two, on a swap. `arrayKey` is this hook's multi-row rebase
+      // (`OutboxEntityRef.arrayKey`), the reason the room grid now
+      // repaints the instant an assign lands rather than waiting for the
+      // next full pull.
+      entity: { listName: "rooming", arrayKey: "rooms" }
+    }),
+    // The desk lane. Every rooming write takes the admin triple, so unlike
+    // `usePickups` there is no member here that deliberately lacks one.
+    direct: (liveClient, input) => liveClient.rooming.assign({ tripRef, ...input })
+  });
+  const [poolTravellers, setPoolTravellers] = useState([]);
+  const [poolLoaded, setPoolLoaded] = useState(false);
+  const [poolFetchFailed, setPoolFetchFailed] = useState(false);
+  const [poolFetchedAt, setPoolFetchedAt] = useState(void 0);
+  const lastRequestedStayWindowIdRef = useRef(void 0);
+  const refreshUnassignedPool = useCallback(
+    async (stayWindowId) => {
+      lastRequestedStayWindowIdRef.current = stayWindowId;
+      try {
+        const response = await client.rooming.read({ tripRef, stayWindowId });
+        setPoolTravellers(response.unassigned);
+        setPoolLoaded(true);
+        setPoolFetchFailed(false);
+        setPoolFetchedAt(response.meta.serverTime);
+      } catch {
+        setPoolFetchFailed(true);
+      }
+    },
+    [client, tripRef]
+  );
+  useEffect(() => {
+    void refreshUnassignedPool();
+  }, [refreshUnassignedPool]);
+  const assignMutate = assignMutation.mutate;
+  const assign = useCallback(
+    async (input) => {
+      const op = await assignMutate(input);
+      void refreshUnassignedPool(lastRequestedStayWindowIdRef.current);
+      return op;
+    },
+    [assignMutate, refreshUnassignedPool]
+  );
+  const createWindowMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/rooming/stay-windows`,
+      operationId: "createRoomingStayWindow",
+      body: input
+    }),
+    direct: (liveClient, input) => liveClient.rooming.stayWindows.create({ tripRef, ...input })
+  });
+  const patchWindowMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { windowId, version, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Patch,
+        path: `/api/v1/trips/${tripRef}/rooming/stay-windows/${windowId}`,
+        operationId: "patchRoomingStayWindow",
+        body,
+        ifMatch: version
+      });
+    },
+    direct: (liveClient, input) => liveClient.rooming.stayWindows.patch({ tripRef, ...input })
+  });
+  const removeWindowMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { windowId, version, force } = input;
+      const query = force === true ? "?force=true" : "";
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Delete,
+        path: `/api/v1/trips/${tripRef}/rooming/stay-windows/${windowId}${query}`,
+        operationId: "deleteRoomingStayWindow",
+        ifMatch: version
+      });
+    },
+    direct: (liveClient, input) => liveClient.rooming.stayWindows.remove({ tripRef, ...input })
+  });
+  const createRoomMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/rooming/rooms`,
+      operationId: "createRoomingRoom",
+      body: input
+    }),
+    direct: (liveClient, input) => liveClient.rooming.rooms.create({ tripRef, ...input })
+  });
+  const patchRoomMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { roomId, version, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Patch,
+        path: `/api/v1/trips/${tripRef}/rooming/rooms/${roomId}`,
+        operationId: "patchRoomingRoom",
+        body,
+        ifMatch: version
+      });
+    },
+    direct: (liveClient, input) => liveClient.rooming.rooms.patch({ tripRef, ...input })
+  });
+  const removeRoomMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { roomId, version, force } = input;
+      const query = force === true ? "?force=true" : "";
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Delete,
+        path: `/api/v1/trips/${tripRef}/rooming/rooms/${roomId}${query}`,
+        operationId: "deleteRoomingRoom",
+        ifMatch: version
+      });
+    },
+    direct: (liveClient, input) => liveClient.rooming.rooms.remove({ tripRef, ...input })
+  });
+  const syncedAt = roomsSyncedAt === void 0 ? windowsSyncedAt : windowsSyncedAt === void 0 ? roomsSyncedAt : roomsSyncedAt > windowsSyncedAt ? roomsSyncedAt : windowsSyncedAt;
+  const autoAssign = useCallback(
+    (input) => client.rooming.autoAssign({ tripRef, ...input }),
+    [client, tripRef]
+  );
+  return {
+    rooms,
+    stayWindows,
+    syncedAt,
+    refreshLive,
+    unassignedPool: {
+      travellers: poolTravellers,
+      loaded: poolLoaded,
+      lastFetchFailed: poolFetchFailed,
+      fetchedAt: poolFetchedAt,
+      refresh: refreshUnassignedPool
+    },
+    assign,
+    autoAssign,
+    createStayWindow: createWindowMutation.mutate,
+    patchStayWindow: patchWindowMutation.mutate,
+    removeStayWindow: removeWindowMutation.mutate,
+    createRoom: createRoomMutation.mutate,
+    patchRoom: patchRoomMutation.mutate,
+    removeRoom: removeRoomMutation.mutate
+  };
+});
+function useRooming(tripRef) {
+  return useRoomingInternal(tripRef);
+}
+var useSeatingInternal = createDomainHook("transport-seating", (tripRef) => {
+  const client = useKaafilClient();
+  const {
+    rows: vehicles,
+    syncedAt,
+    refreshLive
+  } = useSnapshotList(tripRef, "seating", {
+    live: async (liveClient, ref) => {
+      const response = await liveClient.seating.read({ tripRef: ref });
+      return { rows: response.vehicles, syncedAt: response.meta.serverTime };
+    }
+  });
+  const assignMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/seating/assign`,
+      operationId: "assignSeating",
+      body: input,
+      // `SeatingAssignDto.vehicles` is "every vehicle touched by this
+      // write, whole — a client rebases without a follow-up read" (the
+      // engine DTO's own words) — up to two, on a displacement. `arrayKey`
+      // is this hook's one multi-row rebase (`OutboxEntityRef.arrayKey`),
+      // the reason the vehicle grid now repaints the instant an assign
+      // lands rather than waiting for the next full pull.
+      entity: { listName: "seating", arrayKey: "vehicles" }
+    }),
+    // The desk lane. Every `transport-seating` write takes the admin triple,
+    // so unlike `usePickups` there is no member here that deliberately
+    // lacks one.
+    direct: (liveClient, input) => liveClient.seating.assign({ tripRef, ...input })
+  });
+  const [poolTravellers, setPoolTravellers] = useState([]);
+  const [poolLoaded, setPoolLoaded] = useState(false);
+  const [poolFetchFailed, setPoolFetchFailed] = useState(false);
+  const [poolFetchedAt, setPoolFetchedAt] = useState(void 0);
+  const refreshUnassignedPool = useCallback(async () => {
+    try {
+      const response = await client.seating.read({ tripRef });
+      setPoolTravellers(response.unassignedPool);
+      setPoolLoaded(true);
+      setPoolFetchFailed(false);
+      setPoolFetchedAt(response.meta.serverTime);
+    } catch {
+      setPoolFetchFailed(true);
+    }
+  }, [client, tripRef]);
+  useEffect(() => {
+    void refreshUnassignedPool();
+  }, [refreshUnassignedPool]);
+  const assignMutate = assignMutation.mutate;
+  const assign = useCallback(
+    async (input) => {
+      const op = await assignMutate(input);
+      void refreshUnassignedPool();
+      return op;
+    },
+    [assignMutate, refreshUnassignedPool]
+  );
+  const createVehicleMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/seating/vehicles`,
+      operationId: "createSeatingVehicle",
+      body: input
+    }),
+    direct: (liveClient, input) => liveClient.seating.vehicles.create({ tripRef, ...input })
+  });
+  const patchVehicleMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { vehicleId, version, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Patch,
+        path: `/api/v1/trips/${tripRef}/seating/vehicles/${vehicleId}`,
+        operationId: "patchSeatingVehicle",
+        body,
+        ifMatch: version
+      });
+    },
+    direct: (liveClient, input) => liveClient.seating.vehicles.patch({ tripRef, ...input })
+  });
+  const removeVehicleMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { vehicleId, version } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Delete,
+        path: `/api/v1/trips/${tripRef}/seating/vehicles/${vehicleId}`,
+        operationId: "deleteSeatingVehicle",
+        ifMatch: version
+      });
+    },
+    direct: (liveClient, input) => liveClient.seating.vehicles.remove({ tripRef, ...input })
+  });
+  const removeVehicleMutate = removeVehicleMutation.mutate;
+  const removeVehicle = useCallback(
+    async (input) => {
+      const op = await removeVehicleMutate(input);
+      void refreshUnassignedPool();
+      return op;
+    },
+    [removeVehicleMutate, refreshUnassignedPool]
+  );
+  const patchVehicleMutate = patchVehicleMutation.mutate;
+  const patchVehicleDays = useCallback(
+    async (vehicleRef, days) => {
+      const current = vehicles.find(
+        (row) => row.id === vehicleRef && !("_tombstone" in row)
+      );
+      if (current === void 0) {
+        throw new Error(
+          `patchVehicleDays: vehicle "${vehicleRef}" is not in the current seating cache \u2014 read the board before patching its day coverage.`
+        );
+      }
+      return patchVehicleMutate({
+        vehicleId: vehicleRef,
+        version: current.version,
+        days: [...days]
+      });
+    },
+    [patchVehicleMutate, vehicles]
+  );
+  const linkManagerMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { vehicleId, ...body } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Post,
+        path: `/api/v1/trips/${tripRef}/seating/vehicles/${vehicleId}/manager`,
+        operationId: "linkSeatingManager",
+        body
+      });
+    },
+    direct: (liveClient, input) => liveClient.seating.vehicles.manager.link({ tripRef, ...input })
+  });
+  const unlinkManagerMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => {
+      const { vehicleId, version } = input;
+      return engine.enqueue({
+        tripRef,
+        method: SyncOpMethod.Delete,
+        path: `/api/v1/trips/${tripRef}/seating/vehicles/${vehicleId}/manager`,
+        operationId: "unlinkSeatingManager",
+        ifMatch: version
+      });
+    },
+    direct: (liveClient, input) => liveClient.seating.vehicles.manager.unlink({ tripRef, ...input })
+  });
+  const autoAssign = useCallback(
+    (input) => client.seating.autoAssign({ tripRef, ...input }),
+    [client, tripRef]
+  );
+  return {
+    vehicles,
+    syncedAt,
+    refreshLive,
+    unassignedPool: {
+      travellers: poolTravellers,
+      loaded: poolLoaded,
+      lastFetchFailed: poolFetchFailed,
+      fetchedAt: poolFetchedAt,
+      refresh: refreshUnassignedPool
+    },
+    assign,
+    autoAssign,
+    createVehicle: createVehicleMutation.mutate,
+    patchVehicle: patchVehicleMutation.mutate,
+    removeVehicle,
+    patchVehicleDays,
+    linkManager: linkManagerMutation.mutate,
+    unlinkManager: unlinkManagerMutation.mutate
+  };
+});
+function useSeating(tripRef) {
+  return useSeatingInternal(tripRef);
+}
+function useTravellerProfile(tripRef, travellerRef) {
+  const client = useKaafilClient();
+  const [read, setRead] = useState(void 0);
+  const [readFailed, setReadFailed] = useState(false);
+  const refresh = useCallback(async () => {
+    try {
+      const response = await client.travellers.getDetail({ tripRef, travellerRef });
+      setRead(response);
+      setReadFailed(false);
+    } catch {
+      setReadFailed(true);
+    }
+  }, [client, tripRef, travellerRef]);
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  useOfflineEvent("sync.drained", refresh);
+  const noteMutation = useOfflineMutation({
+    tripRef,
+    enqueue: (engine, input) => engine.enqueue({
+      tripRef,
+      method: SyncOpMethod.Post,
+      path: `/api/v1/trips/${tripRef}/travellers/${travellerRef}/notes`,
+      operationId: "addTravellerNote",
+      body: input
+    })
+  });
+  const noteMutate = noteMutation.mutate;
+  const addNote = useCallback(
+    async (input) => {
+      const op = await noteMutate(input);
+      void refresh();
+      return op;
+    },
+    [noteMutate, refresh]
+  );
+  return { read, readFailed, refresh, addNote };
+}
+function useVendors(tripRef, agencyRef) {
+  const client = useKaafilClient();
+  const { rows, loaded: capabilitiesLoaded } = useCapabilityRows(tripRef);
+  const [vendors, setVendors] = useState([]);
+  const [listLoaded, setListLoaded] = useState(false);
+  const [lastFetchFailed, setLastFetchFailed] = useState(false);
+  const [syncedAt, setSyncedAt] = useState(void 0);
+  const [firstLoadError, setFirstLoadError] = useState(void 0);
+  const refresh = useCallback(async () => {
+    try {
+      const response = await client.vendors.list({ tripRef });
+      setVendors(response);
+      setListLoaded(true);
+      setLastFetchFailed(false);
+      setSyncedAt(response.meta.serverTime);
+      setFirstLoadError(void 0);
+    } catch (error) {
+      setLastFetchFailed(true);
+      setFirstLoadError((previous) => previous ?? classifyError(error));
+    }
+  }, [client, tripRef]);
+  useEffect(() => {
+    void refresh();
+  }, [refresh]);
+  const create = useCallback((input) => client.vendors.create(input), [client]);
+  const upsert = useCallback((input) => client.vendors.upsert(input), [client]);
+  const remove = useCallback((input) => client.vendors.remove(input), [client]);
+  if (!capabilitiesLoaded) {
+    return { status: "loading" };
+  }
+  const row = rows.find((candidate) => candidate.capability === "vendors");
+  const triple = row === void 0 ? UNKNOWN_CAPABILITY_TRIPLE : deriveCapabilityTriple(row);
+  if (triple.status !== "lit") {
+    const reason = darkReasonFor(triple);
+    return { status: "dark", reason };
+  }
+  if (!listLoaded && lastFetchFailed) {
+    return {
+      status: "error",
+      error: firstLoadError ?? {
+        path: "surface-to-user",
+        code: void 0,
+        status: void 0,
+        unsatisfiableScheme: false,
+        cause: void 0
+      }
+    };
+  }
+  return {
+    status: "ready",
+    vendors,
+    loaded: listLoaded,
+    lastFetchFailed,
+    syncedAt,
+    refresh,
+    create,
+    upsert,
+    remove
+  };
+}
+
+export { ERROR_HANDLING_PATH, FORM_FIELD_KIND_SINGLE_BOOLEAN, classifyError, createDomainHook, useChecklists, useCloseout, useCollections, useExpenses, useFiles, useFloat, useForms, useItinerary, useManagerToday, useManagers, useParties, usePickups, useRooming, useSeating, useSnapshotList, useTravellerProfile, useVendors };
+//# sourceMappingURL=chunk-UYJ6LIWP.js.map
+//# sourceMappingURL=chunk-UYJ6LIWP.js.map