@stamprally/core 0.6.0 → 0.8.0

package/dist/index.cjs

@@ -31,7 +31,7 @@ function contextTypeMismatch(conditionType, expectedContextType, actualContextTy
 function assertNever(value) {
   throw new Error(`Unexpected condition: ${JSON.stringify(value)}`);
 }
-function evaluateConditionDetailed(condition2, context, now) {
+function evaluateConditionDetailed(condition2, context, now2) {
   switch (condition2.type) {
     case "instant":
       return context.type === "instant" ? { ok: true, value: { conditionType: "instant" } } : contextTypeMismatch("instant", "instant", context.type);
@@ -61,14 +61,14 @@ function evaluateConditionDetailed(condition2, context, now) {
           }
         };
       }
-      const distanceMeters = calculateDistanceMeters(
+      const distanceMeters2 = calculateDistanceMeters(
         condition2.latitude,
         condition2.longitude,
         context.currentLatitude,
         context.currentLongitude
       );
-      if (distanceMeters <= condition2.radiusMeters) {
-        return { ok: true, value: { conditionType: "geo", distanceMeters } };
+      if (distanceMeters2 <= condition2.radiusMeters) {
+        return { ok: true, value: { conditionType: "geo", distanceMeters: distanceMeters2 } };
       }
       return {
         ok: false,
@@ -76,9 +76,9 @@ function evaluateConditionDetailed(condition2, context, now) {
           code: "CONDITION_MISMATCH",
           conditionType: "geo",
           reason: "OUTSIDE_RADIUS",
-          distanceMeters,
+          distanceMeters: distanceMeters2,
           radiusMeters: condition2.radiusMeters,
-          differenceMeters: distanceMeters - condition2.radiusMeters
+          differenceMeters: distanceMeters2 - condition2.radiusMeters
         }
       };
     }
@@ -103,7 +103,7 @@ function evaluateConditionDetailed(condition2, context, now) {
       for (const [index, childCondition] of condition2.conditions.entries()) {
         const childContext = context.contexts[index];
         if (childContext === void 0) continue;
-        const result = evaluateConditionDetailed(childCondition, childContext, now);
+        const result = evaluateConditionDetailed(childCondition, childContext, now2);
         if (result.ok) matchedCount += 1;
         else failures.push({ index, error: result.error });
       }
@@ -126,7 +126,7 @@ function evaluateConditionDetailed(condition2, context, now) {
     case "time_window": {
       const startsAt = Date.parse(condition2.startsAt);
       const endsAt = Date.parse(condition2.endsAt);
-      const currentTime = Date.parse(now);
+      const currentTime = Date.parse(now2);
       if (!Number.isFinite(currentTime)) {
         return {
           ok: false,
@@ -134,7 +134,7 @@ function evaluateConditionDetailed(condition2, context, now) {
             code: "CONDITION_MISMATCH",
             conditionType: "time_window",
             reason: "INVALID_NOW",
-            now,
+            now: now2,
             startsAt: condition2.startsAt,
             endsAt: condition2.endsAt
           }
@@ -147,7 +147,7 @@ function evaluateConditionDetailed(condition2, context, now) {
             code: "CONDITION_MISMATCH",
             conditionType: "time_window",
             reason: "INVALID_TIME_WINDOW",
-            now,
+            now: now2,
             startsAt: condition2.startsAt,
             endsAt: condition2.endsAt
           }
@@ -160,21 +160,21 @@ function evaluateConditionDetailed(condition2, context, now) {
             code: "CONDITION_MISMATCH",
             conditionType: "time_window",
             reason: currentTime < startsAt ? "BEFORE_START" : "AFTER_END",
-            now,
+            now: now2,
             startsAt: condition2.startsAt,
             endsAt: condition2.endsAt
           }
         };
       }
-      const childResult = evaluateConditionDetailed(condition2.condition, context, now);
+      const childResult = evaluateConditionDetailed(condition2.condition, context, now2);
       return childResult.ok ? { ok: true, value: { conditionType: "time_window" } } : childResult;
     }
     default:
       return assertNever(condition2);
   }
 }
-function evaluateCondition(condition2, context, now) {
-  return evaluateConditionDetailed(condition2, context, now ?? "").ok;
+function evaluateCondition(condition2, context, now2) {
+  return evaluateConditionDetailed(condition2, context, now2 ?? "").ok;
 }
 
 // src/engine/checkIn.ts
@@ -623,14 +623,14 @@ async function readQrContext(videoElement, options = {}) {
 }
 
 // src/engine/transition.ts
-function reconcileRewardStates(rewards, currentStates, acquiredStampCount, now) {
+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(now)) {
+    if (reward.validUntil !== void 0 && Date.parse(reward.validUntil) <= Date.parse(now2)) {
       return { rewardId: reward.id, status: "EXPIRED" };
     }
     const stockLimit = reward.stockLimit ?? reward.maxStock;
@@ -646,7 +646,7 @@ function reconcileRewardStates(rewards, currentStates, acquiredStampCount, now)
       return {
         rewardId: reward.id,
         status: "AVAILABLE",
-        unlockedAt: current?.unlockedAt ?? now,
+        unlockedAt: current?.unlockedAt ?? now2,
         ...current?.claimTicketNumber === void 0 ? {} : { claimTicketNumber: current.claimTicketNumber }
       };
     }
@@ -711,7 +711,7 @@ function consumeReward(params) {
     }
   };
 }
-function processStamp(state, config, targetStampId, context, now) {
+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 } };
@@ -736,7 +736,7 @@ function processStamp(state, config, targetStampId, context, now) {
       };
     }
   }
