kaafil-js 0.1.0-beta.2 → 0.1.0-beta.3

package/dist/client-entry.cjs

@@ -16,20 +16,96 @@ var SECURITY_SCHEME_CARRIERS = {
   shareAuth: { kind: "bearer" }
 };
 var OperationId = {
+  AddChecklistItem: "addChecklistItem",
+  AddItineraryItem: "addItineraryItem",
+  AdjustFloat: "adjustFloat",
+  AssignPickupTraveller: "assignPickupTraveller",
+  AssignRoomingBed: "assignRoomingBed",
+  AssignSeating: "assignSeating",
+  AutoAssignRooming: "autoAssignRooming",
+  AutoAssignSeating: "autoAssignSeating",
+  BoardPickupTraveller: "boardPickupTraveller",
+  ClaimStatusIngest: "claimStatusIngest",
+  ClosePickupStop: "closePickupStop",
+  ConfirmFileUpload: "confirmFileUpload",
+  CreatePickupStop: "createPickupStop",
+  CreateRoomingRoom: "createRoomingRoom",
+  CreateRoomingStayWindow: "createRoomingStayWindow",
+  CreateSeatingVehicle: "createSeatingVehicle",
+  CreateTrekWalkIn: "createTrekWalkIn",
+  DeleteChecklistItem: "deleteChecklistItem",
+  DeleteItineraryItem: "deleteItineraryItem",
+  DeletePickupStop: "deletePickupStop",
+  DeleteRoomingRoom: "deleteRoomingRoom",
+  DeleteRoomingStayWindow: "deleteRoomingStayWindow",
+  DeleteSeatingVehicle: "deleteSeatingVehicle",
+  ExportCloseoutPack: "exportCloseoutPack",
   GetShareManifest: "getShareManifest",
   GetShareSnapshot: "getShareSnapshot",
+  IssueFloat: "issueFloat",
+  LinkExpenseReceipt: "linkExpenseReceipt",
+  LinkSeatingManager: "linkSeatingManager",
+  ListChecklistTemplates: "listChecklistTemplates",
+  ListCollections: "listCollections",
+  ListEligibleCollections: "listEligibleCollections",
+  ListExpenses: "listExpenses",
   ListJourneyTriggers: "listJourneyTriggers",
   ListManagerNotifications: "listManagerNotifications",
+  ListPickupStops: "listPickupStops",
+  ListRoomingStayWindows: "listRoomingStayWindows",
   ListTripVendors: "listTripVendors",
+  LockCloseout: "lockCloseout",
+  LogExpense: "logExpense",
+  PatchChecklistItem: "patchChecklistItem",
+  PatchItineraryDay: "patchItineraryDay",
+  PatchItineraryItem: "patchItineraryItem",
   PatchJourneyTrigger: "patchJourneyTrigger",
+  PatchPickupStop: "patchPickupStop",
+  PatchRoomingRoom: "patchRoomingRoom",
+  PatchRoomingStayWindow: "patchRoomingStayWindow",
+  PatchSeatingVehicle: "patchSeatingVehicle",
+  PostponeTrek: "postponeTrek",
+  PullChecklistTemplate: "pullChecklistTemplate",
+  ReadChecklistAggregate: "readChecklistAggregate",
+  ReadCloseout: "readCloseout",
+  ReadExpense: "readExpense",
+  ReadFile: "readFile",
+  ReadFileUrl: "readFileUrl",
+  ReadFloatLedger: "readFloatLedger",
+  ReadFloatSummary: "readFloatSummary",
+  ReadItinerary: "readItinerary",
+  ReadItineraryChangeLog: "readItineraryChangeLog",
   ReadJourney: "readJourney",
   ReadJourneyCapabilities: "readJourneyCapabilities",
+  ReadManifestByPickup: "readManifestByPickup",
+  ReadRoomingBoard: "readRoomingBoard",
+  ReadSeatingBoard: "readSeatingBoard",
+  ReadTrekBoard: "readTrekBoard",
+  ReadTrekWalkInMeta: "readTrekWalkInMeta",
   RebuildJourney: "rebuildJourney",
+  RecordCollection: "recordCollection",
+  ReopenPickupStop: "reopenPickupStop",
+  ReorderItineraryItem: "reorderItineraryItem",
+  ReorderPickupStops: "reorderPickupStops",
+  RequestFileUpload: "requestFileUpload",
+  ReturnFloat: "returnFloat",
   RunJourneyStep: "runJourneyStep",
+  SaveCloseoutHandover: "saveCloseoutHandover",
   ShareListForms: "shareListForms",
   ShareRenderForm: "shareRenderForm",
   ShareSaveForm: "shareSaveForm",
-  ShareSubmitForm: "shareSubmitForm"};
+  ShareSubmitForm: "shareSubmitForm",
+  SubmitExpenseClaim: "submitExpenseClaim",
+  SyncPullTrip: "syncPullTrip",
+  SyncPush: "syncPush",
+  SyncPushShare: "syncPushShare",
+  ToggleChecklistItem: "toggleChecklistItem",
+  UnlinkSeatingManager: "unlinkSeatingManager",
+  UnlockCloseout: "unlockCloseout",
+  VoidCollection: "voidCollection",
+  VoidExpense: "voidExpense",
+  WithdrawExpenseClaim: "withdrawExpenseClaim"
+};
 var OPERATION_SECURITY = {
   acceptConsoleInvite: [],
   acceptPlatformAdminInvite: [],
@@ -82,6 +158,7 @@ var OPERATION_SECURITY = {
   deleteSeatingVehicle: ["managerAuth"],
   dispatchForm: ["managerAuth", "apiKeyAuth"],
   editWebhookEndpoint: ["consoleAuth"],
+  exportCloseoutPack: ["managerAuth", "apiKeyAuth"],
   exportFormResponses: ["apiKeyAuth", "managerAuth"],
   getForm: ["apiKeyAuth", "agencyAdminAuth", "managerAuth"],
   getFormAggregate: ["apiKeyAuth"],
@@ -126,6 +203,7 @@ var OPERATION_SECURITY = {
   listTripVendors: ["apiKeyAuth", "managerAuth", "agencyAdminAuth"],
   listWebhookDeliveries: ["apiKeyAuth"],
   listWebhookEndpoints: ["consoleAuth"],
+  lockCloseout: ["managerAuth"],
   logExpense: ["managerAuth"],
   managerCreateFormResponse: ["managerAuth"],
   markNotificationRead: ["managerAuth"],
@@ -165,6 +243,7 @@ var OPERATION_SECURITY = {
   readAgencyFeedbackSummary: ["agencyAdminAuth", "apiKeyAuth"],
   readApiKey: ["consoleAuth"],
   readChecklistAggregate: ["managerAuth", "apiKeyAuth"],
+  readCloseout: ["managerAuth", "apiKeyAuth"],
   readCommsConfig: ["apiKeyAuth"],
   readConsoleAudit: ["consoleAuth"],
   readConsoleChecklist: ["consoleAuth"],
@@ -227,6 +306,7 @@ var OPERATION_SECURITY = {
   rotateApiKey: ["consoleAuth"],
   rotateWebhookEndpointSecret: ["consoleAuth"],
   runJourneyStep: ["apiKeyAuth"],
+  saveCloseoutHandover: ["managerAuth"],
   sendMessage: ["apiKeyAuth"],
   setPlatformPartnerStatus: ["platformAdminAuth"],
   shareListForms: ["shareAuth"],
@@ -234,10 +314,15 @@ var OPERATION_SECURITY = {
   shareSaveForm: ["shareAuth"],
   shareSubmitForm: ["shareAuth"],
   submitExpenseClaim: ["managerAuth"],
+  syncDigest: ["apiKeyAuth"],
+  syncPullTrip: ["managerAuth", "apiKeyAuth"],
+  syncPush: ["managerAuth", "apiKeyAuth"],
+  syncPushShare: [],
   toggleChecklistItem: ["managerAuth"],
   unarchiveForm: ["apiKeyAuth", "agencyAdminAuth"],
   unassignManager: ["apiKeyAuth"],
   unlinkSeatingManager: ["managerAuth"],
+  unlockCloseout: ["apiKeyAuth"],
   upsertAgencyAdmin: ["apiKeyAuth"],
   upsertManager: ["apiKeyAuth"],
   upsertTravellerProfile: ["apiKeyAuth"],
@@ -298,6 +383,7 @@ var OPERATION_ACCEPTS_IDEMPOTENCY_KEY = {
   deleteSeatingVehicle: false,
   dispatchForm: true,
   editWebhookEndpoint: true,
+  exportCloseoutPack: false,
   exportFormResponses: false,
   getForm: false,
   getFormAggregate: false,
@@ -342,6 +428,7 @@ var OPERATION_ACCEPTS_IDEMPOTENCY_KEY = {
   listTripVendors: false,
   listWebhookDeliveries: false,
   listWebhookEndpoints: false,
+  lockCloseout: true,
   logExpense: true,
   managerCreateFormResponse: true,
   markNotificationRead: true,
@@ -381,6 +468,7 @@ var OPERATION_ACCEPTS_IDEMPOTENCY_KEY = {
   readAgencyFeedbackSummary: false,
   readApiKey: false,
   readChecklistAggregate: false,
+  readCloseout: false,
   readCommsConfig: false,
   readConsoleAudit: false,
   readConsoleChecklist: false,
@@ -443,6 +531,7 @@ var OPERATION_ACCEPTS_IDEMPOTENCY_KEY = {
   rotateApiKey: true,
   rotateWebhookEndpointSecret: true,
   runJourneyStep: true,
+  saveCloseoutHandover: true,
   sendMessage: true,
   setPlatformPartnerStatus: false,
   shareListForms: false,
@@ -450,10 +539,15 @@ var OPERATION_ACCEPTS_IDEMPOTENCY_KEY = {
   shareSaveForm: true,
   shareSubmitForm: true,
   submitExpenseClaim: true,
+  syncDigest: false,
+  syncPullTrip: false,
+  syncPush: false,
+  syncPushShare: false,
   toggleChecklistItem: true,
   unarchiveForm: false,
   unassignManager: true,
   unlinkSeatingManager: false,
+  unlockCloseout: true,
   upsertAgencyAdmin: true,
   upsertManager: true,
   upsertTravellerProfile: true,
@@ -495,10 +589,12 @@ var KaafilErrorCode = {
   SecretNotReplayable: "SECRET_NOT_REPLAYABLE",
   ShareTokenExpired: "SHARE_TOKEN_EXPIRED",
   ShareTokenRevoked: "SHARE_TOKEN_REVOKED",
+  ShareWriteGraceExpired: "SHARE_WRITE_GRACE_EXPIRED",
   StayWindowHasAssignments: "STAY_WINDOW_HAS_ASSIGNMENTS",
   StayWindowOverlap: "STAY_WINDOW_OVERLAP",
   StopHasPending: "STOP_HAS_PENDING",
   SubjectRequired: "SUBJECT_REQUIRED",
+  SyncTargetRefused: "SYNC_TARGET_REFUSED",
   TenantScopeMissing: "TENANT_SCOPE_MISSING",
   Unauthenticated: "UNAUTHENTICATED",
   UploadMismatch: "UPLOAD_MISMATCH",
@@ -546,10 +642,12 @@ var ERROR_CODE_TABLE = {
   SECRET_NOT_REPLAYABLE: { status: 409, retryability: "no", outboxClass: "CONFLICT" },
   SHARE_TOKEN_EXPIRED: { status: 401, retryability: "no", outboxClass: "FATAL" },
   SHARE_TOKEN_REVOKED: { status: 401, retryability: "no", outboxClass: "FATAL" },
+  SHARE_WRITE_GRACE_EXPIRED: { status: 422, retryability: "no", outboxClass: "FATAL" },
   STAY_WINDOW_HAS_ASSIGNMENTS: { status: 422, retryability: "no", outboxClass: "FATAL" },
   STAY_WINDOW_OVERLAP: { status: 422, retryability: "no", outboxClass: "FATAL" },
   STOP_HAS_PENDING: { status: 422, retryability: "no", outboxClass: "FATAL" },
   SUBJECT_REQUIRED: { status: 422, retryability: "no", outboxClass: "FATAL" },
+  SYNC_TARGET_REFUSED: { status: 422, retryability: "no", outboxClass: "FATAL" },
   TENANT_SCOPE_MISSING: { status: 500, retryability: "yes", outboxClass: "TRANSIENT" },
   UNAUTHENTICATED: { status: 401, retryability: "after-refresh", outboxClass: "FATAL" },
   UPLOAD_MISMATCH: { status: 422, retryability: "no", outboxClass: "FATAL" },
@@ -1184,7 +1282,8 @@ function createHttpClient(config) {
     random: config.random
   };
   return {
-    execute: (request) => execute(ctx, request)
+    execute: (request) => execute(ctx, request),
+    executeBinary: (request) => executeBinary(ctx, request)
   };
 }
 function renderPath(template, params) {
@@ -1241,7 +1340,7 @@ async function buildHeaders(ctx, request, idempotencyKey, hasBody) {
   const acceptedSchemes = OPERATION_SECURITY[request.operationId];
   const credential = await ctx.credentials.resolveHeaders(request.operationId, acceptedSchemes);
   const headers = new Headers();
-  headers.set("Accept", "application/json");
+  headers.set("Accept", request.accept ?? "application/json");
   if (hasBody) {
     headers.set("Content-Type", "application/json");
   }
@@ -1317,7 +1416,17 @@ function describeCrossOriginSuspect(url) {
   }
   return `Request failed while calling a different origin (${url.origin}) than the page's own origin (${origin}). The most likely cause is that the API has not allowlisted this origin for CORS \u2014 but the browser withholds the actual reason from JavaScript when it blocks a cross-origin response, so the SDK cannot confirm this; a genuine network outage produces the same rejection. If this is unexpected, the fix is server-side: add this origin to the API's CORS allowlist.`;
 }
-async function sendOnce(ctx, request, idempotencyKey) {
+async function throwFromErrorResponse(response, status, requestId) {
+  const text = await response.text();
+  const body = text.length > 0 ? tryParseJson(text) : void 0;
+  const retryAfterSeconds = parseRetryAfterSeconds(response.headers.get("retry-after"));
+  throw fromEnvelope(body, {
+    status,
+    ...requestId !== void 0 ? { requestId } : {},
+    ...retryAfterSeconds !== void 0 ? { retryAfterSeconds } : {}
+  });
+}
+async function sendOnceWith(ctx, request, idempotencyKey, readSuccess) {
   const hasBody = request.body !== void 0;
   const renderedPath = renderPath(request.path, request.pathParams);
   const url = buildUrl(ctx.baseUrl, renderedPath, request.query);
@@ -1332,23 +1441,10 @@ async function sendOnce(ctx, request, idempotencyKey) {
     });
     const requestId = response.headers.get("x-request-id") ?? void 0;
     const status = response.status;
-    const text = await response.text();
-    const body = text.length > 0 ? tryParseJson(text) : void 0;
     if (response.ok) {
-      if (!isSuccessEnvelope(body)) {
-        throw new KaafilNetworkError(`Received an unrecognizable success body for HTTP ${status}`, {
-          status,
-          ...requestId !== void 0 ? { requestId } : {}
-        });
-      }
-      return { data: body.data, meta: buildResponseMeta(status, requestId, body.meta) };
+      return await readSuccess(response, status, requestId);
     }
-    const retryAfterSeconds = parseRetryAfterSeconds(response.headers.get("retry-after"));
-    throw fromEnvelope(body, {
-      status,
-      ...requestId !== void 0 ? { requestId } : {},
-      ...retryAfterSeconds !== void 0 ? { retryAfterSeconds } : {}
-    });
+    return await throwFromErrorResponse(response, status, requestId);
   } catch (error) {
     if (isKaafilError(error)) {
       throw error;
@@ -1366,6 +1462,30 @@ async function sendOnce(ctx, request, idempotencyKey) {
     combined.cleanup();
   }
 }
+function sendOnce(ctx, request, idempotencyKey) {
+  return sendOnceWith(ctx, request, idempotencyKey, async (response, status, requestId) => {
+    const text = await response.text();
+    const body = text.length > 0 ? tryParseJson(text) : void 0;
+    if (!isSuccessEnvelope(body)) {
+      throw new KaafilNetworkError(`Received an unrecognizable success body for HTTP ${status}`, {
+        status,
+        ...requestId !== void 0 ? { requestId } : {}
+      });
+    }
+    return { data: body.data, meta: buildResponseMeta(status, requestId, body.meta) };
+  });
+}
+function sendOnceBinary(ctx, request, idempotencyKey) {
+  return sendOnceWith(ctx, request, idempotencyKey, async (response, status, requestId) => {
+    const buffer = await response.arrayBuffer();
+    const meta = {
+      status,
+      requestId,
+      contentType: response.headers.get("content-type") ?? void 0
+    };
+    return { bytes: new Uint8Array(buffer), meta };
+  });
+}
 var MANAGER_TOKENS_REFRESH_PATH = "/api/v1/auth/manager-tokens/refresh";
 var AGENCY_ADMIN_TOKENS_REFRESH_PATH = "/api/v1/auth/agency-admin-tokens/refresh";
 function createRotatingSessionRefreshExchange(baseUrl, refreshPath, networkErrorMessage) {
@@ -1433,17 +1553,19 @@ function toFailureOutcome(error) {
     ...error instanceof KaafilRateLimitedError && error.retryAfterSeconds !== void 0 ? { retryAfterSeconds: error.retryAfterSeconds } : {}
   };
 }
-async function execute(ctx, request) {
+async function runWithLadder(ctx, request, send) {
   const idempotencyKey = OPERATION_ACCEPTS_IDEMPOTENCY_KEY[request.operationId] ? request.idempotencyKey ?? globalThis.crypto.randomUUID() : void 0;
   let lastError;
   let refreshAttempted = false;
   const sendAndClassify = async () => {
     try {
-      const { data, meta } = await sendOnce(ctx, request, idempotencyKey);
-      return { ok: true, value: attachMeta(data, meta) };
+      return { ok: true, value: await send(idempotencyKey) };
     } catch (error) {
       const typed = toKaafilError(error);
       lastError = typed;
+      if (typed.kind === "transport" && !isRetryable(typed)) {
+        throw typed;
+      }
       return toFailureOutcome(typed);
     }
   };
@@ -1483,167 +1605,2695 @@ async function execute(ctx, request) {
     throw error;
   }
 }
+function execute(ctx, request) {
+  return runWithLadder(ctx, request, async (idempotencyKey) => {
+    const { data, meta } = await sendOnce(ctx, request, idempotencyKey);
+    return attachMeta(data, meta);
+  });
+}
+function executeBinary(ctx, request) {
+  return runWithLadder(
+    ctx,
+    request,
+    (idempotencyKey) => sendOnceBinary(ctx, request, idempotencyKey)
+  );
+}
 
 // src/idempotency.ts
 function newIdempotencyKey() {
   return globalThis.crypto.randomUUID();
 }
 
-// src/resources/journey.ts
-var DEFAULT_WAIT_UNTIL_READY_TIMEOUT_MS = 6e4;
-var DEFAULT_WAIT_UNTIL_READY_POLL_INTERVAL_MS = 1e3;
-function createJourneyResource(client) {
-  const resource = {
-    async get(options) {
-      const { tripRef, signal } = options;
+// src/resources/sync.ts
+var KaafilShareBatchUnauthenticatedError = class _KaafilShareBatchUnauthenticatedError extends KaafilInvalidRequestError {
+  constructor() {
+    super(
+      `The vendored spec declares no security scheme for "syncPushShare", so a batched share push would be sent with no credential at all, carrying a traveller's queued writes. Refused locally. Drain share ops through their own endpoints (shareSaveForm / shareSubmitForm) until the engine declares shareAuth on POST /api/v1/sync/push/share.`
+    );
+    this.name = "KaafilShareBatchUnauthenticatedError";
+    Object.setPrototypeOf(this, _KaafilShareBatchUnauthenticatedError.prototype);
+  }
+};
+function isShareBatchPushAvailable() {
+  return OPERATION_SECURITY[OperationId.SyncPushShare].includes(
+    SecuritySchemeId.ShareAuth
+  );
+}
+function createSyncResource(client) {
+  return {
+    async push(options) {
+      const { ops, signal } = options;
+      const body = { ops: [...ops] };
       return client.execute({
-        method: "GET",
-        operationId: OperationId.ReadJourney,
-        path: "/api/v1/trips/{ref}/journey",
-        pathParams: { ref: tripRef },
+        method: "POST",
+        operationId: OperationId.SyncPush,
+        path: "/api/v1/sync/push",
+        body,
         ...signal !== void 0 ? { signal } : {}
       });
     },
-    async capabilities(options) {
-      const { tripRef, signal } = options;
+    async pullTrip(options) {
+      const { tripRef, since, signal } = options;
       return client.execute({
         method: "GET",
-        operationId: OperationId.ReadJourneyCapabilities,
-        path: "/api/v1/trips/{ref}/journey/capabilities",
+        operationId: OperationId.SyncPullTrip,
+        path: "/api/v1/trips/{ref}/sync",
         pathParams: { ref: tripRef },
+        // A `since` of `undefined` is omitted by `RequestDescriptor`'s own
+        // rule, which is exactly the cold-start shape: no `?since=` at all.
+        query: { since },
         ...signal !== void 0 ? { signal } : {}
       });
     },
-    async rebuild(options) {
-      const { tripRef, idempotencyKey, signal } = options;
+    async pushShare(options) {
+      if (!isShareBatchPushAvailable()) {
+        throw new KaafilShareBatchUnauthenticatedError();
+      }
+      const { ops, signal } = options;
+      const body = { ops: [...ops] };
       return client.execute({
         method: "POST",
-        operationId: OperationId.RebuildJourney,
-        path: "/api/v1/trips/{ref}/journey/rebuild",
-        pathParams: { ref: tripRef },
-        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        operationId: OperationId.SyncPushShare,
+        path: "/api/v1/sync/push/share",
+        body,
         ...signal !== void 0 ? { signal } : {}
       });
+    }
+  };
+}
+
+// src/http/classify.ts
+var OUTBOX_CLASS_TO_VERDICT = {
+  TRANSIENT: "transient",
+  CONFLICT: "conflict",
+  FATAL: "fatal"
+};
+function classifyFailure(input) {
+  if (input.status === null) {
+    return "transient";
+  }
+  const entry = input.code !== void 0 ? ERROR_CODE_TABLE[input.code] : void 0;
+  if (entry !== void 0) {
+    return OUTBOX_CLASS_TO_VERDICT[entry.outboxClass];
+  }
+  if (input.status === 429 || input.status >= 500 && input.status <= 599 && input.status !== 501) {
+    return "transient";
+  }
+  if (input.status === 409) {
+    return "conflict";
+  }
+  return "fatal";
+}
+
+// src/offline/blob.ts
+var BlobStatus = {
+  Pending: "pending",
+  Confirmed: "confirmed",
+  Parked: "parked"
+};
+function createBlobLane(options) {
+  const key = `${options.keyPrefix}:blobs`;
+  const now = options.now ?? Date.now;
+  const random = options.random ?? Math.random;
+  let blobs = /* @__PURE__ */ new Map();
+  const bodyBuilders = /* @__PURE__ */ new Map();
+  let backfills = /* @__PURE__ */ new Map();
+  async function persist() {
+    const shape = {
+      blobs: [...blobs.values()],
+      backfills: Object.fromEntries(backfills)
+    };
+    await options.storage.set(key, JSON.stringify(shape));
+  }
+  async function update(id, patch) {
+    const held = blobs.get(id);
+    if (held === void 0) {
+      return void 0;
+    }
+    const next = { ...held, ...patch };
+    blobs.set(id, next);
+    await persist();
+    return next;
+  }
+  async function park(id, reason) {
+    const record = await update(id, {
+      status: BlobStatus.Parked,
+      parkReason: reason,
+      nextRetryAt: null
+    });
+    if (record !== void 0) {
+      options.onParked?.(record);
+    }
+  }
+  async function retryLater(record) {
+    await update(record.id, {
+      attemptCount: record.attemptCount + 1,
+      nextRetryAt: now() + computeRetryDelayMs(record.attemptCount + 1, { random })
+    });
+  }
+  async function driveOne(record) {
+    const backfill = backfills.get(record.id);
+    const buildBody = bodyBuilders.get(record.id);
+    if (backfill === void 0 || buildBody === void 0) {
+      await park(
+        record.id,
+        "No back-fill builder is registered for this blob in the current process, so the file key could not be written onto the parent entity. Re-register it and re-enqueue."
+      );
+      return "parked";
+    }
+    const bytes = await options.source(record.id);
+    if (bytes === void 0) {
+      await park(
+        record.id,
+        "The bytes for this attachment were not retained across the restart, so it can never be uploaded. The entity it belongs to is unaffected."
+      );
+      return "parked";
+    }
+    let fileId = record.fileId;
+    if (fileId === void 0) {
+      try {
+        const created = await options.uploader.request({
+          contentType: record.contentType,
+          sizeBytes: record.sizeBytes,
+          tripRef: record.tripRef
+        });
+        fileId = created.fileId;
+        await update(record.id, { fileId });
+        const put = await options.uploader.put({
+          uploadUrl: created.uploadUrl,
+          bytes,
+          contentType: record.contentType
+        });
+        if (put.status < 200 || put.status >= 300) {
+          await retryLater({ ...record, fileId });
+          return "pending";
+        }
+      } catch {
+        await retryLater(record);
+        return "pending";
+      }
+    }
+    let confirmStatus;
+    let confirmCode;
+    try {
+      const confirmed = await options.uploader.confirm({ fileId });
+      confirmStatus = confirmed.status;
+      confirmCode = confirmed.code;
+    } catch {
+      await retryLater(record);
+      return "pending";
+    }
+    if (confirmStatus < 200 || confirmStatus >= 300) {
+      const verdict = classifyFailure({
+        status: confirmStatus,
+        ...confirmCode !== void 0 ? { code: confirmCode } : {}
+      });
+      if (verdict === "transient") {
+        await retryLater(record);
+        return "pending";
+      }
+      await park(
+        record.id,
+        `The upload could not be confirmed (${confirmCode ?? confirmStatus}). The entity it belongs to is unaffected.`
+      );
+      return "parked";
+    }
+    await options.outbox.enqueue({
+      tripRef: record.tripRef,
+      method: backfill.method,
+      path: backfill.path,
+      operationId: backfill.operationId,
+      body: buildBody(fileId),
+      ...backfill.entity !== void 0 ? { entity: backfill.entity } : {},
+      ...backfill.ifMatch !== void 0 ? { ifMatch: backfill.ifMatch } : {}
+    });
+    await update(record.id, { status: BlobStatus.Confirmed, nextRetryAt: null });
+    return "confirmed";
+  }
+  return {
+    async load() {
+      blobs = /* @__PURE__ */ new Map();
+      backfills = /* @__PURE__ */ new Map();
+      const raw = await options.storage.get(key);
+      if (raw === void 0) {
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      for (const record of parsed.blobs ?? []) {
+        blobs.set(record.id, record);
+      }
+      for (const [id, shape] of Object.entries(parsed.backfills ?? {})) {
+        backfills.set(id, shape);
+      }
     },
-    async runStep(options) {
-      const { tripRef, stepId, idempotencyKey, signal } = options;
-      return client.execute({
-        method: "POST",
-        operationId: OperationId.RunJourneyStep,
-        path: "/api/v1/trips/{ref}/journey/steps/{stepId}/run",
-        pathParams: { ref: tripRef, stepId },
-        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
-        ...signal !== void 0 ? { signal } : {}
+    async enqueue(args) {
+      const record = {
+        id: args.blobId,
+        tripRef: args.tripRef,
+        parentOpId: args.parentOpId,
+        contentType: args.contentType,
+        sizeBytes: args.sizeBytes,
+        status: BlobStatus.Pending,
+        attemptCount: 0,
+        nextRetryAt: null,
+        fileId: void 0,
+        parkReason: void 0
+      };
+      blobs.set(record.id, record);
+      backfills.set(record.id, {
+        method: args.backfill.method,
+        path: args.backfill.path,
+        operationId: args.backfill.operationId,
+        entity: args.backfill.entity,
+        ifMatch: args.backfill.ifMatch
       });
+      bodyBuilders.set(record.id, args.backfill.body);
+      await persist();
+      return record;
     },
-    async waitUntilReady(options) {
-      const {
-        tripRef,
-        timeoutMs = DEFAULT_WAIT_UNTIL_READY_TIMEOUT_MS,
-        pollIntervalMs = DEFAULT_WAIT_UNTIL_READY_POLL_INTERVAL_MS,
-        signal
-      } = options;
-      const deadlineAt = Date.now() + timeoutMs;
-      for (; ; ) {
-        try {
-          return await resource.get({ tripRef, ...signal !== void 0 ? { signal } : {} });
-        } catch (error) {
-          if (!(error instanceof KaafilNotFoundError)) {
-            throw error;
-          }
-          const remainingMs = deadlineAt - Date.now();
-          if (remainingMs <= 0) {
-            throw new KaafilTimeoutError(
-              `journey.waitUntilReady timed out after ${String(timeoutMs)}ms waiting for trip "${tripRef}" to become ready. The most likely cause is that the background worker that consumes the build queue is not running against this engine.`,
-              { cause: error }
-            );
-          }
-          try {
-            await delayWithAbort(Math.min(pollIntervalMs, remainingMs), signal);
-          } catch (sleepError) {
-            throw new KaafilAbortError("Request aborted", { cause: sleepError });
-          }
+    async drain() {
+      let confirmed = 0;
+      let parked = 0;
+      const at = now();
+      for (const record of [...blobs.values()]) {
+        if (record.status !== BlobStatus.Pending) {
+          continue;
+        }
+        if (record.nextRetryAt !== null && record.nextRetryAt > at) {
+          continue;
+        }
+        const outcome = await driveOne(record);
+        if (outcome === "confirmed") {
+          confirmed += 1;
+        } else if (outcome === "parked") {
+          parked += 1;
         }
       }
-    },
-    triggers: {
-      async list(options) {
-        const { agencyRef, signal } = options;
-        return client.execute({
-          method: "GET",
-          operationId: OperationId.ListJourneyTriggers,
-          path: "/api/v1/agencies/{ref}/journey-triggers",
-          pathParams: { ref: agencyRef },
-          ...signal !== void 0 ? { signal } : {}
-        });
-      },
-      async patch(options) {
-        const { agencyRef, key, version, idempotencyKey, signal, ...body } = options;
-        return client.execute({
-          method: "PATCH",
-          operationId: OperationId.PatchJourneyTrigger,
-          path: "/api/v1/agencies/{ref}/journey-triggers/{key}",
-          pathParams: { ref: agencyRef, key },
-          body,
-          headers: { "If-Match": String(version) },
-          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
-          ...signal !== void 0 ? { signal } : {}
-        });
+      let pending = 0;
+      for (const record of blobs.values()) {
+        if (record.status === BlobStatus.Pending) {
+          pending += 1;
+        }
       }
+      return { confirmed, parked, pending };
+    },
+    all() {
+      return [...blobs.values()];
     }
   };
-  return resource;
 }
 
-// src/resources/notifications.ts
-function createNotificationsResource(client) {
+// src/offline/outbox.ts
+var OutboxStatus = {
+  /** Waiting to be sent, or waiting out a backoff rung. */
+  Pending: "pending",
+  /** Handed to the transport; not yet answered. */
+  Inflight: "inflight",
+  /** Terminal failure. Out of the FIFO ordering; surfaced to the user. */
+  Parked: "parked",
+  /** Terminal success. Pruned on the next persist. */
+  Done: "done"
+};
+function createOutbox(options) {
+  const key = `${options.keyPrefix}:outbox`;
+  const mintId = options.newId ?? newIdempotencyKey;
+  let ops = /* @__PURE__ */ new Map();
+  let seq = 0;
+  function ordered() {
+    return [...ops.values()].sort((a, b) => a.seq - b.seq);
+  }
+  async function persist() {
+    for (const [id, op] of [...ops]) {
+      if (op.status === OutboxStatus.Done) {
+        ops.delete(id);
+      }
+    }
+    const shape = { seq, ops: ordered() };
+    await options.storage.set(key, JSON.stringify(shape));
+  }
+  async function mutate(opId, patch) {
+    const op = ops.get(opId);
+    if (op === void 0) {
+      return;
+    }
+    ops.set(opId, { ...op, ...patch });
+    await persist();
+  }
   return {
-    async list(options = {}) {
-      const { since, signal } = options;
-      return client.execute({
-        method: "GET",
-        operationId: OperationId.ListManagerNotifications,
-        path: "/api/v1/managers/me/notifications",
-        ...since !== void 0 ? { query: { since } } : {},
-        ...signal !== void 0 ? { signal } : {}
+    async load() {
+      ops = /* @__PURE__ */ new Map();
+      seq = 0;
+      const raw = await options.storage.get(key);
+      if (raw === void 0) {
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      seq = typeof parsed.seq === "number" ? parsed.seq : 0;
+      for (const op of parsed.ops ?? []) {
+        ops.set(op.id, {
+          ...op,
+          status: op.status === OutboxStatus.Inflight ? OutboxStatus.Pending : op.status
+        });
+      }
+    },
+    async enqueue(input) {
+      seq += 1;
+      const op = {
+        id: mintId(),
+        seq,
+        tripRef: input.tripRef,
+        method: input.method,
+        path: input.path,
+        operationId: input.operationId,
+        body: input.body,
+        ifMatch: input.ifMatch,
+        entity: input.entity,
+        idempotencyKey: input.idempotencyKey ?? newIdempotencyKey(),
+        enqueuedAt: input.enqueuedAt,
+        receiptPending: input.receiptPending === true,
+        blobId: input.blobId,
+        status: OutboxStatus.Pending,
+        attemptCount: 0,
+        nextRetryAt: null,
+        refreshAttempted: false,
+        parkReason: void 0
+      };
+      ops.set(op.id, op);
+      await persist();
+      return op;
+    },
+    get(opId) {
+      return ops.get(opId);
+    },
+    all() {
+      return ordered();
+    },
+    lanes() {
+      const seen = /* @__PURE__ */ new Set();
+      for (const op of ops.values()) {
+        if (op.status === OutboxStatus.Pending) {
+          seen.add(op.tripRef);
+        }
+      }
+      return [...seen];
+    },
+    head(tripRef) {
+      return ordered().find((op) => op.tripRef === tripRef && op.status === OutboxStatus.Pending);
+    },
+    readyPrefix(tripRef, at, limit) {
+      const out = [];
+      for (const op of ordered()) {
+        if (op.tripRef !== tripRef || op.status !== OutboxStatus.Pending) {
+          continue;
+        }
+        if (op.nextRetryAt !== null && op.nextRetryAt > at) {
+          break;
+        }
+        out.push(op);
+        if (out.length >= limit) {
+          break;
+        }
+      }
+      return out;
+    },
+    async markInflight(opId) {
+      await mutate(opId, { status: OutboxStatus.Inflight });
+    },
+    async markDone(opId) {
+      await mutate(opId, { status: OutboxStatus.Done });
+    },
+    async park(opId, reason) {
+      const op = ops.get(opId);
+      await mutate(opId, {
+        status: OutboxStatus.Parked,
+        parkReason: reason,
+        attemptCount: (op?.attemptCount ?? 0) + 1,
+        nextRetryAt: null
+      });
+    },
+    async scheduleRetry(opId, nextRetryAt) {
+      const op = ops.get(opId);
+      await mutate(opId, {
+        status: OutboxStatus.Pending,
+        attemptCount: (op?.attemptCount ?? 0) + 1,
+        nextRetryAt
+      });
+    },
+    async requeue(opId) {
+      await mutate(opId, { status: OutboxStatus.Pending });
+    },
+    async markRefreshAttempted(opId) {
+      await mutate(opId, { refreshAttempted: true });
+    },
+    async reissue(opId, patch) {
+      const op = ops.get(opId);
+      if (op === void 0) {
+        return;
+      }
+      ops.set(opId, {
+        ...op,
+        status: OutboxStatus.Pending,
+        nextRetryAt: null,
+        attemptCount: op.attemptCount + 1,
+        ...patch.body !== void 0 ? { body: patch.body } : {},
+        ...patch.ifMatch !== void 0 ? { ifMatch: patch.ifMatch } : {}
       });
+      await persist();
+    },
+    async drop(opId) {
+      if (!ops.delete(opId)) {
+        return;
+      }
+      await persist();
+    },
+    counts() {
+      let pending = 0;
+      let inflight = 0;
+      let parked = 0;
+      for (const op of ops.values()) {
+        if (op.status === OutboxStatus.Pending) {
+          pending += 1;
+        } else if (op.status === OutboxStatus.Inflight) {
+          inflight += 1;
+        } else if (op.status === OutboxStatus.Parked) {
+          parked += 1;
+        }
+      }
+      return { pending, inflight, parked };
     }
   };
 }
 
-// src/resources/share.ts
-function createShareResource(client) {
-  return {
-    async snapshot(options) {
-      const { token, signal } = options;
-      return client.execute({
-        method: "GET",
-        operationId: OperationId.GetShareSnapshot,
-        path: "/api/v1/share/{token}",
-        pathParams: { token },
-        ...signal !== void 0 ? { signal } : {}
+// src/offline/reconcile.ts
+function readCurrentVersion(details) {
+  const value = details?.currentVersion;
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+async function reconcileConflict(args) {
+  const { op, transport, snapshot, resolver } = args;
+  const currentVersion = readCurrentVersion(args.details);
+  let current;
+  if (op.entity !== void 0 && transport.readEntity !== void 0) {
+    let read;
+    try {
+      read = await transport.readEntity({
+        tripRef: op.tripRef,
+        listName: op.entity.listName,
+        id: op.entity.id
       });
-    },
-    async manifest(options) {
-      const { token, signal } = options;
-      return client.execute({
-        method: "GET",
-        operationId: OperationId.GetShareManifest,
-        path: "/api/v1/share/{token}/manifest",
-        pathParams: { token },
-        ...signal !== void 0 ? { signal } : {}
+    } catch {
+      return { action: "deferred", body: void 0, currentVersion, current: void 0 };
+    }
+    if (read.status === 200 && read.entity !== void 0) {
+      current = read.entity;
+      await snapshot.upsert({
+        tripRef: op.tripRef,
+        listName: op.entity.listName,
+        row: read.entity
       });
-    },
-    forms: {
-      async list(options) {
-        const { token, signal } = options;
-        return client.execute({
-          method: "GET",
-          operationId: OperationId.ShareListForms,
-          path: "/api/v1/share/{token}/forms",
-          pathParams: { token },
-          ...signal !== void 0 ? { signal } : {}
-        });
+    }
+  }
+  const context = { op, currentVersion, current };
+  const resolution = resolver === void 0 ? { action: "surface" } : await resolver(context);
+  return {
+    action: resolution.action,
+    body: resolution.action === "reissue" ? resolution.body : void 0,
+    currentVersion,
+    current
+  };
+}
+
+// src/offline/transport.ts
+var BATCH_THRESHOLD_OPS = 5;
+var MAX_BATCH_OPS = 200;
+var CONSOLIDATED_PULL_THRESHOLD_LISTS = 3;
+function shouldUseBatchTransport(args) {
+  return args.transport.sendBatch !== void 0 && args.readyCount >= BATCH_THRESHOLD_OPS;
+}
+
+// src/offline/drainer.ts
+function userMessageFor(outcome) {
+  if (outcome.code === "LOCKED" || outcome.status === 423) {
+    return "This trip has been closed out, so this change was not saved.";
+  }
+  if (outcome.code === "FILE_PURGED" || outcome.status === 410) {
+    return "That file is no longer available \u2014 its retention period has ended.";
+  }
+  if (outcome.code === "PLAN_FEATURE_DISABLED" || outcome.status === 402) {
+    return "That feature is not included in this plan, so this change was not saved.";
+  }
+  if (outcome.code === "SHARE_WRITE_GRACE_EXPIRED") {
+    return "This link expired \u2014 your submission was not delivered.";
+  }
+  if (outcome.status === 404) {
+    return "That item is no longer available to you.";
+  }
+  if (outcome.status === 401) {
+    return "Your session expired, so this change was not saved. Sign in again.";
+  }
+  return "This change could not be saved.";
+}
+function createDrainer(options) {
+  const { outbox, snapshot, transport, events } = options;
+  const now = options.now ?? Date.now;
+  const random = options.random ?? Math.random;
+  let inFlight = null;
+  function observeServerTime(outcome) {
+    if (outcome.serverTime !== void 0) {
+      options.onServerTime?.(outcome.serverTime);
+    }
+  }
+  async function applySuccess(op, outcome, state) {
+    if (op.entity !== void 0 && outcome.entity !== void 0) {
+      await snapshot.upsert({
+        tripRef: op.tripRef,
+        listName: op.entity.listName,
+        row: outcome.entity,
+        ...outcome.serverTime !== void 0 ? { syncedAt: outcome.serverTime } : {}
+      });
+    }
+    await outbox.markDone(op.id);
+    state.applied += 1;
+  }
+  async function park(op, outcome, state) {
+    const message = userMessageFor(outcome);
+    await outbox.park(op.id, {
+      status: outcome.status,
+      code: outcome.code,
+      userMessage: message
+    });
+    state.parked += 1;
+    events.emit("sync.error", {
+      opId: op.id,
+      tripRef: op.tripRef,
+      error: outcome.error,
+      status: outcome.status,
+      parked: true,
+      userMessage: message
+    });
+  }
+  async function purgeIfCached(op, outcome) {
+    if (op.entity === void 0) {
+      return;
+    }
+    const held = snapshot.list(op.tripRef, op.entity.listName).some((row) => row.id === op.entity?.id);
+    if (!held) {
+      return;
+    }
+    if (outcome.status === 404 || outcome.status === 410) {
+      await snapshot.purgeEntity(op.tripRef, op.entity.listName, op.entity.id);
+    }
+  }
+  async function applyOutcome(op, outcome, state) {
+    observeServerTime(outcome);
+    if (outcome.status !== null && outcome.status >= 200 && outcome.status < 300) {
+      await applySuccess(op, outcome, state);
+      return "terminal";
+    }
+    if (outcome.status === 401 && !op.refreshAttempted) {
+      await outbox.markRefreshAttempted(op.id);
+      let refreshed = false;
+      try {
+        refreshed = await transport.refreshSession?.() === true;
+      } catch {
+        refreshed = false;
+      }
+      if (refreshed) {
+        await outbox.requeue(op.id);
+        return "pending";
+      }
+      events.emit("session.expired", { reason: "refresh-failed" });
+      await park(op, outcome, state);
+      return "terminal";
+    }
+    const verdict = classifyFailure({
+      status: outcome.status,
+      ...outcome.code !== void 0 ? { code: outcome.code } : {},
+      ...outcome.transportFailureKind !== void 0 ? { transportFailureKind: outcome.transportFailureKind } : {}
+    });
+    if (verdict === "transient") {
+      const delay = computeRetryDelayMs(op.attemptCount + 1, {
+        ...outcome.retryAfterSeconds !== void 0 ? { retryAfterSeconds: outcome.retryAfterSeconds } : {},
+        random
+      });
+      await outbox.scheduleRetry(op.id, now() + delay);
+      events.emit("sync.error", {
+        opId: op.id,
+        tripRef: op.tripRef,
+        error: outcome.error,
+        status: outcome.status,
+        parked: false
+      });
+      return "pending";
+    }
+    if (verdict === "conflict") {
+      state.conflicted += 1;
+      const result = await reconcileConflict({
+        op,
+        details: outcome.details,
+        transport,
+        snapshot,
+        resolver: options.conflictResolver
+      });
+      switch (result.action) {
+        case "drop":
+          await outbox.drop(op.id);
+          return "terminal";
+        case "reissue":
+          await outbox.reissue(op.id, {
+            ...result.body !== void 0 ? { body: result.body } : {},
+            ...result.currentVersion !== void 0 ? { ifMatch: result.currentVersion } : {}
+          });
+          return "pending";
+        case "deferred":
+          await outbox.requeue(op.id);
+          return "pending";
+        case "surface":
+          await park(op, outcome, state);
+          return "terminal";
+      }
+    }
+    await purgeIfCached(op, outcome);
+    await park(op, outcome, state);
+    return "terminal";
+  }
+  async function drainLane(tripRef, state, signal) {
+    for (; ; ) {
+      if (signal?.aborted === true) {
+        return;
+      }
+      const head = outbox.head(tripRef);
+      if (head === void 0) {
+        return;
+      }
+      if (head.nextRetryAt !== null && head.nextRetryAt > now()) {
+        return;
+      }
+      const ready = outbox.readyPrefix(tripRef, now(), MAX_BATCH_OPS);
+      if (ready.length === 0) {
+        return;
+      }
+      if (shouldUseBatchTransport({ transport, readyCount: ready.length })) {
+        state.usedBatch = true;
+        const sent = await sendBatchedPrefix(ready, state, signal);
+        if (!sent) {
+          return;
+        }
+        continue;
+      }
+      await outbox.markInflight(head.id);
+      let outcome;
+      try {
+        outcome = await transport.sendOne(head, signal);
+      } catch (error) {
+        outcome = {
+          status: null,
+          transportFailureKind: "network",
+          ...isKaafilLike(error) ? { error } : {}
+        };
+      }
+      const disposition = await applyOutcome(head, outcome, state);
+      if (disposition === "pending") {
+        const again = outbox.get(head.id);
+        if (again !== void 0 && again.nextRetryAt !== null && again.nextRetryAt > now()) {
+          return;
+        }
+      }
+    }
+  }
+  async function sendBatchedPrefix(ready, state, signal) {
+    const sendBatch = transport.sendBatch;
+    if (sendBatch === void 0) {
+      return false;
+    }
+    for (const op of ready) {
+      await outbox.markInflight(op.id);
+    }
+    let outcomes;
+    try {
+      outcomes = await sendBatch(ready, signal);
+    } catch {
+      const [head, ...rest] = ready;
+      if (head !== void 0) {
+        await outbox.scheduleRetry(
+          head.id,
+          now() + computeRetryDelayMs(head.attemptCount + 1, { random })
+        );
+      }
+      for (const op of rest) {
+        await outbox.requeue(op.id);
+      }
+      return false;
+    }
+    let halted = false;
+    for (let index = 0; index < ready.length; index += 1) {
+      const op = ready[index];
+      if (op === void 0) {
+        continue;
+      }
+      if (halted) {
+        await outbox.requeue(op.id);
+        continue;
+      }
+      const outcome = outcomes[index];
+      if (outcome === void 0) {
+        await outbox.requeue(op.id);
+        halted = true;
+        continue;
+      }
+      const disposition = await applyOutcome(op, outcome, state);
+      if (disposition === "pending") {
+        halted = true;
+      }
+    }
+    return !halted;
+  }
+  async function runPass(signal) {
+    const state = { applied: 0, parked: 0, conflicted: 0, usedBatch: false };
+    const lanes = outbox.lanes();
+    await Promise.all(lanes.map((tripRef) => drainLane(tripRef, state, signal)));
+    const report = {
+      applied: state.applied,
+      parked: state.parked,
+      conflicted: state.conflicted,
+      remaining: outbox.counts().pending,
+      usedBatchTransport: state.usedBatch,
+      lanes
+    };
+    events.emit("sync.drained", {
+      applied: report.applied,
+      parked: report.parked,
+      conflicted: report.conflicted,
+      remaining: report.remaining,
+      usedBatchTransport: report.usedBatchTransport
+    });
+    return report;
+  }
+  const drainer = {
+    async drain(drainOptions = {}) {
+      if (inFlight !== null) {
+        return inFlight;
+      }
+      const pass = runPass(drainOptions.signal).finally(() => {
+        inFlight = null;
+      });
+      inFlight = pass;
+      return pass;
+    },
+    kick() {
+      void drainer.drain().catch(() => {
+      });
+    },
+    bindOpportunisticTriggers() {
+      const target = typeof globalThis.addEventListener === "function" ? globalThis : void 0;
+      if (target === void 0) {
+        return () => {
+        };
+      }
+      const onOnline = () => {
+        drainer.kick();
+      };
+      const onVisible = () => {
+        const state = globalThis.document?.visibilityState;
+        if (state === void 0 || state === "visible") {
+          drainer.kick();
+        }
+      };
+      target.addEventListener("online", onOnline);
+      target.addEventListener("visibilitychange", onVisible);
+      target.addEventListener("focus", onVisible);
+      return () => {
+        target.removeEventListener("online", onOnline);
+        target.removeEventListener("visibilitychange", onVisible);
+        target.removeEventListener("focus", onVisible);
+      };
+    }
+  };
+  return drainer;
+}
+function isKaafilLike(error) {
+  return typeof error === "object" && error !== null && "kind" in error && error instanceof Error;
+}
+
+// src/offline/events.ts
+function createOfflineEvents(options = {}) {
+  const handlers = /* @__PURE__ */ new Map();
+  return {
+    on(name, handler) {
+      let set = handlers.get(name);
+      if (set === void 0) {
+        set = /* @__PURE__ */ new Set();
+        handlers.set(name, set);
+      }
+      set.add(handler);
+      let removed = false;
+      return () => {
+        if (removed) {
+          return;
+        }
+        removed = true;
+        set?.delete(handler);
+      };
+    },
+    emit(name, event) {
+      const set = handlers.get(name);
+      if (set === void 0) {
+        return;
+      }
+      for (const handler of [...set]) {
+        try {
+          handler(event);
+        } catch (error) {
+          options.onHandlerError?.(error, name);
+        }
+      }
+    },
+    clear() {
+      handlers.clear();
+    }
+  };
+}
+
+// src/offline/pull.ts
+var SYNC_PULL_SECTIONS = [
+  "rooming",
+  "stayWindows",
+  "pickups",
+  "seating",
+  "bookings",
+  "expenses",
+  "checklist",
+  "float",
+  "collections",
+  "itinerary",
+  "closeout"
+];
+function extractSectionRows(data) {
+  if (Array.isArray(data)) {
+    return isRowArray(data) ? data : void 0;
+  }
+  if (typeof data !== "object" || data === null) {
+    return void 0;
+  }
+  let found;
+  for (const value of Object.values(data)) {
+    if (!Array.isArray(value) || !isRowArray(value)) {
+      continue;
+    }
+    if (found !== void 0) {
+      return void 0;
+    }
+    found = value;
+  }
+  return found;
+}
+function isRowArray(value) {
+  return value.every(
+    (item) => typeof item === "object" && item !== null && typeof item.id === "string"
+  );
+}
+function createPullCoordinator(options) {
+  const { snapshot, transport, events } = options;
+  function sinceFor(tripRef) {
+    const known = snapshot.listNames(tripRef).filter(
+      (name) => SYNC_PULL_SECTIONS.includes(name)
+    );
+    if (known.length === 0) {
+      return void 0;
+    }
+    let min;
+    for (const name of known) {
+      const cursor = snapshot.cursor(tripRef, name);
+      if (cursor === void 0) {
+        return void 0;
+      }
+      if (min === void 0 || cursor < min) {
+        min = cursor;
+      }
+    }
+    return min;
+  }
+  async function applyOnce(tripRef, since, signal) {
+    const pullTripFn = transport.pullTrip;
+    if (pullTripFn === void 0) {
+      throw new TypeError(
+        "This offline engine was built without a consolidated-pull transport, so pullTrip() has nothing to call. Supply OfflineTransport.pullTrip."
+      );
+    }
+    const response = await pullTripFn({
+      tripRef,
+      since,
+      ...signal !== void 0 ? { signal } : {}
+    });
+    const serverTime = response.serverTime;
+    options.onServerTime?.(serverTime);
+    const present = [];
+    const absent = [];
+    const unmapped = [];
+    const changed = [];
+    let coldRepullNeeded = false;
+    for (const name of SYNC_PULL_SECTIONS) {
+      const section = response.sections[name];
+      if (section === void 0) {
+        absent.push(name);
+        continue;
+      }
+      const rows = extractSectionRows(section.data);
+      if (rows === void 0) {
+        unmapped.push(name);
+        continue;
+      }
+      present.push(name);
+      const hadCursor = snapshot.cursor(tripRef, name) !== void 0;
+      if (!hadCursor && since !== void 0) {
+        coldRepullNeeded = true;
+      }
+      const applied = await snapshot.applyPull({ tripRef, listName: name, rows, serverTime });
+      if (applied.changed) {
+        changed.push(name);
+      }
+    }
+    if (changed.length > 0) {
+      events.emit("snapshot.updated", { tripRef, lists: changed, serverTime });
+    }
+    return {
+      result: { tripRef, serverTime, present, absent, unmapped, changed, coldRepulled: false },
+      coldRepullNeeded
+    };
+  }
+  return {
+    sinceFor,
+    async pullTrip({ tripRef, signal, cold }) {
+      const since = cold === true ? void 0 : sinceFor(tripRef);
+      const first = await applyOnce(tripRef, since, signal);
+      if (!first.coldRepullNeeded) {
+        return first.result;
+      }
+      const second = await applyOnce(tripRef, void 0, signal);
+      return { ...second.result, coldRepulled: true };
+    }
+  };
+}
+
+// src/offline/share.ts
+var SHARE_WRITE_GRACE_MS = 7 * 24 * 60 * 60 * 1e3;
+var KaafilShareLinkExpiredError = class _KaafilShareLinkExpiredError extends Error {
+  constructor() {
+    super("This link has expired, so it can no longer be used to view or submit anything.");
+    this.name = "KaafilShareLinkExpiredError";
+    Object.setPrototypeOf(this, _KaafilShareLinkExpiredError.prototype);
+  }
+};
+function defaultMonotonicClock() {
+  const performanceNow = globalThis.performance?.now;
+  if (typeof performanceNow === "function") {
+    return () => performanceNow.call(globalThis.performance);
+  }
+  let ticks = 0;
+  return () => {
+    ticks += 1;
+    return ticks;
+  };
+}
+function createShareGuard(options) {
+  const monotonic = options.monotonic ?? defaultMonotonicClock();
+  const expiresAtMs = Date.parse(options.expiresAt);
+  let anchor;
+  function estimateNow() {
+    if (anchor === void 0) {
+      return void 0;
+    }
+    return anchor.serverMs + Math.max(0, monotonic() - anchor.monotonicMs);
+  }
+  const guard = {
+    observeServerTime(serverTime) {
+      const parsed = Date.parse(serverTime);
+      if (Number.isNaN(parsed)) {
+        return;
+      }
+      if (anchor !== void 0 && parsed <= anchor.serverMs) {
+        return;
+      }
+      anchor = { serverMs: parsed, monotonicMs: monotonic() };
+    },
+    now() {
+      return estimateNow();
+    },
+    isExpired() {
+      const at = estimateNow();
+      if (at === void 0 || Number.isNaN(expiresAtMs)) {
+        return false;
+      }
+      return at >= expiresAtMs;
+    },
+    isGraceClosed() {
+      const at = estimateNow();
+      if (at === void 0 || Number.isNaN(expiresAtMs)) {
+        return false;
+      }
+      return at >= expiresAtMs + SHARE_WRITE_GRACE_MS;
+    },
+    assertWritable() {
+      if (guard.isExpired()) {
+        throw new KaafilShareLinkExpiredError();
+      }
+    },
+    async invalidate(reason, code) {
+      await options.snapshot.purgeTrip(options.tripRef);
+      const preserved = options.outbox.counts().pending;
+      const payload = {
+        code: code === KaafilErrorCode.ShareTokenExpired || code === KaafilErrorCode.ShareTokenRevoked ? code : void 0,
+        snapshotPurged: true,
+        pendingOpsPreserved: preserved
+      };
+      options.events.emit(reason === "expired" ? "share.expired" : "share.revoked", payload);
+    },
+    async applyPreflight(result) {
+      if (result.code === KaafilErrorCode.ShareTokenRevoked) {
+        await guard.invalidate("revoked", result.code);
+        return "revoked";
+      }
+      if (result.code === KaafilErrorCode.ShareTokenExpired) {
+        await guard.invalidate("expired", result.code);
+        return "expired";
+      }
+      return "valid";
+    },
+    async parkOpsPastGrace() {
+      if (!guard.isGraceClosed()) {
+        return 0;
+      }
+      let parked = 0;
+      for (const op of options.outbox.all()) {
+        if (op.status !== "pending") {
+          continue;
+        }
+        await options.outbox.park(op.id, {
+          status: null,
+          code: KaafilErrorCode.ShareWriteGraceExpired,
+          userMessage: "This link expired \u2014 your submission was not delivered."
+        });
+        parked += 1;
+        options.events.emit("sync.error", {
+          opId: op.id,
+          tripRef: op.tripRef,
+          error: void 0,
+          status: null,
+          parked: true,
+          userMessage: "This link expired \u2014 your submission was not delivered."
+        });
+      }
+      return parked;
+    }
+  };
+  return guard;
+}
+
+// src/datetime.ts
+var FULL_DATETIME_WITH_OFFSET = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+var DATE_ONLY = /^\d{4}-\d{2}-\d{2}$/;
+function invalidRequest(fieldPath, message) {
+  return new KaafilInvalidRequestError(`${fieldPath}: ${message}`);
+}
+function normalizeDateTimeInput(value, fieldPath) {
+  if (value instanceof Date) {
+    if (Number.isNaN(value.getTime())) {
+      throw invalidRequest(fieldPath, "received an invalid Date (getTime() is NaN).");
+    }
+    return value.toISOString();
+  }
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) {
+      throw invalidRequest(
+        fieldPath,
+        `received a non-finite number (${String(value)}); expected epoch milliseconds.`
+      );
+    }
+    return new Date(value).toISOString();
+  }
+  if (FULL_DATETIME_WITH_OFFSET.test(value)) {
+    return value;
+  }
+  if (DATE_ONLY.test(value)) {
+    throw invalidRequest(
+      fieldPath,
+      `received a date-only string ("${value}"). This API requires a full ISO-8601 datetime WITH an offset, and the SDK will not guess which timezone you meant (midnight UTC is rarely midnight where the trip actually starts). Pass a \`Date\` instead \u2014 e.g. \`new Date("2026-08-20T09:00:00+05:30")\` \u2014 or add an explicit offset yourself, e.g. "2026-08-20T00:00:00+05:30".`
+    );
+  }
+  throw invalidRequest(
+    fieldPath,
+    `received "${value}", which is not a full ISO-8601 datetime with an offset. Pass a \`Date\`, an epoch-milliseconds number, or a string like "2026-08-20T09:00:00+05:30".`
+  );
+}
+function normalizeNullableDateTimeInput(value, fieldPath) {
+  return value === null ? null : normalizeDateTimeInput(value, fieldPath);
+}
+
+// src/delta/cursor.ts
+function isTombstone(row) {
+  return row._tombstone === true;
+}
+function mergeDeltaRows(store, rows) {
+  let added = 0;
+  let updated = 0;
+  let removed = 0;
+  let unchanged = 0;
+  for (const row of rows) {
+    const held = store.get(row.id);
+    if (isTombstone(row)) {
+      if (held === void 0 || held.version > row.version) {
+        unchanged += 1;
+        continue;
+      }
+      store.delete(row.id);
+      removed += 1;
+      continue;
+    }
+    if (held === void 0) {
+      store.set(row.id, row);
+      added += 1;
+      continue;
+    }
+    if (held.version >= row.version) {
+      unchanged += 1;
+      continue;
+    }
+    store.set(row.id, row);
+    updated += 1;
+  }
+  return { added, updated, removed, unchanged };
+}
+var KaafilDeltaCursorInFlightError = class _KaafilDeltaCursorInFlightError extends Error {
+  constructor() {
+    super(
+      "pull() was called while a previous pull on this delta cursor was still in flight. Two concurrent pulls would settle in an unknown order and leave the cursor at whichever response landed last, not the newest \u2014 await the first one's result."
+    );
+    this.name = "KaafilDeltaCursorInFlightError";
+    Object.setPrototypeOf(this, _KaafilDeltaCursorInFlightError.prototype);
+  }
+};
+function createDeltaCursor(config) {
+  const { fetchDelta } = config;
+  const state = {
+    cursor: void 0,
+    isLoading: false
+  };
+  function restore(cursor) {
+    state.cursor = normalizeDateTimeInput(cursor, "cursor");
+  }
+  if (config.cursor !== void 0) {
+    restore(config.cursor);
+  }
+  async function pull(options = {}) {
+    if (state.isLoading) {
+      throw new KaafilDeltaCursorInFlightError();
+    }
+    const previousCursor = state.cursor;
+    state.isLoading = true;
+    try {
+      const response = await fetchDelta({ since: previousCursor, signal: options.signal });
+      state.cursor = response.meta.serverTime;
+      return {
+        data: response,
+        meta: response.meta,
+        cursor: response.meta.serverTime,
+        previousCursor
+      };
+    } finally {
+      state.isLoading = false;
+    }
+  }
+  return {
+    get cursor() {
+      return state.cursor;
+    },
+    get isLoading() {
+      return state.isLoading;
+    },
+    get hasSynced() {
+      return state.cursor !== void 0;
+    },
+    pull,
+    restore,
+    reset() {
+      state.cursor = void 0;
+    }
+  };
+}
+
+// src/offline/snapshot.ts
+var EMPTY_LIST = { cursor: void 0, rows: {}, syncedAt: {} };
+function createSnapshotStore(options) {
+  const key = `${options.keyPrefix}:snapshot`;
+  let trips = /* @__PURE__ */ new Map();
+  async function persist() {
+    const shape = { trips: {} };
+    for (const [tripRef, lists] of trips) {
+      const out = {};
+      for (const [listName, value] of lists) {
+        out[listName] = value;
+      }
+      shape.trips[tripRef] = out;
+    }
+    await options.storage.set(key, JSON.stringify(shape));
+  }
+  function getList(tripRef, listName) {
+    return trips.get(tripRef)?.get(listName) ?? EMPTY_LIST;
+  }
+  function setList(tripRef, listName, value) {
+    let lists = trips.get(tripRef);
+    if (lists === void 0) {
+      lists = /* @__PURE__ */ new Map();
+      trips.set(tripRef, lists);
+    }
+    lists.set(listName, value);
+  }
+  return {
+    async load() {
+      const raw = await options.storage.get(key);
+      trips = /* @__PURE__ */ new Map();
+      if (raw === void 0) {
+        return;
+      }
+      let parsed;
+      try {
+        parsed = JSON.parse(raw);
+      } catch {
+        return;
+      }
+      for (const [tripRef, lists] of Object.entries(parsed.trips ?? {})) {
+        for (const [listName, value] of Object.entries(lists)) {
+          setList(tripRef, listName, {
+            cursor: value.cursor,
+            rows: value.rows ?? {},
+            syncedAt: value.syncedAt ?? {}
+          });
+        }
+      }
+    },
+    list(tripRef, listName) {
+      return Object.values(getList(tripRef, listName).rows);
+    },
+    cursor(tripRef, listName) {
+      return getList(tripRef, listName).cursor;
+    },
+    syncedAt(tripRef, listName, id) {
+      return getList(tripRef, listName).syncedAt[id];
+    },
+    listNames(tripRef) {
+      return [...trips.get(tripRef)?.keys() ?? []];
+    },
+    async applyPull({ tripRef, listName, rows, serverTime }) {
+      const current = getList(tripRef, listName);
+      const merged = new Map(Object.entries(current.rows));
+      const stats = mergeDeltaRows(merged, rows);
+      const syncedAt = {};
+      for (const id of merged.keys()) {
+        syncedAt[id] = current.rows[id] === merged.get(id) ? current.syncedAt[id] ?? serverTime : serverTime;
+      }
+      setList(tripRef, listName, {
+        cursor: serverTime,
+        rows: Object.fromEntries(merged),
+        syncedAt
+      });
+      await persist();
+      return {
+        stats,
+        // Derived from what the merge DID, not from `rows.length` — an
+        // at-least-once window routinely re-delivers rows that change
+        // nothing, and counting them would report a change that never
+        // happened (`06 §5`).
+        changed: stats.added + stats.updated + stats.removed > 0,
+        cursor: serverTime
+      };
+    },
+    async upsert({ tripRef, listName, row, syncedAt }) {
+      const current = getList(tripRef, listName);
+      const held = current.rows[row.id];
+      if (held !== void 0 && held.version > row.version) {
+        return false;
+      }
+      setList(tripRef, listName, {
+        cursor: current.cursor,
+        rows: { ...current.rows, [row.id]: row },
+        syncedAt: syncedAt !== void 0 ? { ...current.syncedAt, [row.id]: syncedAt } : current.syncedAt
+      });
+      await persist();
+      return true;
+    },
+    async purgeEntity(tripRef, listName, id) {
+      const current = getList(tripRef, listName);
+      if (current.rows[id] === void 0) {
+        return;
+      }
+      const rows = { ...current.rows };
+      const stamps = { ...current.syncedAt };
+      delete rows[id];
+      delete stamps[id];
+      setList(tripRef, listName, { cursor: current.cursor, rows, syncedAt: stamps });
+      await persist();
+    },
+    async purgeTrip(tripRef) {
+      if (!trips.delete(tripRef)) {
+        return;
+      }
+      await persist();
+    }
+  };
+}
+
+// src/offline/engine.ts
+function createOfflineEngine(options) {
+  const keyPrefix = `kaafil:v1:${options.scope}`;
+  const events = createOfflineEvents({
+    ...options.onEventHandlerError !== void 0 ? { onHandlerError: (error) => options.onEventHandlerError?.(error) } : {}
+  });
+  const snapshot = createSnapshotStore({ storage: options.storage, keyPrefix });
+  const outbox = createOutbox({
+    storage: options.storage,
+    keyPrefix,
+    ...options.now !== void 0 ? { now: options.now } : {},
+    ...options.newId !== void 0 ? { newId: options.newId } : {}
+  });
+  let share;
+  const onServerTime = (serverTime) => {
+    share?.observeServerTime(serverTime);
+  };
+  if (options.share !== void 0) {
+    share = createShareGuard({
+      tripRef: options.share.tripRef,
+      expiresAt: options.share.expiresAt,
+      snapshot,
+      outbox,
+      events,
+      ...options.share.monotonic !== void 0 ? { monotonic: options.share.monotonic } : {}
+    });
+  }
+  const drainer = createDrainer({
+    outbox,
+    snapshot,
+    transport: options.transport,
+    events,
+    onServerTime,
+    ...options.conflictResolver !== void 0 ? { conflictResolver: options.conflictResolver } : {},
+    ...options.now !== void 0 ? { now: options.now } : {},
+    ...options.random !== void 0 ? { random: options.random } : {}
+  });
+  const pull = createPullCoordinator({
+    snapshot,
+    transport: options.transport,
+    events,
+    onServerTime
+  });
+  const blobs = options.blob === void 0 ? void 0 : createBlobLane({
+    storage: options.storage,
+    keyPrefix,
+    outbox,
+    uploader: options.blob.uploader,
+    source: options.blob.source,
+    ...options.now !== void 0 ? { now: options.now } : {},
+    ...options.random !== void 0 ? { random: options.random } : {}
+  });
+  let unbind;
+  async function enqueue(input) {
+    share?.assertWritable();
+    const op = await outbox.enqueue({
+      tripRef: input.tripRef,
+      method: input.method,
+      path: input.path,
+      operationId: input.operationId,
+      ...input.body !== void 0 ? { body: input.body } : {},
+      ...input.ifMatch !== void 0 ? { ifMatch: input.ifMatch } : {},
+      ...input.entity !== void 0 ? { entity: input.entity } : {},
+      ...input.idempotencyKey !== void 0 ? { idempotencyKey: input.idempotencyKey } : {},
+      ...input.enqueuedAt !== void 0 ? { enqueuedAt: input.enqueuedAt } : {}
+    });
+    if (input.optimistic !== void 0 && input.entity !== void 0) {
+      await snapshot.upsert({
+        tripRef: input.tripRef,
+        listName: input.entity.listName,
+        row: input.optimistic
+      });
+    }
+    drainer.kick();
+    return op;
+  }
+  return {
+    events,
+    snapshot,
+    outbox,
+    drainer,
+    pull,
+    blobs,
+    share,
+    async open() {
+      await Promise.all([snapshot.load(), outbox.load(), blobs?.load() ?? Promise.resolve()]);
+      unbind = drainer.bindOpportunisticTriggers();
+    },
+    enqueue,
+    async enqueueWithBlob(input) {
+      const { blob, ...rest } = input;
+      share?.assertWritable();
+      const op = await outbox.enqueue({
+        tripRef: rest.tripRef,
+        method: rest.method,
+        path: rest.path,
+        operationId: rest.operationId,
+        receiptPending: true,
+        blobId: blob.id,
+        ...rest.body !== void 0 ? { body: rest.body } : {},
+        ...rest.ifMatch !== void 0 ? { ifMatch: rest.ifMatch } : {},
+        ...rest.entity !== void 0 ? { entity: rest.entity } : {},
+        ...rest.idempotencyKey !== void 0 ? { idempotencyKey: rest.idempotencyKey } : {},
+        ...rest.enqueuedAt !== void 0 ? { enqueuedAt: rest.enqueuedAt } : {}
+      });
+      if (rest.optimistic !== void 0 && rest.entity !== void 0) {
+        await snapshot.upsert({
+          tripRef: rest.tripRef,
+          listName: rest.entity.listName,
+          row: rest.optimistic
+        });
+      }
+      if (blobs !== void 0) {
+        await blobs.enqueue({
+          blobId: blob.id,
+          tripRef: rest.tripRef,
+          parentOpId: op.id,
+          contentType: blob.contentType,
+          sizeBytes: blob.sizeBytes,
+          backfill: blob.backfill
+        });
+      }
+      drainer.kick();
+      return op;
+    },
+    async drain() {
+      await share?.parkOpsPastGrace();
+      const report = await drainer.drain();
+      await blobs?.drain();
+      return report;
+    },
+    close() {
+      unbind?.();
+      unbind = void 0;
+      events.clear();
+    }
+  };
+}
+function outcomeFromError(error) {
+  if (isKaafilError(error)) {
+    const kaafil = error;
+    return {
+      status: kaafil.status ?? null,
+      ...kaafil.code !== void 0 ? { code: kaafil.code } : {},
+      ...kaafil.details !== void 0 ? { details: kaafil.details } : {},
+      ...kaafil.meta?.serverTime !== void 0 ? { serverTime: kaafil.meta.serverTime } : {},
+      error: kaafil
+    };
+  }
+  return { status: null, transportFailureKind: "network" };
+}
+function entityFromBody(body) {
+  if (typeof body !== "object" || body === null) {
+    return void 0;
+  }
+  const candidate = body;
+  if (typeof candidate.id === "string" && typeof candidate.version === "number") {
+    return body;
+  }
+  return void 0;
+}
+function createHttpOfflineTransport(options) {
+  const { http, sync } = options;
+  const batchable = options.credential !== "share" || isShareBatchPushAvailable();
+  const transport = {
+    async sendOne(op, signal) {
+      try {
+        const response = await http.execute({
+          method: op.method,
+          operationId: op.operationId,
+          path: op.path,
+          // The op's OWN key, fixed at enqueue and reused on every attempt.
+          idempotencyKey: op.idempotencyKey,
+          ...op.body !== void 0 ? { body: op.body } : {},
+          ...op.ifMatch !== void 0 ? { headers: { "If-Match": String(op.ifMatch) } } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+        const { meta, ...data } = response;
+        const entity = entityFromBody(data);
+        return {
+          status: meta.status,
+          serverTime: meta.serverTime,
+          ...entity !== void 0 ? { entity } : {}
+        };
+      } catch (error) {
+        return outcomeFromError(error);
+      }
+    },
+    ...options.readEntity !== void 0 ? { readEntity: options.readEntity } : {},
+    async pullTrip({ tripRef, since, signal }) {
+      const response = await sync.pullTrip({
+        tripRef,
+        ...since !== void 0 ? { since } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+      return {
+        tripRef: response.tripRef,
+        // `sections` is a PARTIAL record and stays one all the way through —
+        // nothing here fills a missing key with an empty list (`./pull.ts`).
+        sections: response.sections,
+        serverTime: response.meta.serverTime
+      };
+    }
+  };
+  if (!batchable) {
+    return transport;
+  }
+  return {
+    ...transport,
+    async sendBatch(ops, signal) {
+      const push = options.credential === "share" ? sync.pushShare : sync.push;
+      const response = await push({
+        ops: ops.map((op) => ({
+          method: op.method,
+          path: op.path,
+          idempotencyKey: op.idempotencyKey,
+          ...op.ifMatch !== void 0 ? { ifMatch: op.ifMatch } : {},
+          ...op.enqueuedAt !== void 0 ? { enqueuedAt: op.enqueuedAt } : {},
+          ...op.body !== void 0 ? { body: op.body } : {}
+        })),
+        ...signal !== void 0 ? { signal } : {}
+      });
+      const serverTime = response.meta.serverTime;
+      const byIndex = new Map(response.verdicts.map((verdict) => [verdict.index, verdict]));
+      return ops.map((_op, index) => {
+        const verdict = byIndex.get(index);
+        if (verdict === void 0) {
+          return { status: null, transportFailureKind: "network" };
+        }
+        const envelope = verdict.body;
+        if (verdict.status >= 200 && verdict.status < 300) {
+          const entity = entityFromBody(envelope?.data);
+          return {
+            status: verdict.status,
+            serverTime,
+            ...entity !== void 0 ? { entity } : {}
+          };
+        }
+        const code = envelope?.error?.code;
+        const details = envelope?.error?.details;
+        return {
+          status: verdict.status,
+          serverTime,
+          ...typeof code === "string" && code in KaafilErrorCodeValues ? { code } : {},
+          ...typeof details === "object" && details !== null ? { details } : {}
+        };
+      });
+    }
+  };
+}
+var KaafilErrorCodeValues = Object.fromEntries(
+  Object.values(KaafilErrorCode).map((code) => [code, true])
+);
+
+// src/resources/checklists.ts
+function createChecklistsResource(client) {
+  return {
+    async read(options) {
+      const { tripRef, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadChecklistAggregate,
+        path: "/api/v1/trips/{ref}/checklist",
+        pathParams: { ref: tripRef },
+        query: { since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    items: {
+      async add(options) {
+        const { tripRef, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.AddChecklistItem,
+          path: "/api/v1/trips/{ref}/checklist/items",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async patch(options) {
+        const { tripRef, itemId, version, signal, ...body } = options;
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchChecklistItem,
+          path: "/api/v1/trips/{ref}/checklist/items/{itemId}",
+          pathParams: { ref: tripRef, itemId },
+          body,
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async remove(options) {
+        const { tripRef, itemId, version, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.DeleteChecklistItem,
+          path: "/api/v1/trips/{ref}/checklist/items/{itemId}",
+          pathParams: { ref: tripRef, itemId },
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async toggle(options) {
+        const { tripRef, itemId, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.ToggleChecklistItem,
+          path: "/api/v1/trips/{ref}/checklist/items/{itemId}/toggle",
+          pathParams: { ref: tripRef, itemId },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    },
+    templates: {
+      async list(options) {
+        const { tripRef, locale, signal } = options;
+        return client.execute({
+          method: "GET",
+          operationId: OperationId.ListChecklistTemplates,
+          path: "/api/v1/trips/{ref}/checklist/templates",
+          pathParams: { ref: tripRef },
+          query: { locale },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async pull(options) {
+        const { tripRef, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.PullChecklistTemplate,
+          path: "/api/v1/trips/{ref}/checklist/pull-template",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    }
+  };
+}
+
+// src/resources/closeout.ts
+function createCloseoutResource(client) {
+  return {
+    async get(options) {
+      const { tripRef, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadCloseout,
+        path: "/api/v1/trips/{ref}/closeout",
+        pathParams: { ref: tripRef },
+        query: { since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async saveHandover(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.SaveCloseoutHandover,
+        path: "/api/v1/trips/{ref}/closeout/handover",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async lock(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.LockCloseout,
+        path: "/api/v1/trips/{ref}/closeout/lock",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async unlock(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.UnlockCloseout,
+        path: "/api/v1/trips/{ref}/closeout/unlock",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async exportPdf(options) {
+      const { tripRef, signal, ...body } = options;
+      return client.executeBinary({
+        method: "POST",
+        operationId: OperationId.ExportCloseoutPack,
+        path: "/api/v1/trips/{ref}/closeout/export-pdf",
+        pathParams: { ref: tripRef },
+        body,
+        // The one place a non-JSON `Accept` is sent. `exportCloseoutPack`
+        // declares no `Idempotency-Key` parameter
+        // (`OPERATION_ACCEPTS_IDEMPOTENCY_KEY.exportCloseoutPack` is `false`),
+        // and rightly — printing the same pack twice creates nothing — so no
+        // key is offered here and the transport mints none.
+        accept: "application/pdf",
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// src/resources/collections.ts
+function createCollectionsResource(client) {
+  return {
+    async list(options) {
+      const { tripRef, travellerId, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ListCollections,
+        path: "/api/v1/trips/{ref}/collections",
+        pathParams: { ref: tripRef },
+        query: { travellerId, since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async eligible(options) {
+      const { tripRef, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ListEligibleCollections,
+        path: "/api/v1/trips/{ref}/collections/eligible",
+        pathParams: { ref: tripRef },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async record(options) {
+      const { tripRef, idempotencyKey, signal, collectedAt, ...rest } = options;
+      const body = {
+        ...rest,
+        ...collectedAt !== void 0 ? { collectedAt: normalizeDateTimeInput(collectedAt, "collectedAt") } : {}
+      };
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.RecordCollection,
+        path: "/api/v1/trips/{ref}/collections",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async void(options) {
+      const { tripRef, collectionId, version, signal, ...body } = options;
+      return client.execute({
+        method: "DELETE",
+        operationId: OperationId.VoidCollection,
+        path: "/api/v1/trips/{ref}/collections/{id}/void",
+        pathParams: { ref: tripRef, id: collectionId },
+        body,
+        headers: { "If-Match": String(version) },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// src/resources/expenses.ts
+function createExpensesResource(client) {
+  return {
+    async list(options) {
+      const { tripRef, since, signal, ...filters } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ListExpenses,
+        path: "/api/v1/trips/{ref}/expenses",
+        pathParams: { ref: tripRef },
+        query: { ...filters, since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async read(options) {
+      const { tripRef, expenseId, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadExpense,
+        path: "/api/v1/trips/{ref}/expenses/{id}",
+        pathParams: { ref: tripRef, id: expenseId },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async log(options) {
+      const { tripRef, idempotencyKey, signal, spentAt, ...rest } = options;
+      const body = {
+        ...rest,
+        ...spentAt !== void 0 ? { spentAt: normalizeDateTimeInput(spentAt, "spentAt") } : {}
+      };
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.LogExpense,
+        path: "/api/v1/trips/{ref}/expenses",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async linkReceipt(options) {
+      const { tripRef, expenseId, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "PATCH",
+        operationId: OperationId.LinkExpenseReceipt,
+        path: "/api/v1/trips/{ref}/expenses/{id}/receipt",
+        pathParams: { ref: tripRef, id: expenseId },
+        body,
+        idempotencyKey,
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async void(options) {
+      const { tripRef, expenseId, version, signal, ...body } = options;
+      return client.execute({
+        method: "DELETE",
+        operationId: OperationId.VoidExpense,
+        path: "/api/v1/trips/{ref}/expenses/{id}/void",
+        pathParams: { ref: tripRef, id: expenseId },
+        body,
+        headers: { "If-Match": String(version) },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    claims: {
+      async submit(options) {
+        const { tripRef, expenseId, idempotencyKey, signal } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.SubmitExpenseClaim,
+          path: "/api/v1/trips/{ref}/expenses/{id}/claim",
+          pathParams: { ref: tripRef, id: expenseId },
+          body: {},
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async withdraw(options) {
+        const { tripRef, expenseId, version, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.WithdrawExpenseClaim,
+          path: "/api/v1/trips/{ref}/expenses/{id}/claim/withdraw",
+          pathParams: { ref: tripRef, id: expenseId },
+          body: {},
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async ingest(options) {
+        const { tripRef, expenseId, idempotencyKey, signal, decisionAt, ...rest } = options;
+        const body = {
+          ...rest,
+          decisionAt: normalizeDateTimeInput(decisionAt, "decisionAt")
+        };
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.ClaimStatusIngest,
+          path: "/api/v1/trips/{ref}/expenses/{id}/claim-status",
+          pathParams: { ref: tripRef, id: expenseId },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    }
+  };
+}
+
+// src/resources/files.ts
+function createFilesResource(client) {
+  return {
+    async request(options) {
+      const { idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.RequestFileUpload,
+        path: "/api/v1/files",
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async meta(options) {
+      const { fileId, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadFile,
+        path: "/api/v1/files/{id}",
+        pathParams: { id: fileId },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async confirm(options) {
+      const { fileId, idempotencyKey, signal } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.ConfirmFileUpload,
+        path: "/api/v1/files/{id}/confirm",
+        pathParams: { id: fileId },
+        body: {},
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async url(options) {
+      const { fileId, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadFileUrl,
+        path: "/api/v1/files/{id}/url",
+        pathParams: { id: fileId },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// src/resources/float.ts
+function createFloatResource(client) {
+  return {
+    async readSummary(options) {
+      const { tripRef, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadFloatSummary,
+        path: "/api/v1/trips/{ref}/float",
+        pathParams: { ref: tripRef },
+        query: { since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async readLedger(options) {
+      const { tripRef, managerId, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadFloatLedger,
+        path: "/api/v1/trips/{ref}/float/{managerId}/ledger",
+        pathParams: { ref: tripRef, managerId },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async issue(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.IssueFloat,
+        path: "/api/v1/trips/{ref}/float/issue",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async return(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.ReturnFloat,
+        path: "/api/v1/trips/{ref}/float/return",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async adjust(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.AdjustFloat,
+        path: "/api/v1/trips/{ref}/float/adjust",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// src/resources/itinerary.ts
+function createItineraryResource(client) {
+  return {
+    async read(options) {
+      const { tripRef, dayIndex, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadItinerary,
+        path: "/api/v1/trips/{ref}/itinerary",
+        pathParams: { ref: tripRef },
+        query: { dayIndex, since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    items: {
+      async add(options) {
+        const { tripRef, idempotencyKey, signal, isoDate, startTime, endTime, ...rest } = options;
+        const body = {
+          ...rest,
+          isoDate: normalizeDateTimeInput(isoDate, "isoDate"),
+          ...startTime !== void 0 ? { startTime: normalizeNullableDateTimeInput(startTime, "startTime") } : {},
+          ...endTime !== void 0 ? { endTime: normalizeNullableDateTimeInput(endTime, "endTime") } : {}
+        };
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.AddItineraryItem,
+          path: "/api/v1/trips/{ref}/itinerary/items",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async patch(options) {
+        const { tripRef, itemId, version, signal, startTime, endTime, ...rest } = options;
+        const body = {
+          ...rest,
+          ...startTime !== void 0 ? { startTime: normalizeNullableDateTimeInput(startTime, "startTime") } : {},
+          ...endTime !== void 0 ? { endTime: normalizeNullableDateTimeInput(endTime, "endTime") } : {}
+        };
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchItineraryItem,
+          path: "/api/v1/trips/{ref}/itinerary/items/{itemId}",
+          pathParams: { ref: tripRef, itemId },
+          body,
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async remove(options) {
+        const { tripRef, itemId, version, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.DeleteItineraryItem,
+          path: "/api/v1/trips/{ref}/itinerary/items/{itemId}",
+          pathParams: { ref: tripRef, itemId },
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async reorder(options) {
+        const { tripRef, itemId, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.ReorderItineraryItem,
+          path: "/api/v1/trips/{ref}/itinerary/items/{itemId}/reorder",
+          pathParams: { ref: tripRef, itemId },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    },
+    days: {
+      async patch(options) {
+        const { tripRef, dayIndex, version, signal, ...body } = options;
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchItineraryDay,
+          path: "/api/v1/trips/{ref}/itinerary/days/{dayIndex}",
+          pathParams: { ref: tripRef, dayIndex },
+          body,
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    },
+    changeLog: {
+      async list(options) {
+        const { tripRef, since, signal } = options;
+        return client.execute({
+          method: "GET",
+          operationId: OperationId.ReadItineraryChangeLog,
+          path: "/api/v1/trips/{ref}/itinerary/change-log",
+          pathParams: { ref: tripRef },
+          query: { since },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    }
+  };
+}
+
+// src/resources/journey.ts
+var DEFAULT_WAIT_UNTIL_READY_TIMEOUT_MS = 6e4;
+var DEFAULT_WAIT_UNTIL_READY_POLL_INTERVAL_MS = 1e3;
+function createJourneyResource(client) {
+  const resource = {
+    async get(options) {
+      const { tripRef, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadJourney,
+        path: "/api/v1/trips/{ref}/journey",
+        pathParams: { ref: tripRef },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async capabilities(options) {
+      const { tripRef, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadJourneyCapabilities,
+        path: "/api/v1/trips/{ref}/journey/capabilities",
+        pathParams: { ref: tripRef },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async rebuild(options) {
+      const { tripRef, idempotencyKey, signal } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.RebuildJourney,
+        path: "/api/v1/trips/{ref}/journey/rebuild",
+        pathParams: { ref: tripRef },
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async runStep(options) {
+      const { tripRef, stepId, idempotencyKey, signal } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.RunJourneyStep,
+        path: "/api/v1/trips/{ref}/journey/steps/{stepId}/run",
+        pathParams: { ref: tripRef, stepId },
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async waitUntilReady(options) {
+      const {
+        tripRef,
+        timeoutMs = DEFAULT_WAIT_UNTIL_READY_TIMEOUT_MS,
+        pollIntervalMs = DEFAULT_WAIT_UNTIL_READY_POLL_INTERVAL_MS,
+        signal
+      } = options;
+      const deadlineAt = Date.now() + timeoutMs;
+      for (; ; ) {
+        try {
+          return await resource.get({ tripRef, ...signal !== void 0 ? { signal } : {} });
+        } catch (error) {
+          if (!(error instanceof KaafilNotFoundError)) {
+            throw error;
+          }
+          const remainingMs = deadlineAt - Date.now();
+          if (remainingMs <= 0) {
+            throw new KaafilTimeoutError(
+              `journey.waitUntilReady timed out after ${String(timeoutMs)}ms waiting for trip "${tripRef}" to become ready. The most likely cause is that the background worker that consumes the build queue is not running against this engine.`,
+              { cause: error }
+            );
+          }
+          try {
+            await delayWithAbort(Math.min(pollIntervalMs, remainingMs), signal);
+          } catch (sleepError) {
+            throw new KaafilAbortError("Request aborted", { cause: sleepError });
+          }
+        }
+      }
+    },
+    triggers: {
+      async list(options) {
+        const { agencyRef, signal } = options;
+        return client.execute({
+          method: "GET",
+          operationId: OperationId.ListJourneyTriggers,
+          path: "/api/v1/agencies/{ref}/journey-triggers",
+          pathParams: { ref: agencyRef },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async patch(options) {
+        const { agencyRef, key, version, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchJourneyTrigger,
+          path: "/api/v1/agencies/{ref}/journey-triggers/{key}",
+          pathParams: { ref: agencyRef, key },
+          body,
+          headers: { "If-Match": String(version) },
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    }
+  };
+  return resource;
+}
+
+// src/resources/notifications.ts
+function createNotificationsResource(client) {
+  return {
+    async list(options = {}) {
+      const { since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ListManagerNotifications,
+        path: "/api/v1/managers/me/notifications",
+        ...since !== void 0 ? { query: { since } } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// src/resources/pickups.ts
+function createPickupsResource(client) {
+  return {
+    async list(options) {
+      const { tripRef, kind, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ListPickupStops,
+        path: "/api/v1/trips/{ref}/pickups",
+        pathParams: { ref: tripRef },
+        query: { kind, since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async create(options) {
+      const { tripRef, idempotencyKey, signal, scheduledTime, ...rest } = options;
+      const body = {
+        ...rest,
+        scheduledTime: normalizeDateTimeInput(scheduledTime, "scheduledTime")
+      };
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.CreatePickupStop,
+        path: "/api/v1/trips/{ref}/pickups",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async patch(options) {
+      const { tripRef, pointId, version, signal, scheduledTime, ...rest } = options;
+      const body = {
+        ...rest,
+        ...scheduledTime !== void 0 ? { scheduledTime: normalizeDateTimeInput(scheduledTime, "scheduledTime") } : {}
+      };
+      return client.execute({
+        method: "PATCH",
+        operationId: OperationId.PatchPickupStop,
+        path: "/api/v1/trips/{ref}/pickups/{pointId}",
+        pathParams: { ref: tripRef, pointId },
+        body,
+        headers: { "If-Match": String(version) },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async remove(options) {
+      const { tripRef, pointId, version, force, signal } = options;
+      return client.execute({
+        method: "DELETE",
+        operationId: OperationId.DeletePickupStop,
+        path: "/api/v1/trips/{ref}/pickups/{pointId}",
+        pathParams: { ref: tripRef, pointId },
+        query: { force },
+        headers: { "If-Match": String(version) },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async reorder(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.ReorderPickupStops,
+        path: "/api/v1/trips/{ref}/pickups/reorder",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async assign(options) {
+      const { tripRef, pointId, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.AssignPickupTraveller,
+        path: "/api/v1/trips/{ref}/pickups/{pointId}/assign",
+        pathParams: { ref: tripRef, pointId },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async board(options) {
+      const { tripRef, pointId, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.BoardPickupTraveller,
+        path: "/api/v1/trips/{ref}/pickups/{pointId}/board",
+        pathParams: { ref: tripRef, pointId },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async close(options) {
+      const { tripRef, pointId, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.ClosePickupStop,
+        path: "/api/v1/trips/{ref}/pickups/{pointId}/close",
+        pathParams: { ref: tripRef, pointId },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async reopen(options) {
+      const { tripRef, pointId, idempotencyKey, signal } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.ReopenPickupStop,
+        path: "/api/v1/trips/{ref}/pickups/{pointId}/reopen",
+        pathParams: { ref: tripRef, pointId },
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async manifestByPickup(options) {
+      const { tripRef, kind, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadManifestByPickup,
+        path: "/api/v1/trips/{ref}/manifest-by-pickup",
+        pathParams: { ref: tripRef },
+        query: { kind },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    }
+  };
+}
+
+// src/resources/rooming.ts
+function createRoomingResource(client) {
+  return {
+    async read(options) {
+      const { tripRef, stayWindowId, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadRoomingBoard,
+        path: "/api/v1/trips/{ref}/rooming",
+        pathParams: { ref: tripRef },
+        query: { stayWindowId, since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async assign(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.AssignRoomingBed,
+        path: "/api/v1/trips/{ref}/rooming/assign",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async autoAssign(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.AutoAssignRooming,
+        path: "/api/v1/trips/{ref}/rooming/auto-assign",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    stayWindows: {
+      async list(options) {
+        const { tripRef, since, signal } = options;
+        return client.execute({
+          method: "GET",
+          operationId: OperationId.ListRoomingStayWindows,
+          path: "/api/v1/trips/{ref}/rooming/stay-windows",
+          pathParams: { ref: tripRef },
+          query: { since },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async create(options) {
+        const { tripRef, idempotencyKey, signal, startDate, endDate, ...rest } = options;
+        const body = {
+          ...rest,
+          startDate: normalizeDateTimeInput(startDate, "startDate"),
+          endDate: normalizeDateTimeInput(endDate, "endDate")
+        };
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.CreateRoomingStayWindow,
+          path: "/api/v1/trips/{ref}/rooming/stay-windows",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async patch(options) {
+        const { tripRef, windowId, version, signal, startDate, endDate, ...rest } = options;
+        const body = {
+          ...rest,
+          ...startDate !== void 0 ? { startDate: normalizeDateTimeInput(startDate, "startDate") } : {},
+          ...endDate !== void 0 ? { endDate: normalizeDateTimeInput(endDate, "endDate") } : {}
+        };
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchRoomingStayWindow,
+          path: "/api/v1/trips/{ref}/rooming/stay-windows/{windowId}",
+          pathParams: { ref: tripRef, windowId },
+          body,
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async remove(options) {
+        const { tripRef, windowId, version, force, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.DeleteRoomingStayWindow,
+          path: "/api/v1/trips/{ref}/rooming/stay-windows/{windowId}",
+          pathParams: { ref: tripRef, windowId },
+          query: { force },
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    },
+    rooms: {
+      async create(options) {
+        const { tripRef, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.CreateRoomingRoom,
+          path: "/api/v1/trips/{ref}/rooming/rooms",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async patch(options) {
+        const { tripRef, roomId, version, signal, ...body } = options;
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchRoomingRoom,
+          path: "/api/v1/trips/{ref}/rooming/rooms/{roomId}",
+          pathParams: { ref: tripRef, roomId },
+          body,
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async remove(options) {
+        const { tripRef, roomId, version, force, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.DeleteRoomingRoom,
+          path: "/api/v1/trips/{ref}/rooming/rooms/{roomId}",
+          pathParams: { ref: tripRef, roomId },
+          query: { force },
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    }
+  };
+}
+
+// src/resources/seating.ts
+function createSeatingResource(client) {
+  return {
+    async read(options) {
+      const { tripRef, since, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadSeatingBoard,
+        path: "/api/v1/trips/{ref}/seating",
+        pathParams: { ref: tripRef },
+        query: { since },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async assign(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.AssignSeating,
+        path: "/api/v1/trips/{ref}/seating/assign",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async autoAssign(options) {
+      const { tripRef, idempotencyKey, signal, ...body } = options;
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.AutoAssignSeating,
+        path: "/api/v1/trips/{ref}/seating/auto-assign",
+        pathParams: { ref: tripRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    vehicles: {
+      async create(options) {
+        const { tripRef, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.CreateSeatingVehicle,
+          path: "/api/v1/trips/{ref}/seating/vehicles",
+          pathParams: { ref: tripRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async patch(options) {
+        const { tripRef, vehicleId, version, signal, ...body } = options;
+        return client.execute({
+          method: "PATCH",
+          operationId: OperationId.PatchSeatingVehicle,
+          path: "/api/v1/trips/{ref}/seating/vehicles/{vehicleId}",
+          pathParams: { ref: tripRef, vehicleId },
+          body,
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async remove(options) {
+        const { tripRef, vehicleId, version, signal } = options;
+        return client.execute({
+          method: "DELETE",
+          operationId: OperationId.DeleteSeatingVehicle,
+          path: "/api/v1/trips/{ref}/seating/vehicles/{vehicleId}",
+          pathParams: { ref: tripRef, vehicleId },
+          headers: { "If-Match": String(version) },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      manager: {
+        async link(options) {
+          const { tripRef, vehicleId, idempotencyKey, signal, ...body } = options;
+          return client.execute({
+            method: "POST",
+            operationId: OperationId.LinkSeatingManager,
+            path: "/api/v1/trips/{ref}/seating/vehicles/{vehicleId}/manager",
+            pathParams: { ref: tripRef, vehicleId },
+            body,
+            ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+            ...signal !== void 0 ? { signal } : {}
+          });
+        },
+        async unlink(options) {
+          const { tripRef, vehicleId, version, signal } = options;
+          return client.execute({
+            method: "DELETE",
+            operationId: OperationId.UnlinkSeatingManager,
+            path: "/api/v1/trips/{ref}/seating/vehicles/{vehicleId}/manager",
+            pathParams: { ref: tripRef, vehicleId },
+            headers: { "If-Match": String(version) },
+            ...signal !== void 0 ? { signal } : {}
+          });
+        }
+      }
+    }
+  };
+}
+
+// src/resources/share.ts
+function createShareResource(client) {
+  return {
+    async snapshot(options) {
+      const { token, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.GetShareSnapshot,
+        path: "/api/v1/share/{token}",
+        pathParams: { token },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async manifest(options) {
+      const { token, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.GetShareManifest,
+        path: "/api/v1/share/{token}/manifest",
+        pathParams: { token },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    forms: {
+      async list(options) {
+        const { token, signal } = options;
+        return client.execute({
+          method: "GET",
+          operationId: OperationId.ShareListForms,
+          path: "/api/v1/share/{token}/forms",
+          pathParams: { token },
+          ...signal !== void 0 ? { signal } : {}
+        });
       },
       async render(options) {
         const { token, formId, travellerRef, signal } = options;
@@ -1686,6 +4336,64 @@ function createShareResource(client) {
   };
 }
 
+// src/resources/treks.ts
+var ACTIVE_TREK_REF = "active";
+function createTreksResource(client) {
+  return {
+    async board(options) {
+      const { trekRef, signal } = options;
+      return client.execute({
+        method: "GET",
+        operationId: OperationId.ReadTrekBoard,
+        path: "/api/v1/treks/{trekRef}/board",
+        pathParams: { trekRef },
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    async postpone(options) {
+      const { trekRef, idempotencyKey, signal, newStartDate, newEndDate, ...rest } = options;
+      const body = {
+        ...rest,
+        newStartDate: normalizeDateTimeInput(newStartDate, "newStartDate"),
+        newEndDate: normalizeDateTimeInput(newEndDate, "newEndDate")
+      };
+      return client.execute({
+        method: "POST",
+        operationId: OperationId.PostponeTrek,
+        path: "/api/v1/treks/{trekRef}/postpone",
+        pathParams: { trekRef },
+        body,
+        ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+        ...signal !== void 0 ? { signal } : {}
+      });
+    },
+    walkIns: {
+      async meta(options) {
+        const { trekRef, signal } = options;
+        return client.execute({
+          method: "GET",
+          operationId: OperationId.ReadTrekWalkInMeta,
+          path: "/api/v1/treks/{trekRef}/walk-ins/meta",
+          pathParams: { trekRef },
+          ...signal !== void 0 ? { signal } : {}
+        });
+      },
+      async create(options) {
+        const { trekRef, idempotencyKey, signal, ...body } = options;
+        return client.execute({
+          method: "POST",
+          operationId: OperationId.CreateTrekWalkIn,
+          path: "/api/v1/treks/{trekRef}/walk-ins",
+          pathParams: { trekRef },
+          body,
+          ...idempotencyKey !== void 0 ? { idempotencyKey } : {},
+          ...signal !== void 0 ? { signal } : {}
+        });
+      }
+    }
+  };
+}
+
 // src/resources/vendors.ts
 function createVendorsResource(client) {
   return {
@@ -1703,26 +4411,116 @@ function createVendorsResource(client) {
 }
 
 // src/generated/enums.ts
+var BoardStatus = {
+  Boarded: "BOARDED",
+  NoShow: "NO_SHOW"
+};
 var BookingStatus = {
   Confirmed: "CONFIRMED",
   Tentative: "TENTATIVE",
   Cancelled: "CANCELLED"
 };
+var ChecklistAudience = {
+  Internal: "INTERNAL",
+  External: "EXTERNAL"
+};
+var ChecklistGate = {
+  None: "NONE",
+  PreToActive: "PRE_TO_ACTIVE",
+  ActiveToClosedOut: "ACTIVE_TO_CLOSED_OUT"
+};
+var ChecklistItemStatus = {
+  Open: "OPEN",
+  Complete: "COMPLETE"
+};
+var ChecklistPhase = {
+  PreDeparture: "PRE_DEPARTURE",
+  InTrip: "IN_TRIP",
+  PostTrip: "POST_TRIP"
+};
+var ChecklistPullTemplateMode = {
+  Append: "append",
+  Replace: "replace"
+};
 var ClaimStatusIngest = {
   Approved: "APPROVED",
   Paid: "PAID",
   Rejected: "REJECTED"
 };
+var CloseoutPackSection = {
+  Summary: "summary",
+  Blockers: "blockers",
+  Handover: "handover",
+  Collections: "collections",
+  Expenses: "expenses",
+  Float: "float",
+  Checklists: "checklists",
+  Forms: "forms",
+  Rooming: "rooming",
+  Seating: "seating",
+  Pickups: "pickups",
+  Vendors: "vendors",
+  Itinerary: "itinerary"
+};
+var CollectionMode = {
+  Cash: "CASH",
+  Upi: "UPI",
+  Card: "CARD",
+  Bank: "BANK"
+};
+var Currency = {
+  Inr: "INR"
+};
 var EventType = {
   Trip: "TRIP",
   Trek: "TREK"
 };
+var ExpenseCategory = {
+  Accom: "ACCOM",
+  Food: "FOOD",
+  Transport: "TRANSPORT",
+  Activity: "ACTIVITY",
+  Misc: "MISC"
+};
+var ExpensePaymentMode = {
+  FloatCash: "FLOAT_CASH",
+  Personal: "PERSONAL",
+  Other: "OTHER"
+};
+var FileContentType = {
+  ImageJpeg: "image/jpeg",
+  ImagePng: "image/png",
+  ImageWebp: "image/webp",
+  ImageHeic: "image/heic",
+  ApplicationPdf: "application/pdf"
+};
+var FilePurpose = {
+  ExpenseReceipt: "expense_receipt",
+  FormAttachment: "form_attachment",
+  BookingVoucher: "booking_voucher"
+};
+var FloatDirection = {
+  In: "IN",
+  Out: "OUT"
+};
 var Gender = {
   Male: "MALE",
   Female: "FEMALE",
   Other: "OTHER",
   Unknown: "UNKNOWN"
 };
+var ItineraryItemStatusUpdate = {
+  Planned: "PLANNED",
+  Completed: "COMPLETED",
+  Skipped: "SKIPPED"
+};
+var ItineraryItemType = {
+  Accommodation: "ACCOMMODATION",
+  Transport: "TRANSPORT",
+  Activity: "ACTIVITY",
+  Meal: "MEAL",
+  Other: "OTHER"
+};
 var ManagerRole = {
   Manager: "MANAGER",
   Coordinator: "COORDINATOR"
@@ -1738,6 +4536,59 @@ var PartyKind = {
   Corporate: "CORPORATE",
   Other: "OTHER"
 };
+var PickupKind = {
+  Pickup: "PICKUP",
+  Drop: "DROP"
+};
+var RoomingFillOrder = {
+  LargestRoomFirst: "LARGEST_ROOM_FIRST",
+  Sequential: "SEQUENTIAL",
+  Balanced: "BALANCED"
+};
+var RoomingGenderPolicy = {
+  StrictSeparate: "STRICT_SEPARATE",
+  GroupMixedOk: "GROUP_MIXED_OK",
+  Off: "OFF"
+};
+var RoomingHeuristicKey = {
+  MedicalFirst: "medicalFirst",
+  Couples: "couples",
+  Parties: "parties",
+  Gender: "gender",
+  Diet: "diet",
+  SpreadSolos: "spreadSolos",
+  PartyGenderPolicy: "partyGenderPolicy",
+  SameBus: "sameBus"
+};
+var RoomType = {
+  Single: "SINGLE",
+  Twin: "TWIN",
+  Shared: "SHARED",
+  Dorm: "DORM"
+};
+var SeatingFillOrder = {
+  Balanced: "BALANCED",
+  FillFirst: "FILL_FIRST",
+  ByStop: "BY_STOP"
+};
+var SeatingGenderAdjacency = {
+  Off: "OFF",
+  AvoidUnrelated: "AVOID_UNRELATED",
+  StrictRows: "STRICT_ROWS"
+};
+var SeatingHeuristicKey = {
+  MedicalFirst: "medicalFirst",
+  Parties: "parties",
+  SameStop: "sameStop",
+  Gender: "gender",
+  BalanceVehicles: "balanceVehicles"
+};
+var SyncOpMethod = {
+  Post: "POST",
+  Patch: "PATCH",
+  Put: "PUT",
+  Delete: "DELETE"
+};
 var TriggerAnchor = {
   Start: "START",
   End: "END"
@@ -1753,6 +4604,19 @@ var TripStatus = {
   Postponed: "POSTPONED",
   Cancelled: "CANCELLED"
 };
+var VehicleLayout = {
+  TwoTwo: "TWO_TWO",
+  TwoOne: "TWO_ONE",
+  Flat: "FLAT"
+};
+var VehicleType = {
+  Bus: "BUS",
+  TempoTraveller: "TEMPO_TRAVELLER",
+  Car: "CAR",
+  Flight: "FLIGHT",
+  Train: "TRAIN",
+  Other: "OTHER"
+};
 
 // src/pagination/paginator.ts
 var KaafilPaginationError = class extends Error {
@@ -1776,6 +4640,200 @@ var KaafilPaginationExhaustedError = class _KaafilPaginationExhaustedError exten
   }
 };
 
+// src/rooming/vocabulary.ts
+var HEURISTIC_SEVERITY = Object.freeze({
+  medicalFirst: "warn",
+  couples: "warn",
+  parties: "split",
+  gender: "never",
+  diet: "info",
+  spreadSolos: "info",
+  partyGenderPolicy: "info",
+  sameBus: "info"
+});
+function isRoomingHeuristicKey(rule) {
+  return Object.hasOwn(HEURISTIC_SEVERITY, rule);
+}
+function roomingHeuristicSeverity(rule) {
+  return isRoomingHeuristicKey(rule) ? HEURISTIC_SEVERITY[rule] : void 0;
+}
+var TONE_FAMILIES = Object.freeze({
+  [Gender.Male]: "male",
+  [Gender.Female]: "female",
+  [Gender.Other]: "other",
+  [Gender.Unknown]: "unknown"
+});
+var UNKNOWN_TONE_FAMILY = TONE_FAMILIES[Gender.Unknown];
+var SHADES_PER_FAMILY = 8;
+var FALLBACK_GLYPH = "?";
+function parseRoomingTone(tone) {
+  const separator = tone.lastIndexOf(".");
+  if (separator <= 0 || separator === tone.length - 1) {
+    return void 0;
+  }
+  const family = tone.slice(0, separator);
+  const rawShade = tone.slice(separator + 1);
+  const shade = Number(rawShade);
+  if (!Number.isInteger(shade) || shade < 0) {
+    return void 0;
+  }
+  return { family, shade };
+}
+
+// src/storage/adapter.ts
+function createInMemoryStorageAdapter() {
+  const store = /* @__PURE__ */ new Map();
+  return {
+    async get(key) {
+      return store.get(key);
+    },
+    async set(key, value) {
+      store.set(key, value);
+    },
+    async remove(key) {
+      store.delete(key);
+    },
+    async clear() {
+      store.clear();
+    }
+  };
+}
+
+// src/storage/indexeddb.ts
+var STORE_NAME = "kv";
+var DEFAULT_DATABASE_PREFIX = "kaafil-js";
+var SCHEMA_VERSION = 1;
+var KaafilIndexedDbUnavailableError = class _KaafilIndexedDbUnavailableError extends Error {
+  reason;
+  constructor(reason, detail) {
+    super(
+      `IndexedDB is not usable in this runtime (${reason})${detail !== void 0 ? `: ${detail}` : ""}. No durable offline store was created. Supply your own KaafilStorageAdapter, or use createInMemoryStorageAdapter() and treat queued writes as process-lifetime only.`
+    );
+    this.name = "KaafilIndexedDbUnavailableError";
+    Object.setPrototypeOf(this, _KaafilIndexedDbUnavailableError.prototype);
+    this.reason = reason;
+  }
+};
+function promisifyRequest(request) {
+  return new Promise((resolve, reject) => {
+    request.onsuccess = () => {
+      resolve(request.result);
+    };
+    request.onerror = () => {
+      reject(request.error ?? new Error("IndexedDB request failed with no error attached"));
+    };
+  });
+}
+async function openDatabase(factory, databaseName) {
+  return new Promise((resolve, reject) => {
+    let request;
+    try {
+      request = factory.open(databaseName, SCHEMA_VERSION);
+    } catch (error) {
+      reject(
+        new KaafilIndexedDbUnavailableError(
+          "open-failed",
+          error instanceof Error ? error.message : String(error)
+        )
+      );
+      return;
+    }
+    request.onupgradeneeded = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.createObjectStore(STORE_NAME);
+      }
+    };
+    request.onsuccess = () => {
+      const db = request.result;
+      if (!db.objectStoreNames.contains(STORE_NAME)) {
+        db.close();
+        reject(new KaafilIndexedDbUnavailableError("open-failed", "object store missing"));
+        return;
+      }
+      resolve(db);
+    };
+    request.onerror = () => {
+      reject(
+        new KaafilIndexedDbUnavailableError(
+          "open-failed",
+          request.error?.message ?? "open request failed"
+        )
+      );
+    };
+    request.onblocked = () => {
+      reject(new KaafilIndexedDbUnavailableError("blocked"));
+    };
+  });
+}
+async function createIndexedDbStorageAdapter(options) {
+  if (typeof options.scope !== "string" || options.scope.length === 0) {
+    throw new TypeError(
+      `"scope" is required and must be a non-empty string \u2014 an unscoped offline store lets one credential's queued writes drain under another's session.`
+    );
+  }
+  const factory = options.indexedDB ?? globalThis.indexedDB;
+  if (factory === void 0 || factory === null) {
+    throw new KaafilIndexedDbUnavailableError("no-indexeddb");
+  }
+  const databaseName = `${options.databasePrefix ?? DEFAULT_DATABASE_PREFIX}:${options.scope}`;
+  const db = await openDatabase(factory, databaseName);
+  const onQuotaExceeded = options.onQuotaExceeded;
+  async function write(run) {
+    return new Promise((resolve, reject) => {
+      let tx;
+      try {
+        tx = db.transaction(STORE_NAME, "readwrite");
+      } catch (error) {
+        reject(error);
+        return;
+      }
+      tx.oncomplete = () => {
+        resolve();
+      };
+      const fail = (error) => {
+        if (error instanceof DOMException && error.name === "QuotaExceededError") {
+          onQuotaExceeded?.(error);
+        }
+        reject(error ?? new Error("IndexedDB transaction failed with no error attached"));
+      };
+      tx.onerror = () => {
+        fail(tx.error);
+      };
+      tx.onabort = () => {
+        fail(tx.error);
+      };
+      try {
+        run(tx.objectStore(STORE_NAME));
+      } catch (error) {
+        fail(error);
+      }
+    });
+  }
+  return {
+    async get(key) {
+      const tx = db.transaction(STORE_NAME, "readonly");
+      const value = await promisifyRequest(tx.objectStore(STORE_NAME).get(key));
+      return typeof value === "string" ? value : void 0;
+    },
+    async set(key, value) {
+      await write((store) => {
+        store.put(value, key);
+      });
+    },
+    async remove(key) {
+      await write((store) => {
+        store.delete(key);
+      });
+    },
+    async clear() {
+      await write((store) => {
+        store.clear();
+      });
+    }
+  };
+}
+
 // src/client-entry.ts
 function openTokenField(input) {
   switch (input.kind) {
@@ -1902,6 +4960,77 @@ var KaafilClient = class {
   get notifications() {
     return this.#requireState().notifications;
   }
+  get itinerary() {
+    return this.#requireState().itinerary;
+  }
+  get rooming() {
+    return this.#requireState().rooming;
+  }
+  get seating() {
+    return this.#requireState().seating;
+  }
+  get pickups() {
+    return this.#requireState().pickups;
+  }
+  get treks() {
+    return this.#requireState().treks;
+  }
+  get checklists() {
+    return this.#requireState().checklists;
+  }
+  get float() {
+    return this.#requireState().float;
+  }
+  get expenses() {
+    return this.#requireState().expenses;
+  }
+  get collections() {
+    return this.#requireState().collections;
+  }
+  get files() {
+    return this.#requireState().files;
+  }
+  get closeout() {
+    return this.#requireState().closeout;
+  }
+  get sync() {
+    return this.#requireState().sync;
+  }
+  /**
+   * Builds the offline layer on top of THIS open session — the durable
+   * snapshot + outbox, the FIFO drainer, the reconciler, the blob lane and
+   * the batched transport (`06-offline-first.md`).
+   *
+   * The transport is assembled here rather than by the caller, so the
+   * automatic parts stay automatic: the op's fixed idempotency key, the
+   * `If-Match` header, the single-vs-batched wire switch and the consolidated
+   * pull are all wired from the session's own `KaafilHttpClient` and `sync`
+   * resource. What the caller supplies is what only the caller can know — a
+   * durable `storage` adapter for its platform, a `scope` for this
+   * credential, optionally an entity re-reader for conflict reconciliation,
+   * and optionally a conflict resolver (with none, every `409` surfaces,
+   * which is the correct default: `06 §6` forbids auto-merging).
+   *
+   * Throws `KaafilClientNotOpenError` before a session is open — there is no
+   * offline layer without a credential to scope it to.
+   */
+  openOffline(options) {
+    const state = this.#requireState();
+    const transport = createHttpOfflineTransport({
+      http: state.http,
+      sync: state.sync,
+      ...options.readEntity !== void 0 ? { readEntity: options.readEntity } : {},
+      ...options.share !== void 0 ? { credential: "share" } : {}
+    });
+    return createOfflineEngine({
+      storage: options.storage,
+      scope: options.scope,
+      transport,
+      ...options.conflictResolver !== void 0 ? { conflictResolver: options.conflictResolver } : {},
+      ...options.blob !== void 0 ? { blob: options.blob } : {},
+      ...options.share !== void 0 ? { share: options.share } : {}
+    });
+  }
   /**
    * Total teardown. One assignment, no field to forget — see
    * `KaafilClientState` above. Safe to call whether or not a session is
@@ -1970,7 +5099,19 @@ var KaafilClient = class {
       vendors: createVendorsResource(http),
       journey: createJourneyResource(http),
       share: createShareResource(http),
-      notifications: createNotificationsResource(http)
+      notifications: createNotificationsResource(http),
+      itinerary: createItineraryResource(http),
+      rooming: createRoomingResource(http),
+      seating: createSeatingResource(http),
+      pickups: createPickupsResource(http),
+      treks: createTreksResource(http),
+      checklists: createChecklistsResource(http),
+      float: createFloatResource(http),
+      expenses: createExpensesResource(http),
+      collections: createCollectionsResource(http),
+      files: createFilesResource(http),
+      closeout: createCloseoutResource(http),
+      sync: createSyncResource(http)
     };
   }
   #requireState() {
@@ -1981,20 +5122,44 @@ var KaafilClient = class {
   }
 };
 
+exports.ACTIVE_TREK_REF = ACTIVE_TREK_REF;
+exports.BATCH_THRESHOLD_OPS = BATCH_THRESHOLD_OPS;
+exports.BlobStatus = BlobStatus;
+exports.BoardStatus = BoardStatus;
 exports.BookingStatus = BookingStatus;
+exports.CONSOLIDATED_PULL_THRESHOLD_LISTS = CONSOLIDATED_PULL_THRESHOLD_LISTS;
+exports.ChecklistAudience = ChecklistAudience;
+exports.ChecklistGate = ChecklistGate;
+exports.ChecklistItemStatus = ChecklistItemStatus;
+exports.ChecklistPhase = ChecklistPhase;
+exports.ChecklistPullTemplateMode = ChecklistPullTemplateMode;
 exports.ClaimStatusIngest = ClaimStatusIngest;
+exports.CloseoutPackSection = CloseoutPackSection;
+exports.CollectionMode = CollectionMode;
+exports.Currency = Currency;
 exports.ERROR_CODE_TABLE = ERROR_CODE_TABLE;
 exports.EventType = EventType;
+exports.ExpenseCategory = ExpenseCategory;
+exports.ExpensePaymentMode = ExpensePaymentMode;
+exports.FALLBACK_GLYPH = FALLBACK_GLYPH;
+exports.FileContentType = FileContentType;
+exports.FilePurpose = FilePurpose;
+exports.FloatDirection = FloatDirection;
 exports.Gender = Gender;
+exports.HEURISTIC_SEVERITY = HEURISTIC_SEVERITY;
+exports.ItineraryItemStatusUpdate = ItineraryItemStatusUpdate;
+exports.ItineraryItemType = ItineraryItemType;
 exports.KaafilAbortError = KaafilAbortError;
 exports.KaafilApiError = KaafilApiError;
 exports.KaafilCapabilityUnavailableError = KaafilCapabilityUnavailableError;
 exports.KaafilClient = KaafilClient;
 exports.KaafilClientAlreadyOpenError = KaafilClientAlreadyOpenError;
 exports.KaafilClientNotOpenError = KaafilClientNotOpenError;
+exports.KaafilDeltaCursorInFlightError = KaafilDeltaCursorInFlightError;
 exports.KaafilEntitlementError = KaafilEntitlementError;
 exports.KaafilError = KaafilError;
 exports.KaafilErrorCode = KaafilErrorCode;
+exports.KaafilIndexedDbUnavailableError = KaafilIndexedDbUnavailableError;
 exports.KaafilInvalidRequestError = KaafilInvalidRequestError;
 exports.KaafilLockedError = KaafilLockedError;
 exports.KaafilNetworkError = KaafilNetworkError;
@@ -2005,6 +5170,8 @@ exports.KaafilPaginationExhaustedError = KaafilPaginationExhaustedError;
 exports.KaafilPaginationInFlightError = KaafilPaginationInFlightError;
 exports.KaafilRateLimitedError = KaafilRateLimitedError;
 exports.KaafilReadOnlyRoleError = KaafilReadOnlyRoleError;
+exports.KaafilShareBatchUnauthenticatedError = KaafilShareBatchUnauthenticatedError;
+exports.KaafilShareLinkExpiredError = KaafilShareLinkExpiredError;
 exports.KaafilShareTokenExpiredError = KaafilShareTokenExpiredError;
 exports.KaafilShareTokenRevokedError = KaafilShareTokenRevokedError;
 exports.KaafilTimeoutError = KaafilTimeoutError;
@@ -2012,16 +5179,57 @@ exports.KaafilTransportError = KaafilTransportError;
 exports.KaafilUnauthenticatedError = KaafilUnauthenticatedError;
 exports.KaafilValidationError = KaafilValidationError;
 exports.KaafilVersionConflictError = KaafilVersionConflictError;
+exports.MAX_BATCH_OPS = MAX_BATCH_OPS;
 exports.ManagerRole = ManagerRole;
 exports.ManifestMode = ManifestMode;
 exports.OutboxClass = OutboxClass;
+exports.OutboxStatus = OutboxStatus;
 exports.PartyKind = PartyKind;
+exports.PickupKind = PickupKind;
 exports.Retryability = Retryability;
+exports.RoomType = RoomType;
+exports.RoomingFillOrder = RoomingFillOrder;
+exports.RoomingGenderPolicy = RoomingGenderPolicy;
+exports.RoomingHeuristicKey = RoomingHeuristicKey;
+exports.SHADES_PER_FAMILY = SHADES_PER_FAMILY;
+exports.SHARE_WRITE_GRACE_MS = SHARE_WRITE_GRACE_MS;
+exports.SYNC_PULL_SECTIONS = SYNC_PULL_SECTIONS;
+exports.SeatingFillOrder = SeatingFillOrder;
+exports.SeatingGenderAdjacency = SeatingGenderAdjacency;
+exports.SeatingHeuristicKey = SeatingHeuristicKey;
+exports.SyncOpMethod = SyncOpMethod;
+exports.TONE_FAMILIES = TONE_FAMILIES;
 exports.TriggerAnchor = TriggerAnchor;
 exports.TripMode = TripMode;
 exports.TripStatus = TripStatus;
+exports.UNKNOWN_TONE_FAMILY = UNKNOWN_TONE_FAMILY;
 exports.UnsatisfiableSchemeError = UnsatisfiableSchemeError;
+exports.VehicleLayout = VehicleLayout;
+exports.VehicleType = VehicleType;
+exports.createBlobLane = createBlobLane;
+exports.createDeltaCursor = createDeltaCursor;
+exports.createDrainer = createDrainer;
+exports.createHttpOfflineTransport = createHttpOfflineTransport;
+exports.createInMemoryStorageAdapter = createInMemoryStorageAdapter;
+exports.createIndexedDbStorageAdapter = createIndexedDbStorageAdapter;
+exports.createOfflineEngine = createOfflineEngine;
+exports.createOfflineEvents = createOfflineEvents;
+exports.createOutbox = createOutbox;
+exports.createPullCoordinator = createPullCoordinator;
+exports.createShareGuard = createShareGuard;
+exports.createSnapshotStore = createSnapshotStore;
+exports.createSyncResource = createSyncResource;
+exports.extractSectionRows = extractSectionRows;
 exports.isKaafilError = isKaafilError;
 exports.isRetryable = isRetryable;
+exports.isRoomingHeuristicKey = isRoomingHeuristicKey;
+exports.isShareBatchPushAvailable = isShareBatchPushAvailable;
+exports.isTombstone = isTombstone;
+exports.mergeDeltaRows = mergeDeltaRows;
+exports.parseRoomingTone = parseRoomingTone;
+exports.readCurrentVersion = readCurrentVersion;
+exports.reconcileConflict = reconcileConflict;
+exports.roomingHeuristicSeverity = roomingHeuristicSeverity;
+exports.shouldUseBatchTransport = shouldUseBatchTransport;
 //# sourceMappingURL=client-entry.cjs.map
 //# sourceMappingURL=client-entry.cjs.map