@stamprally/core 0.16.0 → 0.18.0

package/dist/index.js

@@ -108,72 +108,20 @@ function issueClaimTicketNumber(reward2, currentState, options = {}) {
 }
 
 // src/engine/sync.ts
-function latestTimestamp(serverTimestamp, localTimestamp) {
-  const serverTime = Date.parse(serverTimestamp);
-  const localTime = Date.parse(localTimestamp);
-  if (!Number.isNaN(serverTime) && !Number.isNaN(localTime))
-    return serverTime >= localTime ? serverTimestamp : localTimestamp;
-  if (!Number.isNaN(serverTime)) return serverTimestamp;
-  if (!Number.isNaN(localTime)) return localTimestamp;
-  return serverTimestamp >= localTimestamp ? serverTimestamp : localTimestamp;
-}
-function mergeRewardStates(serverRewards, localRewards) {
-  const merged = new Map(serverRewards.map((reward2) => [reward2.rewardId, reward2]));
-  for (const localReward of localRewards) {
-    const serverReward = merged.get(localReward.rewardId);
-    if (serverReward === void 0) {
-      merged.set(localReward.rewardId, localReward);
-      continue;
-    }
-    const winner = localReward.status === "CONSUMED" && serverReward.status !== "CONSUMED" ? localReward : serverReward;
-    merged.set(localReward.rewardId, {
-      ...winner,
-      ...serverReward.unlockedAt === void 0 && localReward.unlockedAt === void 0 ? {} : {
-        unlockedAt: serverReward.unlockedAt === void 0 ? localReward.unlockedAt : localReward.unlockedAt === void 0 ? serverReward.unlockedAt : latestTimestamp(serverReward.unlockedAt, localReward.unlockedAt)
-      },
-      ...serverReward.consumedAt === void 0 && localReward.consumedAt === void 0 ? {} : {
-        consumedAt: serverReward.consumedAt === void 0 ? localReward.consumedAt : localReward.consumedAt === void 0 ? serverReward.consumedAt : latestTimestamp(serverReward.consumedAt, localReward.consumedAt)
-      },
-      ...serverReward.redeemedCount === void 0 && localReward.redeemedCount === void 0 ? {} : {
-        redeemedCount: Math.max(
-          serverReward.redeemedCount ?? 0,
-          localReward.redeemedCount ?? 0
-        )
-      },
-      ...serverReward.userRedemptionCount === void 0 && localReward.userRedemptionCount === void 0 ? {} : {
-        userRedemptionCount: Math.max(
-          serverReward.userRedemptionCount ?? 0,
-          localReward.userRedemptionCount ?? 0
-        )
-      }
-    });
-  }
-  return [...merged.values()];
-}
-function mergeStampRecords(serverRecords, localRecords) {
-  const merged = /* @__PURE__ */ new Map();
-  for (const record of [...serverRecords, ...localRecords]) {
-    const current = merged.get(record.stampId);
-    if (current === void 0) {
-      merged.set(record.stampId, record);
-      continue;
-    }
-    const acquiredAt = latestTimestamp(current.acquiredAt, record.acquiredAt);
-    merged.set(record.stampId, {
-      ...current,
-      ...acquiredAt === current.acquiredAt ? {} : { acquiredAt },
-      ...current.metadata === void 0 && record.metadata !== void 0 ? { metadata: record.metadata } : {}
-    });
-  }
-  return [...merged.values()];
-}
-function resolveRallyStateConflict(serverState, localState, options = { policy: "merge" }) {
-  if (options.policy === "server_wins") return serverState;
+function resolveRallyStateConflict(serverState, _localState) {
   return {
     ...serverState,
-    records: mergeStampRecords(serverState.records, localState.records),
-    rewards: mergeRewardStates(serverState.rewards, localState.rewards),
-    updatedAt: latestTimestamp(serverState.updatedAt, localState.updatedAt)
+    records: serverState.records.map((record) => ({
+      ...record,
+      ...record.metadata === void 0 ? {} : { metadata: { ...record.metadata } }
+    })),
+    rewards: serverState.rewards.map((reward2) => ({ ...reward2 })),
+    ...serverState.inventory === void 0 ? {} : {
+      inventory: {
+        ...serverState.inventory,
+        ...serverState.inventory.rewardRemaining === void 0 ? {} : { rewardRemaining: { ...serverState.inventory.rewardRemaining } }
+      }
+    }
   };
 }
 
@@ -1056,1079 +1004,1390 @@ var IndexedDBAdapter = class {
   }
 };
 
