@stamprally/core 0.7.0 → 0.9.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 assertNever(value) {
-  throw new Error(`Unexpected condition: ${JSON.stringify(value)}`);
-}
-function evaluateConditionDetailed(condition2, context, now) {
-  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"
-          }
-        };
-      }
+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 mismatch(conditionType, reason, extra = {}) {
+  return { ok: false, error: { code: "CONDITION_MISMATCH", conditionType, reason, ...extra } };
+}
+function evaluateConditionDetailed(condition, context) {
+  switch (condition.type) {
+    case "qr":
+      return context.type === "qr" && context.token === condition.secretToken ? { ok: true, value: { conditionType: "qr" } } : mismatch("qr", "INVALID_PROOF");
+    case "passcode":
+      return context.type === "passcode" && (condition.caseSensitive === false ? context.code.toLocaleLowerCase() === condition.code.toLocaleLowerCase() : context.code === condition.code) ? { ok: true, value: { conditionType: "passcode" } } : mismatch("passcode", "INVALID_PROOF");
+    case "nfc":
+      return context.type === "nfc" && context.tagId === condition.tagId ? { ok: true, value: { conditionType: "nfc" } } : mismatch("nfc", "INVALID_PROOF");
+    case "custom":
+      return mismatch("custom", "VALIDATOR_FAILED");
+    case "gps": {
+      if (!Number.isFinite(condition.latitude) || !Number.isFinite(condition.longitude) || !Number.isFinite(condition.radiusMeters) || condition.radiusMeters < 0 || context.type !== "gps" || !Number.isFinite(context.latitude) || !Number.isFinite(context.longitude))
+        return mismatch("gps", "INVALID_GEO_INPUT");
       const distanceMeters = calculateDistanceMeters(
-        condition2.latitude,
-        condition2.longitude,
-        context.currentLatitude,
-        context.currentLongitude
+        condition.latitude,
+        condition.longitude,
+        context.latitude,
+        context.longitude
       );
-      if (distanceMeters <= condition2.radiusMeters) {
-        return { ok: true, value: { conditionType: "geo", distanceMeters } };
-      }
-      return {
-        ok: false,
-        error: {
-          code: "CONDITION_MISMATCH",
-          conditionType: "geo",
-          reason: "OUTSIDE_RADIUS",
-          distanceMeters,
-          radiusMeters: condition2.radiusMeters,
-          differenceMeters: distanceMeters - 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, now);
-        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(now);
-      if (!Number.isFinite(currentTime)) {
-        return {
-          ok: false,
-          error: {
-            code: "CONDITION_MISMATCH",
-            conditionType: "time_window",
-            reason: "INVALID_NOW",
-            now,
-            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,
-            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,
-            startsAt: condition2.startsAt,
-            endsAt: condition2.endsAt
-          }
-        };
-      }
-      const childResult = evaluateConditionDetailed(condition2.condition, context, now);
-      return childResult.ok ? { ok: true, value: { conditionType: "time_window" } } : childResult;
+      return distanceMeters <= condition.radiusMeters ? { ok: true, value: { conditionType: "gps", distanceMeters } } : mismatch("gps", "OUTSIDE_RADIUS", {
+        distanceMeters,
+        radiusMeters: condition.radiusMeters
+      });
     }
-    default:
-      return assertNever(condition2);
   }
 }
-function evaluateCondition(condition2, context, now) {
-  return evaluateConditionDetailed(condition2, context, now ?? "").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(condition, context) {
+  return evaluateConditionDetailed(condition, 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((spot) => spot.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((spot) => !acquired.has(spot.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)
   };
 }
 
@@ -283,7 +95,7 @@ function createUniqueClaimTicketNumber(rewardId, issuedAt) {
 }
 function issueClaimTicketNumber(reward, currentState, options = {}) {
   if (currentState.claimTicketNumber !== void 0) return currentState;
-  const claimTicketNumber = reward.claimTicketNumber ?? createClaimTicketNumber(reward.id, options);
+  const claimTicketNumber = createClaimTicketNumber(reward.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 {
@@ -491,14 +303,8 @@ function normalizePasscode(input, caseSensitive = false) {
   const normalized = input.normalize("NFKC").trim();
   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."
-  };
+function verifyPasscode(inputCode, condition) {
+  return normalizePasscode(inputCode, condition.caseSensitive) === normalizePasscode(condition.code, condition.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;
@@ -624,80 +430,47 @@ async function readQrContext(videoElement, options = {}) {
 
 // src/engine/transition.ts
 function reconcileRewardStates(rewards, currentStates, acquiredStampCount, now) {
-  const statesById = new Map(currentStates.map((state) => [state.rewardId, state]));
+  const states = 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(now)) {
+    const current = states.get(reward.id);
+    if (current?.status === "CONSUMED" || current?.status === "EXPIRED") return current;
+    if (reward.validUntil !== void 0 && Date.parse(reward.validUntil) <= Date.parse(now))
       return { rewardId: reward.id, status: "EXPIRED" };
-    }
-    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;
+    if (reward.stockLimit !== void 0 && (current?.redeemedCount ?? 0) >= reward.stockLimit)
+      return { rewardId: reward.id, status: "EXPIRED" };
+    if (acquiredStampCount >= reward.requiredStampCount)
       return {
         rewardId: reward.id,
         status: "AVAILABLE",
-        unlockedAt: current?.unlockedAt ?? now,
-        ...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" };
   });
 }
 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) {
+  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", rewardId: reward.id } };
+  if (reward.stockLimit !== void 0 && (currentState.redeemedCount ?? 0) >= reward.stockLimit)
     return { ok: false, error: { code: "OUT_OF_STOCK", rewardId: reward.id } };
-  }
-  if (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.userClaimLimit !== void 0 && (params.userRedemptionCount ?? currentState.userRedemptionCount ?? 0) >= reward.userClaimLimit)
+    return { ok: false, error: { code: "USER_LIMIT_REACHED", rewardId: reward.id } };
   if (reward.redemptionMethod === "staff_passcode") {
-    const passcodeResult = reward.staffPasscode === void 0 ? null : verifyPasscode(params.inputPasscode ?? "", { passcode: reward.staffPasscode });
-    if (passcodeResult === null || !passcodeResult.success) {
+    if (reward.staffPasscode === void 0 || !verifyPasscode(params.inputPasscode ?? "", { code: reward.staffPasscode }).success)
       return {
         ok: false,
         error: {
           code: "INVALID_PASSCODE",
           rewardId: reward.id,
-          message: passcodeResult?.message ?? "The passcode is invalid."
+          message: "The passcode is invalid."
         }
       };
-    }
-  }
-  if (reward.redemptionMethod === "view_only") {
-    return { ok: true, value: currentState };
   }
+  if (reward.redemptionMethod === "view_only") return { ok: true, value: currentState };
   return {
     ok: true,
     value: {
@@ -705,71 +478,40 @@ function consumeReward(params) {
       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 },
+      redeemedCount: (currentState.redeemedCount ?? 0) + 1,
       ...params.staffId === void 0 ? {} : { consumedByStaffId: params.staffId }
     }
   };
 }
-function processStamp(state, config, targetStampId, context, now) {
-  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 spot = config.spots.find((item) => item.id === spotId);
+  if (spot === void 0) return { ok: false, error: { code: "SPOT_NOT_FOUND", spotId } };
+  if (state.records.some((record2) => record2.stampId === spotId))
+    return { ok: false, error: { code: "STAMP_ALREADY_ACQUIRED", spotId } };
+  const acquired = new Set(state.records.map((record2) => record2.stampId));
+  if (spot.prerequisites?.some((id2) => !acquired.has(id2)))
+    return { ok: false, error: { code: "PREREQUISITES_NOT_MET", spotId } };
+  for (const condition of spot.conditions) {
+    if (condition.type === "custom" || !evaluateConditionDetailed(condition, context).ok)
       return {
         ok: false,
-        error: {
-          code: "INVALID_ORDER",
-          stampId: targetStampId,
-          expectedStampId: expectedStamp.id
-        }
+        error: condition.type === "custom" ? {
+          code: "CUSTOM_VALIDATION_FAILED",
+          spotId,
+          message: "Custom validation requires an async validator."
+        } : { code: "INVALID_PROOF", spotId }
       };
-    }
-  }
-  const conditionResult = evaluateConditionDetailed(targetStamp.condition, context, now);
-  if (!conditionResult.ok) {
-    return {
-      ok: false,
-      error: {
-        code: "CONDITION_MISMATCH",
-        stampId: targetStampId,
-        mismatch: conditionResult.error
-      }
-    };
   }
-  const record = { stampId: targetStampId, acquiredAt: now };
-  const nextRecords = [...state.records, record];
-  const nextRewards = config.rewards === void 0 && state.rewards === void 0 ? void 0 : reconcileRewardStates(config.rewards ?? [], state.rewards ?? [], nextRecords.length, now);
-  const nextState = {
-    ...state,
-    records: nextRecords,
-    ...nextRewards === void 0 ? {} : { rewards: nextRewards },
-    updatedAt: now
-  };
-  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: now });
-      }
+  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: now });
-  }
-  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,72 +944,89 @@ var IndexedDBAdapter = class {
 };
 
 // src/client/client.ts
