@stamprally/core 0.9.0 → 0.11.0

package/dist/index.cjs

@@ -12,34 +12,34 @@ function calculateDistanceMeters(aLat, aLon, bLat, bLon) {
 function mismatch(conditionType, reason, extra = {}) {
   return { ok: false, error: { code: "CONDITION_MISMATCH", conditionType, reason, ...extra } };
 }
-function evaluateConditionDetailed(condition, context) {
-  switch (condition.type) {
+function evaluateConditionDetailed(condition2, context) {
+  switch (condition2.type) {
     case "qr":
-      return context.type === "qr" && context.token === condition.secretToken ? { ok: true, value: { conditionType: "qr" } } : mismatch("qr", "INVALID_PROOF");
+      return context.type === "qr" && context.token === condition2.secretToken ? { ok: true, value: { conditionType: "qr" } } : mismatch("qr", "INVALID_PROOF");
     case "passcode":
-      return context.type === "passcode" && (condition.caseSensitive === false ? context.code.toLocaleLowerCase() === condition.code.toLocaleLowerCase() : context.code === condition.code) ? { ok: true, value: { conditionType: "passcode" } } : mismatch("passcode", "INVALID_PROOF");
+      return context.type === "passcode" && (condition2.caseSensitive === false ? context.code.toLocaleLowerCase() === condition2.code.toLocaleLowerCase() : context.code === condition2.code) ? { ok: true, value: { conditionType: "passcode" } } : mismatch("passcode", "INVALID_PROOF");
     case "nfc":
-      return context.type === "nfc" && context.tagId === condition.tagId ? { ok: true, value: { conditionType: "nfc" } } : mismatch("nfc", "INVALID_PROOF");
+      return context.type === "nfc" && context.tagId === condition2.tagId ? { ok: true, value: { conditionType: "nfc" } } : mismatch("nfc", "INVALID_PROOF");
     case "custom":
       return mismatch("custom", "VALIDATOR_FAILED");
     case "gps": {
-      if (!Number.isFinite(condition.latitude) || !Number.isFinite(condition.longitude) || !Number.isFinite(condition.radiusMeters) || condition.radiusMeters < 0 || context.type !== "gps" || !Number.isFinite(context.latitude) || !Number.isFinite(context.longitude))
+      if (!Number.isFinite(condition2.latitude) || !Number.isFinite(condition2.longitude) || !Number.isFinite(condition2.radiusMeters) || condition2.radiusMeters < 0 || context.type !== "gps" || !Number.isFinite(context.latitude) || !Number.isFinite(context.longitude))
         return mismatch("gps", "INVALID_GEO_INPUT");
       const distanceMeters = calculateDistanceMeters(
-        condition.latitude,
-        condition.longitude,
+        condition2.latitude,
+        condition2.longitude,
         context.latitude,
         context.longitude
       );
-      return distanceMeters <= condition.radiusMeters ? { ok: true, value: { conditionType: "gps", distanceMeters } } : mismatch("gps", "OUTSIDE_RADIUS", {
+      return distanceMeters <= condition2.radiusMeters ? { ok: true, value: { conditionType: "gps", distanceMeters } } : mismatch("gps", "OUTSIDE_RADIUS", {
         distanceMeters,
-        radiusMeters: condition.radiusMeters
+        radiusMeters: condition2.radiusMeters
       });
     }
   }
 }
-function evaluateCondition(condition, context) {
-  return evaluateConditionDetailed(condition, context).ok;
+function evaluateCondition(condition2, context) {
+  return evaluateConditionDetailed(condition2, context).ok;
 }
 
 // src/engine/order.ts
@@ -49,11 +49,11 @@ function getOrderedSpots(spots) {
 
 // src/engine/progress.ts
 function calculateProgress(state, config) {
-  const ids = new Set(config.spots.map((spot) => spot.id));
+  const ids = new Set(config.spots.map((spot2) => spot2.id));
   const acquired = new Set(
     state.records.map((record) => record.stampId).filter((id2) => ids.has(id2))
   );
-  const remaining = config.spots.filter((spot) => !acquired.has(spot.id));
+  const remaining = config.spots.filter((spot2) => !acquired.has(spot2.id));
   return {
     acquired: acquired.size,
     total: config.spots.length,
@@ -93,9 +93,9 @@ function createUniqueClaimTicketNumber(rewardId, issuedAt) {
   const timestampPart = Number.isNaN(timestamp) ? Date.now() : timestamp;
   return `CLAIM-${rewardId}-${timestampPart}-${createRandomHash()}`;
 }
-function issueClaimTicketNumber(reward, currentState, options = {}) {
+function issueClaimTicketNumber(reward2, currentState, options = {}) {
   if (currentState.claimTicketNumber !== void 0) return currentState;
-  const claimTicketNumber = createClaimTicketNumber(reward.id, options);
+  const claimTicketNumber = createClaimTicketNumber(reward2.id, options);
   return { ...currentState, claimTicketNumber };
 }
 
@@ -303,8 +303,8 @@ function normalizePasscode(input, caseSensitive = false) {
   const normalized = input.normalize("NFKC").trim();
   return caseSensitive ? normalized : normalized.toUpperCase();
 }
-function verifyPasscode(inputCode, condition) {
-  return normalizePasscode(inputCode, condition.caseSensitive) === normalizePasscode(condition.code, condition.caseSensitive) ? { success: true } : { success: false, message: "The passcode is invalid." };
+function verifyPasscode(inputCode, condition2) {
+  return normalizePasscode(inputCode, condition2.caseSensitive) === normalizePasscode(condition2.code, condition2.caseSensitive) ? { success: true } : { success: false, message: "The passcode is invalid." };
 }
 
 // src/detectors/qr.ts
@@ -431,71 +431,71 @@ async function readQrContext(videoElement, options = {}) {
 // src/engine/transition.ts
 function reconcileRewardStates(rewards, currentStates, acquiredStampCount, now) {
   const states = new Map(currentStates.map((state) => [state.rewardId, state]));
-  return rewards.map((reward) => {
-    const current = states.get(reward.id);
+  return rewards.map((reward2) => {
+    const current = states.get(reward2.id);
     if (current?.status === "CONSUMED" || current?.status === "EXPIRED") return current;
-    if (reward.validUntil !== void 0 && Date.parse(reward.validUntil) <= Date.parse(now))
-      return { rewardId: reward.id, status: "EXPIRED" };
-    if (reward.stockLimit !== void 0 && (current?.redeemedCount ?? 0) >= reward.stockLimit)
-      return { rewardId: reward.id, status: "EXPIRED" };
-    if (acquiredStampCount >= reward.requiredStampCount)
+    if (reward2.validUntil !== void 0 && Date.parse(reward2.validUntil) <= Date.parse(now))
+      return { rewardId: reward2.id, status: "EXPIRED" };
+    if (reward2.stockLimit !== void 0 && (current?.redeemedCount ?? 0) >= reward2.stockLimit)
+      return { rewardId: reward2.id, status: "EXPIRED" };
+    if (acquiredStampCount >= reward2.requiredStampCount)
       return {
-        rewardId: reward.id,
+        rewardId: reward2.id,
         status: "AVAILABLE",
         ...current?.unlockedAt === void 0 ? { unlockedAt: now } : { unlockedAt: current.unlockedAt }
       };
-    return { rewardId: reward.id, status: "LOCKED" };
+    return { rewardId: reward2.id, status: "LOCKED" };
   });
 }
 function consumeReward(params) {
-  const { reward, currentState } = params;
+  const { reward: reward2, currentState } = params;
   if (currentState.status === "CONSUMED")
-    return { ok: false, error: { code: "ALREADY_CONSUMED", rewardId: reward.id } };
+    return { ok: false, error: { code: "ALREADY_CONSUMED", rewardId: reward2.id } };
   if (currentState.status !== "AVAILABLE")
-    return { ok: false, error: { code: "NOT_AVAILABLE", rewardId: reward.id } };
-  if (reward.validUntil !== void 0 && Date.parse(reward.validUntil) <= Date.parse(params.now))
-    return { ok: false, error: { code: "EXPIRED", rewardId: reward.id } };
-  if (reward.stockLimit !== void 0 && (currentState.redeemedCount ?? 0) >= reward.stockLimit)
-    return { ok: false, error: { code: "OUT_OF_STOCK", rewardId: reward.id } };
-  if (reward.userClaimLimit !== void 0 && (params.userRedemptionCount ?? currentState.userRedemptionCount ?? 0) >= reward.userClaimLimit)
-    return { ok: false, error: { code: "USER_LIMIT_REACHED", rewardId: reward.id } };
-  if (reward.redemptionMethod === "staff_passcode") {
-    if (reward.staffPasscode === void 0 || !verifyPasscode(params.inputPasscode ?? "", { code: reward.staffPasscode }).success)
+    return { ok: false, error: { code: "NOT_AVAILABLE", rewardId: reward2.id } };
+  if (reward2.validUntil !== void 0 && Date.parse(reward2.validUntil) <= Date.parse(params.now))
+    return { ok: false, error: { code: "EXPIRED", rewardId: reward2.id } };
+  if (reward2.stockLimit !== void 0 && (currentState.redeemedCount ?? 0) >= reward2.stockLimit)
+    return { ok: false, error: { code: "OUT_OF_STOCK", rewardId: reward2.id } };
+  if (reward2.userClaimLimit !== void 0 && (params.userRedemptionCount ?? currentState.userRedemptionCount ?? 0) >= reward2.userClaimLimit)
+    return { ok: false, error: { code: "USER_LIMIT_REACHED", rewardId: reward2.id } };
+  if (reward2.redemptionMethod === "staff_passcode") {
+    if (reward2.staffPasscode === void 0 || !verifyPasscode(params.inputPasscode ?? "", { code: reward2.staffPasscode }).success)
       return {
         ok: false,
         error: {
           code: "INVALID_PASSCODE",
-          rewardId: reward.id,
+          rewardId: reward2.id,
           message: "The passcode is invalid."
         }
       };
   }
-  if (reward.redemptionMethod === "view_only") return { ok: true, value: currentState };
+  if (reward2.redemptionMethod === "view_only") return { ok: true, value: currentState };
   return {
     ok: true,
     value: {
       ...currentState,
       status: "CONSUMED",
       consumedAt: params.now,
-      claimTicketNumber: createUniqueClaimTicketNumber(reward.id, params.now),
+      claimTicketNumber: createUniqueClaimTicketNumber(reward2.id, params.now),
       redeemedCount: (currentState.redeemedCount ?? 0) + 1,
       ...params.staffId === void 0 ? {} : { consumedByStaffId: params.staffId }
     }
   };
 }
 function processStamp(state, config, spotId, context, now) {
-  const spot = config.spots.find((item) => item.id === spotId);
-  if (spot === void 0) return { ok: false, error: { code: "SPOT_NOT_FOUND", spotId } };
+  const spot2 = config.spots.find((item) => item.id === spotId);
+  if (spot2 === void 0) return { ok: false, error: { code: "SPOT_NOT_FOUND", spotId } };
   if (state.records.some((record2) => record2.stampId === spotId))
     return { ok: false, error: { code: "STAMP_ALREADY_ACQUIRED", spotId } };
   const acquired = new Set(state.records.map((record2) => record2.stampId));
-  if (spot.prerequisites?.some((id2) => !acquired.has(id2)))
+  if (spot2.prerequisites?.some((id2) => !acquired.has(id2)))
     return { ok: false, error: { code: "PREREQUISITES_NOT_MET", spotId } };
-  for (const condition of spot.conditions) {
-    if (condition.type === "custom" || !evaluateConditionDetailed(condition, context).ok)
+  for (const condition2 of spot2.conditions) {
+    if (condition2.type === "custom" || !evaluateConditionDetailed(condition2, context).ok)
       return {
         ok: false,
-        error: condition.type === "custom" ? {
+        error: condition2.type === "custom" ? {
           code: "CUSTOM_VALIDATION_FAILED",
           spotId,
           message: "Custom validation requires an async validator."
@@ -959,18 +959,18 @@ function proof(value) {
   }
   return "";
 }
-function matches(condition, value) {
-  if (condition.type === "gps") {
+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 - condition.latitude);
-    const dLon = radians(longitude - condition.longitude);
-    const h = Math.sin(dLat / 2) ** 2 + Math.cos(radians(condition.latitude)) * Math.cos(radians(latitude)) * Math.sin(dLon / 2) ** 2;
-    return 6371e3 * 2 * Math.asin(Math.sqrt(Math.min(1, h))) <= condition.radiusMeters;
+    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;
   }
   return proof(value).trim() !== "";
 }
@@ -989,6 +989,7 @@ var StampRallyClient = class {
   #storage;
   #options;
   #config;
+  #offlineQueue;
   #userId;
   #state = null;
   #initialization = null;
@@ -998,6 +999,7 @@ var StampRallyClient = class {
     this.#options = isStorage(storageOrOptions) ? { storage: storageOrOptions } : storageOrOptions;
     this.#storage = this.#options.storage ?? new InMemoryStorage();
     this.#userId = this.#options.userId ?? null;
+    this.#offlineQueue = this.#options.offlineQueue;
   }
   getConfig() {
     return this.#config;
@@ -1008,6 +1010,12 @@ var StampRallyClient = class {
   getUserId() {
     return this.#userId;
   }
+  get syncState() {
+    return this.#offlineQueue?.syncState ?? "idle";
+  }
+  get pendingCount() {
+    return this.#offlineQueue?.pendingCount ?? 0;
+  }
   subscribe(listener) {
     this.#listeners.add(listener);
     return () => this.#listeners.delete(listener);
@@ -1057,8 +1065,8 @@ var StampRallyClient = class {
   checkIn(spotId, proofData, options = {}) {
     return this.#enqueue(async () => {
       const current = await this.initialize();
-      const spot = this.#config.spots.find((item) => item.id === spotId);
-      if (spot === void 0)
+      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({
@@ -1067,15 +1075,15 @@ var StampRallyClient = class {
           message: "Spot was already claimed."
         });
       const acquired = new Set(current.records.map((record2) => record2.stampId));
-      if (spot.prerequisites?.some((id2) => !acquired.has(id2)))
+      if (spot2.prerequisites?.some((id2) => !acquired.has(id2)))
         return this.#fail({
           code: "PREREQUISITES_NOT_MET",
           spotId,
           message: "Prerequisite spots are not complete."
         });
-      for (const condition of spot.conditions) {
-        if (condition.type === "custom") {
-          const validator = this.#options.customValidators?.[condition.validatorName] ?? this.#options.customValidator;
+      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",
@@ -1086,7 +1094,7 @@ var StampRallyClient = class {
             rallyId: this.#config.id,
             spotId,
             proofData,
-            condition: { type: "custom", validatorName: condition.validatorName },
+            condition: { type: "custom", validatorName: condition2.validatorName },
             userState: current
           };
           const result = typeof validator === "function" ? await validator(context) : await validator.validate(context);
@@ -1096,7 +1104,7 @@ var StampRallyClient = class {
               spotId,
               message: typeof result === "object" && result.message !== void 0 ? result.message : "Custom validation failed."
             });
-        } else if (!matches(condition, proofData))
+        } else if (!matches(condition2, proofData))
           return this.#fail({ code: "INVALID_PROOF", spotId, message: "Verification failed." });
       }
       const now = options.now ?? this.#now();
@@ -1111,8 +1119,21 @@ var StampRallyClient = class {
       };
       const remote = this.#options.syncAdapter?.checkIn;
       if (options.sync !== false && remote !== void 0) {
-        const result = await remote(request);
-        return result.ok ? this.#commitCheckIn(result) : this.#fail(result.error);
+        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({
@@ -1154,8 +1175,22 @@ var StampRallyClient = class {
       };
       const remote = this.#options.syncAdapter?.claimReward;
       if (options.sync !== false && remote !== void 0) {
-        const result = await remote(request);
-        return result.ok ? this.#commitClaim(result) : this.#fail(result.error);
+        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,
@@ -1169,6 +1204,18 @@ var StampRallyClient = class {
   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: current });
         return;
@@ -1182,6 +1229,9 @@ var StampRallyClient = class {
       this.#emitEvent({ type: "sync", state: next });
     });
   }
+  retrySync() {
+    return this.sync();
+  }
   reset() {
     return this.#enqueue(async () => {
       await this.#storage.remove(this.#config.id, this.#userId);
@@ -1216,7 +1266,7 @@ var StampRallyClient = class {
     return Promise.resolve(next);
   }
   #reconcile(state) {
-    const ids = new Set(this.#config.spots.map((spot) => spot.id));
+    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
     );
@@ -1263,6 +1313,205 @@ var StampRallyClient = class {
   }
 };
 
+// src/client/offlineQueue.ts
+var MemoryQueueStorage = class {
+  #values = /* @__PURE__ */ new Map();
+  async load(key) {
+    return this.#values.get(key) ?? [];
+  }
+  async save(key, operations) {
+    this.#values.set(key, structuredClone(operations));
+  }
+};
+var LocalStorageQueueStorage = class {
+  constructor(storage) {
+    this.storage = storage;
+  }
+  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 [];
+    }
+  }
+  async save(key, operations) {
+    this.storage.setItem(key, JSON.stringify(operations));
+  }
+};
+var IndexedDBOfflineQueueStorage = class {
+  #providedFactory;
+  #databaseName;
+  #databasePromise = null;
+  constructor(options = {}) {
+    this.#providedFactory = options.indexedDB;
+    this.#databaseName = options.databaseName ?? "stamprally-offline-queue";
+  }
+  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."));
+    });
+  }
+  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."));
+    });
+  }
+  #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;
+  }
+};
+function defaultStorage(databaseName) {
+  try {
+    const indexedDB = globalThis.indexedDB;
+    if (indexedDB !== void 0)
+      return new IndexedDBOfflineQueueStorage({
+        indexedDB,
+        ...databaseName === void 0 ? {} : { databaseName }
+      });
+    const storage = globalThis.localStorage;
+    if (storage !== void 0 && storage !== null) return new LocalStorageQueueStorage(storage);
+  } catch {
+  }
+  return new MemoryQueueStorage();
+}
+function operationId(operation) {
+  return operation.kind === "checkIn" ? `checkIn:${operation.request.rallyId}:${operation.request.userId ?? "anonymous"}:${operation.request.idempotencyKey}` : `claimReward:${operation.request.rallyId}:${operation.request.userId ?? "anonymous"}:${operation.request.idempotencyKey}`;
+}
+var OfflineQueue = class {
+  #storage;
+  #key;
+  #conflictPolicy;
+  #onSyncConflict;
+  #operations = [];
+  #loaded = false;
+  #state = "idle";
+  #error = null;
+  #sender;
+  #syncPromise = null;
+  constructor(options = {}) {
+    if (options.storage !== void 0) this.#storage = options.storage;
+    else if (options.storageLike !== void 0 && options.storageLike !== null)
+      this.#storage = new LocalStorageQueueStorage(options.storageLike);
+    else this.#storage = defaultStorage(options.databaseName);
+    this.#key = options.key ?? "stamprally:offline-queue";
+    this.#conflictPolicy = options.conflictPolicy ?? "server_wins";
+    this.#onSyncConflict = options.onSyncConflict;
+  }
+  get syncState() {
+    return this.#state;
+  }
+  get pendingCount() {
+    return this.#operations.length;
+  }
+  get error() {
+    return this.#error;
+  }
+  get operations() {
+    return this.#operations;
+  }
+  async initialize() {
+    if (this.#loaded) return;
+    this.#operations = [...await this.#storage.load(this.#key)];
+    this.#loaded = true;
+  }
+  setSender(sender) {
+    this.#sender = sender;
+  }
+  async enqueue(operation) {
+    await this.initialize();
+    const id2 = operationId(operation);
+    if (this.#operations.some((item) => operationId(item) === id2)) return;
+    this.#operations = [...this.#operations, operation];
+    await this.#storage.save(this.#key, this.#operations);
+  }
+  async enqueueCheckIn(request) {
+    return this.enqueue({ kind: "checkIn", request });
+  }
+  async enqueueClaimReward(request) {
+    return this.enqueue({ kind: "claimReward", request });
+  }
+  async clear() {
+    await this.initialize();
+    this.#operations = [];
+    await this.#storage.save(this.#key, this.#operations);
+  }
+  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 retrySync(sender = this.#sender) {
+    return this.sync(sender);
+  }
+  async #run(sender) {
+    this.#state = "syncing";
+    this.#error = null;
+    try {
+      while (this.#operations.length > 0) {
+        const operation = this.#operations[0];
+        if (operation === void 0) break;
+        let result;
+        try {
+          result = await sender(operation);
+        } catch (cause) {
+          throw cause instanceof Error ? cause : new Error(String(cause));
+        }
+        if ("conflict" in result && result.conflict === true)
+          await this.resolveConflict(operation, result.localState, result.serverState);
+        this.#operations = this.#operations.slice(1);
+        await this.#storage.save(this.#key, this.#operations);
+      }
+      this.#state = "idle";
+    } catch (cause) {
+      this.#state = "error";
+      this.#error = cause instanceof Error ? cause : new Error(String(cause));
+      throw this.#error;
+    }
+  }
+  async resolveConflict(operation, localState, serverState) {
+    const configured = this.#onSyncConflict;
+    const policy = (typeof configured === "function" ? await configured({ operation, localState, serverState }) : configured) ?? this.#conflictPolicy;
+    if (policy === "merge") {
+      return;
+    }
+  }
+};
+
 // src/crypto/token.ts
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
@@ -1395,22 +1644,6 @@ async function decryptPayload(body, secret) {
   );
 }
 
-// src/domain/i18n.ts
-function resolveLocalizedText(text, locale, fallbackLocale) {
-  if (text === void 0 || text === "") return "";
-  if (typeof text === "string") return text;
-  const fallback = fallbackLocale === void 0 ? Object.values(text).find((value) => typeof value === "string") : text[fallbackLocale];
-  return text[locale] || fallback || "";
-}
-function toLocalizedString(text) {
-  if (text === void 0) return { ja: "", en: "" };
-  return typeof text === "string" ? { ja: text, en: "" } : {
-    ja: text["ja"] ?? "",
-    en: text["en"] ?? "",
-    ...text
-  };
-}
-
 // src/domain/models.ts
 var DEFAULT_SHEET_THEME = {
   primaryColor: "#9e551e",
@@ -1422,23 +1655,23 @@ var DEFAULT_SHEET_THEME = {
   unclaimedOpacity: 1,
   fontFamily: "serif"
 };
-function publicCondition(condition) {
-  switch (condition.type) {
+function publicCondition(condition2) {
+  switch (condition2.type) {
     case "qr":
-      return condition.qrEntryUrl === void 0 ? { type: "qr" } : { type: "qr", qrEntryUrl: condition.qrEntryUrl };
+      return condition2.qrEntryUrl === void 0 ? { type: "qr" } : { type: "qr", qrEntryUrl: condition2.qrEntryUrl };
     case "passcode":
       return { type: "passcode" };
     case "gps":
       return {
         type: "gps",
-        latitude: condition.latitude,
-        longitude: condition.longitude,
-        radiusMeters: condition.radiusMeters
+        latitude: condition2.latitude,
+        longitude: condition2.longitude,
+        radiusMeters: condition2.radiusMeters
       };
     case "nfc":
       return { type: "nfc" };
     case "custom":
-      return { type: "custom", validatorName: condition.validatorName };
+      return { type: "custom", validatorName: condition2.validatorName };
   }
 }
 function toPublicConfig(config) {
@@ -1448,14 +1681,14 @@ function toPublicConfig(config) {
     title: config.title,
     ...config.description === void 0 ? {} : { description: config.description },
     ...config.theme === void 0 ? {} : { theme: config.theme },
-    spots: config.spots.map((spot) => ({
-      ...spot,
-      conditions: spot.conditions.map(publicCondition)
+    spots: config.spots.map((spot2) => ({
+      ...spot2,
+      conditions: spot2.conditions.map(publicCondition)
     })),
     rewards: config.rewards.map(
-      ({ digitalContentUrl: _content, staffPasscode: _passcode, ...reward }) => reward
+      ({ digitalContentUrl: _content, staffPasscode: _passcode, ...reward2 }) => reward2
     ),
-    ...config.metadata === void 0 ? {} : { metadata: config.metadata },
+    ...config.publicMetadata !== void 0 ? { metadata: config.publicMetadata } : config.metadata === void 0 ? {} : { metadata: config.metadata },
     ...config.serverEndpoint === void 0 ? {} : { serverEndpoint: config.serverEndpoint }
   };
 }
@@ -1491,15 +1724,15 @@ function isPublicConfig(value) {
   }
   if (typeof candidate.id !== "string" || typeof candidate.version !== "string" || typeof candidate.title !== "string" && (typeof candidate.title !== "object" || candidate.title === null || Array.isArray(candidate.title)) || !Array.isArray(candidate.spots) || !Array.isArray(candidate.rewards))
     return false;
-  return candidate.spots.every((spot) => {
-    if (typeof spot !== "object" || spot === null || Array.isArray(spot)) return false;
-    const item = spot;
+  return candidate.spots.every((spot2) => {
+    if (typeof spot2 !== "object" || spot2 === null || Array.isArray(spot2)) return false;
+    const item = spot2;
     if (typeof item.id !== "string" || typeof item.orderIndex !== "number" || item.name === void 0 || "secretToken" in item || "code" in item || "tagId" in item || "secretParams" in item)
       return false;
-    return Array.isArray(item.conditions) && item.conditions.every((condition) => {
-      if (typeof condition !== "object" || condition === null || Array.isArray(condition))
+    return Array.isArray(item.conditions) && item.conditions.every((condition2) => {
+      if (typeof condition2 !== "object" || condition2 === null || Array.isArray(condition2))
         return false;
-      const value2 = condition;
+      const value2 = condition2;
       if ("secretToken" in value2 || "code" in value2 || "tagId" in value2 || "secretParams" in value2)
         return false;
       const type = value2.type;
@@ -1507,13 +1740,125 @@ function isPublicConfig(value) {
       if (type === "custom") return typeof value2.validatorName === "string";
       return type === "gps" && typeof value2.latitude === "number" && typeof value2.longitude === "number" && typeof value2.radiusMeters === "number";
     });
-  }) && candidate.rewards.every((reward) => {
-    if (typeof reward !== "object" || reward === null || Array.isArray(reward)) return false;
-    const item = reward;
+  }) && candidate.rewards.every((reward2) => {
+    if (typeof reward2 !== "object" || reward2 === null || Array.isArray(reward2)) return false;
+    const item = reward2;
     return typeof item.id === "string" && typeof item.requiredStampCount === "number" && (item.type === "digital" || item.type === "in_person") && (item.redemptionMethod === "manual_slide" || item.redemptionMethod === "staff_passcode" || item.redemptionMethod === "view_only" || item.redemptionMethod === "server_claim") && !("staffPasscode" in item || "digitalContentUrl" in item);
   });
 }
 
+// src/domain/configTransform.ts
+var PRIVATE_KEYS = /* @__PURE__ */ new Set([
+  "staffPasscode",
+  "serverMetadata",
+  "inventory",
+  "secretToken",
+  "secretParams",
+  "digitalContentUrl",
+  "code",
+  "tagId"
+]);
+var SENSITIVE_KEY_PATTERN = /^(?:api[_-]?key|access[_-]?token|auth[_-]?token|password|private[_-]?key|secret)$/i;
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isPrivateKey(key) {
+  return PRIVATE_KEYS.has(key) || SENSITIVE_KEY_PATTERN.test(key);
+}
+function sanitizeValue(value, customFilter, seen) {
+  if (Array.isArray(value)) {
+    if (seen.has(value)) return void 0;
+    seen.add(value);
+    const items = value.map((item) => sanitizeValue(item, customFilter, seen)).filter((item) => item !== void 0);
+    return items;
+  }
+  if (!isRecord2(value)) return value;
+  if (seen.has(value)) return void 0;
+  seen.add(value);
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (isPrivateKey(key) || customFilter?.(key, item) === false) continue;
+    const sanitized = sanitizeValue(item, customFilter, seen);
+    if (sanitized !== void 0) result[key] = sanitized;
+  }
+  return result;
+}
+function sanitizeSpot(spot2, customFilter) {
+  return sanitizeValue(
+    toPublicConfig({
+      id: "__spot__",
+      version: "1",
+      title: "__spot__",
+      spots: [spot2],
+      rewards: []
+    }).spots[0],
+    customFilter,
+    /* @__PURE__ */ new WeakSet()
+  );
+}
+function sanitizeReward(reward2, customFilter) {
+  return sanitizeValue(
+    toPublicConfig({
+      id: "__reward__",
+      version: "1",
+      title: "__reward__",
+      spots: [],
+      rewards: [reward2]
+    }).rewards[0],
+    customFilter,
+    /* @__PURE__ */ new WeakSet()
+  );
+}
+function sanitizeAdminConfig(admin, customFilter) {
+  const publicConfig = toPublicConfig(admin);
+  const sanitized = sanitizeValue(publicConfig, customFilter, /* @__PURE__ */ new WeakSet());
+  sanitized.spots = admin.spots.map((spot2) => sanitizeSpot(spot2, customFilter));
+  sanitized.rewards = admin.rewards.map((reward2) => sanitizeReward(reward2, customFilter));
+  return sanitized;
+}
+function validatePublicConfigSafety(publicConfig) {
+  const leakedKeys = [];
+  const seen = /* @__PURE__ */ new WeakSet();
+  const visit = (value, path) => {
+    if (Array.isArray(value)) {
+      value.forEach((item, index) => {
+        visit(item, `${path}[${index}]`);
+      });
+      return;
+    }
+    if (!isRecord2(value) || seen.has(value)) return;
+    seen.add(value);
+    for (const [key, item] of Object.entries(value)) {
+      const nextPath = path === "$" ? key : `${path}.${key}`;
+      if (isPrivateKey(key)) leakedKeys.push(nextPath);
+      visit(item, nextPath);
+    }
+  };
+  visit(publicConfig, "$");
+  return { safe: leakedKeys.length === 0, leakedKeys };
+}
+
+// src/domain/i18n.ts
+function updateLocalizedField(current, locale, newValue) {
+  if (typeof current === "string" || current === void 0)
+    return { [locale]: newValue };
+  return { ...current, [locale]: newValue };
+}
+function resolveLocalizedText(text, locale, fallbackLocale) {
+  if (text === void 0 || text === "") return "";
+  if (typeof text === "string") return text;
+  const fallback = fallbackLocale === void 0 ? Object.values(text).find((value) => typeof value === "string") : text[fallbackLocale];
+  return text[locale] || fallback || "";
+}
+function toLocalizedString(text) {
+  if (text === void 0) return { ja: "", en: "" };
+  return typeof text === "string" ? { ja: text, en: "" } : {
+    ja: text["ja"] ?? "",
+    en: text["en"] ?? "",
+    ...text
+  };
+}
+
 // src/domain/themePresets.ts
 var THEME_PRESETS = [
   {
@@ -1613,6 +1958,326 @@ var THEME_PRESETS = [
   }
 ];
 
+// src/domain/validation.ts
+var ConfigValidationError = class extends Error {
+  constructor(errors) {
+    super(errors.map((error) => `${error.path}: ${error.message}`).join("; "));
+    this.errors = errors;
+  }
+  errors;
+  name = "ConfigValidationError";
+};
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(value, key) {
+  return Object.hasOwn(value, key);
+}
+function add(errors, path, message, code) {
+  errors.push({ path, message, code });
+}
+function requiredString(value, key, path, errors) {
+  if (typeof value[key] !== "string" || value[key].length === 0) {
+    add(errors, `${path}.${key}`, "A non-empty string is required.", "required_string");
+    return false;
+  }
+  return true;
+}
+function optionalString(value, key, path, errors) {
+  if (hasOwn(value, key) && value[key] !== void 0 && typeof value[key] !== "string")
+    add(errors, `${path}.${key}`, "Expected a string.", "invalid_type");
+}
+function optionalBoolean(value, key, path, errors) {
+  if (hasOwn(value, key) && value[key] !== void 0 && typeof value[key] !== "boolean")
+    add(errors, `${path}.${key}`, "Expected a boolean.", "invalid_type");
+}
+function finiteNumber(value, key, path, errors, minimum) {
+  const item = value[key];
+  if (typeof item !== "number" || !Number.isFinite(item)) {
+    add(errors, `${path}.${key}`, "Expected a finite number.", "invalid_number");
+  } else if (minimum !== void 0 && item < minimum) {
+    add(
+      errors,
+      `${path}.${key}`,
+      `Expected a number greater than or equal to ${minimum}.`,
+      "out_of_range"
+    );
+  }
+}
+function localizedText(value, path, errors) {
+  if (typeof value === "string") return;
+  if (!isRecord3(value)) {
+    add(errors, path, "Expected a string or a locale map.", "invalid_localized_text");
+    return;
+  }
+  for (const [locale, text] of Object.entries(value)) {
+    if (typeof text !== "string")
+      add(errors, `${path}.${locale}`, "Expected a string.", "invalid_type");
+  }
+}
+function theme(value, path, errors) {
+  if (!isRecord3(value)) {
+    add(errors, path, "Expected a theme object.", "invalid_type");
+    return;
+  }
+  for (const key of ["primaryColor", "cardBackgroundColor", "textColor"])
+    requiredString(value, key, path, errors);
+  optionalString(value, "backgroundColor", path, errors);
+  optionalString(value, "backgroundImageUrl", path, errors);
+  optionalString(value, "completedStampColor", path, errors);
+  optionalString(value, "fontFamily", path, errors);
+  const slotShape = value.slotShape;
+  if (slotShape !== "circle" && slotShape !== "square" && slotShape !== "rounded")
+    add(errors, `${path}.slotShape`, "Expected circle, square, or rounded.", "invalid_enum");
+  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);
+}
+function externalReferences(value, path, errors) {
+  if (!Array.isArray(value)) {
+    add(errors, path, "Expected an array.", "invalid_type");
+    return;
+  }
+  value.forEach((item, index) => {
+    const itemPath = `${path}[${index}]`;
+    if (!isRecord3(item)) {
+      add(errors, itemPath, "Expected an object.", "invalid_type");
+      return;
+    }
+    requiredString(item, "type", itemPath, errors);
+    requiredString(item, "id", itemPath, errors);
+    optionalString(item, "url", itemPath, errors);
+  });
+}
+function condition(value, path, errors, isPublic) {
+  if (!isRecord3(value)) {
+    add(errors, path, "Expected a condition object.", "invalid_type");
+    return;
+  }
+  const type = value.type;
+  if (type === "qr") {
+    if (isPublic) {
+      if (hasOwn(value, "secretToken"))
+        add(errors, `${path}.secretToken`, "Private field is not allowed.", "private_field");
+    } else requiredString(value, "secretToken", path, errors);
+    optionalString(value, "qrEntryUrl", path, errors);
+    return;
+  }
+  if (type === "passcode") {
+    if (isPublic) {
+      for (const key of ["code", "caseSensitive"])
+        if (hasOwn(value, key))
+          add(errors, `${path}.${key}`, "Private field is not allowed.", "private_field");
+    } else {
+      requiredString(value, "code", path, errors);
+      optionalBoolean(value, "caseSensitive", path, errors);
+    }
+    return;
+  }
+  if (type === "gps") {
+    finiteNumber(value, "latitude", path, errors);
+    finiteNumber(value, "longitude", path, errors);
+    finiteNumber(value, "radiusMeters", path, errors, 0);
+    if (typeof value.latitude === "number" && (value.latitude < -90 || value.latitude > 90))
+      add(errors, `${path}.latitude`, "Expected a latitude between -90 and 90.", "out_of_range");
+    if (typeof value.longitude === "number" && (value.longitude < -180 || value.longitude > 180))
+      add(
+        errors,
+        `${path}.longitude`,
+        "Expected a longitude between -180 and 180.",
+        "out_of_range"
+      );
+    return;
+  }
+  if (type === "nfc") {
+    if (isPublic) {
+      if (hasOwn(value, "tagId"))
+        add(errors, `${path}.tagId`, "Private field is not allowed.", "private_field");
+    } else requiredString(value, "tagId", path, errors);
+    return;
+  }
+  if (type === "custom") {
+    requiredString(value, "validatorName", path, errors);
+    if (isPublic && hasOwn(value, "secretParams"))
+      add(errors, `${path}.secretParams`, "Private field is not allowed.", "private_field");
+    if (!isPublic && hasOwn(value, "secretParams") && !isRecord3(value.secretParams))
+      add(errors, `${path}.secretParams`, "Expected an object.", "invalid_type");
+    return;
+  }
+  add(errors, `${path}.type`, "Unknown condition type.", "invalid_enum");
+}
+function unlockCondition(value, path, errors) {
+  if (!isRecord3(value)) {
+    add(errors, path, "Expected an unlock condition object.", "invalid_type");
+    return;
+  }
+  if (value.type === "stamp_count") {
+    finiteNumber(value, "count", path, errors, 0);
+    return;
+  }
+  if (value.type === "stamps") {
+    if (!Array.isArray(value.stampIds))
+      add(errors, `${path}.stampIds`, "Expected an array.", "invalid_type");
+    else
+      value.stampIds.forEach((item, index) => {
+        if (typeof item !== "string" || item.length === 0)
+          add(
+            errors,
+            `${path}.stampIds[${index}]`,
+            "Expected a non-empty string.",
+            "required_string"
+          );
+      });
+    return;
+  }
+  if (value.type === "all" || value.type === "any") {
+    if (!Array.isArray(value.conditions))
+      add(errors, `${path}.conditions`, "Expected an array.", "invalid_type");
+    else
+      value.conditions.forEach((item, index) => {
+        unlockCondition(item, `${path}.conditions[${index}]`, errors);
+      });
+    return;
+  }
+  add(errors, `${path}.type`, "Unknown unlock condition type.", "invalid_enum");
+}
+function spot(value, path, errors, isPublic) {
+  if (!isRecord3(value)) {
+    add(errors, path, "Expected a spot object.", "invalid_type");
+    return;
+  }
+  requiredString(value, "id", path, errors);
+  finiteNumber(value, "orderIndex", path, errors, 0);
+  if (typeof value.orderIndex === "number" && !Number.isInteger(value.orderIndex))
+    add(errors, `${path}.orderIndex`, "Expected an integer.", "invalid_integer");
+  localizedText(value.name, `${path}.name`, errors);
+  for (const key of ["description", "hint"])
+    if (hasOwn(value, key)) localizedText(value[key], `${path}.${key}`, errors);
+  for (const key of ["imageUrl", "iconUrl", "redirectUrlAfterClaim"])
+    optionalString(value, key, path, errors);
+  if (hasOwn(value, "externalReferences") && value.externalReferences !== void 0)
+    externalReferences(value.externalReferences, `${path}.externalReferences`, errors);
+  if (hasOwn(value, "prerequisites") && value.prerequisites !== void 0) {
+    if (!Array.isArray(value.prerequisites))
+      add(errors, `${path}.prerequisites`, "Expected an array.", "invalid_type");
+    else
+      value.prerequisites.forEach((item, index) => {
+        if (typeof item !== "string" || item.length === 0)
+          add(
+            errors,
+            `${path}.prerequisites[${index}]`,
+            "Expected a non-empty string.",
+            "required_string"
+          );
+      });
+  }
+  if (!Array.isArray(value.conditions))
+    add(errors, `${path}.conditions`, "Expected an array.", "invalid_type");
+  else
+    value.conditions.forEach((item, index) => {
+      condition(item, `${path}.conditions[${index}]`, errors, isPublic);
+    });
+}
+function reward(value, path, errors, isPublic) {
+  if (!isRecord3(value)) {
+    add(errors, path, "Expected a reward object.", "invalid_type");
+    return;
+  }
+  requiredString(value, "id", path, errors);
+  localizedText(value.title, `${path}.title`, errors);
+  if (hasOwn(value, "description")) localizedText(value.description, `${path}.description`, errors);
+  if (value.type !== "digital" && value.type !== "in_person")
+    add(errors, `${path}.type`, "Unknown reward type.", "invalid_enum");
+  if (!["manual_slide", "staff_passcode", "view_only", "server_claim"].includes(
+    String(value.redemptionMethod)
+  ))
+    add(errors, `${path}.redemptionMethod`, "Unknown redemption method.", "invalid_enum");
+  finiteNumber(value, "requiredStampCount", path, errors, 0);
+  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");
+    }
+  }
+  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");
+  if (isPublic) {
+    for (const key of ["staffPasscode", "digitalContentUrl"])
+      if (hasOwn(value, key))
+        add(errors, `${path}.${key}`, "Private field is not allowed.", "private_field");
+  } else {
+    optionalString(value, "staffPasscode", path, errors);
+    optionalString(value, "digitalContentUrl", path, errors);
+  }
+  if (hasOwn(value, "conditions") && value.conditions !== void 0) {
+    if (!Array.isArray(value.conditions))
+      add(errors, `${path}.conditions`, "Expected an array.", "invalid_type");
+    else
+      value.conditions.forEach((item, index) => {
+        unlockCondition(item, `${path}.conditions[${index}]`, errors);
+      });
+  }
+}
+function validate(value, isPublic) {
+  const errors = [];
+  if (!isRecord3(value)) {
+    add(errors, "$", "Expected a configuration object.", "invalid_type");
+    return errors;
+  }
+  requiredString(value, "id", "$", errors);
+  requiredString(value, "version", "$", errors);
+  localizedText(value.title, "$.title", errors);
+  if (hasOwn(value, "description")) localizedText(value.description, "$.description", errors);
+  if (hasOwn(value, "theme") && value.theme !== void 0) theme(value.theme, "$.theme", errors);
+  if (!Array.isArray(value.spots)) add(errors, "spots", "Expected an array.", "invalid_type");
+  else
+    value.spots.forEach((item, index) => {
+      spot(item, `spots[${index}]`, errors, isPublic);
+    });
+  if (!Array.isArray(value.rewards)) add(errors, "rewards", "Expected an array.", "invalid_type");
+  else
+    value.rewards.forEach((item, index) => {
+      reward(item, `rewards[${index}]`, errors, 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, "serverMetadata") && value.serverMetadata !== void 0 && !isRecord3(value.serverMetadata))
+      add(errors, "$.serverMetadata", "Expected an object.", "invalid_type");
+    if (hasOwn(value, "publicMetadata") && value.publicMetadata !== void 0 && !isRecord3(value.publicMetadata))
+      add(errors, "$.publicMetadata", "Expected an object.", "invalid_type");
+    optionalString(value, "serverEndpoint", "$", errors);
+  } else {
+    for (const key of ["staffPasscode", "serverMetadata", "inventory"])
+      if (hasOwn(value, key))
+        add(errors, `$.${key}`, "Private field is not allowed.", "private_field");
+    optionalString(value, "serverEndpoint", "$", errors);
+  }
+  return errors;
+}
+function safeParseAdminConfig(input) {
+  const errors = validate(input, false);
+  return errors.length === 0 ? { success: true, data: input } : { success: false, errors };
+}
+function parseAdminConfig(input) {
+  const result = safeParseAdminConfig(input);
+  if (!result.success) throw new ConfigValidationError(result.errors);
+  return result.data;
+}
+function safeParsePublicConfig(input) {
+  const errors = validate(input, true);
+  return errors.length === 0 ? { success: true, data: input } : { success: false, errors };
+}
+function parsePublicConfig(input) {
+  const result = safeParsePublicConfig(input);
+  if (!result.success) throw new ConfigValidationError(result.errors);
+  return result.data;
+}
+
 // src/security/snapshotToken.ts
 var encoder2 = new TextEncoder();
 function cryptoApi2() {
@@ -1732,10 +2397,14 @@ async function verifySnapshotToken(token, secretKey, now = Date.now()) {
   }
 }
 
+exports.ConfigValidationError = ConfigValidationError;
 exports.DEFAULT_SHEET_THEME = DEFAULT_SHEET_THEME;
+exports.InMemoryOfflineQueueStorage = MemoryQueueStorage;
 exports.InMemoryStorage = InMemoryStorage;
 exports.IndexedDBAdapter = IndexedDBAdapter;
+exports.IndexedDBOfflineQueueStorage = IndexedDBOfflineQueueStorage;
 exports.LocalStorageAdapter = LocalStorageAdapter;
+exports.OfflineQueue = OfflineQueue;
 exports.StampRallyClient = StampRallyClient;
 exports.StorageAdapterError = StorageAdapterError;
 exports.THEME_PRESETS = THEME_PRESETS;
@@ -1761,14 +2430,21 @@ exports.isRewardState = isRewardState;
 exports.isStampRallyState = isStampRallyState;
 exports.issueClaimTicketNumber = issueClaimTicketNumber;
 exports.normalizePasscode = normalizePasscode;
+exports.parseAdminConfig = parseAdminConfig;
+exports.parsePublicConfig = parsePublicConfig;
 exports.processStamp = processStamp;
 exports.readNfcContext = readNfcContext;
 exports.readQrContext = readQrContext;
 exports.reconcileRewardStates = reconcileRewardStates;
 exports.resolveLocalizedText = resolveLocalizedText;
+exports.safeParseAdminConfig = safeParseAdminConfig;
+exports.safeParsePublicConfig = safeParsePublicConfig;
+exports.sanitizeAdminConfig = sanitizeAdminConfig;
 exports.storageKey = storageKey;
 exports.toLocalizedString = toLocalizedString;
 exports.toPublicConfig = toPublicConfig;
+exports.updateLocalizedField = updateLocalizedField;
+exports.validatePublicConfigSafety = validatePublicConfigSafety;
 exports.verifyPasscode = verifyPasscode;
 exports.verifySecureToken = verifySecureToken;
 exports.verifySnapshotToken = verifySnapshotToken;