-  const conditionResult = evaluateConditionDetailed(targetStamp.condition, context, now);
+  const conditionResult = evaluateConditionDetailed(targetStamp.condition, context, now2);
   if (!conditionResult.ok) {
     return {
       ok: false,
@@ -747,27 +747,27 @@ function processStamp(state, config, targetStampId, context, now) {
       }
     };
   }
-  const record = { stampId: targetStampId, acquiredAt: now };
+  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, now);
+  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: now
+    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: now });
+        events.push({ type: "rewardUnlocked", rewardId: rewardState.rewardId, unlockedAt: now2 });
       }
     }
   }
   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 });
+    events.push({ type: "rallyCompleted", rallyId: config.id, completedAt: now2 });
   }
   return { ok: true, value: { nextState, events } };
 }
@@ -1272,10 +1272,10 @@ var StampRallyClient = class {
     }
     return this.#initialization;
   }
-  acquire(stampId, context, now = this.#clock()) {
+  acquire(stampId, context, now2 = this.#clock()) {
     return this.#enqueue(async () => {
       const currentState = await this.initialize();
-      const result = processStamp(currentState, this.#config, stampId, context, now);
+      const result = processStamp(currentState, this.#config, stampId, context, now2);
       if (!result.ok) {
         this.#emitEvent({ type: "error", error: result.error });
         return result;
@@ -1287,14 +1287,14 @@ var StampRallyClient = class {
       return result;
     });
   }
-  reset(now = this.#clock()) {
+  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(now);
+      const nextState = this.#createEmptyState(now2);
       this.#currentState = nextState;
       this.#initialization = Promise.resolve(nextState);
       this.#emit(nextState);
@@ -1336,18 +1336,18 @@ var StampRallyClient = class {
   #emitEvent(event) {
     for (const listener of this.#eventListeners) listener(event);
   }
-  #createEmptyState(now) {
+  #createEmptyState(now2) {
     const state = {
       rallyId: this.#config.id,
       records: [],
       ...this.#config.rewards === void 0 ? {} : {
-        rewards: reconcileRewardStates(this.#config.rewards, [], 0, now)
+        rewards: reconcileRewardStates(this.#config.rewards, [], 0, now2)
       },
-      updatedAt: now
+      updatedAt: now2
     };
     return state;
   }
-  #reconcileState(state, now) {
+  #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) => {
@@ -1365,12 +1365,319 @@ var StampRallyClient = class {
         this.#config.rewards ?? [],
         state.rewards ?? [],
         records.length,
-        now
+        now2
       )
     };
   }
 };
 
+// src/client/universalClient.ts
+function isStorage(value) {
+  return "load" in value && "save" in value && "remove" in value;
+}
+function randomId(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) {
+  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];
+    }
+  }
+  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);
+  return {
+    rallyId: config.id,
+    records: [],
+    rewards: reconcileRewardStates(rewards, [], 0, timestamp),
+    updatedAt: timestamp
+  };
+}
+var UniversalStampRallyClient = class {
+  #listeners = /* @__PURE__ */ new Set();
+  #eventListeners = /* @__PURE__ */ new Set();
+  #config;
+  #storage;
+  #options;
+  #state = null;
+  #initialization = null;
+  #queue = Promise.resolve();
+  constructor(config, storageOrOptions = {}, clock) {
+    this.#config = config;
+    this.#options = isStorage(storageOrOptions) ? { storage: storageOrOptions, ...clock === void 0 ? {} : { clock } } : storageOrOptions;
+    this.#storage = this.#options.storage ?? new InMemoryStorage();
+  }
+  getConfig() {
+    return this.#config;
+  }
+  getState() {
+    return this.#state;
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => this.#listeners.delete(listener);
+  }
+  subscribeEvents(listener) {
+    this.#eventListeners.add(listener);
+    return () => this.#eventListeners.delete(listener);
+  }
+  init() {
+    return this.initialize();
+  }
+  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;
+      }).catch((error) => {
+        this.#initialization = null;
+        throw error;
+      });
+    }
+    return this.#initialization;
+  }
+  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)
+        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((id) => !acquired.has(id)))
+        return this.#fail({
+          code: "PREREQUISITES_NOT_MET",
+          spotId,
+          message: "Prerequisite spots are not complete."
+        });
+      for (const condition2 of spot.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 {
+            return this.#fail({
+              code: "CUSTOM_VALIDATION_FAILED",
+              spotId,
+              message: "No custom validator is registered."
+            });
+          }
+        } else if (!conditionMatches(condition2, proofData)) {
+          return this.#fail({ code: "INVALID_PROOF", spotId, message: "Verification failed." });
+        }
+      }
+      const timestamp = options.now ?? this.#now();
+      const request = {
+        rallyId: this.#config.id,
+        spotId,
+        proofData,
+        idempotencyKey: options.idempotencyKey ?? randomId("check-in"),
+        now: timestamp,
+        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);
+      }
+      const record = { stampId: spotId, acquiredAt: timestamp };
+      const next = this.#reconcile({
+        ...current,
+        records: [...current.records, record],
+        updatedAt: timestamp
+      });
+      await this.#storage.save(next);
+      return this.#commitCheckIn(next, { ok: true, value: { state: next, record } });
+    });
+  }
+  claimReward(rewardId, options = {}) {
+    return this.#enqueue(async () => {
+      const current = await this.initialize();
+      const configured = this.#config.rewards.find((item) => item.id === rewardId);
+      if (configured === void 0)
+        return this.#fail({ code: "REWARD_NOT_FOUND", rewardId, message: "Reward was not found." });
+      const timestamp = options.now ?? this.#now();
+      const state = current.rewards?.find((item) => item.rewardId === rewardId) ?? {
+        rewardId,
+        status: "LOCKED"
+      };
+      const local = consumeReward({
+        reward: asReward(configured),
+        currentState: state,
+        now: timestamp,
+        ...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,
+        rewardId,
+        idempotencyKey: options.idempotencyKey ?? randomId("claim"),
+        now: timestamp,
+        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);
+      }
+      const nextRewards = (current.rewards ?? []).map(
+        (item) => item.rewardId === rewardId ? local.value : item
+      );
+      const next = { ...current, rewards: nextRewards, updatedAt: timestamp };
+      await this.#storage.save(next);
+      return this.#commitClaim(next, { 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;
+      }
+      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;
+      }
+    });
+  }
+  #now() {
+    return this.#options.clock?.() ?? now();
+  }
+  #reconcile(state) {
+    const ids = new Set(this.#config.spots.map((spot) => spot.id));
+    const seen = /* @__PURE__ */ new Set();
+    const records = state.records.filter(
+      (record) => ids.has(record.stampId) && !seen.has(record.stampId) && seen.add(record.stampId)
+    );
+    return {
+      ...cloneState(state),
+      records,
+      rewards: reconcileRewardStates(
+        this.#config.rewards.map(asReward),
+        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;
+  }
+  #fail(error) {
+    this.#emitEvent({ type: "error", error });
+    return { ok: false, error };
+  }
+  #commitCheckIn(state, result) {
+    this.#state = state;
+    this.#emit(state);
+    this.#emitEvent({ type: "checkIn", result });
+    return result;
+  }
+  #commitClaim(state, result) {
+    this.#state = state;
+    this.#emit(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
 var encoder = new TextEncoder();
 var decoder = new TextDecoder();