-// src/client/client.ts
-function isStorage(value) {
-  return "load" in value && "save" in value && "remove" in value;
-}
-function id(prefix) {
-  return `${prefix}-${globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`}`;
-}
-function proof(value) {
-  if (typeof value === "string") return value;
-  if (typeof value === "object" && value !== null) {
-    const item = value;
-    for (const key of ["token", "code", "passcode", "value", "tagId"])
-      if (typeof item[key] === "string") return item[key];
-  }
-  return "";
-}
-function matches(condition2, value) {
-  if (condition2.type === "gps") {
-    if (typeof value !== "object" || value === null) return false;
-    const item = value;
-    const latitude = item.latitude;
-    const longitude = item.longitude;
-    if (typeof latitude !== "number" || typeof longitude !== "number") return false;
-    const radians = (v) => v * Math.PI / 180;
-    const dLat = radians(latitude - condition2.latitude);
-    const dLon = radians(longitude - condition2.longitude);
-    const h = Math.sin(dLat / 2) ** 2 + Math.cos(radians(condition2.latitude)) * Math.cos(radians(latitude)) * Math.sin(dLon / 2) ** 2;
-    return 6371e3 * 2 * Math.asin(Math.sqrt(Math.min(1, h))) <= condition2.radiusMeters;
+// src/client/offlineQueue.ts
+function rollbackOptimisticOperation(state, operation) {
+  const previous = operation.request.state;
+  if (operation.kind === "checkIn") {
+    const records = state.records.filter(
+      (record) => record.stampId !== operation.request.spotId || record.acquiredAt !== operation.request.now
+    );
+    const previousRewards = new Map(previous.rewards.map((reward2) => [reward2.rewardId, reward2]));
+    const rewards2 = state.rewards.map((reward2) => previousRewards.get(reward2.rewardId) ?? reward2);
+    return { ...cloneState(state), records, rewards: rewards2, updatedAt: previous.updatedAt };
   }
-  return proof(value).trim() !== "";
-}
-function emptyState(config, userId, now) {
-  return {
-    rallyId: config.id,
-    userId,
-    records: [],
-    rewards: reconcileRewardStates(config.rewards, [], 0, now),
-    updatedAt: now
+  const previousReward = previous.rewards.find(
+    (reward2) => reward2.rewardId === operation.request.rewardId
+  );
+  const rewards = state.rewards.filter(
+    (reward2) => reward2.rewardId !== operation.request.rewardId || previousReward !== void 0
+  ).map(
+    (reward2) => reward2.rewardId === operation.request.rewardId && previousReward !== void 0 ? { ...previousReward } : reward2
+  );
+  const cloned = cloneState(state);
+  const { inventory: _inventory, ...stateWithoutInventory } = cloned;
+  const previousInventory = previous.inventory;
+  return previousInventory === void 0 ? { ...stateWithoutInventory, rewards, updatedAt: previous.updatedAt } : {
+    ...stateWithoutInventory,
+    rewards,
+    inventory: {
+      ...previousInventory,
+      ...previousInventory.rewardRemaining === void 0 ? {} : { rewardRemaining: { ...previousInventory.rewardRemaining } }
+    },
+    updatedAt: previous.updatedAt
   };
 }
-var StampRallyClient = class {
-  #listeners = /* @__PURE__ */ new Set();
-  #eventListeners = /* @__PURE__ */ new Set();
-  #storage;
-  #options;
-  #config;
-  #offlineQueue;
-  #userId;
-  #anonymousSessionId;
-  #state = null;
-  #initialization = null;
-  #queue = Promise.resolve();
-  constructor(config, storageOrOptions = {}) {
-    this.#config = config;
-    this.#options = isStorage(storageOrOptions) ? { storage: storageOrOptions } : storageOrOptions;
-    this.#storage = this.#options.storage ?? new InMemoryStorage();
-    this.#anonymousSessionId = this.#options.anonymousSessionId ?? createAnonymousSessionId();
-    this.#userId = this.#options.userId ?? this.#anonymousSessionId;
-    this.#offlineQueue = this.#options.offlineQueue;
-    this.#offlineQueue?.setSyncResultListener((event) => this.#handleOfflineSyncResult(event));
-  }
-  getConfig() {
-    return this.#config;
-  }
-  getState() {
-    return this.#state;
-  }
-  getUserId() {
-    return this.#userId;
+var MemoryQueueStorage = class {
+  #values = /* @__PURE__ */ new Map();
+  #rejected = /* @__PURE__ */ new Map();
+  async load(key) {
+    return this.#values.get(key) ?? [];
   }
-  getAnonymousSessionId() {
-    return this.#anonymousSessionId;
+  async save(key, operations) {
+    this.#values.set(key, structuredClone(operations));
   }
-  get syncState() {
-    return this.#offlineQueue?.syncState ?? "idle";
+  async loadRejectedHistory(key) {
+    return this.#rejected.get(key) ?? [];
   }
-  get pendingCount() {
-    return this.#offlineQueue?.pendingCount ?? 0;
+  async saveRejectedHistory(key, history) {
+    this.#rejected.set(key, structuredClone(history));
   }
-  get rejectedHistory() {
-    return this.#offlineQueue?.rejectedHistory ?? [];
+};
+var LocalStorageQueueStorage = class {
+  constructor(storage) {
+    this.storage = storage;
   }
-  get queueCapability() {
-    return this.#offlineQueue?.queueCapability ?? "custom";
+  storage;
+  async load(key) {
+    const value = this.storage.getItem(key);
+    if (value === null) return [];
+    try {
+      const parsed = JSON.parse(value);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
   }
-  discardRejected(operationId) {
-    return this.#offlineQueue?.discardRejected(operationId) ?? Promise.resolve(false);
+  async save(key, operations) {
+    this.storage.setItem(key, JSON.stringify(operations));
   }
-  retryRejected(operationId) {
-    return this.#offlineQueue?.retryRejected(operationId) ?? Promise.resolve(false);
+  async loadRejectedHistory(key) {
+    const value = this.storage.getItem(`${key}:rejected-history`);
+    if (value === null) return [];
+    try {
+      const parsed = JSON.parse(value);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
   }
-  subscribe(listener) {
-    this.#listeners.add(listener);
-    return () => this.#listeners.delete(listener);
+  async saveRejectedHistory(key, history) {
+    this.storage.setItem(`${key}:rejected-history`, JSON.stringify(history));
   }
-  subscribeEvents(listener) {
-    this.#eventListeners.add(listener);
-    return () => this.#eventListeners.delete(listener);
+};
+var IndexedDBOfflineQueueStorage = class {
+  #providedFactory;
+  #databaseName;
+  #databasePromise = null;
+  constructor(options = {}) {
+    this.#providedFactory = options.indexedDB;
+    this.#databaseName = options.databaseName ?? "stamprally-offline-queue";
   }
-  init() {
-    return this.initialize();
+  async load(key) {
+    const database = await this.#open();
+    return new Promise((resolve, reject) => {
+      const request = database.transaction("operations", "readonly").objectStore("operations").get(key);
+      request.onsuccess = () => resolve(Array.isArray(request.result) ? request.result : []);
+      request.onerror = () => reject(request.error ?? new Error("Failed to read offline queue."));
+    });
   }
-  initialize() {
-    if (this.#state !== null) return Promise.resolve(this.#state);
-    if (this.#initialization === null) {
-      this.#initialization = (async () => {
-        await this.#offlineQueue?.setScope(this.#config.id, this.#userId);
-        return this.#storage.load(this.#config.id, this.#userId);
-      })().then((state) => {
-        const next = state === null ? emptyState(this.#config, this.#userId, this.#now()) : this.#reconcile(state);
-        this.#state = next;
-        this.#emit(next);
-        return next;
-      }).catch((error) => {
-        this.#initialization = null;
-        throw error;
-      });
-    }
-    return this.#initialization;
+  async save(key, operations) {
+    const database = await this.#open();
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction("operations", "readwrite");
+      transaction.objectStore("operations").put(structuredClone(operations), key);
+      transaction.oncomplete = () => resolve();
+      transaction.onerror = () => reject(transaction.error ?? new Error("Failed to save offline queue."));
+      transaction.onabort = () => reject(transaction.error ?? new Error("Offline queue write aborted."));
+    });
   }
-  switchUser(newUserId) {
-    return this.#enqueue(async () => {
-      const nextUserId = newUserId ?? this.#anonymousSessionId;
-      if (this.#userId === nextUserId && this.#state !== null) return this.#state;
-      this.#userId = nextUserId;
-      this.#state = null;
-      this.#initialization = null;
-      await this.#offlineQueue?.switchUser(nextUserId);
-      return this.initialize();
+  async loadRejectedHistory(key) {
+    const database = await this.#open();
+    return new Promise((resolve, reject) => {
+      const request = database.transaction("operations", "readonly").objectStore("operations").get(`${key}:rejected-history`);
+      request.onsuccess = () => resolve(
+        Array.isArray(request.result) ? request.result : []
+      );
+      request.onerror = () => reject(request.error ?? new Error("Failed to read rejected operation history."));
     });
   }
-  async getUserState(rallyId, userId) {
-    return this.#storage.load(rallyId, userId);
+  async saveRejectedHistory(key, history) {
+    const database = await this.#open();
+    return new Promise((resolve, reject) => {
+      const transaction = database.transaction("operations", "readwrite");
+      transaction.objectStore("operations").put(structuredClone(history), `${key}:rejected-history`);
+      transaction.oncomplete = () => resolve();
+      transaction.onerror = () => reject(transaction.error ?? new Error("Failed to save rejected operation history."));
+      transaction.onabort = () => reject(transaction.error ?? new Error("Rejected operation history write aborted."));
+    });
   }
-  clearUserState(userId = this.#userId) {
-    return this.#enqueue(async () => {
-      await this.#storage.remove(this.#config.id, userId);
-      if (userId === this.#userId) {
-        await this.#initializeFresh();
-      }
+  #open() {
+    if (this.#databasePromise !== null) return this.#databasePromise;
+    let factory = this.#providedFactory;
+    if (factory === void 0)
+      factory = globalThis.indexedDB;
+    if (factory === void 0 || factory === null)
+      return Promise.reject(new Error("IndexedDB is unavailable in this environment."));
+    this.#databasePromise = new Promise((resolve, reject) => {
+      const request = factory.open(this.#databaseName, 1);
+      request.onupgradeneeded = () => {
+        if (!request.result.objectStoreNames.contains("operations"))
+          request.result.createObjectStore("operations");
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => reject(request.error ?? new Error("Failed to open offline queue."));
+    }).catch((error) => {
+      this.#databasePromise = null;
+      throw error;
     });
+    return this.#databasePromise;
   }
-  checkIn(spotId, proofData, options = {}) {
-    return this.#enqueue(async () => {
-      const current = await this.initialize();
-      const spot2 = this.#config.spots.find((item) => item.id === spotId);
-      if (spot2 === void 0)
-        return this.#fail({ code: "SPOT_NOT_FOUND", spotId, message: "Spot was not found." });
-      if (current.records.some((record2) => record2.stampId === spotId))
-        return this.#fail({
-          code: "STAMP_ALREADY_ACQUIRED",
-          spotId,
-          message: "Spot was already claimed."
-        });
-      const acquired = new Set(current.records.map((record2) => record2.stampId));
-      if (spot2.prerequisites?.some((id2) => !acquired.has(id2)))
-        return this.#fail({
-          code: "PREREQUISITES_NOT_MET",
-          spotId,
-          message: "Prerequisite spots are not complete."
-        });
-      for (const condition2 of spot2.conditions) {
-        if (condition2.type === "custom") {
-          const validator = this.#options.customValidators?.[condition2.validatorName] ?? this.#options.customValidator;
-          if (validator === void 0)
-            return this.#fail({
-              code: "CUSTOM_VALIDATION_FAILED",
-              spotId,
-              message: "No custom validator is registered."
-            });
-          const context = {
-            rallyId: this.#config.id,
-            spotId,
-            proofData,
-            condition: { type: "custom", validatorName: condition2.validatorName },
-            userState: current
-          };
-          const result = typeof validator === "function" ? await validator(context) : await validator.validate(context);
-          if (result === false || typeof result === "object" && !result.valid)
-            return this.#fail({
-              code: "CUSTOM_VALIDATION_FAILED",
-              spotId,
-              message: typeof result === "object" && result.message !== void 0 ? result.message : "Custom validation failed."
-            });
-        } else if (!matches(condition2, proofData))
-          return this.#fail({ code: "INVALID_PROOF", spotId, message: "Verification failed." });
-      }
-      const now = options.now ?? this.#now();
-      const request = {
-        rallyId: this.#config.id,
-        userId: this.#userId,
-        spotId,
-        proofData,
-        idempotencyKey: options.idempotencyKey ?? id("check-in"),
-        now,
-        state: current,
-        ...this.#userId === this.#anonymousSessionId ? { anonymousSessionId: this.#anonymousSessionId } : {}
-      };
-      const remote = this.#options.syncAdapter?.checkIn;
-      if (options.sync !== false && remote !== void 0) {
-        try {
-          const result = await remote(request);
-          return result.ok ? this.#commitCheckIn(result) : this.#fail(result.error);
-        } catch (error) {
-          if (this.#offlineQueue === void 0) throw error;
-          await this.#offlineQueue.enqueueCheckIn(request);
-          const record2 = { stampId: spotId, acquiredAt: now };
-          const next2 = this.#reconcile({
-            ...current,
-            records: [...current.records, record2],
-            updatedAt: now
-          });
-          await this.#storage.save(next2);
-          return this.#commitCheckIn({ ok: true, value: { state: next2, record: record2 } });
-        }
-      }
-      const record = { stampId: spotId, acquiredAt: now };
-      const next = this.#reconcile({
-        ...current,
-        records: [...current.records, record],
-        updatedAt: now
-      });
-      await this.#storage.save(next);
-      return this.#commitCheckIn({ ok: true, value: { state: next, record } });
-    });
+};
+function availableLocalStorage() {
+  try {
+    const storage = globalThis.localStorage;
+    return storage ?? null;
+  } catch {
+    return null;
   }
-  claimReward(rewardId, options = {}) {
-    return this.#enqueue(async () => {
-      const current = await this.initialize();
-      const configured = this.#config.rewards.find((item) => item.id === rewardId);
-      if (configured === void 0)
-        return this.#fail({ code: "REWARD_NOT_FOUND", rewardId, message: "Reward was not found." });
-      const now = options.now ?? this.#now();
-      const state = current.rewards.find((item) => item.rewardId === rewardId) ?? {
-        rewardId,
-        status: "LOCKED"
-      };
-      const local = consumeReward({
-        reward: configured,
-        currentState: state,
-        now,
-        ...options.staffPasscode === void 0 ? {} : { inputPasscode: options.staffPasscode },
-        ...options.staffId === void 0 ? {} : { staffId: options.staffId }
-      });
-      if (!local.ok) return this.#fail(local.error);
-      const request = {
-        rallyId: this.#config.id,
-        userId: this.#userId,
-        rewardId,
-        idempotencyKey: options.idempotencyKey ?? id("claim"),
-        now,
-        options,
-        state: current,
-        ...this.#userId === this.#anonymousSessionId ? { anonymousSessionId: this.#anonymousSessionId } : {}
-      };
-      const remote = this.#options.syncAdapter?.claimReward;
-      if (options.sync !== false && remote !== void 0) {
-        try {
-          const result = await remote(request);
-          return result.ok ? this.#commitClaim(result) : this.#fail(result.error);
-        } catch (error) {
-          if (this.#offlineQueue === void 0) throw error;
-          await this.#offlineQueue.enqueueClaimReward(request);
-          const next2 = {
-            ...current,
-            rewards: current.rewards.map(
-              (item) => item.rewardId === rewardId ? local.value : item
-            ),
-            updatedAt: now
-          };
-          await this.#storage.save(next2);
-          return this.#commitClaim({ ok: true, value: { state: next2, reward: local.value } });
-        }
-      }
-      const next = {
-        ...current,
-        rewards: current.rewards.map((item) => item.rewardId === rewardId ? local.value : item),
-        updatedAt: now
+}
+function defaultStorage(databaseName) {
+  try {
+    const indexedDB = globalThis.indexedDB;
+    if (indexedDB !== void 0)
+      return {
+        storage: new IndexedDBOfflineQueueStorage({
+          indexedDB,
+          ...databaseName === void 0 ? {} : { databaseName }
+        }),
+        capability: "indexeddb"
       };
-      await this.#storage.save(next);
-      return this.#commitClaim({ ok: true, value: { state: next, reward: local.value } });
-    });
+    const storage = availableLocalStorage();
+    if (storage !== void 0 && storage !== null)
+      return { storage: new LocalStorageQueueStorage(storage), capability: "localstorage" };
+  } catch {
   }
-  sync(adapter = this.#options.syncAdapter) {
-    return this.#enqueue(async () => {
-      const current = await this.initialize();
-      if (this.#offlineQueue !== void 0 && adapter !== void 0) {
-        await this.#offlineQueue.sync(async (operation) => {
-          if (operation.kind === "checkIn") {
-            if (adapter.checkIn === void 0)
-              throw new Error("No check-in sync adapter is configured.");
-            return adapter.checkIn(operation.request);
-          }
-          if (adapter.claimReward === void 0)
-            throw new Error("No reward sync adapter is configured.");
-          return adapter.claimReward(operation.request);
-        });
-      }
-      if (adapter?.sync === void 0) {
-        this.#emitEvent({ type: "sync", state: this.#state ?? current });
-        return;
-      }
-      const serverState = await adapter.sync({
-        rallyId: this.#config.id,
-        userId: this.#userId,
-        state: this.#state ?? current,
-        ...this.#userId === this.#anonymousSessionId ? { anonymousSessionId: this.#anonymousSessionId } : {}
-      });
-      const next = this.#reconcile(serverState);
-      await this.#storage.save(next);
-      this.#state = next;
-      this.#emit(next);
-      this.#emitEvent({ type: "sync", state: next });
-    });
+  return { storage: new MemoryQueueStorage(), capability: "memory" };
+}
+function offlineOperationId(operation) {
+  const identity = operation.request.userId ?? operation.request.anonymousSessionId ?? "anonymous";
+  return operation.kind === "checkIn" ? `checkIn:${operation.request.rallyId}:${identity}:${operation.request.idempotencyKey}` : `claimReward:${operation.request.rallyId}:${identity}:${operation.request.idempotencyKey}`;
+}
+function requestScope(operation) {
+  return {
+    rallyId: operation.request.rallyId,
+    userId: operation.request.userId
+  };
+}
+function errorValue(value, fallbackCode) {
+  if (typeof value === "object" && value !== null) {
+    const candidate = value;
+    if (typeof candidate.code === "string" && typeof candidate.message === "string")
+      return { ...candidate, code: candidate.code, message: candidate.message };
   }
-  retrySync() {
-    return this.sync();
+  if (value instanceof Error) return { code: fallbackCode, message: value.message };
+  if (typeof value === "string") return { code: fallbackCode, message: value };
+  return { code: fallbackCode, message: "Offline operation was rejected." };
+}
+var syncLocks = /* @__PURE__ */ new Map();
+var SYNC_LOCK_TTL_MS = 3e4;
+var DEFAULT_RETRY_OPTIONS = {
+  maxRetries: 0,
+  initialIntervalMs: 250,
+  backoffMultiplier: 2
+};
+function randomId() {
+  return globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
+var OfflineQueue = class {
+  #storage;
+  #queueCapability;
+  #configuredKey;
+  #rallyId;
+  #userId;
+  #operations = [];
+  #rejectedHistory = [];
+  #loaded = false;
+  #state = "idle";
+  #error = null;
+  #sender;
+  #syncPromise = null;
+  #syncResultListener;
+  #changeListener;
+  #synchronizeInstances;
+  #retryOptions;
+  #instanceId = randomId();
+  #lockStorage;
+  #observedLocks = /* @__PURE__ */ new Map();
+  #warnedMemoryLock = false;
+  #capabilityWarningListener;
+  #replayConfig;
+  #storageListener;
+  #channel = null;
+  constructor(options = {}) {
+    if (options.storage !== void 0) {
+      this.#storage = options.storage;
+      this.#queueCapability = "custom";
+    } else if (options.storageLike !== void 0 && options.storageLike !== null) {
+      this.#storage = new LocalStorageQueueStorage(options.storageLike);
+      this.#queueCapability = "localstorage";
+    } else {
+      const selected = defaultStorage(options.databaseName);
+      this.#storage = selected.storage;
+      this.#queueCapability = selected.capability;
+    }
+    this.#configuredKey = options.key;
+    this.#rallyId = options.rallyId;
+    this.#userId = options.userId ?? null;
+    this.#synchronizeInstances = options.synchronizeInstances ?? true;
+    const retryOptions = {
+      ...DEFAULT_RETRY_OPTIONS,
+      ...options.retryOptions ?? options.syncRetryOptions ?? options.retry ?? {}
+    };
+    this.#retryOptions = {
+      maxRetries: Math.max(0, Math.floor(retryOptions.maxRetries)),
+      initialIntervalMs: Math.max(0, retryOptions.initialIntervalMs),
+      backoffMultiplier: Math.max(1, retryOptions.backoffMultiplier)
+    };
+    this.#lockStorage = options.storageLike ?? availableLocalStorage();
+    if (this.#synchronizeInstances) this.#subscribeToExternalChanges();
   }
-  reset() {
-    return this.#enqueue(async () => {
-      await this.#storage.remove(this.#config.id, this.#userId);
-      return this.#initializeFresh();
-    });
+  get syncState() {
+    return this.#state;
   }
-  restore(state) {
-    return this.#enqueue(async () => {
-      if (state.rallyId !== this.#config.id || state.userId !== this.#userId)
-        throw new Error("State belongs to another rally or user.");
-      const next = this.#reconcile(state);
-      await this.#storage.save(next);
-      this.#state = next;
-      this.#initialization = Promise.resolve(next);
-      this.#emit(next);
-      return next;
-    });
+  get pendingCount() {
+    return this.#operations.length;
   }
-  #enqueue(operation) {
-    const next = this.#queue.then(operation, operation);
-    this.#queue = next.then(
-      () => void 0,
-      () => void 0
-    );
-    return next;
+  get queueCapability() {
+    return this.#queueCapability;
   }
-  #initializeFresh() {
-    const next = emptyState(this.#config, this.#userId, this.#now());
-    this.#state = next;
-    this.#initialization = Promise.resolve(next);
-    this.#emit(next);
-    return Promise.resolve(next);
+  get storageCapability() {
+    if (this.#queueCapability === "memory") return "memory";
+    const locks = globalThis.navigator?.locks;
+    return locks !== void 0 || this.#lockStorage !== null ? this.#queueCapability : "volatile_single_tab";
   }
-  #reconcile(state) {
-    const ids = new Set(this.#config.spots.map((spot2) => spot2.id));
-    const records = state.records.filter(
-      (record, index, all) => ids.has(record.stampId) && all.findIndex((candidate) => candidate.stampId === record.stampId) === index
-    );
-    return {
-      ...cloneState(state),
-      userId: this.#userId,
-      records,
-      rewards: reconcileRewardStates(
-        this.#config.rewards,
-        state.rewards,
-        records.length,
-        state.updatedAt
-      )
-    };
+  get isStoragePersistent() {
+    return this.#queueCapability !== "memory";
   }
-  async #handleOfflineSyncResult(event) {
-    if (event.state !== void 0) {
-      const next = this.#reconcile(event.state);
-      await this.#storage.save(next);
-      this.#state = next;
-      this.#emit(next);
+  get rejectedHistory() {
+    return this.#rejectedHistory;
+  }
+  get error() {
+    return this.#error;
+  }
+  get operations() {
+    return this.#operations;
+  }
+  get storageKey() {
+    return this.#storageKey();
+  }
+  get rallyId() {
+    return this.#rallyId;
+  }
+  get userId() {
+    return this.#userId;
+  }
+  setSyncResultListener(listener) {
+    this.#syncResultListener = listener;
+  }
+  setChangeListener(listener) {
+    this.#changeListener = listener;
+  }
+  setCapabilityWarningListener(listener) {
+    this.#capabilityWarningListener = listener;
+  }
+  setReplayConfig(config) {
+    this.#replayConfig = config;
+  }
+  async initialize() {
+    if (this.#loaded) return;
+    try {
+      const key = this.#storageKey();
+      this.#operations = (await this.#storage.load(key)).map(normalizeOperation);
+      this.#rejectedHistory = (await this.#storage.loadRejectedHistory?.(key))?.map(normalizeRejectedHistory) ?? [];
+    } catch (error) {
+      if (this.#queueCapability === "memory") throw error;
+      this.#storage = new MemoryQueueStorage();
+      this.#queueCapability = "memory";
+      this.#operations = [];
+      this.#rejectedHistory = [];
+      this.#warnMemoryLock(
+        `Offline queue persistence is unavailable; queued data can be lost after reload (${String(error)}).`
+      );
     }
-    if (event.error !== void 0) this.#emitEvent({ type: "error", error: event.error });
-    else if (event.result !== void 0 && "ok" in event.result && !event.result.ok)
-      this.#emitEvent({ type: "error", error: event.result.error });
+    if (this.#queueCapability === "memory")
+      this.#warnMemoryLock("Offline queue persistence is unavailable; queued data is memory-only.");
+    this.#loaded = true;
   }
-  #now() {
-    return this.#options.clock?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+  /** Releases browser listeners when the queue is no longer used. */
+  dispose() {
+    const windowLike = globalThis.window;
+    if (windowLike !== void 0 && this.#storageListener !== void 0)
+      windowLike.removeEventListener("storage", this.#storageListener);
+    this.#storageListener = void 0;
+    this.#channel?.close();
+    this.#channel = null;
+    this.#releaseSyncLock();
   }
-  #fail(error) {
-    this.#emitEvent({ type: "error", error });
-    return { ok: false, error };
+  /** Selects a rally/user queue scope and loads its pending operations. */
+  async setScope(rallyId, userId) {
+    if (this.#configuredKey !== void 0) {
+      this.#rallyId = rallyId;
+      this.#userId = userId;
+      return this.initialize();
+    }
+    if (this.#rallyId === rallyId && this.#userId === userId && this.#loaded) return;
+    this.#rallyId = rallyId;
+    this.#userId = userId;
+    this.#operations = [];
+    this.#loaded = false;
+    await this.initialize();
+  }
+  async switchUser(newUserId) {
+    if (this.#rallyId === void 0)
+      throw new Error("OfflineQueue.switchUser requires a rally scope.");
+    await this.setScope(this.#rallyId, newUserId);
+  }
+  setSender(sender) {
+    this.#sender = sender;
+  }
+  async enqueue(operation) {
+    if (this.#configuredKey === void 0) {
+      const scope = requestScope(operation);
+      if (this.#rallyId === void 0) await this.setScope(scope.rallyId, scope.userId);
+      if (this.#rallyId !== scope.rallyId || this.#userId !== scope.userId)
+        throw new Error("Offline operation belongs to another rally or user queue.");
+    }
+    await this.initialize();
+    const id2 = offlineOperationId(operation);
+    if (this.#operations.some((item) => offlineOperationId(item) === id2)) return;
+    this.#operations = [...this.#operations, { ...operation, status: "PENDING", attempts: 0 }];
+    await this.#storage.save(this.#storageKey(), this.#operations);
+    this.#announceChange();
+  }
+  async enqueueCheckIn(request, optimisticState) {
+    return this.enqueue({
+      kind: "checkIn",
+      request,
+      ...optimisticState === void 0 ? {} : { optimisticState }
+    });
+  }
+  async enqueueClaimReward(request, optimisticState) {
+    return this.enqueue({
+      kind: "claimReward",
+      request,
+      ...optimisticState === void 0 ? {} : { optimisticState }
+    });
   }
-  #commitCheckIn(result) {
-    if (result.ok) {
-      this.#state = result.value.state;
-      this.#emit(this.#state);
-    }
-    this.#emitEvent({ type: "checkIn", result });
-    return result;
+  async clear() {
+    await this.initialize();
+    this.#operations = [];
+    await this.#storage.save(this.#storageKey(), this.#operations);
+    this.#announceChange();
   }
-  #commitClaim(result) {
-    if (result.ok) {
-      this.#state = result.value.state;
-      this.#emit(this.#state);
-    }
-    this.#emitEvent({ type: "rewardClaimed", result });
-    return result;
+  async discardRejected(operationId2) {
+    await this.initialize();
+    const next = this.#rejectedHistory.filter(
+      (entry) => offlineOperationId(entry.operation) !== operationId2
+    );
+    if (next.length === this.#rejectedHistory.length) return false;
+    this.#rejectedHistory = next;
+    await this.#saveRejectedHistory();
+    this.#announceChange();
+    return true;
   }
-  #emit(state) {
-    for (const listener of this.#listeners) listener(state);
+  async retryRejected(operationId2) {
+    await this.initialize();
+    const entry = this.#rejectedHistory.find(
+      (candidate) => offlineOperationId(candidate.operation) === operationId2
+    );
+    if (entry === void 0) return false;
+    if (!this.#operations.some((operation) => offlineOperationId(operation) === operationId2))
+      this.#operations = [
+        ...this.#operations,
+        { ...entry.operation, status: "PENDING", attempts: 0 }
+      ];
+    this.#rejectedHistory = this.#rejectedHistory.filter((candidate) => candidate !== entry);
+    await this.#storage.save(this.#storageKey(), this.#operations);
+    await this.#saveRejectedHistory();
+    this.#announceChange();
+    return true;
   }
-  #emitEvent(event) {
-    for (const listener of this.#eventListeners) listener(event);
+  async discardRejectedOperation(operationId2) {
+    return this.discardRejected(operationId2);
   }
-};
-
-// src/client/offlineQueue.ts
-var MemoryQueueStorage = class {
-  #values = /* @__PURE__ */ new Map();
-  #rejected = /* @__PURE__ */ new Map();
-  async load(key) {
-    return this.#values.get(key) ?? [];
+  async retryRejectedOperation(operationId2) {
+    return this.retryRejected(operationId2);
   }
-  async save(key, operations) {
-    this.#values.set(key, structuredClone(operations));
+  async clearRejectedHistory() {
+    await this.initialize();
+    if (this.#rejectedHistory.length === 0) return;
+    this.#rejectedHistory = [];
+    await this.#saveRejectedHistory();
+    this.#announceChange();
   }
-  async loadRejectedHistory(key) {
-    return this.#rejected.get(key) ?? [];
+  async sync(sender = this.#sender) {
+    await this.initialize();
+    if (sender === void 0) throw new Error("OfflineQueue.sync requires a sender.");
+    if (this.#syncPromise !== null) return this.#syncPromise;
+    this.#sender = sender;
+    this.#syncPromise = this.#run(sender).finally(() => {
+      this.#syncPromise = null;
+    });
+    return this.#syncPromise;
   }
-  async saveRejectedHistory(key, history) {
-    this.#rejected.set(key, structuredClone(history));
+  async retrySync(sender = this.#sender) {
+    return this.sync(sender);
   }
-};
-var LocalStorageQueueStorage = class {
-  constructor(storage) {
-    this.storage = storage;
+  async #run(sender) {
+    const locks = globalThis.navigator?.locks;
+    if (locks !== void 0 && typeof locks.request === "function") {
+      let callbackStarted = false;
+      try {
+        const acquired = await locks.request(
+          `stamprally:${this.#storageKey()}:sync`,
+          { ifAvailable: true },
+          async (lock) => {
+            if (lock === null) {
+              await this.#reloadFromStorage();
+              this.#state = "idle";
+              this.#changeListener?.();
+              return false;
+            }
+            callbackStarted = true;
+            await this.#runWithStorageLock(sender);
+            return true;
+          }
+        );
+        if (!acquired) return;
+        return;
+      } catch (error) {
+        if (callbackStarted) throw error;
+      }
+    }
+    if (this.storageCapability === "volatile_single_tab")
+      this.#warnMemoryLock(
+        "No cross-tab storage lock is available; offline sync is single-tab only."
+      );
+    await this.#runWithStorageLock(sender);
   }