-var systemClock = () => (/* @__PURE__ */ new Date()).toISOString();
+function isStorage(value) {
+  return "load" in value && "save" in value && "remove" in value;
+}
+function id(prefix) {
+  return `${prefix}-${globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`}`;
+}
+function proof(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "object" && value !== null) {
+    const item = value;
+    for (const key of ["token", "code", "passcode", "value", "tagId"])
+      if (typeof item[key] === "string") return item[key];
+  }
+  return "";
+}
+function matches(condition, value) {
+  if (condition.type === "gps") {
+    if (typeof value !== "object" || value === null) return false;
+    const item = value;
+    const latitude = item.latitude;
+    const longitude = item.longitude;
+    if (typeof latitude !== "number" || typeof longitude !== "number") return false;
+    const radians = (v) => v * Math.PI / 180;
+    const dLat = radians(latitude - condition.latitude);
+    const dLon = radians(longitude - condition.longitude);
+    const h = Math.sin(dLat / 2) ** 2 + Math.cos(radians(condition.latitude)) * Math.cos(radians(latitude)) * Math.sin(dLon / 2) ** 2;
+    return 6371e3 * 2 * Math.asin(Math.sqrt(Math.min(1, h))) <= condition.radiusMeters;
+  }
+  return proof(value).trim() !== "";
+}
+function emptyState(config, userId, now) {
+  return {
+    rallyId: config.id,
+    userId,
+    records: [],
+    rewards: reconcileRewardStates(config.rewards, [], 0, now),
+    updatedAt: now
+  };
+}
 var StampRallyClient = class {
   #listeners = /* @__PURE__ */ new Set();
   #eventListeners = /* @__PURE__ */ new Set();
-  #config;
   #storage;
-  #clock;
-  #currentState = null;
+  #options;
+  #config;
+  #userId;
+  #state = null;
   #initialization = null;
-  #operationQueue = Promise.resolve();
-  constructor(config, storage, clock = systemClock) {
+  #queue = Promise.resolve();
+  constructor(config, storageOrOptions = {}) {
     this.#config = config;
-    this.#storage = storage;
-    this.#clock = clock;
-  }
-  getState() {
-    return this.#currentState;
+    this.#options = isStorage(storageOrOptions) ? { storage: storageOrOptions } : storageOrOptions;
+    this.#storage = this.#options.storage ?? new InMemoryStorage();
+    this.#userId = this.#options.userId ?? null;
   }
   getConfig() {
     return this.#config;
   }
-  subscribe(listener, options = {}) {
-    if (options.events === true) {
-      this.#eventListeners.add(listener);
-      return () => this.#eventListeners.delete(listener);
-    }
+  getState() {
+    return this.#state;
+  }
+  getUserId() {
+    return this.#userId;
+  }
+  subscribe(listener) {
     this.#listeners.add(listener);
-    return () => {
-      this.#listeners.delete(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.#state !== null) return Promise.resolve(this.#state);
     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;
+      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;
@@ -1272,103 +1034,233 @@ var StampRallyClient = class {
     }
     return this.#initialization;
   }
-  acquire(stampId, context, now = this.#clock()) {
+  switchUser(newUserId) {
     return this.#enqueue(async () => {
-      const currentState = await this.initialize();
-      const result = processStamp(currentState, this.#config, stampId, context, now);
-      if (!result.ok) {
-        this.#emitEvent({ type: "error", error: result.error });
-        return result;
+      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();
       }
-      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(now = this.#clock()) {
+  checkIn(spotId, proofData, options = {}) {
     return this.#enqueue(async () => {
-      const initialization = this.#initialization;
-      if (initialization !== null) {
-        await initialization.catch(() => void 0);
+      const current = await this.initialize();
+      const spot = this.#config.spots.find((item) => item.id === spotId);
+      if (spot === void 0)
+        return this.#fail({ code: "SPOT_NOT_FOUND", spotId, message: "Spot was not found." });
+      if (current.records.some((record2) => record2.stampId === spotId))
+        return this.#fail({
+          code: "STAMP_ALREADY_ACQUIRED",
+          spotId,
+          message: "Spot was already claimed."
+        });
+      const acquired = new Set(current.records.map((record2) => record2.stampId));
+      if (spot.prerequisites?.some((id2) => !acquired.has(id2)))
+        return this.#fail({
+          code: "PREREQUISITES_NOT_MET",
+          spotId,
+          message: "Prerequisite spots are not complete."
+        });
+      for (const condition of spot.conditions) {
+        if (condition.type === "custom") {
+          const validator = this.#options.customValidators?.[condition.validatorName] ?? this.#options.customValidator;
+          if (validator === void 0)
+            return this.#fail({
+              code: "CUSTOM_VALIDATION_FAILED",
+              spotId,
+              message: "No custom validator is registered."
+            });
+          const context = {
+            rallyId: this.#config.id,
+            spotId,
+            proofData,
+            condition: { type: "custom", validatorName: condition.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(condition, proofData))
+          return this.#fail({ code: "INVALID_PROOF", spotId, message: "Verification failed." });
+      }
+      const now = options.now ?? this.#now();
+      const request = {
+        rallyId: this.#config.id,
+        userId: this.#userId,
+        spotId,
+        proofData,
+        idempotencyKey: options.idempotencyKey ?? id("check-in"),
+        now,
+        state: current
+      };
+      const remote = this.#options.syncAdapter?.checkIn;
+      if (options.sync !== false && remote !== void 0) {
+        const result = await remote(request);
+        return result.ok ? this.#commitCheckIn(result) : this.#fail(result.error);
       }
-      await this.#storage.remove(this.#config.id);
-      const nextState = this.#createEmptyState(now);
-      this.#currentState = nextState;
-      this.#initialization = Promise.resolve(nextState);
-      this.#emit(nextState);
-      return nextState;
+      const record = { stampId: spotId, acquiredAt: now };
+      const next = this.#reconcile({
+        ...current,
+        records: [...current.records, record],
+        updatedAt: now
+      });
+      await this.#storage.save(next);
+      return this.#commitCheckIn({ ok: true, value: { state: next, record } });
     });
   }
-  restore(state) {
+  claimReward(rewardId, options = {}) {
     return this.#enqueue(async () => {
-      const initialization = this.#initialization;
-      if (initialization !== null) {
-        await initialization.catch(() => void 0);
+      const current = await this.initialize();
+      const configured = this.#config.rewards.find((item) => item.id === rewardId);
+      if (configured === void 0)
+        return this.#fail({ code: "REWARD_NOT_FOUND", rewardId, message: "Reward was not found." });
+      const now = options.now ?? this.#now();
+      const state = current.rewards.find((item) => item.rewardId === rewardId) ?? {
+        rewardId,
+        status: "LOCKED"
+      };
+      const local = consumeReward({
+        reward: configured,
+        currentState: state,
+        now,
+        ...options.staffPasscode === void 0 ? {} : { inputPasscode: options.staffPasscode },
+        ...options.staffId === void 0 ? {} : { staffId: options.staffId }
+      });
+      if (!local.ok) return this.#fail(local.error);
+      const request = {
+        rallyId: this.#config.id,
+        userId: this.#userId,
+        rewardId,
+        idempotencyKey: options.idempotencyKey ?? id("claim"),
+        now,
+        options,
+        state: current
+      };
+      const remote = this.#options.syncAdapter?.claimReward;
+      if (options.sync !== false && remote !== void 0) {
+        const result = await remote(request);
+        return result.ok ? this.#commitClaim(result) : this.#fail(result.error);
       }
-      if (state.rallyId !== this.#config.id) {
-        throw new Error(
-          `Cannot restore rally '${state.rallyId}' into client '${this.#config.id}'.`
-        );
+      const next = {
+        ...current,
+        rewards: current.rewards.map((item) => item.rewardId === rewardId ? local.value : item),
+        updatedAt: now
+      };
+      await this.#storage.save(next);
+      return this.#commitClaim({ ok: true, value: { state: next, reward: local.value } });
+    });
+  }
+  sync(adapter = this.#options.syncAdapter) {
+    return this.#enqueue(async () => {
+      const current = await this.initialize();
+      if (adapter?.sync === void 0) {
+        this.#emitEvent({ type: "sync", state: current });
+        return;
       }
-      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;
+      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 });
+    });
+  }
+  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.#operationQueue.then(operation, operation);
-    this.#operationQueue = next.then(
+    const next = this.#queue.then(operation, operation);
+    this.#queue = 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(now) {
-    const state = {
-      rallyId: this.#config.id,
-      records: [],
-      ...this.#config.rewards === void 0 ? {} : {
-        rewards: reconcileRewardStates(this.#config.rewards, [], 0, now)
-      },
-      updatedAt: now
-    };
-    return state;
-  }
-  #reconcileState(state, now) {
-    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 };
-    }
+  #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 records = state.records.filter(
+      (record, index, all) => ids.has(record.stampId) && all.findIndex((candidate) => candidate.stampId === record.stampId) === index
+    );
     return {
-      ...state,
+      ...cloneState(state),
+      userId: this.#userId,
       records,
       rewards: reconcileRewardStates(
-        this.#config.rewards ?? [],
-        state.rewards ?? [],
+        this.#config.rewards,
+        state.rewards,
         records.length,
-        now
+        state.updatedAt
       )
     };
   }
+  #now() {
+    return this.#options.clock?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+  }
+  #fail(error) {
+    this.#emitEvent({ type: "error", error });
+    return { ok: false, error };
+  }
+  #commitCheckIn(result) {
+    if (result.ok) {
+      this.#state = result.value.state;
+      this.#emit(this.#state);
+    }
+    this.#emitEvent({ type: "checkIn", result });
+    return result;
+  }
+  #commitClaim(result) {
+    if (result.ok) {
+      this.#state = result.value.state;
+      this.#emit(this.#state);
+    }
+    this.#emitEvent({ type: "rewardClaimed", result });
+    return result;
+  }
+  #emit(state) {
+    for (const listener of this.#listeners) listener(state);
+  }
+  #emitEvent(event) {
+    for (const listener of this.#eventListeners) listener(event);
+  }
 };
 
 // src/crypto/token.ts
@@ -1504,367 +1396,18 @@ async function decryptPayload(body, secret) {
 }
 
 // src/domain/i18n.ts
-function resolveLocalizedText(text2, locale, fallbackLocale) {
-  if (text2 === void 0 || text2 === "") return "";
-  if (typeof text2 === "string") return text2;
-  const fallback = fallbackLocale === void 0 ? Object.values(text2).find((value) => typeof value === "string") : text2[fallbackLocale];
-  return text2[locale] || fallback || "";
-}
-function toLocalizedString(text2) {
-  if (text2 === void 0) return { ja: "", en: "" };
-  return typeof text2 === "string" ? { ja: text2, en: "" } : {
-    ja: text2["ja"] ?? "",
-    en: text2["en"] ?? "",
-    ...text2
-  };
-}
-
-// 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 text(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 = text(source2.description);
-  const hint = text(source2.hint);
-  return {
-    id,
-    name: text(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: text(source2.title) ?? `Reward ${index + 1}`,
-    description: text(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 = text(source2.title);
-  const description = text(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 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
   };
 }
 
@@ -1879,69 +1422,98 @@ var DEFAULT_SHEET_THEME = {
   unclaimedOpacity: 1,
   fontFamily: "serif"
 };
-
-// src/domain/universalModel.ts
-function toPublicCondition(condition2) {
-  switch (condition2.type) {
+function publicCondition(condition) {
+  switch (condition.type) {
     case "qr":
-      return { type: "qr", qrEntryUrl: condition2.qrEntryUrl ?? "" };
+      return condition.qrEntryUrl === void 0 ? { type: "qr" } : { type: "qr", qrEntryUrl: condition.qrEntryUrl };
     case "passcode":
       return { type: "passcode" };
     case "gps":
       return {
         type: "gps",
-        latitude: condition2.latitude,
-        longitude: condition2.longitude,
-        radiusMeters: condition2.radiusMeters
+        latitude: condition.latitude,
+        longitude: condition.longitude,
+        radiusMeters: condition.radiusMeters
       };
+    case "nfc":
+      return { type: "nfc" };
     case "custom":
-      return { type: "custom", validatorName: condition2.validatorName };
+      return { type: "custom", validatorName: condition.validatorName };
   }
 }
-function toPublicRallyConfig(config) {
+function toPublicConfig(config) {
   return {
-    ...config,
+    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((spot) => ({
       ...spot,
-      conditions: spot.conditions.map(toPublicCondition)
+      conditions: spot.conditions.map(publicCondition)
     })),
     rewards: config.rewards.map(
-      ({ staffPasscode: _staffPasscode, digitalContentUrl: _content, ...reward }) => reward
-    )
+      ({ digitalContentUrl: _content, staffPasscode: _passcode, ...reward }) => reward
+    ),
+    ...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) => {
+  return 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";
+    const item = spot;
+    if (typeof item.id !== "string" || typeof item.orderIndex !== "number" || item.name === void 0 || "secretToken" in item || "code" in item || "tagId" in item || "secretParams" in item)
+      return false;
+    return Array.isArray(item.conditions) && item.conditions.every((condition) => {
+      if (typeof condition !== "object" || condition === null || Array.isArray(condition))
+        return false;
+      const value2 = condition;
+      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;
+    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 = [
   {
@@ -2041,180 +1613,6 @@ var THEME_PRESETS = [
   }
 ];
 
-// src/domain/universalValidation.ts
-function isObject3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function add2(errors, path, code, message) {
-  errors.push({ path, code, message });
-}
-function hasText2(value) {
-  if (typeof value === "string") return value.trim() !== "";
-  return isObject3(value) && Object.values(value).some((item) => typeof item === "string" && item.trim() !== "");
-}
-function validateCondition2(condition2, path, errors) {
-  if (!isObject3(condition2) || typeof condition2.type !== "string") {
-    add2(errors, path, "INVALID_TYPE", "Condition must have a type.");
-    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.");
-      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(
-        errors,
-        `spots.${id}.prerequisites`,
-        "CYCLE_DETECTED",
-        `Dependency cycle detected at '${id}'.`
-      );
-      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);
-}
-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."
-        );
-    });
-  }
-  return { valid: errors.length === 0, errors };
-}
-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(
-            errors,
-            `spots[${index}].conditions[${conditionIndex}]`,
-            "SECRET_IN_PUBLIC_CONFIG",
-            "Public condition contains verification secret material."
-          );
-      });
-    });
-  return { valid: errors.length === 0, errors };
-}
-function isAdminRallyConfig(value) {
-  return validateAdminRallyConfig(value).valid;
-}
-function isPublicRallyConfigShape(value) {
-  return validatePublicRallyConfig(value).valid;
-}
-
 // src/security/snapshotToken.ts
 var encoder2 = new TextEncoder();
 function cryptoApi2() {
@@ -2334,7 +1732,6 @@ async function verifySnapshotToken(token, secretKey, now = Date.now()) {
   }
 }
 
-exports.CURRENT_RALLY_CONFIG_VERSION = CURRENT_RALLY_CONFIG_VERSION;
 exports.DEFAULT_SHEET_THEME = DEFAULT_SHEET_THEME;
 exports.InMemoryStorage = InMemoryStorage;
 exports.IndexedDBAdapter = IndexedDBAdapter;
@@ -2342,6 +1739,7 @@ exports.LocalStorageAdapter = LocalStorageAdapter;
 exports.StampRallyClient = StampRallyClient;
 exports.StorageAdapterError = StorageAdapterError;
 exports.THEME_PRESETS = THEME_PRESETS;
+exports.assertPublicConfig = assertPublicConfig;
 exports.calculateDistanceMeters = calculateDistanceMeters;
 exports.calculateProgress = calculateProgress;
 exports.consumeReward = consumeReward;
@@ -2349,34 +1747,28 @@ 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.processStamp = processStamp;
 exports.readNfcContext = readNfcContext;
 exports.readQrContext = readQrContext;
 exports.reconcileRewardStates = reconcileRewardStates;
 exports.resolveLocalizedText = resolveLocalizedText;
-exports.stripSensitiveConfig = stripSensitiveConfig;
+exports.storageKey = storageKey;
 exports.toLocalizedString = toLocalizedString;
-exports.toPublicRallyConfig = toPublicRallyConfig;
-exports.validateAdminRallyConfig = validateAdminRallyConfig;
-exports.validatePublicRallyConfig = validatePublicRallyConfig;
-exports.validateRallyConfig = validateRallyConfig;
+exports.toPublicConfig = toPublicConfig;
 exports.verifyPasscode = verifyPasscode;
 exports.verifySecureToken = verifySecureToken;
 exports.verifySnapshotToken = verifySnapshotToken;