@stamprally/core 0.12.0 → 0.14.0

package/README.md

@@ -23,6 +23,19 @@ The browser detectors `getCurrentGeoContext`, `readNfcContext`, and `readQrConte
 
 `InMemoryStorage`, `LocalStorageAdapter`, and `IndexedDBAdapter` implement `StampStorage`. `updateLocalizedField` updates one locale without dropping existing translations.
 
+## v0.13 offline synchronization
+
+Configure `OfflineQueue` with `rallyId` and `userId` to persist pending work under
+`stamprally:queue:<rallyId>:<userId-or-anonymous>`. `switchUser` loads the other
+user's queue. Conflict policy `merge` unions stamp records, keeps the latest
+timestamps, and gives `CONSUMED` reward states priority; `server_wins` uses the
+server state unchanged. Sync adapters may return `ACCEPTED`, `REJECTED_PERMANENT`,
+or `RETRYABLE_ERROR`; only the first two remove an operation.
+
+`evaluateSpotStatus` derives `UNCLAIMED`, `CLAIMED`, `LOCKED`, or `VERIFYING`
+without mutating state. A spot with incomplete `prerequisites` is `LOCKED` and
+must not be verified by a client or viewer.
+
 ## License
 
 MIT

package/dist/index.cjs

@@ -41,6 +41,14 @@ function evaluateConditionDetailed(condition2, context) {
 function evaluateCondition(condition2, context) {
   return evaluateConditionDetailed(condition2, context).ok;
 }
+function evaluateSpotStatus(spot2, state, options = {}) {
+  if (options.verifying === true) return "VERIFYING";
+  if (state.records.some((record) => record.stampId === spot2.id)) return "CLAIMED";
+  const acquired = new Set(state.records.map((record) => record.stampId));
+  if (spot2.prerequisites?.some((prerequisite) => !acquired.has(prerequisite))) return "LOCKED";
+  return "UNCLAIMED";
+}
+var getSpotStatus = evaluateSpotStatus;
 
 // src/engine/order.ts
 function getOrderedSpots(spots) {
@@ -53,7 +61,9 @@ function calculateProgress(state, config) {
   const acquired = new Set(
     state.records.map((record) => record.stampId).filter((id2) => ids.has(id2))
   );
-  const remaining = config.spots.filter((spot2) => !acquired.has(spot2.id));
+  const remaining = config.spots.filter(
+    (spot2) => !acquired.has(spot2.id) && (spot2.prerequisites === void 0 || spot2.prerequisites.every((id2) => acquired.has(id2)))
+  );
   return {
     acquired: acquired.size,
     total: config.spots.length,
@@ -117,24 +127,53 @@ function mergeRewardStates(serverRewards, localRewards) {
       merged.set(localReward.rewardId, localReward);
       continue;
     }
-    if (localReward.status === "CONSUMED" && serverReward.status !== "CONSUMED")
-      merged.set(localReward.rewardId, localReward);
+    const winner = localReward.status === "CONSUMED" && serverReward.status !== "CONSUMED" ? localReward : serverReward;
+    merged.set(localReward.rewardId, {
+      ...winner,
+      ...serverReward.unlockedAt === void 0 && localReward.unlockedAt === void 0 ? {} : {
+        unlockedAt: serverReward.unlockedAt === void 0 ? localReward.unlockedAt : localReward.unlockedAt === void 0 ? serverReward.unlockedAt : latestTimestamp(serverReward.unlockedAt, localReward.unlockedAt)
+      },
+      ...serverReward.consumedAt === void 0 && localReward.consumedAt === void 0 ? {} : {
+        consumedAt: serverReward.consumedAt === void 0 ? localReward.consumedAt : localReward.consumedAt === void 0 ? serverReward.consumedAt : latestTimestamp(serverReward.consumedAt, localReward.consumedAt)
+      },
+      ...serverReward.redeemedCount === void 0 && localReward.redeemedCount === void 0 ? {} : {
+        redeemedCount: Math.max(
+          serverReward.redeemedCount ?? 0,
+          localReward.redeemedCount ?? 0
+        )
+      },
+      ...serverReward.userRedemptionCount === void 0 && localReward.userRedemptionCount === void 0 ? {} : {
+        userRedemptionCount: Math.max(
+          serverReward.userRedemptionCount ?? 0,
+          localReward.userRedemptionCount ?? 0
+        )
+      }
+    });
   }
   return [...merged.values()];
 }
-function resolveRallyStateConflict(serverState, localState, options = { policy: "merge" }) {
-  if (options.policy === "server_wins") return serverState;
-  const records = [...serverState.records];
-  const knownStamps = new Set(records.map((record) => record.stampId));
-  for (const record of localState.records) {
-    if (!knownStamps.has(record.stampId)) {
-      records.push(record);
-      knownStamps.add(record.stampId);
+function mergeStampRecords(serverRecords, localRecords) {
+  const merged = /* @__PURE__ */ new Map();
+  for (const record of [...serverRecords, ...localRecords]) {
+    const current = merged.get(record.stampId);
+    if (current === void 0) {
+      merged.set(record.stampId, record);
+      continue;
     }
+    const acquiredAt = latestTimestamp(current.acquiredAt, record.acquiredAt);
+    merged.set(record.stampId, {
+      ...current,
+      ...acquiredAt === current.acquiredAt ? {} : { acquiredAt },
+      ...current.metadata === void 0 && record.metadata !== void 0 ? { metadata: record.metadata } : {}
+    });
   }
+  return [...merged.values()];
+}
+function resolveRallyStateConflict(serverState, localState, options = { policy: "merge" }) {
+  if (options.policy === "server_wins") return serverState;
   return {
     ...serverState,
-    records,
+    records: mergeStampRecords(serverState.records, localState.records),
     rewards: mergeRewardStates(serverState.rewards, localState.rewards),
     updatedAt: latestTimestamp(serverState.updatedAt, localState.updatedAt)
   };
@@ -1072,7 +1111,10 @@ var StampRallyClient = class {
   initialize() {
     if (this.#state !== null) return Promise.resolve(this.#state);
     if (this.#initialization === null) {
-      this.#initialization = this.#storage.load(this.#config.id, this.#userId).then((state) => {
+      this.#initialization = (async () => {
+        await this.#offlineQueue?.setScope(this.#config.id, this.#userId);
+        return this.#storage.load(this.#config.id, this.#userId);
+      })().then((state) => {
         const next = state === null ? emptyState(this.#config, this.#userId, this.#now()) : this.#reconcile(state);
         this.#state = next;
         this.#emit(next);
@@ -1090,6 +1132,7 @@ var StampRallyClient = class {
       this.#userId = newUserId;
       this.#state = null;
       this.#initialization = null;
+      await this.#offlineQueue?.switchUser(newUserId);
       return this.initialize();
     });
   }
@@ -1338,7 +1381,8 @@ var StampRallyClient = class {
       this.#state = next;
       this.#emit(next);
     }
-    if ("ok" in event.result && !event.result.ok)
+    if (event.error !== void 0) this.#emitEvent({ type: "error", error: event.error });
+    else if (event.result !== void 0 && "ok" in event.result && !event.result.ok)
       this.#emitEvent({ type: "error", error: event.result.error });
   }
   #now() {
@@ -1466,9 +1510,32 @@ function defaultStorage(databaseName) {
 function operationId(operation) {
   return operation.kind === "checkIn" ? `checkIn:${operation.request.rallyId}:${operation.request.userId ?? "anonymous"}:${operation.request.idempotencyKey}` : `claimReward:${operation.request.rallyId}:${operation.request.userId ?? "anonymous"}:${operation.request.idempotencyKey}`;
 }
+function requestScope(operation) {
+  return {
+    rallyId: operation.request.rallyId,
+    userId: operation.request.userId
+  };
+}
+function errorValue(value, fallbackCode) {
+  if (typeof value === "object" && value !== null) {
+    const candidate = value;
+    if (typeof candidate.code === "string" && typeof candidate.message === "string")
+      return { ...candidate, code: candidate.code, message: candidate.message };
+  }
+  if (value instanceof Error) return { code: fallbackCode, message: value.message };
+  if (typeof value === "string") return { code: fallbackCode, message: value };
+  return { code: fallbackCode, message: "Offline operation was rejected." };
+}
+var syncLocks = /* @__PURE__ */ new Map();
+var SYNC_LOCK_TTL_MS = 3e4;
+function randomId() {
+  return globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`;
+}
 var OfflineQueue = class {
   #storage;
-  #key;
+  #configuredKey;
+  #rallyId;
+  #userId;
   #conflictPolicy;
   #onSyncConflict;
   #operations = [];
@@ -1478,14 +1545,24 @@ var OfflineQueue = class {
   #sender;
   #syncPromise = null;
   #syncResultListener;
+  #synchronizeInstances;
+  #instanceId = randomId();
+  #lockStorage;
+  #storageListener;
+  #channel = null;
   constructor(options = {}) {
     if (options.storage !== void 0) this.#storage = options.storage;
     else if (options.storageLike !== void 0 && options.storageLike !== null)
       this.#storage = new LocalStorageQueueStorage(options.storageLike);
     else this.#storage = defaultStorage(options.databaseName);
-    this.#key = options.key ?? "stamprally:offline-queue";
+    this.#configuredKey = options.key;
+    this.#rallyId = options.rallyId;
+    this.#userId = options.userId ?? null;
     this.#conflictPolicy = options.conflictPolicy ?? "server_wins";
     this.#onSyncConflict = options.onSyncConflict;
+    this.#synchronizeInstances = options.synchronizeInstances ?? true;
+    this.#lockStorage = options.storageLike ?? globalThis.localStorage ?? null;
+    if (this.#synchronizeInstances) this.#subscribeToExternalChanges();
   }
   get syncState() {
     return this.#state;
@@ -1502,23 +1579,68 @@ var OfflineQueue = class {
   get conflictPolicy() {
     return this.#conflictPolicy;
   }
+  get storageKey() {
+    return this.#storageKey();
+  }
+  get rallyId() {
+    return this.#rallyId;
+  }
+  get userId() {
+    return this.#userId;
+  }
   setSyncResultListener(listener) {
     this.#syncResultListener = listener;
   }
   async initialize() {
     if (this.#loaded) return;
-    this.#operations = [...await this.#storage.load(this.#key)];
+    this.#operations = [...await this.#storage.load(this.#storageKey())];
     this.#loaded = true;
   }
+  /** Releases browser listeners when the queue is no longer used. */
+  dispose() {
+    const windowLike = globalThis.window;
+    if (windowLike !== void 0 && this.#storageListener !== void 0)
+      windowLike.removeEventListener("storage", this.#storageListener);
+    this.#storageListener = void 0;
+    this.#channel?.close();
+    this.#channel = null;
+    this.#releaseSyncLock();
+  }
+  /** Selects a rally/user queue scope and loads its pending operations. */
+  async setScope(rallyId, userId) {
+    if (this.#configuredKey !== void 0) {
+      this.#rallyId = rallyId;
+      this.#userId = userId;
+      return this.initialize();
+    }
+    if (this.#rallyId === rallyId && this.#userId === userId && this.#loaded) return;
+    this.#rallyId = rallyId;
+    this.#userId = userId;
+    this.#operations = [];
+    this.#loaded = false;
+    await this.initialize();
+  }
+  async switchUser(newUserId) {
+    if (this.#rallyId === void 0)
+      throw new Error("OfflineQueue.switchUser requires a rally scope.");
+    await this.setScope(this.#rallyId, newUserId);
+  }
   setSender(sender) {
     this.#sender = sender;
   }
   async enqueue(operation) {
+    if (this.#configuredKey === void 0) {
+      const scope = requestScope(operation);
+      if (this.#rallyId === void 0) await this.setScope(scope.rallyId, scope.userId);
+      if (this.#rallyId !== scope.rallyId || this.#userId !== scope.userId)
+        throw new Error("Offline operation belongs to another rally or user queue.");
+    }
     await this.initialize();
     const id2 = operationId(operation);
     if (this.#operations.some((item) => operationId(item) === id2)) return;
     this.#operations = [...this.#operations, operation];
-    await this.#storage.save(this.#key, this.#operations);
+    await this.#storage.save(this.#storageKey(), this.#operations);
+    this.#announceChange();
   }
   async enqueueCheckIn(request) {
     return this.enqueue({ kind: "checkIn", request });
@@ -1529,7 +1651,8 @@ var OfflineQueue = class {
   async clear() {
     await this.initialize();
     this.#operations = [];
-    await this.#storage.save(this.#key, this.#operations);
+    await this.#storage.save(this.#storageKey(), this.#operations);
+    this.#announceChange();
   }
   async sync(sender = this.#sender) {
     await this.initialize();
@@ -1547,31 +1670,140 @@ var OfflineQueue = class {
   async #run(sender) {
     this.#state = "syncing";
     this.#error = null;
+    if (!this.#acquireSyncLock()) {
+      await this.#reloadFromStorage();
+      this.#state = "idle";
+      return;
+    }
     try {
       while (this.#operations.length > 0) {
         const operation = this.#operations[0];
         if (operation === void 0) break;
-        let result;
+        let rawResult;
         try {
-          result = await sender(operation);
+          rawResult = await sender(operation);
         } catch (cause) {
-          throw cause instanceof Error ? cause : new Error(String(cause));
+          throw new Error(errorValue(cause, "RETRYABLE_ERROR").message);
         }
-        const state = "conflict" in result && result.conflict === true ? await this.resolveConflict(operation, result.localState, result.serverState) : "ok" in result && result.ok ? result.value.state : void 0;
+        const response = this.#normalizeResponse(rawResult);
+        if (response.status === "RETRYABLE_ERROR") {
+          const error2 = errorValue(response.error ?? response.reason, "RETRYABLE_ERROR");
+          await this.#syncResultListener?.({ operation, status: response.status, error: error2 });
+          throw new Error(error2.message);
+        }
+        const result = response.result;
+        const state = response.state ?? (result !== void 0 && "conflict" in result && result.conflict === true ? await this.resolveConflict(operation, result.localState, result.serverState) : result !== void 0 && "ok" in result && result.ok ? result.value.state : void 0);
+        const error = response.status === "REJECTED_PERMANENT" ? errorValue(response.error ?? response.reason, "REJECTED_PERMANENT") : void 0;
+        this.#operations = this.#operations.slice(1);
+        await this.#storage.save(this.#storageKey(), this.#operations);
+        this.#announceChange();
         await this.#syncResultListener?.({
           operation,
-          result,
+          ...result === void 0 ? {} : { result },
+          status: response.status,
+          ...error === void 0 ? {} : { error },
           ...state === void 0 ? {} : { state }
         });
-        this.#operations = this.#operations.slice(1);
-        await this.#storage.save(this.#key, this.#operations);
       }
       this.#state = "idle";
     } catch (cause) {
       this.#state = "error";
       this.#error = cause instanceof Error ? cause : new Error(String(cause));
       throw this.#error;
+    } finally {
+      this.#releaseSyncLock();
+    }
+  }
+  #subscribeToExternalChanges() {
+    const windowLike = globalThis.window;
+    if (windowLike !== void 0) {
+      this.#storageListener = (event) => {
+        if (event.key === this.#storageKey()) void this.#reloadFromStorage();
+      };
+      windowLike.addEventListener("storage", this.#storageListener);
     }
+    const Channel = globalThis.BroadcastChannel;
+    if (Channel !== void 0) {
+      try {
+        this.#channel = new Channel("stamprally:queue-sync");
+        this.#channel.addEventListener("message", (event) => {
+          if (typeof event.data === "object" && event.data !== null && "key" in event.data && event.data.key === this.#storageKey())
+            void this.#reloadFromStorage();
+        });
+      } catch {
+        this.#channel = null;
+      }
+    }
+  }
+  #announceChange() {
+    this.#channel?.postMessage({ key: this.#storageKey(), owner: this.#instanceId });
+  }
+  async #reloadFromStorage() {
+    if (this.#state === "syncing") return;
+    try {
+      this.#operations = [...await this.#storage.load(this.#storageKey())];
+      this.#loaded = true;
+    } catch {
+    }
+  }
+  #lockKey() {
+    return `${this.#storageKey()}:sync-lock`;
+  }
+  #acquireSyncLock() {
+    const key = this.#lockKey();
+    const now = Date.now();
+    const local = syncLocks.get(key);
+    if (local !== void 0 && local.expiresAt > now && local.owner !== this.#instanceId)
+      return false;
+    if (this.#lockStorage !== null) {
+      try {
+        const existing = this.#lockStorage.getItem(key);
+        if (existing !== null) {
+          const parsed = JSON.parse(existing);
+          if (typeof parsed === "object" && parsed !== null && typeof parsed.expiresAt === "number" && parsed.expiresAt > now && parsed.owner !== this.#instanceId)
+            return false;
+        }
+        this.#lockStorage.setItem(
+          key,
+          JSON.stringify({ owner: this.#instanceId, expiresAt: now + SYNC_LOCK_TTL_MS })
+        );
+      } catch {
+      }
+    }
+    syncLocks.set(key, { owner: this.#instanceId, expiresAt: now + SYNC_LOCK_TTL_MS });
+    return true;
+  }
+  #releaseSyncLock() {
+    const key = this.#lockKey();
+    const current = syncLocks.get(key);
+    if (current?.owner === this.#instanceId) syncLocks.delete(key);
+    if (this.#lockStorage !== null) {
+      try {
+        const value = this.#lockStorage.getItem(key);
+        if (value !== null && JSON.parse(value).owner === this.#instanceId)
+          this.#lockStorage.removeItem?.(key);
+      } catch {
+      }
+    }
+  }
+  #storageKey() {
+    if (this.#configuredKey !== void 0) return this.#configuredKey;
+    return `stamprally:queue:${this.#rallyId ?? "unscoped"}:${this.#userId ?? "anonymous"}`;
+  }
+  #normalizeResponse(value) {
+    if ("ok" in value) {
+      if (value.ok === false) {
+        if ("status" in value && value.status === "RETRYABLE_ERROR")
+          return { status: "RETRYABLE_ERROR", error: errorValue(value.error, "RETRYABLE_ERROR") };
+        return { status: "REJECTED_PERMANENT", result: value };
+      }
+      return { status: "ACCEPTED", result: value };
+    }
+    if ("status" in value) {
+      if (value.status === "ACCEPTED") return value;
+      return value;
+    }
+    return { status: "ACCEPTED", result: value };
   }
   async resolveConflict(operation, localState, serverState) {
     const configured = this.#onSyncConflict;
@@ -2314,21 +2546,112 @@ function validate(value, isPublic) {
     optionalString(value, "staffPasscode", "$", errors);
     if (hasOwn(value, "inventory") && value.inventory !== void 0 && !isRecord3(value.inventory))
       add(errors, "$.inventory", "Expected an object.", "invalid_type");
+    if (hasOwn(value, "inventoryMode") && value.inventoryMode !== void 0 && value.inventoryMode !== "shared" && value.inventoryMode !== "per_reward")
+      add(errors, "$.inventoryMode", "Expected shared or per_reward.", "invalid_enum");
     if (hasOwn(value, "serverMetadata") && value.serverMetadata !== void 0 && !isRecord3(value.serverMetadata))
       add(errors, "$.serverMetadata", "Expected an object.", "invalid_type");
     if (hasOwn(value, "publicMetadata") && value.publicMetadata !== void 0 && !isRecord3(value.publicMetadata))
       add(errors, "$.publicMetadata", "Expected an object.", "invalid_type");
     optionalString(value, "serverEndpoint", "$", errors);
   } else {
-    for (const key of ["staffPasscode", "serverMetadata", "inventory"])
+    for (const key of ["staffPasscode", "serverMetadata", "inventory", "inventoryMode"])
       if (hasOwn(value, key))
         add(errors, `$.${key}`, "Private field is not allowed.", "private_field");
     optionalString(value, "serverEndpoint", "$", errors);
   }
   return errors;
 }
+function validateRallyConfigRelations(config) {
+  const errors = [];
+  const spotIds = /* @__PURE__ */ new Set();
+  const rewardIds = /* @__PURE__ */ new Set();
+  const orderIndexes = /* @__PURE__ */ new Map();
+  config.spots.forEach((spot2, index) => {
+    if (spotIds.has(spot2.id))
+      add(errors, `spots[${index}].id`, "Spot ID must be unique.", "duplicate_spot_id");
+    spotIds.add(spot2.id);
+    const previousIndex = orderIndexes.get(spot2.orderIndex);
+    if (previousIndex !== void 0)
+      add(
+        errors,
+        `spots[${index}].orderIndex`,
+        `orderIndex duplicates spots[${previousIndex}].`,
+        "duplicate_order_index"
+      );
+    else orderIndexes.set(spot2.orderIndex, index);
+    if (spot2.orderIndex < 0)
+      add(
+        errors,
+        `spots[${index}].orderIndex`,
+        "orderIndex must not be negative.",
+        "negative_order_index"
+      );
+    spot2.prerequisites?.forEach((prerequisite, prerequisiteIndex) => {
+      if (!spotIds.has(prerequisite) && !config.spots.some((candidate) => candidate.id === prerequisite))
+        add(
+          errors,
+          `spots[${index}].prerequisites[${prerequisiteIndex}]`,
+          "Prerequisite spot does not exist.",
+          "missing_prerequisite"
+        );
+    });
+  });
+  config.rewards.forEach((reward2, index) => {
+    if (rewardIds.has(reward2.id))
+      add(errors, `rewards[${index}].id`, "Reward ID must be unique.", "duplicate_reward_id");
+    rewardIds.add(reward2.id);
+    const visit = (condition2, path) => {
+      if (condition2.type === "stamps")
+        condition2.stampIds.forEach((stampId, stampIndex) => {
+          if (!spotIds.has(stampId))
+            add(
+              errors,
+              `${path}.stampIds[${stampIndex}]`,
+              "Referenced spot does not exist.",
+              "missing_reward_spot"
+            );
+        });
+      else if (condition2.type === "all" || condition2.type === "any")
+        condition2.conditions.forEach((nested, nestedIndex) => {
+          visit(nested, `${path}.conditions[${nestedIndex}]`);
+        });
+    };
+    reward2.conditions?.forEach((condition2, conditionIndex) => {
+      visit(condition2, `rewards[${index}].conditions[${conditionIndex}]`);
+    });
+  });
+  const visiting = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  const cycleNodes = /* @__PURE__ */ new Set();
+  const visitSpot = (spotId) => {
+    if (visiting.has(spotId)) {
+      cycleNodes.add(spotId);
+      return;
+    }
+    if (visited.has(spotId)) return;
+    visiting.add(spotId);
+    const spot2 = config.spots.find((candidate) => candidate.id === spotId);
+    spot2?.prerequisites?.forEach(visitSpot);
+    visiting.delete(spotId);
+    visited.add(spotId);
+  };
+  config.spots.forEach((spot2) => {
+    visitSpot(spot2.id);
+  });
+  cycleNodes.forEach((spotId) => {
+    const index = config.spots.findIndex((spot2) => spot2.id === spotId);
+    add(
+      errors,
+      `spots[${index}].prerequisites`,
+      "Prerequisites must form a DAG.",
+      "cyclic_prerequisites"
+    );
+  });
+  return errors;
+}
 function safeParseAdminConfig(input) {
-  const errors = validate(input, false);
+  const errors = [...validate(input, false)];
+  if (errors.length === 0) errors.push(...validateRallyConfigRelations(input));
   return errors.length === 0 ? { success: true, data: input } : { success: false, errors };
 }
 function parseAdminConfig(input) {
@@ -2337,7 +2660,8 @@ function parseAdminConfig(input) {
   return result.data;
 }
 function safeParsePublicConfig(input) {
-  const errors = validate(input, true);
+  const errors = [...validate(input, true)];
+  if (errors.length === 0) errors.push(...validateRallyConfigRelations(input));
   return errors.length === 0 ? { success: true, data: input } : { success: false, errors };
 }
 function parsePublicConfig(input) {
@@ -2486,9 +2810,11 @@ exports.createSignedSnapshotToken = createSignedSnapshotToken;
 exports.createUniqueClaimTicketNumber = createUniqueClaimTicketNumber;
 exports.evaluateCondition = evaluateCondition;
 exports.evaluateConditionDetailed = evaluateConditionDetailed;
+exports.evaluateSpotStatus = evaluateSpotStatus;
 exports.exportProgressToken = exportProgressToken;
 exports.getCurrentGeoContext = getCurrentGeoContext;
 exports.getOrderedSpots = getOrderedSpots;
+exports.getSpotStatus = getSpotStatus;
 exports.importProgressToken = importProgressToken;
 exports.isGeolocationSupported = isGeolocationSupported;
 exports.isNfcSupported = isNfcSupported;
@@ -2514,6 +2840,7 @@ exports.toLocalizedString = toLocalizedString;
 exports.toPublicConfig = toPublicConfig;
 exports.updateLocalizedField = updateLocalizedField;
 exports.validatePublicConfigSafety = validatePublicConfigSafety;
+exports.validateRallyConfigRelations = validateRallyConfigRelations;
 exports.verifyPasscode = verifyPasscode;
 exports.verifySecureToken = verifySecureToken;
 exports.verifySnapshotToken = verifySnapshotToken;