-  storage;
-  async load(key) {
-    const value = this.storage.getItem(key);
-    if (value === null) return [];
+  async #runWithStorageLock(sender) {
+    this.#state = "syncing";
+    this.#error = null;
+    this.#changeListener?.();
+    if (!this.#acquireSyncLock()) {
+      await this.#reloadFromStorage();
+      this.#state = "idle";
+      this.#changeListener?.();
+      return;
+    }
     try {
-      const parsed = JSON.parse(value);
-      return Array.isArray(parsed) ? parsed : [];
-    } catch {
-      return [];
+      while (this.#operations.length > 0) {
+        const operation = this.#operations[0];
+        if (operation === void 0) break;
+        if (await this.#rejectFailedPrerequisite(operation)) continue;
+        let attempt = 0;
+        let response;
+        while (true) {
+          await this.#updateOperationStatus("IN_FLIGHT", attempt);
+          try {
+            response = this.#normalizeResponse(await sender(operation));
+          } catch (cause) {
+            response = {
+              status: "RETRYABLE_ERROR",
+              error: errorValue(cause, "RETRYABLE_ERROR")
+            };
+          }
+          if (response.status !== "RETRYABLE_ERROR") break;
+          const error2 = errorValue(response.error ?? response.reason, "RETRYABLE_ERROR");
+          await this.#updateOperationStatus("PENDING", attempt + 1);
+          await this.#syncResultListener?.({ operation, status: response.status, error: error2 });
+          if (attempt >= this.#retryOptions.maxRetries) {
+            await this.#updateOperationStatus("FAILED_RETRYABLE", attempt + 1);
+            throw new Error(error2.message);
+          }
+          const interval = this.#retryOptions.initialIntervalMs * this.#retryOptions.backoffMultiplier ** attempt;
+          await new Promise((resolve) => setTimeout(resolve, Math.max(0, interval)));
+          attempt += 1;
+        }
+        const result = response.result;
+        const state = response.state ?? (result !== void 0 && "conflict" in result && result.conflict === true ? result.serverState : result !== void 0 && "ok" in result && result.ok ? result.value.state : void 0);
+        const error = response.status === "REJECTED_PERMANENT" ? errorValue(
+          response.error ?? response.reason ?? (result !== void 0 && "ok" in result && !result.ok ? result.error : void 0),
+          "REJECTED_PERMANENT"
+        ) : void 0;
+        await this.#updateOperationStatus(
+          response.status === "ACCEPTED" ? "ACCEPTED" : "REJECTED_PERMANENT",
+          attempt + 1
+        );
+        const eventState = state;
+        if (response.status === "REJECTED_PERMANENT" && error !== void 0) {
+          this.#rejectedHistory = [
+            ...this.#rejectedHistory,
+            {
+              operation: { ...operation, status: "REJECTED_PERMANENT", attempts: attempt + 1 },
+              reason: error,
+              errorCode: error.code,
+              rejectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+              attempts: attempt + 1
+            }
+          ];
+          await this.#saveRejectedHistory();
+        }
+        this.#operations = this.#operations.slice(1);
+        await this.#storage.save(this.#storageKey(), this.#operations);
+        this.#announceChange();
+        await this.#syncResultListener?.({
+          operation,
+          ...result === void 0 ? {} : { result },
+          status: response.status,
+          ...error === void 0 ? {} : { error },
+          ...eventState === void 0 ? {} : { state: eventState }
+        });
+      }
+      this.#state = "idle";
+      this.#changeListener?.();
+    } catch (cause) {
+      this.#state = "error";
+      this.#error = cause instanceof Error ? cause : new Error(String(cause));
+      this.#changeListener?.();
+      throw this.#error;
+    } finally {
+      this.#releaseSyncLock();
     }
   }
