@stamprally/core 0.8.0 → 0.10.0

package/dist/index.cjs

@@ -2,252 +2,64 @@
 
 // src/engine/evaluate.ts
 var EARTH_RADIUS_METERS = 6371e3;
-function toRadians(degrees) {
-  return degrees * Math.PI / 180;
-}
-function calculateDistanceMeters(latitudeA, longitudeA, latitudeB, longitudeB) {
-  const latitudeDelta = toRadians(latitudeB - latitudeA);
-  const longitudeDelta = toRadians(longitudeB - longitudeA);
-  const latitudeARadians = toRadians(latitudeA);
-  const latitudeBRadians = toRadians(latitudeB);
-  const haversine = Math.sin(latitudeDelta / 2) ** 2 + Math.cos(latitudeARadians) * Math.cos(latitudeBRadians) * Math.sin(longitudeDelta / 2) ** 2;
-  return 2 * EARTH_RADIUS_METERS * Math.asin(Math.sqrt(Math.min(1, haversine)));
-}
-function isValidCoordinate(latitude, longitude) {
-  return Number.isFinite(latitude) && latitude >= -90 && latitude <= 90 && Number.isFinite(longitude) && longitude >= -180 && longitude <= 180;
-}
-function contextTypeMismatch(conditionType, expectedContextType, actualContextType) {
-  return {
-    ok: false,
-    error: {
-      code: "CONDITION_MISMATCH",
-      conditionType,
-      reason: "CONTEXT_TYPE_MISMATCH",
-      expectedContextType,
-      actualContextType
-    }
-  };
+function calculateDistanceMeters(aLat, aLon, bLat, bLon) {
+  const radians = (value2) => value2 * Math.PI / 180;
+  const dLat = radians(bLat - aLat);
+  const dLon = radians(bLon - aLon);
+  const value = Math.sin(dLat / 2) ** 2 + Math.cos(radians(aLat)) * Math.cos(radians(bLat)) * Math.sin(dLon / 2) ** 2;
+  return 2 * EARTH_RADIUS_METERS * Math.asin(Math.sqrt(Math.min(1, value)));
 }
-function assertNever(value) {
-  throw new Error(`Unexpected condition: ${JSON.stringify(value)}`);
+function mismatch(conditionType, reason, extra = {}) {
+  return { ok: false, error: { code: "CONDITION_MISMATCH", conditionType, reason, ...extra } };
 }
-function evaluateConditionDetailed(condition2, context, now2) {
+function evaluateConditionDetailed(condition2, context) {
   switch (condition2.type) {
-    case "instant":
-      return context.type === "instant" ? { ok: true, value: { conditionType: "instant" } } : contextTypeMismatch("instant", "instant", context.type);
-    case "token":
-      if (context.type !== "token") {
-        return contextTypeMismatch("token", "token", context.type);
-      }
-      return context.token === condition2.token ? { ok: true, value: { conditionType: "token" } } : {
-        ok: false,
-        error: {
-          code: "CONDITION_MISMATCH",
-          conditionType: "token",
-          reason: "TOKEN_MISMATCH"
-        }
-      };
-    case "geo": {
-      if (context.type !== "geo") {
-        return contextTypeMismatch("geo", "geo", context.type);
-      }
-      if (!isValidCoordinate(condition2.latitude, condition2.longitude) || !isValidCoordinate(context.currentLatitude, context.currentLongitude) || !Number.isFinite(condition2.radiusMeters) || condition2.radiusMeters < 0) {
-        return {
-          ok: false,
-          error: {
-            code: "CONDITION_MISMATCH",
-            conditionType: "geo",
-            reason: "INVALID_GEO_INPUT"
-          }
-        };
-      }
-      const distanceMeters2 = calculateDistanceMeters(
+    case "qr":
+      return context.type === "qr" && context.token === condition2.secretToken ? { ok: true, value: { conditionType: "qr" } } : mismatch("qr", "INVALID_PROOF");
+    case "passcode":
+      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 === condition2.tagId ? { ok: true, value: { conditionType: "nfc" } } : mismatch("nfc", "INVALID_PROOF");
+    case "custom":
+      return mismatch("custom", "VALIDATOR_FAILED");
+    case "gps": {
+      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(
         condition2.latitude,
         condition2.longitude,
-        context.currentLatitude,
-        context.currentLongitude
+        context.latitude,
+        context.longitude
       );
-      if (distanceMeters2 <= condition2.radiusMeters) {
-        return { ok: true, value: { conditionType: "geo", distanceMeters: distanceMeters2 } };
-      }
-      return {
-        ok: false,
-        error: {
-          code: "CONDITION_MISMATCH",
-          conditionType: "geo",
-          reason: "OUTSIDE_RADIUS",
-          distanceMeters: distanceMeters2,
-          radiusMeters: condition2.radiusMeters,
-          differenceMeters: distanceMeters2 - condition2.radiusMeters
-        }
-      };
-    }
-    case "composite": {
-      if (context.type !== "composite") {
-        return contextTypeMismatch("composite", "composite", context.type);
-      }
-      if (condition2.conditions.length !== context.contexts.length) {
-        return {
-          ok: false,
-          error: {
-            code: "CONDITION_MISMATCH",
-            conditionType: "composite",
-            reason: "CONTEXT_LENGTH_MISMATCH",
-            expectedCount: condition2.conditions.length,
-            actualCount: context.contexts.length
-          }
-        };
-      }
-      const failures = [];
-      let matchedCount = 0;
-      for (const [index, childCondition] of condition2.conditions.entries()) {
-        const childContext = context.contexts[index];
-        if (childContext === void 0) continue;
-        const result = evaluateConditionDetailed(childCondition, childContext, now2);
-        if (result.ok) matchedCount += 1;
-        else failures.push({ index, error: result.error });
-      }
-      if (condition2.operator === "AND" && failures.length === 0) {
-        return { ok: true, value: { conditionType: "composite" } };
-      }
-      if (condition2.operator === "OR" && matchedCount > 0) {
-        return { ok: true, value: { conditionType: "composite" } };
-      }
-      return {
-        ok: false,
-        error: {
-          code: "CONDITION_MISMATCH",
-          conditionType: "composite",
-          reason: condition2.operator === "AND" ? "AND_CHILD_FAILED" : "OR_ALL_FAILED",
-          failures
-        }
-      };
-    }
-    case "time_window": {
-      const startsAt = Date.parse(condition2.startsAt);
-      const endsAt = Date.parse(condition2.endsAt);
-      const currentTime = Date.parse(now2);
-      if (!Number.isFinite(currentTime)) {
-        return {
-          ok: false,
-          error: {
-            code: "CONDITION_MISMATCH",
-            conditionType: "time_window",
-            reason: "INVALID_NOW",
-            now: now2,
-            startsAt: condition2.startsAt,
-            endsAt: condition2.endsAt
-          }
-        };
-      }
-      if (!Number.isFinite(startsAt) || !Number.isFinite(endsAt) || startsAt > endsAt) {
-        return {
-          ok: false,
-          error: {
-            code: "CONDITION_MISMATCH",
-            conditionType: "time_window",
-            reason: "INVALID_TIME_WINDOW",
-            now: now2,
-            startsAt: condition2.startsAt,
-            endsAt: condition2.endsAt
-          }
-        };
-      }
-      if (currentTime < startsAt || currentTime > endsAt) {
-        return {
-          ok: false,
-          error: {
-            code: "CONDITION_MISMATCH",
-            conditionType: "time_window",
-            reason: currentTime < startsAt ? "BEFORE_START" : "AFTER_END",
-            now: now2,
-            startsAt: condition2.startsAt,
-            endsAt: condition2.endsAt
-          }
-        };
-      }
-      const childResult = evaluateConditionDetailed(condition2.condition, context, now2);
-      return childResult.ok ? { ok: true, value: { conditionType: "time_window" } } : childResult;
+      return distanceMeters <= condition2.radiusMeters ? { ok: true, value: { conditionType: "gps", distanceMeters } } : mismatch("gps", "OUTSIDE_RADIUS", {
+        distanceMeters,
+        radiusMeters: condition2.radiusMeters
+      });
     }
-    default:
-      return assertNever(condition2);
   }
 }
-function evaluateCondition(condition2, context, now2) {
-  return evaluateConditionDetailed(condition2, context, now2 ?? "").ok;
-}
-
-// src/engine/checkIn.ts
-function unwrapContext(input) {
-  if ("verificationContext" in input) {
-    return {
-      context: input.verificationContext,
-      now: input.now ?? (/* @__PURE__ */ new Date()).toISOString(),
-      ...input.expectedStampId === void 0 ? {} : { expectedStampId: input.expectedStampId },
-      alreadyClaimed: input.alreadyClaimed ?? false
-    };
-  }
-  return {
-    context: input,
-    now: "now" in input && typeof input.now === "string" ? input.now : (/* @__PURE__ */ new Date()).toISOString(),
-    ..."expectedStampId" in input && typeof input.expectedStampId === "string" ? { expectedStampId: input.expectedStampId } : {},
-    alreadyClaimed: "alreadyClaimed" in input && input.alreadyClaimed === true
-  };
-}
-function evaluateCheckIn(spot, input) {
-  const context = unwrapContext(input);
-  if (context.alreadyClaimed) {
-    return {
-      ok: false,
-      success: false,
-      code: "ALREADY_CLAIMED",
-      stampId: spot.id,
-      message: "This spot has already been claimed."
-    };
-  }
-  if (context.expectedStampId !== void 0 && context.expectedStampId !== spot.id) {
-    return {
-      ok: false,
-      success: false,
-      code: "ORDER_VIOLATION",
-      stampId: spot.id,
-      message: `The next required spot is '${context.expectedStampId}'.`
-    };
-  }
-  const evaluated = evaluateConditionDetailed(spot.condition, context.context, context.now);
-  if (evaluated.ok) {
-    return { ok: true, success: true, stampId: spot.id, checkedAt: context.now };
-  }
-  const code = evaluated.error.reason === "OUTSIDE_RADIUS" ? "OUT_OF_RANGE" : evaluated.error.reason === "BEFORE_START" || evaluated.error.reason === "AFTER_END" ? "EXPIRED" : evaluated.error.reason === "TOKEN_MISMATCH" ? "INVALID_PROOF" : "INVALID_CONTEXT";
-  return { ok: false, success: false, code, stampId: spot.id, message: evaluated.error.reason };
+function evaluateCondition(condition2, context) {
+  return evaluateConditionDetailed(condition2, context).ok;
 }
 
 // src/engine/order.ts
-function getOrderedStamps(config) {
-  return config.stamps.map((stamp, index) => ({ stamp, index })).sort((left, right) => {
-    const orderDifference = (left.stamp.orderIndex ?? left.stamp.order ?? Number.POSITIVE_INFINITY) - (right.stamp.orderIndex ?? right.stamp.order ?? Number.POSITIVE_INFINITY);
-    return orderDifference === 0 ? left.index - right.index : orderDifference;
-  }).map(({ stamp }) => stamp);
+function getOrderedSpots(spots) {
+  return [...spots].sort((left, right) => left.orderIndex - right.orderIndex);
 }
 
 // src/engine/progress.ts
 function calculateProgress(state, config) {
-  const configuredStampIds = new Set(config.stamps.map((stamp) => stamp.id));
-  const acquiredStampIds = new Set(
-    state.records.map((record) => record.stampId).filter((stampId) => configuredStampIds.has(stampId))
+  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 total = config.stamps.length;
-  const acquired = acquiredStampIds.size;
-  const isCompleted = total > 0 && acquired === total;
-  const remainingStamps = config.stamps.filter((stamp) => !acquiredStampIds.has(stamp.id));
-  const nextAvailableStamps = config.isSequential === true ? getOrderedStamps(config).filter((stamp) => !acquiredStampIds.has(stamp.id)).slice(0, 1) : remainingStamps;
+  const remaining = config.spots.filter((spot2) => !acquired.has(spot2.id));
   return {
-    acquired,
-    total,
-    percentage: total === 0 ? 0 : acquired / total * 100,
-    isCompleted,
-    isComplete: isCompleted,
-    nextAvailableStamps
+    acquired: acquired.size,
+    total: config.spots.length,
+    percentage: config.spots.length === 0 ? 0 : acquired.size / config.spots.length * 100,
+    isCompleted: config.spots.length > 0 && acquired.size === config.spots.length,
+    nextAvailableSpots: [...remaining].sort((left, right) => left.orderIndex - right.orderIndex)
   };
 }
 
@@ -281,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 = reward.claimTicketNumber ?? createClaimTicketNumber(reward.id, options);
+  const claimTicketNumber = createClaimTicketNumber(reward2.id, options);
   return { ...currentState, claimTicketNumber };
 }
 
@@ -352,9 +164,9 @@ function getCurrentGeoContext(options = {}) {
     try {
       navigator.geolocation.getCurrentPosition(
         (position) => {
-          const currentLatitude = position.coords.latitude;
-          const currentLongitude = position.coords.longitude;
-          if (!Number.isFinite(currentLatitude) || currentLatitude < -90 || currentLatitude > 90 || !Number.isFinite(currentLongitude) || currentLongitude < -180 || currentLongitude > 180) {
+          const latitude = position.coords.latitude;
+          const longitude = position.coords.longitude;
+          if (!Number.isFinite(latitude) || latitude < -90 || latitude > 90 || !Number.isFinite(longitude) || longitude < -180 || longitude > 180) {
             resolve({
               ok: false,
               error: createDetectorError(
@@ -367,7 +179,7 @@ function getCurrentGeoContext(options = {}) {
           }
           resolve({
             ok: true,
-            value: { type: "geo", currentLatitude, currentLongitude }
+            value: { type: "gps", latitude, longitude }
           });
         },
         (error) => {
@@ -475,7 +287,7 @@ function readNfcContext(options = {}) {
         fail(createDetectorError("nfc", "NO_TOKEN", "The NFC tag has no text token."));
         return;
       }
-      finish({ ok: true, value: { type: "token", token } });
+      finish({ ok: true, value: { type: "nfc", tagId: token } });
     };
     reader.onreadingerror = (event) => fail(createDetectorError("nfc", "READ_FAILED", "The NFC tag could not be read.", event));
     try {
@@ -492,13 +304,7 @@ function normalizePasscode(input, caseSensitive = false) {
   return caseSensitive ? normalized : normalized.toUpperCase();
 }
 function verifyPasscode(inputCode, condition2) {
-  const input = normalizePasscode(inputCode, condition2.caseSensitive);
-  const expected = normalizePasscode(condition2.passcode, condition2.caseSensitive);
-  return input === expected ? { success: true } : {
-    success: false,
-    reason: "INVALID_PASSCODE",
-    message: "The passcode is invalid."
-  };
+  return normalizePasscode(inputCode, condition2.caseSensitive) === normalizePasscode(condition2.code, condition2.caseSensitive) ? { success: true } : { success: false, message: "The passcode is invalid." };
 }
 
 // src/detectors/qr.ts
@@ -605,7 +411,7 @@ async function readQrContext(videoElement, options = {}) {
       if (!detection.ok) return detection;
       const token = detection.value.find((barcode) => barcode.rawValue.length > 0)?.rawValue;
       if (token !== void 0) {
-        return { ok: true, value: { type: "token", token } };
+        return { ok: true, value: { type: "qr", token } };
       }
       const interval = await raceWithTermination(waitForNextScan(), termination.promise);
       if (!interval.ok) return interval;
@@ -623,153 +429,89 @@ async function readQrContext(videoElement, options = {}) {
 }
 
 // src/engine/transition.ts
-function reconcileRewardStates(rewards, currentStates, acquiredStampCount, now2) {
-  const statesById = new Map(currentStates.map((state) => [state.rewardId, state]));
-  return rewards.map((reward) => {
-    const current = statesById.get(reward.id);
-    if (current?.status === "CONSUMED" || current?.status === "EXPIRED") {
-      return current;
-    }
-    if (reward.validUntil !== void 0 && Date.parse(reward.validUntil) <= Date.parse(now2)) {
-      return { rewardId: reward.id, status: "EXPIRED" };
-    }
-    const stockLimit = reward.stockLimit ?? reward.maxStock;
-    if (stockLimit !== void 0 && (current?.redeemedCount ?? 0) >= stockLimit) {
-      return {
-        rewardId: reward.id,
-        status: "EXPIRED",
-        ...current?.claimTicketNumber === void 0 ? {} : { claimTicketNumber: current.claimTicketNumber }
-      };
-    }
-    if (acquiredStampCount >= reward.requiredStampCount) {
-      if (current?.status === "AVAILABLE") return current;
+function reconcileRewardStates(rewards, currentStates, acquiredStampCount, now) {
+  const states = new Map(currentStates.map((state) => [state.rewardId, state]));
+  return rewards.map((reward2) => {
+    const current = states.get(reward2.id);
+    if (current?.status === "CONSUMED" || current?.status === "EXPIRED") return current;
+    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",
-        unlockedAt: current?.unlockedAt ?? now2,
-        ...current?.claimTicketNumber === void 0 ? {} : { claimTicketNumber: current.claimTicketNumber }
+        ...current?.unlockedAt === void 0 ? { unlockedAt: now } : { unlockedAt: current.unlockedAt }
       };
-    }
-    if (current?.status === "LOCKED" && current.unlockedAt === void 0) return current;
-    return { rewardId: reward.id, status: "LOCKED" };
+    return { rewardId: reward2.id, status: "LOCKED" };
   });
 }
 function consumeReward(params) {
-  const { reward, currentState } = params;
-  if (currentState.status === "CONSUMED") {
-    return {
-      ok: false,
-      error: { code: "ALREADY_CONSUMED", rewardId: reward.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", reason: "EXPIRED", rewardId: reward.id } };
-  }
-  const stockLimit = reward.stockLimit ?? reward.maxStock;
-  const userClaimLimit = reward.userClaimLimit ?? reward.limitPerUser;
-  if (stockLimit !== void 0 && (currentState.redeemedCount ?? 0) >= stockLimit) {
-    return { ok: false, error: { code: "OUT_OF_STOCK", rewardId: reward.id } };
-  }
-  if (userClaimLimit !== void 0 && (params.userRedemptionCount ?? currentState.userRedemptionCount ?? 0) >= userClaimLimit) {
-    return {
-      ok: false,
-      error: { code: "USER_LIMIT_REACHED", reason: "LIMIT_EXCEEDED", rewardId: reward.id }
-    };
-  }
-  if (reward.redemptionMethod === "staff_passcode") {
-    const passcodeResult = reward.staffPasscode === void 0 ? null : verifyPasscode(params.inputPasscode ?? "", { passcode: reward.staffPasscode });
-    if (passcodeResult === null || !passcodeResult.success) {
+  const { reward: reward2, currentState } = params;
+  if (currentState.status === "CONSUMED")
+    return { ok: false, error: { code: "ALREADY_CONSUMED", rewardId: reward2.id } };
+  if (currentState.status !== "AVAILABLE")
+    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,
-          message: passcodeResult?.message ?? "The passcode is invalid."
+          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),
-      ...stockLimit !== void 0 || params.userId !== void 0 || params.userRedemptionCount !== void 0 ? { redeemedCount: (currentState.redeemedCount ?? 0) + 1 } : {},
-      ...params.userId === void 0 ? {} : { userRedemptionCount: (currentState.userRedemptionCount ?? 0) + 1 },
+      claimTicketNumber: createUniqueClaimTicketNumber(reward2.id, params.now),
+      redeemedCount: (currentState.redeemedCount ?? 0) + 1,
       ...params.staffId === void 0 ? {} : { consumedByStaffId: params.staffId }
     }
   };
 }
-function processStamp(state, config, targetStampId, context, now2) {
-  const targetStamp = config.stamps.find((stamp) => stamp.id === targetStampId);
-  if (targetStamp === void 0) {
-    return { ok: false, error: { code: "STAMP_NOT_FOUND", stampId: targetStampId } };
-  }
-  const acquiredStampIds = new Set(state.records.map((record2) => record2.stampId));
-  if (acquiredStampIds.has(targetStampId)) {
-    return {
-      ok: false,
-      error: { code: "STAMP_ALREADY_ACQUIRED", stampId: targetStampId }
-    };
-  }
-  if (config.isSequential === true) {
-    const expectedStamp = getOrderedStamps(config).find((stamp) => !acquiredStampIds.has(stamp.id));
-    if (expectedStamp !== void 0 && expectedStamp.id !== targetStampId) {
+function processStamp(state, config, spotId, context, now) {
+  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 (spot2.prerequisites?.some((id2) => !acquired.has(id2)))
+    return { ok: false, error: { code: "PREREQUISITES_NOT_MET", spotId } };
+  for (const condition2 of spot2.conditions) {
+    if (condition2.type === "custom" || !evaluateConditionDetailed(condition2, context).ok)
       return {
         ok: false,
-        error: {
-          code: "INVALID_ORDER",
-          stampId: targetStampId,
-          expectedStampId: expectedStamp.id
-        }
+        error: condition2.type === "custom" ? {
+          code: "CUSTOM_VALIDATION_FAILED",
+          spotId,
+          message: "Custom validation requires an async validator."
+        } : { code: "INVALID_PROOF", spotId }
       };
-    }
-  }
-  const conditionResult = evaluateConditionDetailed(targetStamp.condition, context, now2);
-  if (!conditionResult.ok) {
-    return {
-      ok: false,
-      error: {
-        code: "CONDITION_MISMATCH",
-        stampId: targetStampId,
-        mismatch: conditionResult.error
-      }
-    };
   }
-  const record = { stampId: targetStampId, acquiredAt: now2 };
-  const nextRecords = [...state.records, record];
-  const nextRewards = config.rewards === void 0 && state.rewards === void 0 ? void 0 : reconcileRewardStates(config.rewards ?? [], state.rewards ?? [], nextRecords.length, now2);
-  const nextState = {
-    ...state,
-    records: nextRecords,
-    ...nextRewards === void 0 ? {} : { rewards: nextRewards },
-    updatedAt: now2
-  };
-  const events = [{ type: "stampAcquired", record }];
-  if (nextRewards !== void 0) {
-    for (const rewardState of nextRewards) {
-      const previous = state.rewards?.find((item) => item.rewardId === rewardState.rewardId);
-      if (rewardState.status === "AVAILABLE" && previous?.status !== "AVAILABLE") {
-        events.push({ type: "rewardUnlocked", rewardId: rewardState.rewardId, unlockedAt: now2 });
-      }
+  const record = { stampId: spotId, acquiredAt: now };
+  const records = [...state.records, record];
+  const rewards = reconcileRewardStates(config.rewards, state.rewards, records.length, now);
+  return {
+    ok: true,
+    value: {
+      nextState: { ...state, records, rewards, updatedAt: now },
+      events: [{ type: "stampAcquired", record }]
     }
-  }
-  const completed = config.stamps.length > 0 && config.stamps.every((stamp) => nextState.records.some((item) => item.stampId === stamp.id));
-  if (completed) {
-    events.push({ type: "rallyCompleted", rallyId: config.id, completedAt: now2 });
-  }
-  return { ok: true, value: { nextState, events } };
+  };
 }
 
 // src/client/storage.ts
@@ -815,7 +557,7 @@ function isRewardState(value) {
 function isStampRallyState(value) {
   if (typeof value !== "object" || value === null) return false;
   const state = value;
-  return typeof state.rallyId === "string" && typeof state.updatedAt === "string" && Array.isArray(state.records) && state.records.every(isRecord) && (state.rewards === void 0 || Array.isArray(state.rewards) && state.rewards.every(isRewardState));
+  return typeof state.rallyId === "string" && (typeof state.userId === "string" || state.userId === null) && typeof state.updatedAt === "string" && Array.isArray(state.records) && state.records.every(isRecord) && (state.rewards === void 0 || Array.isArray(state.rewards) && state.rewards.every(isRewardState));
 }
 function isValidDate(value) {
   return typeof value === "string" && !Number.isNaN(Date.parse(value));
@@ -826,7 +568,7 @@ function isSnapshotRecord(value) {
 function isRallySnapshot(value) {
   if (typeof value !== "object" || value === null) return false;
   const snapshot = value;
-  return snapshot.version === 1 && typeof snapshot.rallyId === "string" && Array.isArray(snapshot.stamps) && snapshot.stamps.every(isSnapshotRecord) && Array.isArray(snapshot.rewards) && snapshot.rewards.every(isRewardState) && isValidDate(snapshot.exportedAt);
+  return snapshot.version === 1 && typeof snapshot.rallyId === "string" && (typeof snapshot.userId === "string" || snapshot.userId === null) && Array.isArray(snapshot.records) && snapshot.records.every(isSnapshotRecord) && Array.isArray(snapshot.rewards) && snapshot.rewards.every(isRewardState) && isValidDate(snapshot.exportedAt);
 }
 function exportProgressToken(snapshot) {
   return globalThis.btoa(encodeURIComponent(JSON.stringify(snapshot)));
@@ -837,7 +579,7 @@ function importProgressToken(token, currentRallyId) {
     if (!isRallySnapshot(parsed) || parsed.rallyId !== currentRallyId) return null;
     return {
       ...parsed,
-      stamps: parsed.stamps.map(cloneRecord),
+      records: parsed.records.map(cloneRecord),
       rewards: parsed.rewards.map(cloneRewardState)
     };
   } catch {
@@ -846,17 +588,20 @@ function importProgressToken(token, currentRallyId) {
 }
 var InMemoryStorage = class {
   #states = /* @__PURE__ */ new Map();
-  async load(rallyId) {
-    const state = this.#states.get(rallyId);
+  async load(rallyId, userId) {
+    const state = this.#states.get(storageKey(rallyId, userId));
     return state === void 0 ? null : cloneState(state);
   }
   async save(state) {
-    this.#states.set(state.rallyId, cloneState(state));
+    this.#states.set(storageKey(state.rallyId, state.userId), cloneState(state));
   }
-  async remove(rallyId) {
-    this.#states.delete(rallyId);
+  async remove(rallyId, userId) {
+    this.#states.delete(storageKey(rallyId, userId));
   }
 };
+function storageKey(rallyId, userId) {
+  return `stamprally:${rallyId}:${userId ?? "anonymous"}`;
+}
 var defaultStorageWarningHandler = (error) => {
   console.warn(`[@stamprally/core] ${error.message}`, error);
 };
@@ -873,10 +618,10 @@ var LocalStorageAdapter = class {
     this.#failureMode = options.failureMode ?? "fallback";
     this.#onWarning = options.onWarning ?? defaultStorageWarningHandler;
   }
-  async load(rallyId) {
-    if (this.#isFallbackActive) return this.#fallbackStorage.load(rallyId);
+  async load(rallyId, userId) {
+    if (this.#isFallbackActive) return this.#fallbackStorage.load(rallyId, userId);
     try {
-      const serialized = this.#getStorage("load", rallyId).getItem(this.#key(rallyId));
+      const serialized = this.#getStorage("load", rallyId).getItem(this.#key(rallyId, userId));
       if (serialized === null) return null;
       let parsed;
       try {
@@ -907,7 +652,7 @@ var LocalStorageAdapter = class {
           `Failed to read rally '${rallyId}' from localStorage.`,
           rallyId
         ),
-        () => this.#fallbackStorage.load(rallyId)
+        () => this.#fallbackStorage.load(rallyId, userId)
       );
     }
   }
@@ -915,7 +660,7 @@ var LocalStorageAdapter = class {
     if (this.#isFallbackActive) return this.#fallbackStorage.save(state);
     try {
       this.#getStorage("save", state.rallyId).setItem(
-        this.#key(state.rallyId),
+        this.#key(state.rallyId, state.userId),
         JSON.stringify(state)
       );
     } catch (cause) {
@@ -931,10 +676,10 @@ var LocalStorageAdapter = class {
       );
     }
   }
-  async remove(rallyId) {
-    if (this.#isFallbackActive) return this.#fallbackStorage.remove(rallyId);
+  async remove(rallyId, userId) {
+    if (this.#isFallbackActive) return this.#fallbackStorage.remove(rallyId, userId);
     try {
-      this.#getStorage("remove", rallyId).removeItem(this.#key(rallyId));
+      this.#getStorage("remove", rallyId).removeItem(this.#key(rallyId, userId));
     } catch (cause) {
       return this.#handleFailure(
         this.#normalizeError(
@@ -944,12 +689,12 @@ var LocalStorageAdapter = class {
           `Failed to remove rally '${rallyId}' from localStorage.`,
           rallyId
         ),
-        () => this.#fallbackStorage.remove(rallyId)
+        () => this.#fallbackStorage.remove(rallyId, userId)
       );
     }
   }
-  #key(rallyId) {
-    return `${this.#keyPrefix}${rallyId}`;
+  #key(rallyId, userId) {
+    return `${this.#keyPrefix}${rallyId}:${userId ?? "anonymous"}`;
   }
   #getStorage(operation, rallyId) {
     if (this.#providedStorage === null) {
@@ -1009,12 +754,12 @@ var IndexedDBAdapter = class {
     this.#providedFactory = options.indexedDB;
     this.#databaseName = options.databaseName ?? "stamprally";
   }
-  async load(rallyId) {
+  async load(rallyId, userId) {
     const database = await this.#openDatabase(rallyId);
     return new Promise((resolve, reject) => {
       try {
         const transaction = database.transaction(INDEXED_DB_STORE_NAME, "readonly");
-        const request = transaction.objectStore(INDEXED_DB_STORE_NAME).get(rallyId);
+        const request = transaction.objectStore(INDEXED_DB_STORE_NAME).get(storageKey(rallyId, userId));
         request.onsuccess = () => {
           const value = request.result;
           if (value === void 0) {
@@ -1061,7 +806,7 @@ var IndexedDBAdapter = class {
     return new Promise((resolve, reject) => {
       try {
         const transaction = database.transaction(INDEXED_DB_STORE_NAME, "readwrite");
-        transaction.objectStore(INDEXED_DB_STORE_NAME).put(cloneState(state), state.rallyId);
+        transaction.objectStore(INDEXED_DB_STORE_NAME).put(cloneState(state), storageKey(state.rallyId, state.userId));
         transaction.oncomplete = () => resolve();
         transaction.onerror = () => {
           reject(
@@ -1086,12 +831,12 @@ var IndexedDBAdapter = class {
       }
     });
   }
-  async remove(rallyId) {
+  async remove(rallyId, userId) {
     const database = await this.#openDatabase(rallyId);
     return new Promise((resolve, reject) => {
       try {
         const transaction = database.transaction(INDEXED_DB_STORE_NAME, "readwrite");
-        transaction.objectStore(INDEXED_DB_STORE_NAME).delete(rallyId);
+        transaction.objectStore(INDEXED_DB_STORE_NAME).delete(storageKey(rallyId, userId));
         transaction.oncomplete = () => resolve();
         transaction.onerror = () => {
           reject(
@@ -1199,255 +944,60 @@ var IndexedDBAdapter = class {
 };
 
 // src/client/client.ts
-var systemClock = () => (/* @__PURE__ */ new Date()).toISOString();
-var StampRallyClient = class {
-  #listeners = /* @__PURE__ */ new Set();
-  #eventListeners = /* @__PURE__ */ new Set();
-  #config;
-  #storage;
-  #clock;
-  #currentState = null;
-  #initialization = null;
-  #operationQueue = Promise.resolve();
-  constructor(config, storage, clock = systemClock) {
-    this.#config = config;
-    this.#storage = storage;
-    this.#clock = clock;
-  }
-  getState() {
-    return this.#currentState;
-  }
-  getConfig() {
-    return this.#config;
-  }
-  subscribe(listener, options = {}) {
-    if (options.events === true) {
-      this.#eventListeners.add(listener);
-      return () => this.#eventListeners.delete(listener);
-    }
-    this.#listeners.add(listener);
-    return () => {
-      this.#listeners.delete(listener);
-    };
-  }
-  subscribeEvents(listener) {
-    this.#eventListeners.add(listener);
-    return () => this.#eventListeners.delete(listener);
-  }
-  async updateConfig(newConfig) {
-    return this.#enqueue(async () => {
-      const current = await this.initialize();
-      this.#config = newConfig;
-      const next = this.#reconcileState(cloneState(current), this.#clock());
-      await this.#storage.save(next);
-      this.#currentState = next;
-      this.#initialization = Promise.resolve(next);
-      this.#emit(next);
-      return next;
-    });
-  }
-  notifyRewardClaimed(rewardId, state = this.#currentState) {
-    if (state !== null) this.#emitEvent({ type: "rewardClaimed", rewardId, state });
-  }
-  notifySyncCompleted(state = this.#currentState) {
-    if (state !== null) this.#emitEvent({ type: "syncCompleted", state });
-  }
-  init() {
-    return this.initialize();
-  }
-  initialize() {
-    if (this.#currentState !== null) {
-      return Promise.resolve(this.#currentState);
-    }
-    if (this.#initialization === null) {
-      this.#initialization = this.#storage.load(this.#config.id).then((storedState) => {
-        const state = storedState === null ? this.#createEmptyState(this.#clock()) : this.#reconcileState(cloneState(storedState), storedState.updatedAt);
-        this.#currentState = state;
-        this.#emit(state);
-        return state;
-      }).catch((error) => {
-        this.#initialization = null;
-        throw error;
-      });
-    }
-    return this.#initialization;
-  }
-  acquire(stampId, context, now2 = this.#clock()) {
-    return this.#enqueue(async () => {
-      const currentState = await this.initialize();
-      const result = processStamp(currentState, this.#config, stampId, context, now2);
-      if (!result.ok) {
-        this.#emitEvent({ type: "error", error: result.error });
-        return result;
-      }
-      await this.#storage.save(result.value.nextState);
-      this.#currentState = result.value.nextState;
-      this.#emit(result.value.nextState);
-      this.#emitEvent({ type: "checkIn", stampId, state: result.value.nextState });
-      return result;
-    });
-  }
-  reset(now2 = this.#clock()) {
-    return this.#enqueue(async () => {
-      const initialization = this.#initialization;
-      if (initialization !== null) {
-        await initialization.catch(() => void 0);
-      }
-      await this.#storage.remove(this.#config.id);
-      const nextState = this.#createEmptyState(now2);
-      this.#currentState = nextState;
-      this.#initialization = Promise.resolve(nextState);
-      this.#emit(nextState);
-      return nextState;
-    });
-  }
-  restore(state) {
-    return this.#enqueue(async () => {
-      const initialization = this.#initialization;
-      if (initialization !== null) {
-        await initialization.catch(() => void 0);
-      }
-      if (state.rallyId !== this.#config.id) {
-        throw new Error(
-          `Cannot restore rally '${state.rallyId}' into client '${this.#config.id}'.`
-        );
-      }
-      const nextState = this.#reconcileState(cloneState(state), state.updatedAt);
-      await this.#storage.save(nextState);
-      this.#currentState = nextState;
-      this.#initialization = Promise.resolve(nextState);
-      this.#emit(nextState);
-      return nextState;
-    });
-  }
-  #enqueue(operation) {
-    const next = this.#operationQueue.then(operation, operation);
-    this.#operationQueue = next.then(
-      () => void 0,
-      () => void 0
-    );
-    return next;
-  }
-  #emit(state) {
-    for (const listener of this.#listeners) {
-      listener(state);
-    }
-  }
-  #emitEvent(event) {
-    for (const listener of this.#eventListeners) listener(event);
-  }
-  #createEmptyState(now2) {
-    const state = {
-      rallyId: this.#config.id,
-      records: [],
-      ...this.#config.rewards === void 0 ? {} : {
-        rewards: reconcileRewardStates(this.#config.rewards, [], 0, now2)
-      },
-      updatedAt: now2
-    };
-    return state;
-  }
-  #reconcileState(state, now2) {
-    const configuredStampIds = new Set(this.#config.stamps.map((stamp) => stamp.id));
-    const seenStampIds = /* @__PURE__ */ new Set();
-    const records = state.records.filter((record) => {
-      if (!configuredStampIds.has(record.stampId) || seenStampIds.has(record.stampId)) return false;
-      seenStampIds.add(record.stampId);
-      return true;
-    });
-    if (this.#config.rewards === void 0 && state.rewards === void 0) {
-      return records.length === state.records.length ? state : { ...state, records };
-    }
-    return {
-      ...state,
-      records,
-      rewards: reconcileRewardStates(
-        this.#config.rewards ?? [],
-        state.rewards ?? [],
-        records.length,
-        now2
-      )
-    };
-  }
-};
-
-// src/client/universalClient.ts
 function isStorage(value) {
   return "load" in value && "save" in value && "remove" in value;
 }
-function randomId(prefix) {
+function id(prefix) {
   return `${prefix}-${globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`}`;
 }
-function now() {
-  return (/* @__PURE__ */ new Date()).toISOString();
-}
-function text(value) {
-  if (typeof value === "string") return value;
-  if (typeof value === "object" && value !== null) {
-    const first = Object.values(value).find((item) => typeof item === "string");
-    if (typeof first === "string") return first;
-  }
-  return "";
-}
-function proofString(value) {
+function proof(value) {
   if (typeof value === "string") return value;
   if (typeof value === "object" && value !== null) {
-    const record = value;
-    for (const key of ["token", "code", "passcode", "value"]) {
-      if (typeof record[key] === "string") return record[key];
-    }
+    const item = value;
+    for (const key of ["token", "code", "passcode", "value", "tagId"])
+      if (typeof item[key] === "string") return item[key];
   }
   return "";
 }
-function distanceMeters(aLat, aLon, bLat, bLon) {
-  const radians = (degrees) => degrees * Math.PI / 180;
-  const dLat = radians(bLat - aLat);
-  const dLon = radians(bLon - aLon);
-  const value = Math.sin(dLat / 2) ** 2 + Math.cos(radians(aLat)) * Math.cos(radians(bLat)) * Math.sin(dLon / 2) ** 2;
-  return 6371e3 * 2 * Math.asin(Math.sqrt(Math.min(1, value)));
-}
-function conditionMatches(condition2, proofData) {
-  switch (condition2.type) {
-    case "qr":
-      return proofString(proofData).trim() !== "";
-    case "passcode":
-      return proofString(proofData).trim() !== "";
-    case "gps": {
-      if (typeof proofData !== "object" || proofData === null) return false;
-      const value = proofData;
-      const latitude = typeof value.latitude === "number" ? value.latitude : Number.NaN;
-      const longitude = typeof value.longitude === "number" ? value.longitude : Number.NaN;
-      return Number.isFinite(latitude) && Number.isFinite(longitude) && distanceMeters(condition2.latitude, condition2.longitude, latitude, longitude) <= condition2.radiusMeters;
-    }
-    case "custom":
-      return true;
-  }
-}
-function asReward(reward) {
-  return { ...reward, description: text(reward.description) };
-}
-function initialState(config, timestamp) {
-  const rewards = config.rewards.map(asReward);
+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;
+  }
+  return proof(value).trim() !== "";
+}
+function emptyState(config, userId, now) {
   return {
     rallyId: config.id,
+    userId,
     records: [],
-    rewards: reconcileRewardStates(rewards, [], 0, timestamp),
-    updatedAt: timestamp
+    rewards: reconcileRewardStates(config.rewards, [], 0, now),
+    updatedAt: now
   };
 }
-var UniversalStampRallyClient = class {
+var StampRallyClient = class {
   #listeners = /* @__PURE__ */ new Set();
   #eventListeners = /* @__PURE__ */ new Set();
-  #config;
   #storage;
   #options;
+  #config;
+  #userId;
   #state = null;
   #initialization = null;
   #queue = Promise.resolve();
-  constructor(config, storageOrOptions = {}, clock) {
+  constructor(config, storageOrOptions = {}) {
     this.#config = config;
-    this.#options = isStorage(storageOrOptions) ? { storage: storageOrOptions, ...clock === void 0 ? {} : { clock } } : storageOrOptions;
+    this.#options = isStorage(storageOrOptions) ? { storage: storageOrOptions } : storageOrOptions;
     this.#storage = this.#options.storage ?? new InMemoryStorage();
+    this.#userId = this.#options.userId ?? null;
   }
   getConfig() {
     return this.#config;
@@ -1455,6 +1005,9 @@ var UniversalStampRallyClient = class {
   getState() {
     return this.#state;
   }
+  getUserId() {
+    return this.#userId;
+  }
   subscribe(listener) {
     this.#listeners.add(listener);
     return () => this.#listeners.delete(listener);
@@ -1469,11 +1022,11 @@ var UniversalStampRallyClient = class {
   initialize() {
     if (this.#state !== null) return Promise.resolve(this.#state);
     if (this.#initialization === null) {
-      this.#initialization = this.#storage.load(this.#config.id).then((stored) => {
-        const state = stored === null ? initialState(this.#config, this.#now()) : this.#reconcile(stored);
-        this.#state = state;
-        this.#emit(state);
-        return state;
+      this.#initialization = 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;
@@ -1481,11 +1034,31 @@ var UniversalStampRallyClient = class {
     }
     return this.#initialization;
   }
+  switchUser(newUserId) {
+    return this.#enqueue(async () => {
+      if (this.#userId === newUserId && this.#state !== null) return this.#state;
+      this.#userId = newUserId;
+      this.#state = null;
+      this.#initialization = null;
+      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();
+      }
+    });
+  }
   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({
@@ -1494,70 +1067,61 @@ var UniversalStampRallyClient = class {
           message: "Spot was already claimed."
         });
       const acquired = new Set(current.records.map((record2) => record2.stampId));
-      if (spot.prerequisites?.some((id) => !acquired.has(id)))
+      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 spot.conditions) {
+      for (const condition2 of spot2.conditions) {
         if (condition2.type === "custom") {
           const validator = this.#options.customValidators?.[condition2.validatorName] ?? this.#options.customValidator;
-          if (validator !== void 0) {
-            try {
-              const validation = await validator({
-                spotId,
-                proofData,
-                config: this.#config,
-                userState: current
-              });
-              if (!validation.success)
-                return this.#fail({
-                  code: "CUSTOM_VALIDATION_FAILED",
-                  spotId,
-                  message: validation.error ?? "Custom validation failed."
-                });
-            } catch (error) {
-              return this.#fail({
-                code: "CUSTOM_VALIDATION_FAILED",
-                spotId,
-                message: error instanceof Error ? error.message : "Custom validation failed."
-              });
-            }
-          } else {
+          if (validator === void 0)
             return this.#fail({
               code: "CUSTOM_VALIDATION_FAILED",
               spotId,
               message: "No custom validator is registered."
             });
-          }
-        } else if (!conditionMatches(condition2, proofData)) {
+          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 timestamp = options.now ?? this.#now();
+      const now = options.now ?? this.#now();
       const request = {
         rallyId: this.#config.id,
+        userId: this.#userId,
         spotId,
         proofData,
-        idempotencyKey: options.idempotencyKey ?? randomId("check-in"),
-        now: timestamp,
+        idempotencyKey: options.idempotencyKey ?? id("check-in"),
+        now,
         state: current
       };
       const remote = this.#options.syncAdapter?.checkIn;
       if (options.sync !== false && remote !== void 0) {
         const result = await remote(request);
-        if (!result.ok) return this.#fail(result.error);
-        return this.#commitCheckIn(result.value.state, result);
+        return result.ok ? this.#commitCheckIn(result) : this.#fail(result.error);
       }
-      const record = { stampId: spotId, acquiredAt: timestamp };
+      const record = { stampId: spotId, acquiredAt: now };
       const next = this.#reconcile({
         ...current,
         records: [...current.records, record],
-        updatedAt: timestamp
+        updatedAt: now
       });
       await this.#storage.save(next);
-      return this.#commitCheckIn(next, { ok: true, value: { state: next, record } });
+      return this.#commitCheckIn({ ok: true, value: { state: next, record } });
     });
   }
   claimReward(rewardId, options = {}) {
@@ -1566,107 +1130,128 @@ var UniversalStampRallyClient = class {
       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 timestamp = options.now ?? this.#now();
-      const state = current.rewards?.find((item) => item.rewardId === rewardId) ?? {
+      const now = options.now ?? this.#now();
+      const state = current.rewards.find((item) => item.rewardId === rewardId) ?? {
         rewardId,
         status: "LOCKED"
       };
       const local = consumeReward({
-        reward: asReward(configured),
+        reward: configured,
         currentState: state,
-        now: timestamp,
+        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 ?? randomId("claim"),
-        now: timestamp,
+        idempotencyKey: options.idempotencyKey ?? id("claim"),
+        now,
         options,
         state: current
       };
       const remote = this.#options.syncAdapter?.claimReward;
       if (options.sync !== false && remote !== void 0) {
         const result = await remote(request);
-        if (!result.ok) return this.#fail(result.error);
-        return this.#commitClaim(result.value.state, result);
+        return result.ok ? this.#commitClaim(result) : this.#fail(result.error);
       }
-      const nextRewards = (current.rewards ?? []).map(
-        (item) => item.rewardId === rewardId ? local.value : item
-      );
-      const next = { ...current, rewards: nextRewards, updatedAt: timestamp };
+      const next = {
+        ...current,
+        rewards: current.rewards.map((item) => item.rewardId === rewardId ? local.value : item),
+        updatedAt: now
+      };
       await this.#storage.save(next);
-      return this.#commitClaim(next, { ok: true, value: { state: next, reward: local.value } });
+      return this.#commitClaim({ ok: true, value: { state: next, reward: local.value } });
     });
   }
-  sync(adapter = this.#options.syncAdapter ?? {}) {
+  sync(adapter = this.#options.syncAdapter) {
     return this.#enqueue(async () => {
       const current = await this.initialize();
-      if (adapter.sync === void 0) {
+      if (adapter?.sync === void 0) {
         this.#emitEvent({ type: "sync", state: current });
         return;
       }
-      try {
-        const next = this.#reconcile(
-          await adapter.sync({ rallyId: this.#config.id, state: current })
-        );
-        await this.#storage.save(next);
-        this.#state = next;
-        this.#emit(next);
-        this.#emitEvent({ type: "sync", state: next });
-      } catch (error) {
-        const failure = {
-          code: "SYNC_FAILED",
-          message: error instanceof Error ? error.message : String(error)
-        };
-        this.#emitEvent({ type: "error", error: failure });
-        throw error;
-      }
+      const next = this.#reconcile(
+        await adapter.sync({ rallyId: this.#config.id, userId: this.#userId, state: current })
+      );
+      await this.#storage.save(next);
+      this.#state = next;
+      this.#emit(next);
+      this.#emitEvent({ type: "sync", state: next });
     });
   }
-  #now() {
-    return this.#options.clock?.() ?? now();
+  reset() {
+    return this.#enqueue(async () => {
+      await this.#storage.remove(this.#config.id, this.#userId);
+      return this.#initializeFresh();
+    });
+  }
+  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;
+    });
+  }
+  #enqueue(operation) {
+    const next = this.#queue.then(operation, operation);
+    this.#queue = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  }
+  #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((spot) => spot.id));
-    const seen = /* @__PURE__ */ new Set();
+    const ids = new Set(this.#config.spots.map((spot2) => spot2.id));
     const records = state.records.filter(
-      (record) => ids.has(record.stampId) && !seen.has(record.stampId) && seen.add(record.stampId)
+      (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.map(asReward),
-        state.rewards ?? [],
+        this.#config.rewards,
+        state.rewards,
         records.length,
         state.updatedAt
       )
     };
   }
-  #enqueue(operation) {
-    const next = this.#queue.then(operation, operation);
-    this.#queue = next.then(
-      () => void 0,
-      () => void 0
-    );
-    return next;
+  #now() {
+    return this.#options.clock?.() ?? (/* @__PURE__ */ new Date()).toISOString();
   }
   #fail(error) {
     this.#emitEvent({ type: "error", error });
     return { ok: false, error };
   }
-  #commitCheckIn(state, result) {
-    this.#state = state;
-    this.#emit(state);
+  #commitCheckIn(result) {
+    if (result.ok) {
+      this.#state = result.value.state;
+      this.#emit(this.#state);
+    }
     this.#emitEvent({ type: "checkIn", result });
     return result;
   }
-  #commitClaim(state, result) {
-    this.#state = state;
-    this.#emit(state);
+  #commitClaim(result) {
+    if (result.ok) {
+      this.#state = result.value.state;
+      this.#emit(this.#state);
+    }
     this.#emitEvent({ type: "rewardClaimed", result });
     return result;
   }
@@ -1739,7 +1324,7 @@ async function encryptPayload(plaintext, secret, api) {
   );
   return encode(new Uint8Array([...iv, ...encrypted]));
 }
-async function verifySecureToken(token, secretKey, now2 = Date.now()) {
+async function verifySecureToken(token, secretKey, now = Date.now()) {
   try {
     const parts = token.split(".");
     if (parts.length !== 4 || parts[0] !== "sr3" || parts[1] !== "e" && parts[1] !== "p") {
@@ -1782,7 +1367,7 @@ async function verifySecureToken(token, secretKey, now2 = Date.now()) {
       };
     }
     const payload = parsed;
-    if (typeof payload.exp === "number" && now2 >= payload.exp * 1e3) {
+    if (typeof payload.exp === "number" && now >= payload.exp * 1e3) {
       return {
         ok: false,
         valid: false,
@@ -1811,367 +1396,23 @@ async function decryptPayload(body, secret) {
 }
 
 // src/domain/i18n.ts
-function resolveLocalizedText(text3, locale, fallbackLocale) {
-  if (text3 === void 0 || text3 === "") return "";
-  if (typeof text3 === "string") return text3;
-  const fallback = fallbackLocale === void 0 ? Object.values(text3).find((value) => typeof value === "string") : text3[fallbackLocale];
-  return text3[locale] || fallback || "";
-}
-function toLocalizedString(text3) {
-  if (text3 === void 0) return { ja: "", en: "" };
-  return typeof text3 === "string" ? { ja: text3, en: "" } : {
-    ja: text3["ja"] ?? "",
-    en: text3["en"] ?? "",
-    ...text3
-  };
-}
-
-// src/domain/validation.ts
-var CURRENT_RALLY_CONFIG_VERSION = 2;
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function add(errors, path, code, message) {
-  errors.push({ path, code, message });
-}
-function hasText(value) {
-  if (typeof value === "string") return value.trim() !== "";
-  if (!isObject(value)) return false;
-  return Object.values(value).some((item) => typeof item === "string" && item.trim() !== "");
-}
-function validateCondition(value, path, errors) {
-  if (!isObject(value) || typeof value.type !== "string") {
-    add(errors, path, "INVALID_TYPE", "Condition must be an object with a type.");
-    return;
-  }
-  switch (value.type) {
-    case "instant":
-      return;
-    case "token":
-      if (typeof value.token !== "string" || value.token.trim() === "") {
-        add(errors, `${path}.token`, "REQUIRED", "Token must not be empty.");
-      }
-      return;
-    case "geo": {
-      const latitude = value.latitude;
-      const longitude = value.longitude;
-      if (typeof latitude !== "number" || !Number.isFinite(latitude) || latitude < -90 || latitude > 90 || typeof longitude !== "number" || !Number.isFinite(longitude) || longitude < -180 || longitude > 180) {
-        add(
-          errors,
-          path,
-          "INVALID_COORDINATES",
-          "Latitude must be between -90 and 90 and longitude between -180 and 180."
-        );
-      }
-      if (typeof value.radiusMeters !== "number" || !Number.isFinite(value.radiusMeters) || value.radiusMeters <= 0) {
-        add(errors, `${path}.radiusMeters`, "INVALID_RADIUS", "Radius must be greater than zero.");
-      }
-      return;
-    }
-    case "composite":
-      if (value.operator !== "AND" && value.operator !== "OR") {
-        add(errors, `${path}.operator`, "INVALID_TYPE", "Operator must be AND or OR.");
-      }
-      if (!Array.isArray(value.conditions)) {
-        add(errors, `${path}.conditions`, "INVALID_TYPE", "Composite conditions must be an array.");
-        return;
-      }
-      value.conditions.forEach((child, index) => {
-        validateCondition(child, `${path}.conditions[${index}]`, errors);
-      });
-      return;
-    case "time_window":
-      if (typeof value.startsAt !== "string" || Number.isNaN(Date.parse(value.startsAt))) {
-        add(errors, `${path}.startsAt`, "INVALID_DATE", "Start must be a valid ISO date.");
-      }
-      if (typeof value.endsAt !== "string" || Number.isNaN(Date.parse(value.endsAt))) {
-        add(errors, `${path}.endsAt`, "INVALID_DATE", "End must be a valid ISO date.");
-      }
-      if (typeof value.startsAt === "string" && typeof value.endsAt === "string" && !Number.isNaN(Date.parse(value.startsAt)) && !Number.isNaN(Date.parse(value.endsAt)) && Date.parse(value.startsAt) >= Date.parse(value.endsAt)) {
-        add(errors, path, "INVALID_DATE", "Time window start must be before its end.");
-      }
-      validateCondition(value.condition, `${path}.condition`, errors);
-      return;
-    default:
-      add(errors, `${path}.type`, "INVALID_TYPE", "Unsupported condition type.");
-  }
-}
-function validateSpot(value, index, errors) {
-  const path = `stamps[${index}]`;
-  if (!isObject(value)) {
-    add(errors, path, "INVALID_TYPE", "Spot must be an object.");
-    return;
-  }
-  if (typeof value.id !== "string") add(errors, `${path}.id`, "REQUIRED", "Spot ID is required.");
-  else if (value.id.trim() === "")
-    add(errors, `${path}.id`, "EMPTY_STRING", "Spot ID must not be empty.");
-  if (value.name === void 0) add(errors, `${path}.name`, "REQUIRED", "Spot name is required.");
-  else if (!hasText(value.name))
-    add(errors, `${path}.name`, "EMPTY_STRING", "Spot name must not be empty.");
-  if (value.order !== void 0 && (typeof value.order !== "number" || !Number.isFinite(value.order))) {
-    add(errors, `${path}.order`, "INVALID_TYPE", "Spot order must be a finite number.");
-  }
-  validateCondition(value.condition, `${path}.condition`, errors);
-  for (const field of ["dependsOn", "requiresStampIds"]) {
-    if (value[field] !== void 0 && (!Array.isArray(value[field]) || value[field].some((item) => typeof item !== "string"))) {
-      add(errors, `${path}.${field}`, "INVALID_TYPE", `${field} must be an array of IDs.`);
-    }
-  }
-  for (const field of ["order", "orderIndex"]) {
-    if (value[field] !== void 0 && (typeof value[field] !== "number" || !Number.isFinite(value[field]))) {
-      add(errors, `${path}.${field}`, "INVALID_TYPE", `${field} must be a finite number.`);
-    }
-  }
-}
-function validateReward(value, index, stampCount, errors) {
-  const path = `rewards[${index}]`;
-  if (!isObject(value)) {
-    add(errors, path, "INVALID_TYPE", "Reward must be an object.");
-    return;
-  }
-  if (typeof value.id !== "string" || value.id.trim() === "") {
-    add(errors, `${path}.id`, "REQUIRED", "Reward ID must not be empty.");
-  }
-  if (!hasText(value.title)) {
-    add(errors, `${path}.title`, "EMPTY_STRING", "Reward title must not be empty.");
-  }
-  if (!hasText(value.description)) {
-    add(errors, `${path}.description`, "EMPTY_STRING", "Reward description must not be empty.");
-  }
-  const required = value.requiredStampCount;
-  if (typeof required !== "number" || !Number.isInteger(required) || required < 0 || required > stampCount) {
-    add(
-      errors,
-      `${path}.requiredStampCount`,
-      "INVALID_REWARD",
-      "Required stamps must be an integer within the rally."
-    );
-  }
-  if (value.validUntil !== void 0 && (typeof value.validUntil !== "string" || Number.isNaN(Date.parse(value.validUntil)))) {
-    add(errors, `${path}.validUntil`, "INVALID_DATE", "Reward expiry must be a valid ISO date.");
-  }
-  for (const field of ["maxStock", "limitPerUser", "stockLimit", "userClaimLimit"]) {
-    const count = value[field];
-    if (count !== void 0 && (typeof count !== "number" || !Number.isInteger(count) || count <= 0)) {
-      add(errors, `${path}.${field}`, "INVALID_REWARD", `${field} must be a positive integer.`);
-    }
-  }
-}
-function collectDependencies(spot) {
-  const dependencies = /* @__PURE__ */ new Set();
-  for (const field of ["dependsOn", "requiresStampIds"]) {
-    const values = spot[field];
-    if (Array.isArray(values)) {
-      for (const value of values) if (typeof value === "string") dependencies.add(value);
-    }
-  }
-  return [...dependencies];
-}
-function validateDag(stamps, errors) {
-  const graph = /* @__PURE__ */ new Map();
-  for (const value of stamps) {
-    if (!isObject(value) || typeof value.id !== "string") continue;
-    graph.set(value.id, [...graph.get(value.id) ?? [], ...collectDependencies(value)]);
-  }
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const visit = (id, path) => {
-    if (visiting.has(id)) {
-      add(errors, path, "CYCLE_DETECTED", `Dependency cycle detected at '${id}'.`);
-      return;
-    }
-    if (visited.has(id)) return;
-    visiting.add(id);
-    for (const dependency of graph.get(id) ?? [])
-      if (graph.has(dependency)) visit(dependency, path);
-    visiting.delete(id);
-    visited.add(id);
-  };
-  for (const id of graph.keys()) visit(id, `stamps[${id}]`);
-}
-function validateRallyConfig(config) {
-  const errors = [];
-  if (!isObject(config))
-    return {
-      valid: false,
-      errors: [{ path: "", code: "INVALID_TYPE", message: "Rally config must be an object." }]
-    };
-  if (typeof config.id !== "string") add(errors, "id", "REQUIRED", "Rally ID is required.");
-  else if (config.id.trim() === "")
-    add(errors, "id", "EMPTY_STRING", "Rally ID must not be empty.");
-  if (config.title !== void 0 && !hasText(config.title))
-    add(errors, "title", "EMPTY_STRING", "Rally title must not be empty.");
-  if (config.version !== void 0 && config.version !== CURRENT_RALLY_CONFIG_VERSION) {
-    add(
-      errors,
-      "version",
-      "INVALID_VERSION",
-      `Config version must be ${CURRENT_RALLY_CONFIG_VERSION}.`
-    );
-  }
-  for (const field of ["startDate", "endDate"]) {
-    if (config[field] !== void 0 && (typeof config[field] !== "string" || Number.isNaN(Date.parse(config[field])))) {
-      add(errors, field, "INVALID_DATE", `${field} must be a valid ISO date.`);
-    }
-  }
-  if (typeof config.startDate === "string" && typeof config.endDate === "string" && !Number.isNaN(Date.parse(config.startDate)) && !Number.isNaN(Date.parse(config.endDate)) && Date.parse(config.startDate) >= Date.parse(config.endDate)) {
-    add(errors, "startDate", "INVALID_DATE", "startDate must be before endDate.");
-  }
-  if (!Array.isArray(config.stamps)) {
-    add(errors, "stamps", "INVALID_TYPE", "stamps must be an array.");
-  } else {
-    config.stamps.forEach((spot, index) => {
-      validateSpot(spot, index, errors);
-    });
-    const ids = config.stamps.map(
-      (spot) => isObject(spot) && typeof spot.id === "string" ? spot.id : ""
-    );
-    ids.forEach((id, index) => {
-      if (id !== "" && ids.indexOf(id) !== index)
-        add(errors, `stamps[${index}].id`, "DUPLICATE_ID", `Duplicate spot ID '${id}'.`);
-    });
-    validateDag(config.stamps, errors);
-  }
-  if (config.rewards !== void 0 && !Array.isArray(config.rewards)) {
-    add(errors, "rewards", "INVALID_TYPE", "rewards must be an array.");
-  } else if (Array.isArray(config.rewards)) {
-    const stampCount = Array.isArray(config.stamps) ? config.stamps.length : 0;
-    config.rewards.forEach((reward, index) => {
-      validateReward(reward, index, stampCount, errors);
-    });
-    const ids = config.rewards.map(
-      (reward) => isObject(reward) && typeof reward.id === "string" ? reward.id : ""
-    );
-    ids.forEach((id, index) => {
-      if (id !== "" && ids.indexOf(id) !== index)
-        add(errors, `rewards[${index}].id`, "DUPLICATE_ID", `Duplicate reward ID '${id}'.`);
-    });
-    if (Array.isArray(config.stamps)) {
-      const stampIds = new Set(
-        config.stamps.map((spot) => isObject(spot) && typeof spot.id === "string" ? spot.id : "")
-      );
-      ids.forEach((id, index) => {
-        if (id !== "" && stampIds.has(id))
-          add(
-            errors,
-            `rewards[${index}].id`,
-            "DUPLICATE_ID",
-            `Reward ID '${id}' is already used by a spot.`
-          );
-      });
-    }
-  }
-  return { valid: errors.length === 0, errors };
-}
-
-// src/domain/migration.ts
-function isObject2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function text2(value) {
-  if (typeof value === "string") return value;
-  if (!isObject2(value)) return void 0;
-  const entries = Object.entries(value).filter(([, item]) => typeof item === "string");
-  return entries.length === 0 ? void 0 : Object.fromEntries(entries);
-}
-function condition(value) {
-  if (!isObject2(value) || typeof value.type !== "string") return { type: "instant" };
-  switch (value.type) {
-    case "instant":
-      return { type: "instant" };
-    case "token":
-    case "passcode":
-      return {
-        type: "token",
-        token: typeof value.token === "string" ? value.token : typeof value.passcode === "string" ? value.passcode : ""
-      };
-    case "geo":
-      return {
-        type: "geo",
-        latitude: typeof value.latitude === "number" ? value.latitude : 0,
-        longitude: typeof value.longitude === "number" ? value.longitude : 0,
-        radiusMeters: typeof value.radiusMeters === "number" ? value.radiusMeters : typeof value.radius === "number" ? value.radius : 1
-      };
-    case "composite":
-      return {
-        type: "composite",
-        operator: value.operator === "OR" ? "OR" : "AND",
-        conditions: Array.isArray(value.conditions) ? value.conditions.map(condition) : []
-      };
-    case "time_window":
-      return {
-        type: "time_window",
-        startsAt: typeof value.startsAt === "string" ? value.startsAt : "1970-01-01T00:00:00.000Z",
-        endsAt: typeof value.endsAt === "string" ? value.endsAt : "9999-12-31T23:59:59.999Z",
-        condition: condition(value.condition)
-      };
-    default:
-      return { type: "instant" };
-  }
-}
-function migrateSpot(value, index) {
-  const source2 = isObject2(value) ? value : {};
-  const id = typeof source2.id === "string" && source2.id.trim() !== "" ? source2.id.trim() : `spot-${index + 1}`;
-  const description = text2(source2.description);
-  const hint = text2(source2.hint);
-  return {
-    id,
-    name: text2(source2.name) ?? `Spot ${index + 1}`,
-    ...description === void 0 ? {} : { description },
-    ...hint === void 0 ? {} : { hint },
-    condition: condition(
-      source2.condition ?? (typeof source2.token === "string" ? { type: "token", token: source2.token } : void 0)
-    ),
-    ...typeof source2.orderIndex === "number" ? { orderIndex: source2.orderIndex } : typeof source2.order === "number" ? { order: source2.order } : {},
-    ...typeof source2.deckId === "string" ? { deckId: source2.deckId } : {},
-    ...typeof source2.groupId === "string" ? { groupId: source2.groupId } : {},
-    ...typeof source2.guideId === "string" ? { guideId: source2.guideId } : {},
-    ...typeof source2.iconUrl === "string" ? { iconUrl: source2.iconUrl } : {},
-    ...typeof source2.imageUrl === "string" ? { imageUrl: source2.imageUrl } : {},
-    ...typeof source2.externalUrl === "string" ? { externalUrl: source2.externalUrl } : {},
-    ...typeof source2.redirectUrlAfterClaim === "string" ? { redirectUrlAfterClaim: source2.redirectUrlAfterClaim } : {},
-    ...isObject2(source2.metadata) ? { metadata: source2.metadata } : {},
-    ...Array.isArray(source2.dependsOn) ? { dependsOn: source2.dependsOn.filter((item) => typeof item === "string") } : {}
-  };
-}
-function migrateReward(value, index) {
-  const source2 = isObject2(value) ? value : {};
-  return {
-    id: typeof source2.id === "string" && source2.id.trim() !== "" ? source2.id.trim() : `reward-${index + 1}`,
-    title: text2(source2.title) ?? `Reward ${index + 1}`,
-    description: text2(source2.description) ?? "",
-    type: source2.type === "digital" ? "digital" : "in_person",
-    redemptionMethod: source2.redemptionMethod === "staff_passcode" || source2.redemptionMethod === "view_only" || source2.redemptionMethod === "server_claim" ? source2.redemptionMethod : "manual_slide",
-    requiredStampCount: typeof source2.requiredStampCount === "number" && Number.isFinite(source2.requiredStampCount) ? Math.max(0, Math.trunc(source2.requiredStampCount)) : 0,
-    ...typeof source2.digitalContentUrl === "string" ? { digitalContentUrl: source2.digitalContentUrl } : {},
-    ...typeof source2.staffPasscode === "string" ? { staffPasscode: source2.staffPasscode } : {},
-    ...typeof source2.validUntil === "string" ? { validUntil: source2.validUntil } : {},
-    ...typeof source2.maxStock === "number" ? { maxStock: source2.maxStock } : {},
-    ...typeof source2.limitPerUser === "number" ? { limitPerUser: source2.limitPerUser } : {},
-    ...typeof source2.stockLimit === "number" ? { stockLimit: source2.stockLimit } : {},
-    ...typeof source2.userClaimLimit === "number" ? { userClaimLimit: source2.userClaimLimit } : {},
-    ...typeof source2.claimTicketNumber === "string" ? { claimTicketNumber: source2.claimTicketNumber } : {}
-  };
-}
-function migrateRallyConfig(raw) {
-  const source2 = isObject2(raw) ? raw : {};
-  const rawStamps = Array.isArray(source2.stamps) ? source2.stamps : Array.isArray(source2.spots) ? source2.spots : [];
-  const rawRewards = Array.isArray(source2.rewards) ? source2.rewards : [];
-  const id = typeof source2.id === "string" && source2.id.trim() !== "" ? source2.id.trim() : "migrated-rally";
-  const title = text2(source2.title);
-  const description = text2(source2.description);
-  const theme = isObject2(source2.theme) ? source2.theme : void 0;
-  return {
-    id,
-    ...title === void 0 ? {} : { title },
-    ...description === void 0 ? {} : { description },
-    stamps: rawStamps.map(migrateSpot),
-    ...rawRewards.length === 0 ? {} : { rewards: rawRewards.map(migrateReward) },
-    ...typeof source2.isSequential === "boolean" ? { isSequential: source2.isSequential } : {},
-    ...theme === void 0 ? {} : { theme },
-    version: CURRENT_RALLY_CONFIG_VERSION,
-    ...typeof source2.startDate === "string" ? { startDate: source2.startDate } : typeof source2.startsAt === "string" ? { startDate: source2.startsAt } : {},
-    ...typeof source2.endDate === "string" ? { endDate: source2.endDate } : typeof source2.endsAt === "string" ? { endDate: source2.endsAt } : {}
+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
   };
 }
 
@@ -2186,12 +1427,10 @@ var DEFAULT_SHEET_THEME = {
   unclaimedOpacity: 1,
   fontFamily: "serif"
 };
-
-// src/domain/universalModel.ts
-function toPublicCondition(condition2) {
+function publicCondition(condition2) {
   switch (condition2.type) {
     case "qr":
-      return { type: "qr", qrEntryUrl: condition2.qrEntryUrl ?? "" };
+      return condition2.qrEntryUrl === void 0 ? { type: "qr" } : { type: "qr", qrEntryUrl: condition2.qrEntryUrl };
     case "passcode":
       return { type: "passcode" };
     case "gps":
@@ -2201,54 +1440,85 @@ function toPublicCondition(condition2) {
         longitude: condition2.longitude,
         radiusMeters: condition2.radiusMeters
       };
+    case "nfc":
+      return { type: "nfc" };
     case "custom":
       return { type: "custom", validatorName: condition2.validatorName };
   }
 }
-function toPublicRallyConfig(config) {
+function toPublicConfig(config) {
   return {
-    ...config,
-    spots: config.spots.map((spot) => ({
-      ...spot,
-      conditions: spot.conditions.map(toPublicCondition)
+    id: config.id,
+    version: config.version,
+    title: config.title,
+    ...config.description === void 0 ? {} : { description: config.description },
+    ...config.theme === void 0 ? {} : { theme: config.theme },
+    spots: config.spots.map((spot2) => ({
+      ...spot2,
+      conditions: spot2.conditions.map(publicCondition)
     })),
     rewards: config.rewards.map(
-      ({ staffPasscode: _staffPasscode, digitalContentUrl: _content, ...reward }) => reward
-    )
+      ({ digitalContentUrl: _content, staffPasscode: _passcode, ...reward2 }) => reward2
+    ),
+    ...config.metadata === void 0 ? {} : { metadata: config.metadata },
+    ...config.serverEndpoint === void 0 ? {} : { serverEndpoint: config.serverEndpoint }
   };
 }
-function isPublicRallyConfig(value) {
+function assertPublicConfig(config) {
+  if (!isPublicConfig(config)) throw new Error("Configuration contains private rally fields.");
+}
+function isPublicConfig(value) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
   const candidate = value;
-  if (candidate.secretKey !== void 0 || candidate.verificationSecrets !== void 0)
+  const seen = /* @__PURE__ */ new Set();
+  const containsPrivateField = (item) => {
+    if (typeof item !== "object" || item === null) return false;
+    if (seen.has(item)) return false;
+    seen.add(item);
+    if (Array.isArray(item)) return item.some(containsPrivateField);
+    const record = item;
+    if (["staffPasscode", "secretToken", "serverMetadata", "secretParams", "digitalContentUrl"].some(
+      (key) => key in record
+    ))
+      return true;
+    return Object.values(record).some(containsPrivateField);
+  };
+  if (containsPrivateField(candidate)) return false;
+  for (const key of [
+    "staffPasscode",
+    "secretToken",
+    "serverMetadata",
+    "secretParams",
+    "code",
+    "tagId"
+  ]) {
+    if (key in candidate) return false;
+  }
+  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 Array.isArray(candidate.spots) && Array.isArray(candidate.rewards) && candidate.spots.every((spot) => {
-    if (typeof spot !== "object" || spot === null || Array.isArray(spot)) return false;
-    const conditions = spot.conditions;
-    return Array.isArray(conditions) && conditions.every((condition2) => {
-      if (typeof condition2 !== "object" || condition2 === null) return false;
-      const type = condition2.type;
-      return type === "qr" || type === "passcode" || type === "gps" || type === "custom";
+  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((condition2) => {
+      if (typeof condition2 !== "object" || condition2 === null || Array.isArray(condition2))
+        return false;
+      const value2 = condition2;
+      if ("secretToken" in value2 || "code" in value2 || "tagId" in value2 || "secretParams" in value2)
+        return false;
+      const type = value2.type;
+      if (type === "qr" || type === "passcode" || type === "nfc") return true;
+      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;
-    return item.staffPasscode === void 0 && item.digitalContentUrl === void 0;
+  }) && 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/publicConfig.ts
-function stripSensitiveConfig(config) {
-  if ("spots" in config && !("stamps" in config)) {
-    return toPublicRallyConfig(config);
-  }
-  const rewards = config.rewards?.map(({ staffPasscode: _staffPasscode, ...reward }) => reward);
-  return {
-    ...config,
-    ...rewards === void 0 ? {} : { rewards }
-  };
-}
-
 // src/domain/themePresets.ts
 var THEME_PRESETS = [
   {
@@ -2348,178 +1618,322 @@ var THEME_PRESETS = [
   }
 ];
 
-// src/domain/universalValidation.ts
-function isObject3(value) {
+// 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 isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function add2(errors, path, code, message) {
-  errors.push({ path, code, message });
+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 hasText2(value) {
-  if (typeof value === "string") return value.trim() !== "";
-  return isObject3(value) && Object.values(value).some((item) => typeof item === "string" && item.trim() !== "");
+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 validateCondition2(condition2, path, errors) {
-  if (!isObject3(condition2) || typeof condition2.type !== "string") {
-    add2(errors, path, "INVALID_TYPE", "Condition must have a 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 (!isRecord2(value)) {
+    add(errors, path, "Expected a string or a locale map.", "invalid_localized_text");
     return;
   }
-  switch (condition2.type) {
-    case "qr":
-      if (typeof condition2.secretToken !== "string" || condition2.secretToken.trim() === "")
-        add2(errors, `${path}.secretToken`, "REQUIRED", "QR secretToken is required.");
-      if (condition2.qrEntryUrl !== void 0 && typeof condition2.qrEntryUrl !== "string")
-        add2(errors, `${path}.qrEntryUrl`, "INVALID_TYPE", "QR entry URL must be a string.");
-      return;
-    case "passcode":
-      if (typeof condition2.code !== "string" || condition2.code.trim() === "")
-        add2(errors, `${path}.code`, "REQUIRED", "Passcode is required.");
-      return;
-    case "gps":
-      if (typeof condition2.latitude !== "number" || !Number.isFinite(condition2.latitude) || condition2.latitude < -90 || condition2.latitude > 90 || typeof condition2.longitude !== "number" || !Number.isFinite(condition2.longitude) || condition2.longitude < -180 || condition2.longitude > 180)
-        add2(errors, path, "INVALID_COORDINATES", "GPS coordinates are invalid.");
-      if (typeof condition2.radiusMeters !== "number" || !Number.isFinite(condition2.radiusMeters) || condition2.radiusMeters <= 0)
-        add2(errors, `${path}.radiusMeters`, "INVALID_RADIUS", "GPS radius must be positive.");
-      return;
-    case "custom":
-      if (typeof condition2.validatorName !== "string" || condition2.validatorName.trim() === "")
-        add2(errors, `${path}.validatorName`, "REQUIRED", "Custom validatorName is required.");
+  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 (!isRecord2(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 (!isRecord2(item)) {
+      add(errors, itemPath, "Expected an object.", "invalid_type");
       return;
-    default:
-      add2(errors, `${path}.type`, "INVALID_TYPE", "Unsupported verification condition.");
-  }
-}
-function validateDag2(spots, errors) {
-  const graph = /* @__PURE__ */ new Map();
-  for (const spot of spots) {
-    if (!isObject3(spot) || typeof spot.id !== "string") continue;
-    const prerequisites = Array.isArray(spot.prerequisites) ? spot.prerequisites.filter((item) => typeof item === "string") : [];
-    graph.set(spot.id, prerequisites);
-  }
-  const visiting = /* @__PURE__ */ new Set();
-  const visited = /* @__PURE__ */ new Set();
-  const visit = (id) => {
-    if (visiting.has(id)) {
-      add2(
+    }
+    requiredString(item, "type", itemPath, errors);
+    requiredString(item, "id", itemPath, errors);
+    optionalString(item, "url", itemPath, errors);
+  });
+}
+function condition(value, path, errors, isPublic) {
+  if (!isRecord2(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,
-        `spots.${id}.prerequisites`,
-        "CYCLE_DETECTED",
-        `Dependency cycle detected at '${id}'.`
+        `${path}.longitude`,
+        "Expected a longitude between -180 and 180.",
+        "out_of_range"
       );
-      return;
-    }
-    if (visited.has(id)) return;
-    visiting.add(id);
-    for (const prerequisite of graph.get(id) ?? [])
-      if (graph.has(prerequisite)) visit(prerequisite);
-    visiting.delete(id);
-    visited.add(id);
-  };
-  for (const id of graph.keys()) visit(id);
+    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") && !isRecord2(value.secretParams))
+      add(errors, `${path}.secretParams`, "Expected an object.", "invalid_type");
+    return;
+  }
+  add(errors, `${path}.type`, "Unknown condition type.", "invalid_enum");
 }
-function validateAdminRallyConfig(value) {
-  const errors = [];
-  if (!isObject3(value))
-    return {
-      valid: false,
-      errors: [{ path: "", code: "INVALID_TYPE", message: "Admin config must be an object." }]
-    };
-  if (typeof value.id !== "string" || value.id.trim() === "")
-    add2(errors, "id", "REQUIRED", "Rally ID is required.");
-  if (typeof value.version !== "string" || value.version.trim() === "")
-    add2(errors, "version", "INVALID_VERSION", "Version is required.");
-  if (!Array.isArray(value.spots)) {
-    add2(errors, "spots", "INVALID_TYPE", "spots must be an array.");
-  } else {
-    const ids = [];
-    value.spots.forEach((spot, index) => {
-      const path = `spots[${index}]`;
-      if (!isObject3(spot)) {
-        add2(errors, path, "INVALID_TYPE", "Spot must be an object.");
-        return;
-      }
-      if (typeof spot.id !== "string" || spot.id.trim() === "")
-        add2(errors, `${path}.id`, "REQUIRED", "Spot ID is required.");
-      else if (ids.includes(spot.id))
-        add2(errors, `${path}.id`, "DUPLICATE_ID", `Duplicate spot ID '${spot.id}'.`);
-      else ids.push(spot.id);
-      if (!hasText2(spot.name)) add2(errors, `${path}.name`, "REQUIRED", "Spot name is required.");
-      if (typeof spot.orderIndex !== "number" || !Number.isInteger(spot.orderIndex))
-        add2(errors, `${path}.orderIndex`, "INVALID_TYPE", "orderIndex must be an integer.");
-      if (!Array.isArray(spot.conditions) || spot.conditions.length === 0)
-        add2(errors, `${path}.conditions`, "REQUIRED", "At least one condition is required.");
-      else {
-        spot.conditions.forEach((condition2, conditionIndex) => {
-          validateCondition2(condition2, `${path}.conditions[${conditionIndex}]`, errors);
-        });
-      }
-    });
-    validateDag2(value.spots, errors);
-  }
-  if (!Array.isArray(value.rewards))
-    add2(errors, "rewards", "INVALID_TYPE", "rewards must be an array.");
-  else {
-    const ids = [];
-    value.rewards.forEach((reward, index) => {
-      const path = `rewards[${index}]`;
-      if (!isObject3(reward)) {
-        add2(errors, path, "INVALID_TYPE", "Reward must be an object.");
-        return;
-      }
-      if (typeof reward.id !== "string" || reward.id.trim() === "")
-        add2(errors, `${path}.id`, "REQUIRED", "Reward ID is required.");
-      else if (ids.includes(reward.id))
-        add2(errors, `${path}.id`, "DUPLICATE_ID", `Duplicate reward ID '${reward.id}'.`);
-      else ids.push(reward.id);
-      if (!hasText2(reward.title))
-        add2(errors, `${path}.title`, "REQUIRED", "Reward title is required.");
-      if (typeof reward.requiredStampCount !== "number" || !Number.isInteger(reward.requiredStampCount) || reward.requiredStampCount < 0)
-        add2(
-          errors,
-          `${path}.requiredStampCount`,
-          "INVALID_REWARD",
-          "requiredStampCount must be a non-negative integer."
-        );
-    });
+function unlockCondition(value, path, errors) {
+  if (!isRecord2(value)) {
+    add(errors, path, "Expected an unlock condition object.", "invalid_type");
+    return;
+  }
+  if (value.type === "stamp_count") {
+    finiteNumber(value, "count", path, errors, 0);
+    return;
   }
-  return { valid: errors.length === 0, errors };
+  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 validatePublicRallyConfig(value) {
-  const errors = [];
-  if (!isObject3(value))
-    return {
-      valid: false,
-      errors: [{ path: "", code: "INVALID_TYPE", message: "Public config must be an object." }]
-    };
-  if ("secretKey" in value || "verificationSecrets" in value)
-    add2(
-      errors,
-      "",
-      "SECRET_IN_PUBLIC_CONFIG",
-      "Public config must not contain server verification secrets."
-    );
-  if (!Array.isArray(value.spots)) add2(errors, "spots", "INVALID_TYPE", "spots must be an array.");
-  else
-    value.spots.forEach((spot, index) => {
-      if (!isObject3(spot) || !Array.isArray(spot.conditions)) return;
-      spot.conditions.forEach((condition2, conditionIndex) => {
-        if (!isObject3(condition2)) return;
-        if ("secretToken" in condition2 || "code" in condition2 || "secretParams" in condition2)
-          add2(
+function spot(value, path, errors, isPublic) {
+  if (!isRecord2(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,
-            `spots[${index}].conditions[${conditionIndex}]`,
-            "SECRET_IN_PUBLIC_CONFIG",
-            "Public condition contains verification secret material."
+            `${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);
     });
-  return { valid: errors.length === 0, errors };
 }
-function isAdminRallyConfig(value) {
-  return validateAdminRallyConfig(value).valid;
+function reward(value, path, errors, isPublic) {
+  if (!isRecord2(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 (!isRecord2(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 && !isRecord2(value.inventory))
+      add(errors, "$.inventory", "Expected an object.", "invalid_type");
+    if (hasOwn(value, "serverMetadata") && value.serverMetadata !== void 0 && !isRecord2(value.serverMetadata))
+      add(errors, "$.serverMetadata", "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 isPublicRallyConfigShape(value) {
-  return validatePublicRallyConfig(value).valid;
+function parsePublicConfig(input) {
+  const result = safeParsePublicConfig(input);
+  if (!result.success) throw new ConfigValidationError(result.errors);
+  return result.data;
 }
 
 // src/security/snapshotToken.ts
@@ -2560,9 +1974,9 @@ async function importAesKey(secret) {
   const digest = await cryptoApi2().subtle.digest("SHA-256", webCryptoBytes(secret));
   return cryptoApi2().subtle.importKey("raw", digest, "AES-GCM", false, ["encrypt", "decrypt"]);
 }
-function isExpired(payload, now2) {
-  if (typeof payload.exp === "number" && now2 >= payload.exp * 1e3) return true;
-  return payload.expiresAt !== void 0 && Date.parse(payload.expiresAt) <= now2;
+function isExpired(payload, now) {
+  if (typeof payload.exp === "number" && now >= payload.exp * 1e3) return true;
+  return payload.expiresAt !== void 0 && Date.parse(payload.expiresAt) <= now;
 }
 async function createSignedSnapshotToken(payload, secretKey) {
   const api = cryptoApi2();
@@ -2582,7 +1996,7 @@ async function createSignedSnapshotToken(payload, secretKey) {
   );
   return `sr2.${body}.${base64Url(signature)}`;
 }
-async function verifySnapshotToken(token, secretKey, now2 = Date.now()) {
+async function verifySnapshotToken(token, secretKey, now = Date.now()) {
   try {
     const parts = token.split(".");
     if (parts.length !== 3 || parts[0] !== "sr2") {
@@ -2624,7 +2038,7 @@ async function verifySnapshotToken(token, secretKey, now2 = Date.now()) {
     const payload = JSON.parse(new TextDecoder().decode(payloadText));
     if (typeof payload !== "object" || payload === null || Array.isArray(payload))
       throw new Error("Invalid payload.");
-    if (isExpired(payload, now2)) {
+    if (isExpired(payload, now)) {
       return {
         ok: false,
         valid: false,
@@ -2641,7 +2055,7 @@ async function verifySnapshotToken(token, secretKey, now2 = Date.now()) {
   }
 }
 
-exports.CURRENT_RALLY_CONFIG_VERSION = CURRENT_RALLY_CONFIG_VERSION;
+exports.ConfigValidationError = ConfigValidationError;
 exports.DEFAULT_SHEET_THEME = DEFAULT_SHEET_THEME;
 exports.InMemoryStorage = InMemoryStorage;
 exports.IndexedDBAdapter = IndexedDBAdapter;
@@ -2649,7 +2063,7 @@ exports.LocalStorageAdapter = LocalStorageAdapter;
 exports.StampRallyClient = StampRallyClient;
 exports.StorageAdapterError = StorageAdapterError;
 exports.THEME_PRESETS = THEME_PRESETS;
-exports.UniversalStampRallyClient = UniversalStampRallyClient;
+exports.assertPublicConfig = assertPublicConfig;
 exports.calculateDistanceMeters = calculateDistanceMeters;
 exports.calculateProgress = calculateProgress;
 exports.consumeReward = consumeReward;
@@ -2657,34 +2071,33 @@ exports.createClaimTicketNumber = createClaimTicketNumber;
 exports.createSecureToken = createSecureToken;
 exports.createSignedSnapshotToken = createSignedSnapshotToken;
 exports.createUniqueClaimTicketNumber = createUniqueClaimTicketNumber;
-exports.evaluateCheckIn = evaluateCheckIn;
 exports.evaluateCondition = evaluateCondition;
 exports.evaluateConditionDetailed = evaluateConditionDetailed;
 exports.exportProgressToken = exportProgressToken;
 exports.getCurrentGeoContext = getCurrentGeoContext;
+exports.getOrderedSpots = getOrderedSpots;
 exports.importProgressToken = importProgressToken;
-exports.isAdminRallyConfig = isAdminRallyConfig;
 exports.isGeolocationSupported = isGeolocationSupported;
 exports.isNfcSupported = isNfcSupported;
-exports.isPublicRallyConfig = isPublicRallyConfig;
-exports.isPublicRallyConfigShape = isPublicRallyConfigShape;
+exports.isPublicConfig = isPublicConfig;
 exports.isQrSupported = isQrSupported;
 exports.isRewardState = isRewardState;
 exports.isStampRallyState = isStampRallyState;
 exports.issueClaimTicketNumber = issueClaimTicketNumber;
-exports.migrateRallyConfig = migrateRallyConfig;
 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.stripSensitiveConfig = stripSensitiveConfig;
+exports.safeParseAdminConfig = safeParseAdminConfig;
+exports.safeParsePublicConfig = safeParsePublicConfig;
+exports.storageKey = storageKey;
 exports.toLocalizedString = toLocalizedString;
-exports.toPublicRallyConfig = toPublicRallyConfig;
-exports.validateAdminRallyConfig = validateAdminRallyConfig;
-exports.validatePublicRallyConfig = validatePublicRallyConfig;
-exports.validateRallyConfig = validateRallyConfig;
+exports.toPublicConfig = toPublicConfig;
+exports.updateLocalizedField = updateLocalizedField;
 exports.verifyPasscode = verifyPasscode;
 exports.verifySecureToken = verifySecureToken;
 exports.verifySnapshotToken = verifySnapshotToken;