@@ -1432,7 +1739,7 @@ async function encryptPayload(plaintext, secret, api) {
   );
   return encode(new Uint8Array([...iv, ...encrypted]));
 }
-async function verifySecureToken(token, secretKey, now = Date.now()) {
+async function verifySecureToken(token, secretKey, now2 = Date.now()) {
   try {
     const parts = token.split(".");
     if (parts.length !== 4 || parts[0] !== "sr3" || parts[1] !== "e" && parts[1] !== "p") {
@@ -1475,7 +1782,7 @@ async function verifySecureToken(token, secretKey, now = Date.now()) {
       };
     }
     const payload = parsed;
-    if (typeof payload.exp === "number" && now >= payload.exp * 1e3) {
+    if (typeof payload.exp === "number" && now2 >= payload.exp * 1e3) {
       return {
         ok: false,
         valid: false,
@@ -1504,18 +1811,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
+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
   };
 }
 
@@ -1761,7 +2068,7 @@ function validateRallyConfig(config) {
 function isObject2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function text(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");
@@ -1805,11 +2112,11 @@ function condition(value) {
 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);
+  const description = text2(source2.description);
+  const hint = text2(source2.hint);
   return {
     id,
-    name: text(source2.name) ?? `Spot ${index + 1}`,
+    name: text2(source2.name) ?? `Spot ${index + 1}`,
     ...description === void 0 ? {} : { description },
     ...hint === void 0 ? {} : { hint },
     condition: condition(
@@ -1831,8 +2138,8 @@ 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) ?? "",
+    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,
@@ -1851,8 +2158,8 @@ function migrateRallyConfig(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 title = text2(source2.title);
+  const description = text2(source2.description);
   const theme = isObject2(source2.theme) ? source2.theme : void 0;
   return {
     id,
@@ -1880,8 +2187,61 @@ var DEFAULT_SHEET_THEME = {
   fontFamily: "serif"
 };
 
+// src/domain/universalModel.ts
+function toPublicCondition(condition2) {
+  switch (condition2.type) {
+    case "qr":
+      return { type: "qr", qrEntryUrl: condition2.qrEntryUrl ?? "" };
+    case "passcode":
+      return { type: "passcode" };
+    case "gps":
+      return {
+        type: "gps",
+        latitude: condition2.latitude,
+        longitude: condition2.longitude,
+        radiusMeters: condition2.radiusMeters
+      };
+    case "custom":
+      return { type: "custom", validatorName: condition2.validatorName };
+  }
+}
+function toPublicRallyConfig(config) {
+  return {
+    ...config,
+    spots: config.spots.map((spot) => ({
+      ...spot,
+      conditions: spot.conditions.map(toPublicCondition)
+    })),
+    rewards: config.rewards.map(
+      ({ staffPasscode: _staffPasscode, digitalContentUrl: _content, ...reward }) => reward
+    )
+  };
+}
+function isPublicRallyConfig(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const candidate = value;
+  if (candidate.secretKey !== void 0 || candidate.verificationSecrets !== void 0)
+    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";
+    });
+  }) && 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;
+  });
+}
+
 // 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,
@@ -1988,6 +2348,180 @@ 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() {
@@ -2026,9 +2560,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, now) {
-  if (typeof payload.exp === "number" && now >= payload.exp * 1e3) return true;
-  return payload.expiresAt !== void 0 && Date.parse(payload.expiresAt) <= now;
+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;
 }
 async function createSignedSnapshotToken(payload, secretKey) {
   const api = cryptoApi2();
@@ -2048,7 +2582,7 @@ async function createSignedSnapshotToken(payload, secretKey) {
   );
   return `sr2.${body}.${base64Url(signature)}`;
 }
-async function verifySnapshotToken(token, secretKey, now = Date.now()) {
+async function verifySnapshotToken(token, secretKey, now2 = Date.now()) {
   try {
     const parts = token.split(".");
     if (parts.length !== 3 || parts[0] !== "sr2") {
@@ -2090,7 +2624,7 @@ async function verifySnapshotToken(token, secretKey, now = 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, now)) {
+    if (isExpired(payload, now2)) {
       return {
         ok: false,
         valid: false,
@@ -2115,6 +2649,7 @@ exports.LocalStorageAdapter = LocalStorageAdapter;
 exports.StampRallyClient = StampRallyClient;
 exports.StorageAdapterError = StorageAdapterError;
 exports.THEME_PRESETS = THEME_PRESETS;
+exports.UniversalStampRallyClient = UniversalStampRallyClient;
 exports.calculateDistanceMeters = calculateDistanceMeters;
 exports.calculateProgress = calculateProgress;
 exports.consumeReward = consumeReward;
@@ -2128,8 +2663,11 @@ exports.evaluateConditionDetailed = evaluateConditionDetailed;
 exports.exportProgressToken = exportProgressToken;
 exports.getCurrentGeoContext = getCurrentGeoContext;
 exports.importProgressToken = importProgressToken;
+exports.isAdminRallyConfig = isAdminRallyConfig;
 exports.isGeolocationSupported = isGeolocationSupported;
 exports.isNfcSupported = isNfcSupported;
+exports.isPublicRallyConfig = isPublicRallyConfig;
+exports.isPublicRallyConfigShape = isPublicRallyConfigShape;
 exports.isQrSupported = isQrSupported;
 exports.isRewardState = isRewardState;
 exports.isStampRallyState = isStampRallyState;
@@ -2143,6 +2681,9 @@ exports.reconcileRewardStates = reconcileRewardStates;
 exports.resolveLocalizedText = resolveLocalizedText;
 exports.stripSensitiveConfig = stripSensitiveConfig;
 exports.toLocalizedString = toLocalizedString;
+exports.toPublicRallyConfig = toPublicRallyConfig;
+exports.validateAdminRallyConfig = validateAdminRallyConfig;
+exports.validatePublicRallyConfig = validatePublicRallyConfig;
 exports.validateRallyConfig = validateRallyConfig;
 exports.verifyPasscode = verifyPasscode;
 exports.verifySecureToken = verifySecureToken;