-  async save(key, operations) {
-    this.storage.setItem(key, JSON.stringify(operations));
+  async #updateOperationStatus(status, attempts) {
+    const operation = this.#operations[0];
+    if (operation === void 0) return;
+    this.#operations = [{ ...operation, status, attempts }, ...this.#operations.slice(1)];
+    await this.#storage.save(this.#storageKey(), this.#operations);
+    this.#announceChange();
   }
-  async loadRejectedHistory(key) {
-    const value = this.storage.getItem(`${key}:rejected-history`);
-    if (value === null) return [];
+  async #rejectFailedPrerequisite(operation) {
+    if (operation.kind !== "checkIn" || this.#replayConfig === void 0) return false;
+    const spot2 = this.#replayConfig.spots.find(
+      (candidate) => candidate.id === operation.request.spotId
+    );
+    if (spot2 === void 0) return false;
+    const failedSpots = new Set(
+      this.#rejectedHistory.filter((entry) => entry.operation.kind === "checkIn").map(
+        (entry) => entry.operation.kind === "checkIn" ? entry.operation.request.spotId : void 0
+      ).filter((spotId) => spotId !== void 0)
+    );
+    if (!spot2.prerequisites?.some((prerequisite) => failedSpots.has(prerequisite))) return false;
+    const error = {
+      code: "REJECTED_PREREQUISITE_FAILED",
+      message: "A prerequisite operation was rejected by the server."
+    };
+    const rejectedOperation = { ...operation, status: "REJECTED_PERMANENT" };
+    this.#rejectedHistory = [
+      ...this.#rejectedHistory,
+      {
+        operation: rejectedOperation,
+        reason: error,
+        errorCode: error.code,
+        rejectedAt: (/* @__PURE__ */ new Date()).toISOString(),
+        attempts: operation.attempts ?? 0
+      }
+    ];
+    this.#operations = this.#operations.slice(1);
+    await this.#storage.save(this.#storageKey(), this.#operations);
+    await this.#saveRejectedHistory();
+    this.#announceChange();
+    await this.#syncResultListener?.({
+      operation,
+      status: "REJECTED_PERMANENT",
+      error
+    });
+    return true;
+  }
+  #subscribeToExternalChanges() {
+    const windowLike = globalThis.window;
+    if (windowLike !== void 0) {
+      this.#storageListener = (event) => {
+        if (event.key === this.#storageKey() || event.key === `${this.#storageKey()}:rejected-history`)
+          void this.#reloadFromStorage();
+      };
+      windowLike.addEventListener("storage", this.#storageListener);
+    }
+    const Channel = globalThis.BroadcastChannel;
+    if (Channel !== void 0) {
+      try {
+        this.#channel = new Channel("stamprally:queue-sync");
+        this.#channel.addEventListener("message", (event) => {
+          if (typeof event.data === "object" && event.data !== null) {
+            const data = event.data;
+            if (data.type === "lock" && data.lockKey === this.#lockKey()) {
+              this.#observedLocks.set(data.lockKey, {
+                owner: typeof data.owner === "string" ? data.owner : "unknown",
+                expiresAt: typeof data.expiresAt === "number" ? data.expiresAt : 0
+              });
+              return;
+            }
+            if (data.type === "unlock" && data.lockKey === this.#lockKey()) {
+              this.#observedLocks.delete(data.lockKey);
+              return;
+            }
+          }
+          if (typeof event.data === "object" && event.data !== null && "key" in event.data && event.data.key === this.#storageKey())
+            void this.#reloadFromStorage();
+        });
+      } catch {
+        this.#channel = null;
+      }
+    }
+  }
+  #announceChange() {
+    this.#changeListener?.();
+    this.#channel?.postMessage({
+      type: "change",
+      key: this.#storageKey(),
+      owner: this.#instanceId
+    });
+  }
+  async #reloadFromStorage() {
+    if (this.#state === "syncing") return;
     try {
-      const parsed = JSON.parse(value);
-      return Array.isArray(parsed) ? parsed : [];
+      const key = this.#storageKey();
+      this.#operations = (await this.#storage.load(key)).map(normalizeOperation);
+      this.#rejectedHistory = (await this.#storage.loadRejectedHistory?.(key))?.map(normalizeRejectedHistory) ?? this.#rejectedHistory;
+      this.#loaded = true;
     } catch {
-      return [];
     }
   }
-  async saveRejectedHistory(key, history) {
-    this.storage.setItem(`${key}:rejected-history`, JSON.stringify(history));
+  #lockKey() {
+    return `${this.#storageKey()}:sync-lock`;
   }
-};
-var IndexedDBOfflineQueueStorage = class {
-  #providedFactory;
-  #databaseName;
-  #databasePromise = null;
-  constructor(options = {}) {
-    this.#providedFactory = options.indexedDB;
-    this.#databaseName = options.databaseName ?? "stamprally-offline-queue";
+  #acquireSyncLock() {
+    const key = this.#lockKey();
+    const now = Date.now();
+    const local = syncLocks.get(key);
+    if (local !== void 0 && local.expiresAt > now && local.owner !== this.#instanceId)
+      return false;
+    const observed = this.#observedLocks.get(key);
+    if (observed !== void 0 && observed.expiresAt > now && observed.owner !== this.#instanceId)
+      return false;
+    if (this.#lockStorage !== null) {
+      try {
+        const existing = this.#lockStorage.getItem(key);
+        if (existing !== null) {
+          const parsed = JSON.parse(existing);
+          if (typeof parsed === "object" && parsed !== null && typeof parsed.expiresAt === "number" && parsed.expiresAt > now && parsed.owner !== this.#instanceId)
+            return false;
+        }
+        this.#lockStorage.setItem(
+          key,
+          JSON.stringify({ owner: this.#instanceId, expiresAt: now + SYNC_LOCK_TTL_MS })
+        );
+        this.#channel?.postMessage({
+          type: "lock",
+          lockKey: key,
+          owner: this.#instanceId,
+          expiresAt: now + SYNC_LOCK_TTL_MS
+        });
+      } catch {
+        this.#warnMemoryLock("Persistent lock access failed; offline sync is single-tab only.");
+      }
+    }
+    syncLocks.set(key, { owner: this.#instanceId, expiresAt: now + SYNC_LOCK_TTL_MS });
+    return true;
   }
-  async load(key) {
-    const database = await this.#open();
-    return new Promise((resolve, reject) => {
-      const request = database.transaction("operations", "readonly").objectStore("operations").get(key);
-      request.onsuccess = () => resolve(Array.isArray(request.result) ? request.result : []);
-      request.onerror = () => reject(request.error ?? new Error("Failed to read offline queue."));
-    });
+  #releaseSyncLock() {
+    const key = this.#lockKey();
+    const current = syncLocks.get(key);
+    if (current?.owner === this.#instanceId) syncLocks.delete(key);
+    if (this.#lockStorage !== null) {
+      try {
+        const value = this.#lockStorage.getItem(key);
+        if (value !== null && JSON.parse(value).owner === this.#instanceId)
+          this.#lockStorage.removeItem?.(key);
+        this.#channel?.postMessage({ type: "unlock", lockKey: key, owner: this.#instanceId });
+      } catch {
+      }
+    }
   }
-  async save(key, operations) {
-    const database = await this.#open();
-    return new Promise((resolve, reject) => {
-      const transaction = database.transaction("operations", "readwrite");
-      transaction.objectStore("operations").put(structuredClone(operations), key);
-      transaction.oncomplete = () => resolve();
-      transaction.onerror = () => reject(transaction.error ?? new Error("Failed to save offline queue."));
-      transaction.onabort = () => reject(transaction.error ?? new Error("Offline queue write aborted."));
-    });
+  #storageKey() {
+    if (this.#configuredKey !== void 0) return this.#configuredKey;
+    return `stamprally:queue:${this.#rallyId ?? "unscoped"}:${this.#userId ?? "anonymous"}`;
   }
-  async loadRejectedHistory(key) {
-    const database = await this.#open();
-    return new Promise((resolve, reject) => {
-      const request = database.transaction("operations", "readonly").objectStore("operations").get(`${key}:rejected-history`);
-      request.onsuccess = () => resolve(
-        Array.isArray(request.result) ? request.result : []
-      );
-      request.onerror = () => reject(request.error ?? new Error("Failed to read rejected operation history."));
-    });
+  #normalizeResponse(value) {
+    if ("ok" in value) {
+      if (value.ok === false) {
+        if ("status" in value && value.status === "RETRYABLE_ERROR")
+          return { status: "RETRYABLE_ERROR", error: errorValue(value.error, "RETRYABLE_ERROR") };
+        return { status: "REJECTED_PERMANENT", result: value };
+      }
+      return { status: "ACCEPTED", result: value };
+    }
+    if ("status" in value) {
+      if (value.status === "ACCEPTED") return value;
+      return value;
+    }
+    return { status: "ACCEPTED", result: value };
   }
-  async saveRejectedHistory(key, history) {
-    const database = await this.#open();
-    return new Promise((resolve, reject) => {
-      const transaction = database.transaction("operations", "readwrite");
-      transaction.objectStore("operations").put(structuredClone(history), `${key}:rejected-history`);
-      transaction.oncomplete = () => resolve();
-      transaction.onerror = () => reject(transaction.error ?? new Error("Failed to save rejected operation history."));
-      transaction.onabort = () => reject(transaction.error ?? new Error("Rejected operation history write aborted."));
-    });
+  async #saveRejectedHistory() {
+    await this.#storage.saveRejectedHistory?.(this.#storageKey(), this.#rejectedHistory);
   }
-  #open() {
-    if (this.#databasePromise !== null) return this.#databasePromise;
-    let factory = this.#providedFactory;
-    if (factory === void 0)
-      factory = globalThis.indexedDB;
-    if (factory === void 0 || factory === null)
-      return Promise.reject(new Error("IndexedDB is unavailable in this environment."));
-    this.#databasePromise = new Promise((resolve, reject) => {
-      const request = factory.open(this.#databaseName, 1);
-      request.onupgradeneeded = () => {
-        if (!request.result.objectStoreNames.contains("operations"))
-          request.result.createObjectStore("operations");
-      };
-      request.onsuccess = () => resolve(request.result);
-      request.onerror = () => reject(request.error ?? new Error("Failed to open offline queue."));
-    }).catch((error) => {
-      this.#databasePromise = null;
-      throw error;
+  #warnMemoryLock(message) {
+    if (this.#warnedMemoryLock) return;
+    this.#warnedMemoryLock = true;
+    console.warn(`[@stamprally/core] ${message}`);
+    this.#capabilityWarningListener?.({
+      type: "STORAGE_CAPABILITY_WARNING",
+      storageCapability: this.storageCapability === "memory" ? "memory" : "volatile_single_tab",
+      isStoragePersistent: this.isStoragePersistent,
+      message
     });
-    return this.#databasePromise;
   }
 };
-function availableLocalStorage() {
-  try {
-    const storage = globalThis.localStorage;
-    return storage ?? null;
-  } catch {
-    return null;
-  }
-}
-function defaultStorage(databaseName) {
-  try {
-    const indexedDB = globalThis.indexedDB;
-    if (indexedDB !== void 0)
-      return {
-        storage: new IndexedDBOfflineQueueStorage({
-          indexedDB,
-          ...databaseName === void 0 ? {} : { databaseName }
-        }),
-        capability: "indexeddb"
-      };
-    const storage = availableLocalStorage();
-    if (storage !== void 0 && storage !== null)
-      return { storage: new LocalStorageQueueStorage(storage), capability: "localstorage" };
-  } catch {
-  }
-  return { storage: new MemoryQueueStorage(), capability: "memory" };
-}
-function offlineOperationId(operation) {
-  const identity = operation.request.userId ?? operation.request.anonymousSessionId ?? "anonymous";
-  return operation.kind === "checkIn" ? `checkIn:${operation.request.rallyId}:${identity}:${operation.request.idempotencyKey}` : `claimReward:${operation.request.rallyId}:${identity}:${operation.request.idempotencyKey}`;
-}
-function requestScope(operation) {
+function normalizeOperation(operation) {
+  const status = operation.status;
   return {
-    rallyId: operation.request.rallyId,
-    userId: operation.request.userId
+    ...operation,
+    status: status === "IN_FLIGHT" || status === "REJECTED" ? "PENDING" : status === "RETRYABLE_ERROR" ? "FAILED_RETRYABLE" : operation.status ?? "PENDING",
+    attempts: operation.attempts ?? 0
   };
 }
-function errorValue(value, fallbackCode) {
-  if (typeof value === "object" && value !== null) {
-    const candidate = value;
-    if (typeof candidate.code === "string" && typeof candidate.message === "string")
-      return { ...candidate, code: candidate.code, message: candidate.message };
-  }
-  if (value instanceof Error) return { code: fallbackCode, message: value.message };
-  if (typeof value === "string") return { code: fallbackCode, message: value };
-  return { code: fallbackCode, message: "Offline operation was rejected." };
+function normalizeRejectedHistory(entry) {
+  return {
+    ...entry,
+    operation: normalizeOperation(entry.operation),
+    reason: errorValue(entry.reason, "REJECTED_PERMANENT"),
+    errorCode: entry.errorCode || entry.reason.code,
+    rejectedAt: entry.rejectedAt || (/* @__PURE__ */ new Date(0)).toISOString(),
+    attempts: entry.attempts ?? entry.operation.attempts ?? 0
+  };
 }
-var syncLocks = /* @__PURE__ */ new Map();
-var SYNC_LOCK_TTL_MS = 3e4;
-var DEFAULT_RETRY_OPTIONS = {
-  maxRetries: 0,
-  initialIntervalMs: 250,
-  backoffMultiplier: 2
-};
-function randomId() {
-  return globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+
+// src/client/sync.ts
+function isReplayable(operation) {
+  return operation.status === void 0 || operation.status === "ACCEPTED" || operation.status === "PENDING" || operation.status === "IN_FLIGHT" || operation.status === "FAILED_RETRYABLE";
 }
-var OfflineQueue = class {
-  #storage;
-  #queueCapability;
-  #configuredKey;
-  #rallyId;
-  #userId;
-  #conflictPolicy;
-  #onSyncConflict;
-  #operations = [];
-  #rejectedHistory = [];
-  #loaded = false;
-  #state = "idle";
-  #error = null;
-  #sender;
-  #syncPromise = null;
-  #syncResultListener;
-  #synchronizeInstances;
-  #retryOptions;
-  #instanceId = randomId();
-  #lockStorage;
-  #observedLocks = /* @__PURE__ */ new Map();
-  #warnedMemoryLock = false;
-  #storageListener;
-  #channel = null;
-  constructor(options = {}) {
-    if (options.storage !== void 0) {
-      this.#storage = options.storage;
-      this.#queueCapability = "custom";
-    } else if (options.storageLike !== void 0 && options.storageLike !== null) {
-      this.#storage = new LocalStorageQueueStorage(options.storageLike);
-      this.#queueCapability = "localstorage";
-    } else {
-      const selected = defaultStorage(options.databaseName);
-      this.#storage = selected.storage;
-      this.#queueCapability = selected.capability;
+function operationId(operation) {
+  const identity = operation.request.userId ?? operation.request.anonymousSessionId ?? "anonymous";
+  return `${operation.kind}:${operation.request.rallyId}:${identity}:${operation.request.idempotencyKey}`;
+}
+function applyInventoryDelta(state, previous, optimistic) {
+  const previousInventory = previous.inventory;
+  const optimisticInventory = optimistic.inventory;
+  if (previousInventory === void 0 || optimisticInventory === void 0) return state;
+  const currentInventory = state.inventory ?? {};
+  const sharedDelta = previousInventory.sharedRemaining === void 0 || optimisticInventory.sharedRemaining === void 0 ? void 0 : optimisticInventory.sharedRemaining - previousInventory.sharedRemaining;
+  const previousRewards = previousInventory.rewardRemaining ?? {};
+  const optimisticRewards = optimisticInventory.rewardRemaining ?? {};
+  const currentRewards = currentInventory.rewardRemaining ?? {};
+  const rewardRemaining = { ...currentRewards };
+  for (const key of /* @__PURE__ */ new Set([...Object.keys(previousRewards), ...Object.keys(optimisticRewards)])) {
+    const before = previousRewards[key];
+    const after = optimisticRewards[key];
+    if (before !== void 0 && after !== void 0)
+      rewardRemaining[key] = Math.max(0, (currentRewards[key] ?? before) + after - before);
+  }
+  return {
+    ...state,
+    inventory: {
+      ...currentInventory.sharedRemaining === void 0 || sharedDelta === void 0 ? {} : { sharedRemaining: Math.max(0, currentInventory.sharedRemaining + sharedDelta) },
+      ...Object.keys(rewardRemaining).length === 0 ? {} : { rewardRemaining }
     }
-    this.#configuredKey = options.key;
-    this.#rallyId = options.rallyId;
-    this.#userId = options.userId ?? null;
-    this.#conflictPolicy = options.conflictPolicy ?? "server_wins";
-    this.#onSyncConflict = options.onSyncConflict;
-    this.#synchronizeInstances = options.synchronizeInstances ?? true;
-    const retryOptions = {
-      ...DEFAULT_RETRY_OPTIONS,
-      ...options.retryOptions ?? options.syncRetryOptions ?? options.retry ?? {}
+  };
+}
+function applyOperation(state, operation, config) {
+  if (operation.kind === "checkIn") {
+    const spot2 = config?.spots.find((candidate) => candidate.id === operation.request.spotId);
+    if (spot2?.prerequisites?.some((id2) => !state.records.some((record2) => record2.stampId === id2)))
+      return { state, prerequisiteFailed: true };
+    if (state.records.some((record2) => record2.stampId === operation.request.spotId))
+      return { state, prerequisiteFailed: false };
+    const optimisticRecord = operation.optimisticState?.records.find(
+      (record2) => record2.stampId === operation.request.spotId
+    );
+    const record = optimisticRecord ?? {
+      stampId: operation.request.spotId,
+      acquiredAt: operation.request.now
     };
-    this.#retryOptions = {
-      maxRetries: Math.max(0, Math.floor(retryOptions.maxRetries)),
-      initialIntervalMs: Math.max(0, retryOptions.initialIntervalMs),
-      backoffMultiplier: Math.max(1, retryOptions.backoffMultiplier)
+    const records = [...state.records, { ...record }];
+    const rewards2 = config === void 0 ? state.rewards : reconcileRewardStates(config.rewards, state.rewards, records.length, record.acquiredAt);
+    return {
+      state: { ...state, records, rewards: rewards2, updatedAt: record.acquiredAt },
+      prerequisiteFailed: false
     };
-    this.#lockStorage = options.storageLike ?? availableLocalStorage();
-    if (this.#synchronizeInstances) this.#subscribeToExternalChanges();
   }
-  get syncState() {
-    return this.#state;
+  const optimisticState = operation.optimisticState;
+  if (optimisticState === void 0) return { state, prerequisiteFailed: false };
+  const optimisticReward = optimisticState?.rewards.find(
+    (reward2) => reward2.rewardId === operation.request.rewardId
+  );
+  if (optimisticReward === void 0) return { state, prerequisiteFailed: false };
+  const rewards = state.rewards.some((reward2) => reward2.rewardId === optimisticReward.rewardId) ? state.rewards.map(
+    (reward2) => reward2.rewardId === optimisticReward.rewardId ? { ...optimisticReward } : reward2
+  ) : [...state.rewards, { ...optimisticReward }];
+  return {
+    state: applyInventoryDelta(
+      { ...state, rewards, updatedAt: optimisticReward.consumedAt ?? state.updatedAt },
+      operation.request.state,
+      optimisticState
+    ),
+    prerequisiteFailed: false
+  };
+}
+function rebuildUserStateFromLog(baselineOrOptions, operationsArgument, configArgument) {
+  const { state } = rebuildUserStateLog(
+    "baseline" in baselineOrOptions ? baselineOrOptions.baseline : baselineOrOptions,
+    "baseline" in baselineOrOptions ? baselineOrOptions.operations : operationsArgument ?? [],
+    "baseline" in baselineOrOptions ? baselineOrOptions.config : configArgument
+  );
+  return state;
+}
+function rebuildUserStateLog(baseline, operations, config) {
+  let state = cloneState(baseline);
+  const rejectedOperationIds = [];
+  for (const operation of operations) {
+    if (!isReplayable(operation)) continue;
+    const replay = applyOperation(state, operation, config);
+    if (replay.prerequisiteFailed) {
+      rejectedOperationIds.push(operationId(operation));
+      continue;
+    }
+    state = replay.state;
   }
-  get pendingCount() {
-    return this.#operations.length;
+  return { state, rejectedOperationIds };
+}
+
+// src/client/client.ts
+function isStorage(value) {
+  return "load" in value && "save" in value && "remove" in value;
+}
+function id(prefix) {
+  return `${prefix}-${globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`}`;
+}
+function proof(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "object" && value !== null) {
+    const item = value;
+    for (const key of ["token", "code", "passcode", "value", "tagId"])
+      if (typeof item[key] === "string") return item[key];
   }
-  get queueCapability() {
-    return this.#queueCapability;
+  return "";
+}
+function matches(condition2, value) {
+  if (condition2.type === "gps") {
+    if (typeof value !== "object" || value === null) return false;
+    const item = value;
+    const latitude = item.latitude;
+    const longitude = item.longitude;
+    if (typeof latitude !== "number" || typeof longitude !== "number") return false;
+    const radians = (v) => v * Math.PI / 180;
+    const dLat = radians(latitude - condition2.latitude);
+    const dLon = radians(longitude - condition2.longitude);
+    const h = Math.sin(dLat / 2) ** 2 + Math.cos(radians(condition2.latitude)) * Math.cos(radians(latitude)) * Math.sin(dLon / 2) ** 2;
+    return 6371e3 * 2 * Math.asin(Math.sqrt(Math.min(1, h))) <= condition2.radiusMeters;
   }
-  get rejectedHistory() {
-    return this.#rejectedHistory;
+  return proof(value).trim() !== "";
+}
+function emptyState(config, userId, now) {
+  return {
+    rallyId: config.id,
+    userId,
+    records: [],
+    rewards: reconcileRewardStates(config.rewards, [], 0, now),
+    updatedAt: now
+  };
+}
+function errorMessage(error, fallback) {
+  return error !== void 0 && "message" in error && typeof error.message === "string" ? error.message : fallback;
+}
+var StampRallyClient = class {
+  #listeners = /* @__PURE__ */ new Set();
+  #eventListeners = /* @__PURE__ */ new Set();
+  #syncEventListeners = /* @__PURE__ */ new Set();
+  #storage;
+  #options;
+  #config;
+  #offlineQueue;
+  #userId;
+  #anonymousSessionId;
+  #state = null;
+  #initialization = null;
+  #queue = Promise.resolve();
+  #syncRevision = 0;
+  #syncMetrics = null;
+  constructor(config, storageOrOptions = {}) {
+    this.#config = config;
+    this.#options = isStorage(storageOrOptions) ? { storage: storageOrOptions } : storageOrOptions;
+    this.#storage = this.#options.storage ?? new InMemoryStorage();
+    this.#anonymousSessionId = this.#options.anonymousSessionId ?? createAnonymousSessionId();
+    this.#userId = this.#options.userId ?? this.#anonymousSessionId;
+    this.#offlineQueue = this.#options.offlineQueue;
+    this.#offlineQueue?.setReplayConfig(config);
+    this.#offlineQueue?.setSyncResultListener((event) => this.#handleOfflineSyncResult(event));
+    this.#offlineQueue?.setChangeListener(() => {
+      this.#syncRevision += 1;
+      if (this.#state !== null) this.#emit(this.#state);
+    });
   }
-  get error() {
-    return this.#error;
+  getConfig() {
+    return this.#config;
   }
-  get operations() {
-    return this.#operations;
+  getState() {
+    return this.#state;
   }
-  get conflictPolicy() {
-    return this.#conflictPolicy;
+  getUserId() {
+    return this.#userId;
   }
-  get storageKey() {
-    return this.#storageKey();
+  getAnonymousSessionId() {
+    return this.#anonymousSessionId;
   }
-  get rallyId() {
-    return this.#rallyId;
+  get syncState() {
+    return this.#offlineQueue?.syncState ?? "idle";
   }
-  get userId() {
-    return this.#userId;
+  get pendingCount() {
+    return this.#offlineQueue?.pendingCount ?? 0;
   }
-  setSyncResultListener(listener) {
-    this.#syncResultListener = listener;
+  get rejectedHistory() {
+    return this.#offlineQueue?.rejectedHistory ?? [];
   }
-  async initialize() {
-    if (this.#loaded) return;
-    try {
-      const key = this.#storageKey();
-      this.#operations = (await this.#storage.load(key)).map(normalizeOperation);
-      this.#rejectedHistory = (await this.#storage.loadRejectedHistory?.(key))?.map(normalizeRejectedHistory) ?? [];
-    } catch (error) {
-      if (this.#queueCapability === "memory") throw error;
-      this.#storage = new MemoryQueueStorage();
-      this.#queueCapability = "memory";
-      this.#operations = [];
-      this.#rejectedHistory = [];
-      this.#warnMemoryLock(
-        `Offline queue persistence is unavailable; queued data can be lost after reload (${String(error)}).`
-      );
-    }
-    this.#loaded = true;
+  getSyncRevision() {
+    return this.#syncRevision;
   }
-  /** Releases browser listeners when the queue is no longer used. */
-  dispose() {
-    const windowLike = globalThis.window;
-    if (windowLike !== void 0 && this.#storageListener !== void 0)
-      windowLike.removeEventListener("storage", this.#storageListener);
-    this.#storageListener = void 0;
-    this.#channel?.close();
-    this.#channel = null;
-    this.#releaseSyncLock();
+  get queueCapability() {
+    return this.#offlineQueue?.queueCapability ?? "custom";
   }
-  /** Selects a rally/user queue scope and loads its pending operations. */
-  async setScope(rallyId, userId) {
-    if (this.#configuredKey !== void 0) {
-      this.#rallyId = rallyId;
-      this.#userId = userId;
-      return this.initialize();
-    }
-    if (this.#rallyId === rallyId && this.#userId === userId && this.#loaded) return;
-    this.#rallyId = rallyId;
-    this.#userId = userId;
-    this.#operations = [];
-    this.#loaded = false;
-    await this.initialize();
+  get storageCapability() {
+    return this.#offlineQueue?.storageCapability ?? "custom";
   }
-  async switchUser(newUserId) {
-    if (this.#rallyId === void 0)
-      throw new Error("OfflineQueue.switchUser requires a rally scope.");
-    await this.setScope(this.#rallyId, newUserId);
+  get isStoragePersistent() {
+    return this.#offlineQueue?.isStoragePersistent ?? true;
   }
-  setSender(sender) {
-    this.#sender = sender;
+  discardRejected(operationId2) {
+    return this.#offlineQueue?.discardRejected(operationId2) ?? Promise.resolve(false);
   }
-  async enqueue(operation) {
-    if (this.#configuredKey === void 0) {
-      const scope = requestScope(operation);
-      if (this.#rallyId === void 0) await this.setScope(scope.rallyId, scope.userId);
-      if (this.#rallyId !== scope.rallyId || this.#userId !== scope.userId)
-        throw new Error("Offline operation belongs to another rally or user queue.");
-    }
-    await this.initialize();
-    const id2 = offlineOperationId(operation);
-    if (this.#operations.some((item) => offlineOperationId(item) === id2)) return;
-    this.#operations = [...this.#operations, { ...operation, status: "PENDING", attempts: 0 }];
-    await this.#storage.save(this.#storageKey(), this.#operations);
-    this.#announceChange();
+  retryRejected(operationId2) {
+    return this.#offlineQueue?.retryRejected(operationId2) ?? Promise.resolve(false);
   }
-  async enqueueCheckIn(request) {
-    return this.enqueue({ kind: "checkIn", request });
+  dismissRejectedOperation(operationId2) {
+    return this.discardRejected(operationId2);
   }
-  async enqueueClaimReward(request) {
-    return this.enqueue({ kind: "claimReward", request });
+  retryOperation(operationId2) {
+    return this.retryRejected(operationId2);
   }
-  async clear() {
-    await this.initialize();
-    this.#operations = [];
-    await this.#storage.save(this.#storageKey(), this.#operations);
-    this.#announceChange();
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
   }
-  async discardRejected(operationId) {
-    await this.initialize();
-    const next = this.#rejectedHistory.filter(
-      (entry) => offlineOperationId(entry.operation) !== operationId
-    );
-    if (next.length === this.#rejectedHistory.length) return false;
-    this.#rejectedHistory = next;
-    await this.#saveRejectedHistory();
-    this.#announceChange();
-    return true;
+  subscribeEvents(listener) {
+    this.#eventListeners.add(listener);
+    return () => this.#eventListeners.delete(listener);
   }
-  async retryRejected(operationId) {
-    await this.initialize();
-    const entry = this.#rejectedHistory.find(
-      (candidate) => offlineOperationId(candidate.operation) === operationId
-    );
-    if (entry === void 0) return false;
-    if (!this.#operations.some((operation) => offlineOperationId(operation) === operationId))
-      this.#operations = [
-        ...this.#operations,
-        { ...entry.operation, status: "PENDING", attempts: 0 }
-      ];
-    this.#rejectedHistory = this.#rejectedHistory.filter((candidate) => candidate !== entry);
-    await this.#storage.save(this.#storageKey(), this.#operations);
-    await this.#saveRejectedHistory();
-    this.#announceChange();
-    return true;
+  subscribeSyncEvents(listener) {
+    this.#syncEventListeners.add(listener);
+    return () => this.#syncEventListeners.delete(listener);
   }
-  async discardRejectedOperation(operationId) {
-    return this.discardRejected(operationId);
+  subscribeSyncState(listener) {
+    const wrapped = () => listener();
+    this.#listeners.add(wrapped);
+    return () => this.#listeners.delete(wrapped);
   }
-  async retryRejectedOperation(operationId) {
-    return this.retryRejected(operationId);
+  init() {
+    return this.initialize();
   }
-  async clearRejectedHistory() {
-    await this.initialize();
-    if (this.#rejectedHistory.length === 0) return;
-    this.#rejectedHistory = [];
-    await this.#saveRejectedHistory();
-    this.#announceChange();
+  initialize() {
+    if (this.#state !== null) return Promise.resolve(this.#state);
+    if (this.#initialization === null) {
+      this.#initialization = (async () => {
+        await this.#offlineQueue?.setScope(this.#config.id, this.#userId);
+        return this.#storage.load(this.#config.id, this.#userId);
+      })().then((state) => {
+        const next = state === null ? emptyState(this.#config, this.#userId, this.#now()) : this.#reconcile(state);
+        this.#state = next;
+        this.#emit(next);
+        return next;
+      }).catch((error) => {
+        this.#initialization = null;
+        throw error;
+      });
+    }
+    return this.#initialization;
   }
-  async sync(sender = this.#sender) {
-    await this.initialize();
-    if (sender === void 0) throw new Error("OfflineQueue.sync requires a sender.");
-    if (this.#syncPromise !== null) return this.#syncPromise;
-    this.#sender = sender;
-    this.#syncPromise = this.#run(sender).finally(() => {
-      this.#syncPromise = null;
+  switchUser(newUserId) {
+    return this.#enqueue(async () => {
+      const nextUserId = newUserId ?? this.#anonymousSessionId;
+      if (this.#userId === nextUserId && this.#state !== null) return this.#state;
+      this.#userId = nextUserId;
+      this.#state = null;
+      this.#initialization = null;
+      await this.#offlineQueue?.switchUser(nextUserId);
+      return this.initialize();
+    });
+  }
+  async getUserState(rallyId, userId) {
+    return this.#storage.load(rallyId, userId);
+  }
+  clearUserState(userId = this.#userId) {
+    return this.#enqueue(async () => {
+      await this.#storage.remove(this.#config.id, userId);
+      if (userId === this.#userId) {
+        await this.#initializeFresh();
+      }
     });
-    return this.#syncPromise;
-  }
-  async retrySync(sender = this.#sender) {
-    return this.sync(sender);
   }
-  async #run(sender) {
-    const locks = globalThis.navigator?.locks;
-    if (locks !== void 0 && typeof locks.request === "function") {
-      let callbackStarted = false;
-      try {
-        const acquired = await locks.request(
-          `stamprally:${this.#storageKey()}:sync`,
-          { ifAvailable: true },
-          async (lock) => {
-            if (lock === null) {
-              await this.#reloadFromStorage();
-              this.#state = "idle";
-              return false;
-            }
-            callbackStarted = true;
-            await this.#runWithStorageLock(sender);
-            return true;
-          }
-        );
-        if (!acquired) return;
-        return;
-      } catch (error) {
-        if (callbackStarted) throw error;
+  checkIn(spotId, proofData, options = {}) {
+    return this.#enqueue(async () => {
+      const current = await this.initialize();
+      const spot2 = this.#config.spots.find((item) => item.id === spotId);
+      if (spot2 === void 0)
+        return this.#fail({ code: "SPOT_NOT_FOUND", spotId, message: "Spot was not found." });
+      if (current.records.some((record2) => record2.stampId === spotId))
+        return this.#fail({
+          code: "STAMP_ALREADY_ACQUIRED",
+          spotId,
+          message: "Spot was already claimed."
+        });
+      const acquired = new Set(current.records.map((record2) => record2.stampId));
+      if (spot2.prerequisites?.some((id2) => !acquired.has(id2)))
+        return this.#fail({
+          code: "PREREQUISITES_NOT_MET",
+          spotId,
+          message: "Prerequisite spots are not complete."
+        });
+      for (const condition2 of spot2.conditions) {
+        if (condition2.type === "custom") {
+          const validator = this.#options.customValidators?.[condition2.validatorName] ?? this.#options.customValidator;
+          if (validator === void 0)
+            return this.#fail({
+              code: "CUSTOM_VALIDATION_FAILED",
+              spotId,
+              message: "No custom validator is registered."
+            });
+          const context = {
+            rallyId: this.#config.id,
+            spotId,
+            proofData,
+            condition: { type: "custom", validatorName: condition2.validatorName },
+            userState: current
+          };
+          const result = typeof validator === "function" ? await validator(context) : await validator.validate(context);
+          if (result === false || typeof result === "object" && !result.valid)
+            return this.#fail({
+              code: "CUSTOM_VALIDATION_FAILED",
+              spotId,
+              message: typeof result === "object" && result.message !== void 0 ? result.message : "Custom validation failed."
+            });
+        } else if (!matches(condition2, proofData))
+          return this.#fail({ code: "INVALID_PROOF", spotId, message: "Verification failed." });
       }
-    }
-    if (this.#lockStorage === null)
-      this.#warnMemoryLock(
-        "No cross-tab storage lock is available; offline sync is single-tab only."
-      );
-    await this.#runWithStorageLock(sender);
-  }
-  async #runWithStorageLock(sender) {
-    this.#state = "syncing";
-    this.#error = null;
-    if (!this.#acquireSyncLock()) {
-      await this.#reloadFromStorage();
-      this.#state = "idle";
-      return;
-    }
-    try {
-      while (this.#operations.length > 0) {
-        const operation = this.#operations[0];
-        if (operation === void 0) break;
-        let attempt = 0;
-        let response;
-        while (true) {
-          await this.#updateOperationStatus("IN_FLIGHT", attempt);
-          try {
-            response = this.#normalizeResponse(await sender(operation));
-          } catch (cause) {
-            response = {
-              status: "RETRYABLE_ERROR",
-              error: errorValue(cause, "RETRYABLE_ERROR")
-            };
-          }
-          if (response.status !== "RETRYABLE_ERROR") break;
-          const error2 = errorValue(response.error ?? response.reason, "RETRYABLE_ERROR");
-          await this.#updateOperationStatus("PENDING", attempt + 1);
-          await this.#syncResultListener?.({ operation, status: response.status, error: error2 });
-          if (attempt >= this.#retryOptions.maxRetries) {
-            await this.#updateOperationStatus("FAILED_RETRYABLE", attempt + 1);
-            throw new Error(error2.message);
-          }
-          const interval = this.#retryOptions.initialIntervalMs * this.#retryOptions.backoffMultiplier ** attempt;
-          await new Promise((resolve) => setTimeout(resolve, Math.max(0, interval)));
-          attempt += 1;
-        }
-        const result = response.result;
-        const state = response.state ?? (result !== void 0 && "conflict" in result && result.conflict === true ? result.serverState : result !== void 0 && "ok" in result && result.ok ? result.value.state : void 0);
-        const error = response.status === "REJECTED_PERMANENT" ? errorValue(
-          response.error ?? response.reason ?? (result !== void 0 && "ok" in result && !result.ok ? result.error : void 0),
-          "REJECTED_PERMANENT"
-        ) : void 0;
-        await this.#updateOperationStatus(
-          response.status === "ACCEPTED" ? "ACCEPTED" : "REJECTED_PERMANENT",
-          attempt + 1
-        );
-        const eventState = state;
-        if (response.status === "REJECTED_PERMANENT" && error !== void 0) {
-          this.#rejectedHistory = [
-            ...this.#rejectedHistory,
-            {
-              operation: { ...operation, status: "REJECTED_PERMANENT", attempts: attempt + 1 },
-              reason: error,
-              errorCode: error.code,
-              rejectedAt: (/* @__PURE__ */ new Date()).toISOString(),
-              attempts: attempt + 1
-            }
-          ];
-          await this.#saveRejectedHistory();
+      const now = options.now ?? this.#now();
+      const request = {
+        rallyId: this.#config.id,
+        userId: this.#userId,
+        spotId,
+        proofData,
+        idempotencyKey: options.idempotencyKey ?? id("check-in"),
+        now,
+        state: current,
+        ...this.#userId === this.#anonymousSessionId ? { anonymousSessionId: this.#anonymousSessionId } : {}
+      };
+      const remote = this.#options.syncAdapter?.checkIn;
+      if (options.sync !== false && remote !== void 0) {
+        try {
+          const result = await remote(request);
+          return result.ok ? this.#commitCheckIn(result) : this.#fail(result.error);
+        } catch (error) {
+          if (this.#offlineQueue === void 0) throw error;
+          const record2 = { stampId: spotId, acquiredAt: now };
+          const next2 = this.#reconcile({
+            ...current,
+            records: [...current.records, record2],
+            updatedAt: now
+          });
+          await this.#offlineQueue.enqueueCheckIn(request, next2);
+          await this.#storage.save(next2);
+          return this.#commitCheckIn({ ok: true, value: { state: next2, record: record2 } });
         }
-        this.#operations = this.#operations.slice(1);
-        await this.#storage.save(this.#storageKey(), this.#operations);
-        this.#announceChange();
-        await this.#syncResultListener?.({
-          operation,
-          ...result === void 0 ? {} : { result },
-          status: response.status,
-          ...error === void 0 ? {} : { error },
-          ...eventState === void 0 ? {} : { state: eventState }
-        });
       }
-      this.#state = "idle";
-    } catch (cause) {
-      this.#state = "error";
-      this.#error = cause instanceof Error ? cause : new Error(String(cause));
-      throw this.#error;
-    } finally {
-      this.#releaseSyncLock();
-    }
-  }
-  async #updateOperationStatus(status, attempts) {
-    const operation = this.#operations[0];
-    if (operation === void 0) return;
-    this.#operations = [{ ...operation, status, attempts }, ...this.#operations.slice(1)];
-    await this.#storage.save(this.#storageKey(), this.#operations);
-    this.#announceChange();
+      const record = { stampId: spotId, acquiredAt: now };
+      const next = this.#reconcile({
+        ...current,
+        records: [...current.records, record],
+        updatedAt: now
+      });
+      await this.#storage.save(next);
+      return this.#commitCheckIn({ ok: true, value: { state: next, record } });
+    });
   }
-  #subscribeToExternalChanges() {
-    const windowLike = globalThis.window;
-    if (windowLike !== void 0) {
-      this.#storageListener = (event) => {
-        if (event.key === this.#storageKey() || event.key === `${this.#storageKey()}:rejected-history`)
-          void this.#reloadFromStorage();
+  claimReward(rewardId, options = {}) {
+    return this.#enqueue(async () => {
+      const current = await this.initialize();
+      const configured = this.#config.rewards.find((item) => item.id === rewardId);
+      if (configured === void 0)
+        return this.#fail({ code: "REWARD_NOT_FOUND", rewardId, message: "Reward was not found." });
+      const now = options.now ?? this.#now();
+      const state = current.rewards.find((item) => item.rewardId === rewardId) ?? {
+        rewardId,
+        status: "LOCKED"
       };
-      windowLike.addEventListener("storage", this.#storageListener);
-    }
-    const Channel = globalThis.BroadcastChannel;
-    if (Channel !== void 0) {
+      const local = consumeReward({
+        reward: configured,
+        currentState: state,
+        now,
+        ...options.staffPasscode === void 0 ? {} : { inputPasscode: options.staffPasscode },
+        ...options.staffId === void 0 ? {} : { staffId: options.staffId }
+      });
+      if (!local.ok) return this.#fail(local.error);
+      const request = {
+        rallyId: this.#config.id,
+        userId: this.#userId,
+        rewardId,
+        idempotencyKey: options.idempotencyKey ?? id("claim"),
+        now,
+        options,
+        state: current,
+        ...this.#userId === this.#anonymousSessionId ? { anonymousSessionId: this.#anonymousSessionId } : {}
+      };
+      const remote = this.#options.syncAdapter?.claimReward;
+      if (options.sync !== false && remote !== void 0) {
+        try {
+          const result = await remote(request);
+          return result.ok ? this.#commitClaim(result) : this.#fail(result.error);
+        } catch (error) {
+          if (this.#offlineQueue === void 0) throw error;
+          const next2 = {
+            ...current,
+            rewards: current.rewards.map(
+              (item) => item.rewardId === rewardId ? local.value : item
+            ),
+            updatedAt: now
+          };
+          await this.#offlineQueue.enqueueClaimReward(request, next2);
+          await this.#storage.save(next2);
+          return this.#commitClaim({ ok: true, value: { state: next2, reward: local.value } });
+        }
+      }
+      const next = {
+        ...current,
+        rewards: current.rewards.map((item) => item.rewardId === rewardId ? local.value : item),
+        updatedAt: now
+      };
+      await this.#storage.save(next);
+      return this.#commitClaim({ ok: true, value: { state: next, reward: local.value } });
+    });
+  }
+  sync(adapter = this.#options.syncAdapter) {
+    return this.#enqueue(async () => {
+      this.#emitSyncEvent({ type: "SYNC_STARTED" });
+      this.#syncMetrics = { processed: 0, failed: 0 };
       try {
-        this.#channel = new Channel("stamprally:queue-sync");
-        this.#channel.addEventListener("message", (event) => {
-          if (typeof event.data === "object" && event.data !== null) {
-            const data = event.data;
-            if (data.type === "lock" && data.lockKey === this.#lockKey()) {
-              this.#observedLocks.set(data.lockKey, {
-                owner: typeof data.owner === "string" ? data.owner : "unknown",
-                expiresAt: typeof data.expiresAt === "number" ? data.expiresAt : 0
-              });
-              return;
-            }
-            if (data.type === "unlock" && data.lockKey === this.#lockKey()) {
-              this.#observedLocks.delete(data.lockKey);
-              return;
+        const current = await this.initialize();
+        if (this.#offlineQueue !== void 0 && adapter !== void 0) {
+          await this.#offlineQueue.sync(async (operation) => {
+            if (operation.kind === "checkIn") {
+              if (adapter.checkIn === void 0)
+                throw new Error("No check-in sync adapter is configured.");
+              return adapter.checkIn(operation.request);
             }
-          }
-          if (typeof event.data === "object" && event.data !== null && "key" in event.data && event.data.key === this.#storageKey())
-            void this.#reloadFromStorage();
+            if (adapter.claimReward === void 0)
+              throw new Error("No reward sync adapter is configured.");
+            return adapter.claimReward(operation.request);
+          });
+        }
+        if (adapter?.sync === void 0) {
+          this.#emitEvent({ type: "sync", state: this.#state ?? current });
+          return;
+        }
+        const localState = this.#state ?? current;
+        const serverState = await adapter.sync({
+          rallyId: this.#config.id,
+          userId: this.#userId,
+          state: localState,
+          ...this.#userId === this.#anonymousSessionId ? { anonymousSessionId: this.#anonymousSessionId } : {}
+        });
+        const resolved = rebuildUserStateFromLog(
+          serverState,
+          this.#offlineQueue?.operations ?? [],
+          this.#config
+        );
+        const next = this.#reconcile(resolved);
+        await this.#storage.save(next);
+        this.#state = next;
+        this.#emit(next);
+        this.#emitEvent({ type: "sync", state: next });
+      } finally {
+        const metrics = this.#syncMetrics ?? { processed: 0, failed: 0 };
+        this.#syncMetrics = null;
+        this.#emitSyncEvent({
+          type: "SYNC_COMPLETED",
+          totalProcessed: metrics.processed,
+          failedCount: metrics.failed
         });
-      } catch {
-        this.#channel = null;
       }
-    }
+    });
   }
-  #announceChange() {
-    this.#channel?.postMessage({
-      type: "change",
-      key: this.#storageKey(),
-      owner: this.#instanceId
+  retrySync() {
+    return this.sync();
+  }
+  reset() {
+    return this.#enqueue(async () => {
+      await this.#storage.remove(this.#config.id, this.#userId);
+      return this.#initializeFresh();
     });
   }
-  async #reloadFromStorage() {
-    if (this.#state === "syncing") return;
-    try {
-      const key = this.#storageKey();
-      this.#operations = (await this.#storage.load(key)).map(normalizeOperation);
-      this.#rejectedHistory = (await this.#storage.loadRejectedHistory?.(key))?.map(normalizeRejectedHistory) ?? this.#rejectedHistory;
-      this.#loaded = true;
-    } catch {
-    }
+  restore(state) {
+    return this.#enqueue(async () => {
+      if (state.rallyId !== this.#config.id || state.userId !== this.#userId)
+        throw new Error("State belongs to another rally or user.");
+      const next = this.#reconcile(state);
+      await this.#storage.save(next);
+      this.#state = next;
+      this.#initialization = Promise.resolve(next);
+      this.#emit(next);
+      return next;
+    });
   }
-  #lockKey() {
-    return `${this.#storageKey()}:sync-lock`;
+  #enqueue(operation) {
+    const next = this.#queue.then(operation, operation);
+    this.#queue = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
   }
-  #acquireSyncLock() {
-    const key = this.#lockKey();
-    const now = Date.now();
-    const local = syncLocks.get(key);
-    if (local !== void 0 && local.expiresAt > now && local.owner !== this.#instanceId)
-      return false;
-    const observed = this.#observedLocks.get(key);
-    if (observed !== void 0 && observed.expiresAt > now && observed.owner !== this.#instanceId)
-      return false;
-    if (this.#lockStorage !== null) {
-      try {
-        const existing = this.#lockStorage.getItem(key);
-        if (existing !== null) {
-          const parsed = JSON.parse(existing);
-          if (typeof parsed === "object" && parsed !== null && typeof parsed.expiresAt === "number" && parsed.expiresAt > now && parsed.owner !== this.#instanceId)
-            return false;
-        }
-        this.#lockStorage.setItem(
-          key,
-          JSON.stringify({ owner: this.#instanceId, expiresAt: now + SYNC_LOCK_TTL_MS })
+  #initializeFresh() {
+    const next = emptyState(this.#config, this.#userId, this.#now());
+    this.#state = next;
+    this.#initialization = Promise.resolve(next);
+    this.#emit(next);
+    return Promise.resolve(next);
+  }
+  #reconcile(state) {
+    const ids = new Set(this.#config.spots.map((spot2) => spot2.id));
+    const records = state.records.filter(
+      (record, index, all) => ids.has(record.stampId) && all.findIndex((candidate) => candidate.stampId === record.stampId) === index
+    );
+    return {
+      ...cloneState(state),
+      userId: this.#userId,
+      records,
+      rewards: reconcileRewardStates(
+        this.#config.rewards,
+        state.rewards,
+        records.length,
+        state.updatedAt
+      )
+    };
+  }
+  async #handleOfflineSyncResult(event) {
+    if (event.status === "ACCEPTED") {
+      if (this.#syncMetrics !== null) this.#syncMetrics.processed += 1;
+      if (event.state !== void 0) {
+        const rebuilt = rebuildUserStateFromLog(
+          event.state,
+          this.#offlineQueue?.operations ?? [],
+          this.#config
         );
-        this.#channel?.postMessage({
-          type: "lock",
-          lockKey: key,
-          owner: this.#instanceId,
-          expiresAt: now + SYNC_LOCK_TTL_MS
-        });
-      } catch {
-        this.#warnMemoryLock("Persistent lock access failed; offline sync is single-tab only.");
+        const next = this.#reconcile(rebuilt);
+        await this.#storage.save(next);
+        this.#state = next;
+        this.#emit(next);
       }
-    }
-    syncLocks.set(key, { owner: this.#instanceId, expiresAt: now + SYNC_LOCK_TTL_MS });
-    return true;
-  }
-  #releaseSyncLock() {
-    const key = this.#lockKey();
-    const current = syncLocks.get(key);
-    if (current?.owner === this.#instanceId) syncLocks.delete(key);
-    if (this.#lockStorage !== null) {
-      try {
-        const value = this.#lockStorage.getItem(key);
-        if (value !== null && JSON.parse(value).owner === this.#instanceId)
-          this.#lockStorage.removeItem?.(key);
-        this.#channel?.postMessage({ type: "unlock", lockKey: key, owner: this.#instanceId });
-      } catch {
+      this.#emitSyncEvent({
+        type: "OPERATION_ACCEPTED",
+        operationId: this.#operationId(event.operation),
+        resourceId: this.#resourceId(event.operation)
+      });
+    } else if (event.status === "REJECTED_PERMANENT") {
+      const error = event.error ?? {
+        code: "REJECTED_PERMANENT",
+        message: "Offline operation was rejected."
+      };
+      if (this.#syncMetrics !== null) {
+        this.#syncMetrics.processed += 1;
+        this.#syncMetrics.failed += 1;
       }
+      const base = event.state ?? this.#state ?? event.operation.request.state;
+      const rollbackBase = event.state === void 0 ? rollbackOptimisticOperation(base, event.operation) : base;
+      const rebuilt = rebuildUserStateFromLog(
+        rollbackBase,
+        this.#offlineQueue?.operations ?? [],
+        this.#config
+      );
+      const next = this.#reconcile(rebuilt);
+      await this.#storage.save(next);
+      this.#state = next;
+      this.#emit(next);
+      this.#emitSyncEvent({
+        type: "OPERATION_ROLLED_BACK",
+        operationId: this.#operationId(event.operation),
+        resourceId: this.#resourceId(event.operation),
+        reason: errorMessage(error, "Offline operation was rejected."),
+        errorCode: error.code
+      });
+    } else if (event.status === "RETRYABLE_ERROR") {
+      if (this.#syncMetrics !== null) this.#syncMetrics.failed += 1;
+      this.#emitSyncEvent({
+        type: "OPERATION_RETRYABLE_ERROR",
+        operationId: this.#operationId(event.operation),
+        error: errorMessage(event.error, "Retryable sync error.")
+      });
+    }
+    if (event.state !== void 0 && event.status === void 0) {
+      const next = this.#reconcile(event.state);
+      await this.#storage.save(next);
+      this.#state = next;
+      this.#emit(next);
     }
+    if (event.error !== void 0) this.#emitEvent({ type: "error", error: event.error });
+    else if (event.result !== void 0 && "ok" in event.result && !event.result.ok)
+      this.#emitEvent({ type: "error", error: event.result.error });
   }
-  #storageKey() {
-    if (this.#configuredKey !== void 0) return this.#configuredKey;
-    return `stamprally:queue:${this.#rallyId ?? "unscoped"}:${this.#userId ?? "anonymous"}`;
+  #now() {
+    return this.#options.clock?.() ?? (/* @__PURE__ */ new Date()).toISOString();
   }
-  #normalizeResponse(value) {
-    if ("ok" in value) {
-      if (value.ok === false) {
-        if ("status" in value && value.status === "RETRYABLE_ERROR")
-          return { status: "RETRYABLE_ERROR", error: errorValue(value.error, "RETRYABLE_ERROR") };
-        return { status: "REJECTED_PERMANENT", result: value };
-      }
-      return { status: "ACCEPTED", result: value };
+  #fail(error) {
+    this.#emitEvent({ type: "error", error });
+    return { ok: false, error };
+  }
+  #commitCheckIn(result) {
+    if (result.ok) {
+      this.#state = result.value.state;
+      this.#emit(this.#state);
     }
-    if ("status" in value) {
-      if (value.status === "ACCEPTED") return value;
-      return value;
+    this.#emitEvent({ type: "checkIn", result });
+    return result;
+  }
+  #commitClaim(result) {
+    if (result.ok) {
+      this.#state = result.value.state;
+      this.#emit(this.#state);
     }
-    return { status: "ACCEPTED", result: value };
+    this.#emitEvent({ type: "rewardClaimed", result });
+    return result;
   }
-  async resolveConflict(operation, localState, serverState) {
-    const configured = this.#onSyncConflict;
-    const policy = (typeof configured === "function" ? await configured({ operation, localState, serverState }) : configured) ?? this.#conflictPolicy;
-    return resolveRallyStateConflict(serverState, localState, { policy });
+  #emit(state) {
+    for (const listener of this.#listeners) listener(state);
   }
-  async #saveRejectedHistory() {
-    await this.#storage.saveRejectedHistory?.(this.#storageKey(), this.#rejectedHistory);
+  #emitEvent(event) {
+    for (const listener of this.#eventListeners) listener(event);
   }
-  #warnMemoryLock(message) {
-    if (this.#warnedMemoryLock) return;
-    this.#warnedMemoryLock = true;
-    console.warn(`[@stamprally/core] ${message}`);
+  #emitSyncEvent(event) {
+    for (const listener of this.#syncEventListeners) listener(event);
+    this.#emitEvent({ type: "syncLifecycle", event });
+  }
+  #operationId(operation) {
+    const identity = operation.request.userId ?? operation.request.anonymousSessionId ?? "anonymous";
+    return `${operation.kind}:${operation.request.rallyId}:${identity}:${operation.request.idempotencyKey}`;
+  }
+  #resourceId(operation) {
+    return operation.kind === "checkIn" ? operation.request.spotId : operation.request.rewardId;
   }
 };
-function normalizeOperation(operation) {
-  const status = operation.status;
-  return {
-    ...operation,
-    status: status === "IN_FLIGHT" || status === "REJECTED" ? "PENDING" : status === "RETRYABLE_ERROR" ? "FAILED_RETRYABLE" : operation.status ?? "PENDING",
-    attempts: operation.attempts ?? 0
-  };
-}
-function normalizeRejectedHistory(entry) {
-  return {
-    ...entry,
-    operation: normalizeOperation(entry.operation),
-    reason: errorValue(entry.reason, "REJECTED_PERMANENT"),
-    errorCode: entry.errorCode || entry.reason.code,
-    rejectedAt: entry.rejectedAt || (/* @__PURE__ */ new Date(0)).toISOString(),
-    attempts: entry.attempts ?? entry.operation.attempts ?? 0
-  };
-}
 
 // src/crypto/token.ts
 var encoder = new TextEncoder();
@@ -2622,6 +2881,18 @@ function finiteNumber(value, key, path, errors, minimum) {
     );
   }
 }
+function nonNegativeInteger(value, key, path, errors) {
+  const item = value[key];
+  if (typeof item !== "number" || !Number.isFinite(item)) {
+    add(errors, `${path}.${key}`, "Expected a finite number.", "invalid_number");
+    return;
+  }
+  if (!Number.isInteger(item)) {
+    add(errors, `${path}.${key}`, "Expected a non-negative integer.", "invalid_integer");
+    return;
+  }
+  if (item < 0) add(errors, `${path}.${key}`, "Expected a non-negative integer.", "out_of_range");
+}
 function localizedText(value, path, errors) {
   if (typeof value === "string") return;
   if (!isRecord3(value)) {
@@ -2650,7 +2921,11 @@ function theme(value, path, errors) {
   finiteNumber(value, "gridColumns", path, errors, 1);
   if (typeof value.gridColumns === "number" && !Number.isInteger(value.gridColumns))
     add(errors, `${path}.gridColumns`, "Expected an integer.", "invalid_integer");
-  if (hasOwn(value, "unclaimedOpacity")) finiteNumber(value, "unclaimedOpacity", path, errors, 0);
+  if (hasOwn(value, "unclaimedOpacity")) {
+    finiteNumber(value, "unclaimedOpacity", path, errors, 0);
+    if (typeof value.unclaimedOpacity === "number" && value.unclaimedOpacity > 1)
+      add(errors, `${path}.unclaimedOpacity`, "Expected a value between 0 and 1.", "out_of_range");
+  }
 }
 function externalReferences(value, path, errors) {
   if (!Array.isArray(value)) {
@@ -2813,14 +3088,14 @@ function reward(value, path, errors, isPublic) {
     String(value.redemptionMethod)
   ))
     add(errors, `${path}.redemptionMethod`, "Unknown redemption method.", "invalid_enum");
-  finiteNumber(value, "requiredStampCount", path, errors, 0);
+  nonNegativeInteger(value, "requiredStampCount", path, errors);
   for (const key of ["stockLimit", "userClaimLimit"]) {
     if (hasOwn(value, key) && value[key] !== void 0) {
-      finiteNumber(value, key, path, errors, 0);
-      if (typeof value[key] === "number" && !Number.isInteger(value[key]))
-        add(errors, `${path}.${key}`, "Expected an integer.", "invalid_integer");
+      nonNegativeInteger(value, key, path, errors);
     }
   }
+  optionalString(value, "stockKey", path, errors);
+  optionalString(value, "secondaryStockKey", path, errors);
   optionalString(value, "validUntil", path, errors);
   if (typeof value.validUntil === "string" && Number.isNaN(Date.parse(value.validUntil)))
     add(errors, `${path}.validUntil`, "Expected a valid date string.", "invalid_date");
@@ -2864,8 +3139,31 @@ function validate(value, isPublic) {
     });
   if (!isPublic) {
     optionalString(value, "staffPasscode", "$", errors);
-    if (hasOwn(value, "inventory") && value.inventory !== void 0 && !isRecord3(value.inventory))
-      add(errors, "$.inventory", "Expected an object.", "invalid_type");
+    if (hasOwn(value, "inventory") && value.inventory !== void 0) {
+      if (!isRecord3(value.inventory))
+        add(errors, "$.inventory", "Expected an object.", "invalid_type");
+      else {
+        for (const [key, item] of Object.entries(value.inventory)) {
+          if (key === "global") {
+            add(
+              errors,
+              "$.inventory.global",
+              "Use sharedStock instead of global.",
+              "deprecated_field"
+            );
+            continue;
+          }
+          if (item !== void 0) nonNegativeInteger(value.inventory, key, "$.inventory", errors);
+        }
+        if (hasOwn(value.inventory, "sharedStock") && hasOwn(value.inventory, "global"))
+          add(
+            errors,
+            "$.inventory",
+            "sharedStock and global cannot be configured together.",
+            "conflicting_fields"
+          );
+      }
+    }
     if (hasOwn(value, "inventoryMode") && value.inventoryMode !== void 0 && value.inventoryMode !== "shared" && value.inventoryMode !== "per_reward")
       add(errors, "$.inventoryMode", "Expected shared or per_reward.", "invalid_enum");
     if (hasOwn(value, "serverMetadata") && value.serverMetadata !== void 0 && !isRecord3(value.serverMetadata))
@@ -2939,6 +3237,33 @@ function validateRallyConfigRelations(config) {
     reward2.conditions?.forEach((condition2, conditionIndex) => {
       visit(condition2, `rewards[${index}].conditions[${conditionIndex}]`);
     });
+    if (reward2.requiredStampCount > config.spots.length)
+      add(
+        errors,
+        `rewards[${index}].requiredStampCount`,
+        "requiredStampCount cannot exceed the number of spots.",
+        "required_stamp_count_exceeds_spots"
+      );
+    const inventory = "inventory" in config ? config.inventory : void 0;
+    for (const [field, key] of [
+      ["stockKey", reward2.stockKey],
+      ["secondaryStockKey", reward2.secondaryStockKey]
+    ]) {
+      if (key !== void 0 && key !== "__shared__" && inventory?.[key] === void 0)
+        add(
+          errors,
+          `rewards[${index}].${field}`,
+          "Referenced inventory key does not exist.",
+          "missing_inventory_key"
+        );
+    }
+    if (reward2.stockKey === "__shared__" && inventory?.sharedStock === void 0)
+      add(
+        errors,
+        `rewards[${index}].stockKey`,
+        "sharedStock is not defined.",
+        "missing_inventory_key"
+      );
   });
   const visiting = /* @__PURE__ */ new Set();
   const visited = /* @__PURE__ */ new Set();
@@ -3109,6 +3434,6 @@ async function verifySnapshotToken(token, secretKey, now = Date.now()) {
   }
 }
 
-export { ConfigValidationError, DEFAULT_SHEET_THEME, MemoryQueueStorage as InMemoryOfflineQueueStorage, InMemoryStorage, IndexedDBAdapter, IndexedDBOfflineQueueStorage, LocalStorageAdapter, OfflineQueue, StampRallyClient, StorageAdapterError, THEME_PRESETS, assertPublicConfig, calculateDistanceMeters, calculateProgress, consumeReward, createAnonymousSessionId, createClaimTicketNumber, createSecureToken, createSignedSnapshotToken, createUniqueClaimTicketNumber, evaluateCondition, evaluateConditionDetailed, evaluateSpotStatus, exportProgressToken, getCurrentGeoContext, getOrderedSpots, getSpotStatus, importProgressToken, isGeolocationSupported, isNfcSupported, isPublicConfig, isQrSupported, isRewardState, isStampRallyState, issueClaimTicketNumber, normalizePasscode, offlineOperationId, parseAdminConfig, parsePublicConfig, processStamp, readNfcContext, readQrContext, reconcileRewardStates, resolveLocalizedText, resolveRallyStateConflict, safeParseAdminConfig, safeParsePublicConfig, sanitizeAdminConfig, storageKey, toLocalizedString, toPublicConfig, updateLocalizedField, validatePublicConfigSafety, validateRallyConfigRelations, verifyPasscode, verifySecureToken, verifySnapshotToken };
+export { ConfigValidationError, DEFAULT_SHEET_THEME, MemoryQueueStorage as InMemoryOfflineQueueStorage, InMemoryStorage, IndexedDBAdapter, IndexedDBOfflineQueueStorage, LocalStorageAdapter, OfflineQueue, StampRallyClient, StorageAdapterError, THEME_PRESETS, assertPublicConfig, calculateDistanceMeters, calculateProgress, consumeReward, createAnonymousSessionId, createClaimTicketNumber, createSecureToken, createSignedSnapshotToken, createUniqueClaimTicketNumber, evaluateCondition, evaluateConditionDetailed, evaluateSpotStatus, exportProgressToken, getCurrentGeoContext, getOrderedSpots, getSpotStatus, importProgressToken, isGeolocationSupported, isNfcSupported, isPublicConfig, isQrSupported, isRewardState, isStampRallyState, issueClaimTicketNumber, normalizePasscode, offlineOperationId, parseAdminConfig, parsePublicConfig, processStamp, readNfcContext, readQrContext, rebuildUserStateFromLog, rebuildUserStateLog, reconcileRewardStates, resolveLocalizedText, resolveRallyStateConflict, rollbackOptimisticOperation, safeParseAdminConfig, safeParsePublicConfig, sanitizeAdminConfig, storageKey, toLocalizedString, toPublicConfig, updateLocalizedField, validatePublicConfigSafety, validateRallyConfigRelations, verifyPasscode, verifySecureToken, verifySnapshotToken };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map