@stamprally/core 0.9.0 → 0.10.0

package/dist/index.cjs

@@ -12,34 +12,34 @@ function calculateDistanceMeters(aLat, aLon, bLat, bLon) {
 function mismatch(conditionType, reason, extra = {}) {
   return { ok: false, error: { code: "CONDITION_MISMATCH", conditionType, reason, ...extra } };
 }
-function evaluateConditionDetailed(condition, context) {
-  switch (condition.type) {
+function evaluateConditionDetailed(condition2, context) {
+  switch (condition2.type) {
     case "qr":
-      return context.type === "qr" && context.token === condition.secretToken ? { ok: true, value: { conditionType: "qr" } } : mismatch("qr", "INVALID_PROOF");
+      return context.type === "qr" && context.token === condition2.secretToken ? { ok: true, value: { conditionType: "qr" } } : mismatch("qr", "INVALID_PROOF");
     case "passcode":
-      return context.type === "passcode" && (condition.caseSensitive === false ? context.code.toLocaleLowerCase() === condition.code.toLocaleLowerCase() : context.code === condition.code) ? { ok: true, value: { conditionType: "passcode" } } : mismatch("passcode", "INVALID_PROOF");
+      return context.type === "passcode" && (condition2.caseSensitive === false ? context.code.toLocaleLowerCase() === condition2.code.toLocaleLowerCase() : context.code === condition2.code) ? { ok: true, value: { conditionType: "passcode" } } : mismatch("passcode", "INVALID_PROOF");
     case "nfc":
-      return context.type === "nfc" && context.tagId === condition.tagId ? { ok: true, value: { conditionType: "nfc" } } : mismatch("nfc", "INVALID_PROOF");
+      return context.type === "nfc" && context.tagId === condition2.tagId ? { ok: true, value: { conditionType: "nfc" } } : mismatch("nfc", "INVALID_PROOF");
     case "custom":
       return mismatch("custom", "VALIDATOR_FAILED");
     case "gps": {
-      if (!Number.isFinite(condition.latitude) || !Number.isFinite(condition.longitude) || !Number.isFinite(condition.radiusMeters) || condition.radiusMeters < 0 || context.type !== "gps" || !Number.isFinite(context.latitude) || !Number.isFinite(context.longitude))
+      if (!Number.isFinite(condition2.latitude) || !Number.isFinite(condition2.longitude) || !Number.isFinite(condition2.radiusMeters) || condition2.radiusMeters < 0 || context.type !== "gps" || !Number.isFinite(context.latitude) || !Number.isFinite(context.longitude))
         return mismatch("gps", "INVALID_GEO_INPUT");
       const distanceMeters = calculateDistanceMeters(
-        condition.latitude,
-        condition.longitude,
+        condition2.latitude,
+        condition2.longitude,
         context.latitude,
         context.longitude
       );
-      return distanceMeters <= condition.radiusMeters ? { ok: true, value: { conditionType: "gps", distanceMeters } } : mismatch("gps", "OUTSIDE_RADIUS", {
+      return distanceMeters <= condition2.radiusMeters ? { ok: true, value: { conditionType: "gps", distanceMeters } } : mismatch("gps", "OUTSIDE_RADIUS", {
         distanceMeters,
-        radiusMeters: condition.radiusMeters
+        radiusMeters: condition2.radiusMeters
       });
     }
   }
 }
-function evaluateCondition(condition, context) {
-  return evaluateConditionDetailed(condition, context).ok;
+function evaluateCondition(condition2, context) {
+  return evaluateConditionDetailed(condition2, context).ok;
 }
 
 // src/engine/order.ts
@@ -49,11 +49,11 @@ function getOrderedSpots(spots) {
 
 // src/engine/progress.ts
 function calculateProgress(state, config) {
-  const ids = new Set(config.spots.map((spot) => spot.id));
+  const ids = new Set(config.spots.map((spot2) => spot2.id));
   const acquired = new Set(
     state.records.map((record) => record.stampId).filter((id2) => ids.has(id2))
   );
-  const remaining = config.spots.filter((spot) => !acquired.has(spot.id));
+  const remaining = config.spots.filter((spot2) => !acquired.has(spot2.id));
   return {
     acquired: acquired.size,
     total: config.spots.length,
@@ -93,9 +93,9 @@ function createUniqueClaimTicketNumber(rewardId, issuedAt) {
   const timestampPart = Number.isNaN(timestamp) ? Date.now() : timestamp;
   return `CLAIM-${rewardId}-${timestampPart}-${createRandomHash()}`;
 }
-function issueClaimTicketNumber(reward, currentState, options = {}) {
+function issueClaimTicketNumber(reward2, currentState, options = {}) {
   if (currentState.claimTicketNumber !== void 0) return currentState;
-  const claimTicketNumber = createClaimTicketNumber(reward.id, options);
+  const claimTicketNumber = createClaimTicketNumber(reward2.id, options);
   return { ...currentState, claimTicketNumber };
 }
 
@@ -303,8 +303,8 @@ function normalizePasscode(input, caseSensitive = false) {
   const normalized = input.normalize("NFKC").trim();
   return caseSensitive ? normalized : normalized.toUpperCase();
 }
-function verifyPasscode(inputCode, condition) {
-  return normalizePasscode(inputCode, condition.caseSensitive) === normalizePasscode(condition.code, condition.caseSensitive) ? { success: true } : { success: false, message: "The passcode is invalid." };
+function verifyPasscode(inputCode, condition2) {
+  return normalizePasscode(inputCode, condition2.caseSensitive) === normalizePasscode(condition2.code, condition2.caseSensitive) ? { success: true } : { success: false, message: "The passcode is invalid." };
 }
 
 // src/detectors/qr.ts
@@ -431,71 +431,71 @@ async function readQrContext(videoElement, options = {}) {
 // src/engine/transition.ts
 function reconcileRewardStates(rewards, currentStates, acquiredStampCount, now) {
   const states = new Map(currentStates.map((state) => [state.rewardId, state]));
-  return rewards.map((reward) => {
-    const current = states.get(reward.id);
+  return rewards.map((reward2) => {
+    const current = states.get(reward2.id);
     if (current?.status === "CONSUMED" || current?.status === "EXPIRED") return current;
-    if (reward.validUntil !== void 0 && Date.parse(reward.validUntil) <= Date.parse(now))
-      return { rewardId: reward.id, status: "EXPIRED" };
-    if (reward.stockLimit !== void 0 && (current?.redeemedCount ?? 0) >= reward.stockLimit)
-      return { rewardId: reward.id, status: "EXPIRED" };
-    if (acquiredStampCount >= reward.requiredStampCount)
+    if (reward2.validUntil !== void 0 && Date.parse(reward2.validUntil) <= Date.parse(now))
+      return { rewardId: reward2.id, status: "EXPIRED" };
+    if (reward2.stockLimit !== void 0 && (current?.redeemedCount ?? 0) >= reward2.stockLimit)
+      return { rewardId: reward2.id, status: "EXPIRED" };
+    if (acquiredStampCount >= reward2.requiredStampCount)
       return {
-        rewardId: reward.id,
+        rewardId: reward2.id,
         status: "AVAILABLE",
         ...current?.unlockedAt === void 0 ? { unlockedAt: now } : { unlockedAt: current.unlockedAt }
       };
-    return { rewardId: reward.id, status: "LOCKED" };
+    return { rewardId: reward2.id, status: "LOCKED" };
   });
 }
 function consumeReward(params) {
-  const { reward, currentState } = params;
+  const { reward: reward2, currentState } = params;
   if (currentState.status === "CONSUMED")
-    return { ok: false, error: { code: "ALREADY_CONSUMED", rewardId: reward.id } };
+    return { ok: false, error: { code: "ALREADY_CONSUMED", rewardId: reward2.id } };
   if (currentState.status !== "AVAILABLE")
-    return { ok: false, error: { code: "NOT_AVAILABLE", rewardId: reward.id } };
-  if (reward.validUntil !== void 0 && Date.parse(reward.validUntil) <= Date.parse(params.now))
-    return { ok: false, error: { code: "EXPIRED", rewardId: reward.id } };
-  if (reward.stockLimit !== void 0 && (currentState.redeemedCount ?? 0) >= reward.stockLimit)
-    return { ok: false, error: { code: "OUT_OF_STOCK", rewardId: reward.id } };
-  if (reward.userClaimLimit !== void 0 && (params.userRedemptionCount ?? currentState.userRedemptionCount ?? 0) >= reward.userClaimLimit)
-    return { ok: false, error: { code: "USER_LIMIT_REACHED", rewardId: reward.id } };
-  if (reward.redemptionMethod === "staff_passcode") {
-    if (reward.staffPasscode === void 0 || !verifyPasscode(params.inputPasscode ?? "", { code: reward.staffPasscode }).success)
+    return { ok: false, error: { code: "NOT_AVAILABLE", rewardId: reward2.id } };
+  if (reward2.validUntil !== void 0 && Date.parse(reward2.validUntil) <= Date.parse(params.now))
+    return { ok: false, error: { code: "EXPIRED", rewardId: reward2.id } };
+  if (reward2.stockLimit !== void 0 && (currentState.redeemedCount ?? 0) >= reward2.stockLimit)
+    return { ok: false, error: { code: "OUT_OF_STOCK", rewardId: reward2.id } };
+  if (reward2.userClaimLimit !== void 0 && (params.userRedemptionCount ?? currentState.userRedemptionCount ?? 0) >= reward2.userClaimLimit)
+    return { ok: false, error: { code: "USER_LIMIT_REACHED", rewardId: reward2.id } };
+  if (reward2.redemptionMethod === "staff_passcode") {
+    if (reward2.staffPasscode === void 0 || !verifyPasscode(params.inputPasscode ?? "", { code: reward2.staffPasscode }).success)
       return {
         ok: false,
         error: {
           code: "INVALID_PASSCODE",
-          rewardId: reward.id,
+          rewardId: reward2.id,
           message: "The passcode is invalid."
         }
       };
   }
-  if (reward.redemptionMethod === "view_only") return { ok: true, value: currentState };
+  if (reward2.redemptionMethod === "view_only") return { ok: true, value: currentState };
   return {
     ok: true,
     value: {
       ...currentState,
       status: "CONSUMED",
       consumedAt: params.now,
-      claimTicketNumber: createUniqueClaimTicketNumber(reward.id, params.now),
+      claimTicketNumber: createUniqueClaimTicketNumber(reward2.id, params.now),
       redeemedCount: (currentState.redeemedCount ?? 0) + 1,
       ...params.staffId === void 0 ? {} : { consumedByStaffId: params.staffId }
     }
   };
 }
 function processStamp(state, config, spotId, context, now) {
-  const spot = config.spots.find((item) => item.id === spotId);
-  if (spot === void 0) return { ok: false, error: { code: "SPOT_NOT_FOUND", spotId } };
+  const spot2 = config.spots.find((item) => item.id === spotId);
+  if (spot2 === void 0) return { ok: false, error: { code: "SPOT_NOT_FOUND", spotId } };
   if (state.records.some((record2) => record2.stampId === spotId))
     return { ok: false, error: { code: "STAMP_ALREADY_ACQUIRED", spotId } };
   const acquired = new Set(state.records.map((record2) => record2.stampId));
-  if (spot.prerequisites?.some((id2) => !acquired.has(id2)))
+  if (spot2.prerequisites?.some((id2) => !acquired.has(id2)))
     return { ok: false, error: { code: "PREREQUISITES_NOT_MET", spotId } };
-  for (const condition of spot.conditions) {
-    if (condition.type === "custom" || !evaluateConditionDetailed(condition, context).ok)
+  for (const condition2 of spot2.conditions) {
+    if (condition2.type === "custom" || !evaluateConditionDetailed(condition2, context).ok)
       return {
         ok: false,
-        error: condition.type === "custom" ? {
+        error: condition2.type === "custom" ? {
           code: "CUSTOM_VALIDATION_FAILED",
           spotId,
           message: "Custom validation requires an async validator."
@@ -959,18 +959,18 @@ function proof(value) {
   }
   return "";
 }
-function matches(condition, value) {
-  if (condition.type === "gps") {
+function matches(condition2, value) {
+  if (condition2.type === "gps") {
     if (typeof value !== "object" || value === null) return false;
     const item = value;
     const latitude = item.latitude;
     const longitude = item.longitude;
     if (typeof latitude !== "number" || typeof longitude !== "number") return false;
     const radians = (v) => v * Math.PI / 180;
-    const dLat = radians(latitude - condition.latitude);
-    const dLon = radians(longitude - condition.longitude);
-    const h = Math.sin(dLat / 2) ** 2 + Math.cos(radians(condition.latitude)) * Math.cos(radians(latitude)) * Math.sin(dLon / 2) ** 2;
-    return 6371e3 * 2 * Math.asin(Math.sqrt(Math.min(1, h))) <= condition.radiusMeters;
+    const dLat = radians(latitude - condition2.latitude);
+    const dLon = radians(longitude - condition2.longitude);
+    const h = Math.sin(dLat / 2) ** 2 + Math.cos(radians(condition2.latitude)) * Math.cos(radians(latitude)) * Math.sin(dLon / 2) ** 2;
+    return 6371e3 * 2 * Math.asin(Math.sqrt(Math.min(1, h))) <= condition2.radiusMeters;
   }
   return proof(value).trim() !== "";
 }
@@ -1057,8 +1057,8 @@ var StampRallyClient = class {
   checkIn(spotId, proofData, options = {}) {
     return this.#enqueue(async () => {
       const current = await this.initialize();
-      const spot = this.#config.spots.find((item) => item.id === spotId);
-      if (spot === void 0)
+      const spot2 = this.#config.spots.find((item) => item.id === spotId);
+      if (spot2 === void 0)
         return this.#fail({ code: "SPOT_NOT_FOUND", spotId, message: "Spot was not found." });
       if (current.records.some((record2) => record2.stampId === spotId))
         return this.#fail({
@@ -1067,15 +1067,15 @@ var StampRallyClient = class {
           message: "Spot was already claimed."
         });
       const acquired = new Set(current.records.map((record2) => record2.stampId));
-      if (spot.prerequisites?.some((id2) => !acquired.has(id2)))
+      if (spot2.prerequisites?.some((id2) => !acquired.has(id2)))
         return this.#fail({
           code: "PREREQUISITES_NOT_MET",
           spotId,
           message: "Prerequisite spots are not complete."
         });
-      for (const condition of spot.conditions) {
-        if (condition.type === "custom") {
-          const validator = this.#options.customValidators?.[condition.validatorName] ?? this.#options.customValidator;
+      for (const condition2 of spot2.conditions) {
+        if (condition2.type === "custom") {
+          const validator = this.#options.customValidators?.[condition2.validatorName] ?? this.#options.customValidator;
           if (validator === void 0)
             return this.#fail({
               code: "CUSTOM_VALIDATION_FAILED",
@@ -1086,7 +1086,7 @@ var StampRallyClient = class {
             rallyId: this.#config.id,
             spotId,
             proofData,
-            condition: { type: "custom", validatorName: condition.validatorName },
+            condition: { type: "custom", validatorName: condition2.validatorName },
             userState: current
           };
           const result = typeof validator === "function" ? await validator(context) : await validator.validate(context);
@@ -1096,7 +1096,7 @@ var StampRallyClient = class {
               spotId,
               message: typeof result === "object" && result.message !== void 0 ? result.message : "Custom validation failed."
             });
-        } else if (!matches(condition, proofData))
+        } else if (!matches(condition2, proofData))
           return this.#fail({ code: "INVALID_PROOF", spotId, message: "Verification failed." });
       }
       const now = options.now ?? this.#now();
@@ -1216,7 +1216,7 @@ var StampRallyClient = class {
     return Promise.resolve(next);
   }
   #reconcile(state) {
-    const ids = new Set(this.#config.spots.map((spot) => spot.id));
+    const ids = new Set(this.#config.spots.map((spot2) => spot2.id));
     const records = state.records.filter(
       (record, index, all) => ids.has(record.stampId) && all.findIndex((candidate) => candidate.stampId === record.stampId) === index
     );
@@ -1396,6 +1396,11 @@ async function decryptPayload(body, secret) {
 }
 
 // src/domain/i18n.ts
+function updateLocalizedField(current, locale, newValue) {
+  if (typeof current === "string" || current === void 0)
+    return { [locale]: newValue };
+  return { ...current, [locale]: newValue };
+}
 function resolveLocalizedText(text, locale, fallbackLocale) {
   if (text === void 0 || text === "") return "";
   if (typeof text === "string") return text;
@@ -1422,23 +1427,23 @@ var DEFAULT_SHEET_THEME = {
   unclaimedOpacity: 1,
   fontFamily: "serif"
 };
-function publicCondition(condition) {
-  switch (condition.type) {
+function publicCondition(condition2) {
+  switch (condition2.type) {
     case "qr":
-      return condition.qrEntryUrl === void 0 ? { type: "qr" } : { type: "qr", qrEntryUrl: condition.qrEntryUrl };
+      return condition2.qrEntryUrl === void 0 ? { type: "qr" } : { type: "qr", qrEntryUrl: condition2.qrEntryUrl };
     case "passcode":
       return { type: "passcode" };
     case "gps":
       return {
         type: "gps",
-        latitude: condition.latitude,
-        longitude: condition.longitude,
-        radiusMeters: condition.radiusMeters
+        latitude: condition2.latitude,
+        longitude: condition2.longitude,
+        radiusMeters: condition2.radiusMeters
       };
     case "nfc":
       return { type: "nfc" };
     case "custom":
-      return { type: "custom", validatorName: condition.validatorName };
+      return { type: "custom", validatorName: condition2.validatorName };
   }
 }
 function toPublicConfig(config) {
@@ -1448,12 +1453,12 @@ function toPublicConfig(config) {
     title: config.title,
     ...config.description === void 0 ? {} : { description: config.description },
     ...config.theme === void 0 ? {} : { theme: config.theme },
-    spots: config.spots.map((spot) => ({
-      ...spot,
-      conditions: spot.conditions.map(publicCondition)
+    spots: config.spots.map((spot2) => ({
+      ...spot2,
+      conditions: spot2.conditions.map(publicCondition)
     })),
     rewards: config.rewards.map(
-      ({ digitalContentUrl: _content, staffPasscode: _passcode, ...reward }) => reward
+      ({ digitalContentUrl: _content, staffPasscode: _passcode, ...reward2 }) => reward2
     ),
     ...config.metadata === void 0 ? {} : { metadata: config.metadata },
     ...config.serverEndpoint === void 0 ? {} : { serverEndpoint: config.serverEndpoint }
@@ -1491,15 +1496,15 @@ function isPublicConfig(value) {
   }
   if (typeof candidate.id !== "string" || typeof candidate.version !== "string" || typeof candidate.title !== "string" && (typeof candidate.title !== "object" || candidate.title === null || Array.isArray(candidate.title)) || !Array.isArray(candidate.spots) || !Array.isArray(candidate.rewards))
     return false;
-  return candidate.spots.every((spot) => {
-    if (typeof spot !== "object" || spot === null || Array.isArray(spot)) return false;
-    const item = spot;
+  return candidate.spots.every((spot2) => {
+    if (typeof spot2 !== "object" || spot2 === null || Array.isArray(spot2)) return false;
+    const item = spot2;
     if (typeof item.id !== "string" || typeof item.orderIndex !== "number" || item.name === void 0 || "secretToken" in item || "code" in item || "tagId" in item || "secretParams" in item)
       return false;
-    return Array.isArray(item.conditions) && item.conditions.every((condition) => {
-      if (typeof condition !== "object" || condition === null || Array.isArray(condition))
+    return Array.isArray(item.conditions) && item.conditions.every((condition2) => {
+      if (typeof condition2 !== "object" || condition2 === null || Array.isArray(condition2))
         return false;
-      const value2 = condition;
+      const value2 = condition2;
       if ("secretToken" in value2 || "code" in value2 || "tagId" in value2 || "secretParams" in value2)
         return false;
       const type = value2.type;
@@ -1507,9 +1512,9 @@ function isPublicConfig(value) {
       if (type === "custom") return typeof value2.validatorName === "string";
       return type === "gps" && typeof value2.latitude === "number" && typeof value2.longitude === "number" && typeof value2.radiusMeters === "number";
     });
-  }) && candidate.rewards.every((reward) => {
-    if (typeof reward !== "object" || reward === null || Array.isArray(reward)) return false;
-    const item = reward;
+  }) && candidate.rewards.every((reward2) => {
+    if (typeof reward2 !== "object" || reward2 === null || Array.isArray(reward2)) return false;
+    const item = reward2;
     return typeof item.id === "string" && typeof item.requiredStampCount === "number" && (item.type === "digital" || item.type === "in_person") && (item.redemptionMethod === "manual_slide" || item.redemptionMethod === "staff_passcode" || item.redemptionMethod === "view_only" || item.redemptionMethod === "server_claim") && !("staffPasscode" in item || "digitalContentUrl" in item);
   });
 }
@@ -1613,6 +1618,324 @@ var THEME_PRESETS = [
   }
 ];
 
+// src/domain/validation.ts
+var ConfigValidationError = class extends Error {
+  constructor(errors) {
+    super(errors.map((error) => `${error.path}: ${error.message}`).join("; "));
+    this.errors = errors;
+  }
+  errors;
+  name = "ConfigValidationError";
+};
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function hasOwn(value, key) {
+  return Object.hasOwn(value, key);
+}
+function add(errors, path, message, code) {
+  errors.push({ path, message, code });
+}
+function requiredString(value, key, path, errors) {
+  if (typeof value[key] !== "string" || value[key].length === 0) {
+    add(errors, `${path}.${key}`, "A non-empty string is required.", "required_string");
+    return false;
+  }
+  return true;
+}
+function optionalString(value, key, path, errors) {
+  if (hasOwn(value, key) && value[key] !== void 0 && typeof value[key] !== "string")
+    add(errors, `${path}.${key}`, "Expected a string.", "invalid_type");
+}
+function optionalBoolean(value, key, path, errors) {
+  if (hasOwn(value, key) && value[key] !== void 0 && typeof value[key] !== "boolean")
+    add(errors, `${path}.${key}`, "Expected a boolean.", "invalid_type");
+}
+function finiteNumber(value, key, path, errors, minimum) {
+  const item = value[key];
+  if (typeof item !== "number" || !Number.isFinite(item)) {
+    add(errors, `${path}.${key}`, "Expected a finite number.", "invalid_number");
+  } else if (minimum !== void 0 && item < minimum) {
+    add(
+      errors,
+      `${path}.${key}`,
+      `Expected a number greater than or equal to ${minimum}.`,
+      "out_of_range"
+    );
+  }
+}
+function localizedText(value, path, errors) {
+  if (typeof value === "string") return;
+  if (!isRecord2(value)) {
+    add(errors, path, "Expected a string or a locale map.", "invalid_localized_text");
+    return;
+  }
+  for (const [locale, text] of Object.entries(value)) {
+    if (typeof text !== "string")
+      add(errors, `${path}.${locale}`, "Expected a string.", "invalid_type");
+  }
+}
+function theme(value, path, errors) {
+  if (!isRecord2(value)) {
+    add(errors, path, "Expected a theme object.", "invalid_type");
+    return;
+  }
+  for (const key of ["primaryColor", "cardBackgroundColor", "textColor"])
+    requiredString(value, key, path, errors);
+  optionalString(value, "backgroundColor", path, errors);
+  optionalString(value, "backgroundImageUrl", path, errors);
+  optionalString(value, "completedStampColor", path, errors);
+  optionalString(value, "fontFamily", path, errors);
+  const slotShape = value.slotShape;
+  if (slotShape !== "circle" && slotShape !== "square" && slotShape !== "rounded")
+    add(errors, `${path}.slotShape`, "Expected circle, square, or rounded.", "invalid_enum");
+  finiteNumber(value, "gridColumns", path, errors, 1);
+  if (typeof value.gridColumns === "number" && !Number.isInteger(value.gridColumns))
+    add(errors, `${path}.gridColumns`, "Expected an integer.", "invalid_integer");
+  if (hasOwn(value, "unclaimedOpacity")) finiteNumber(value, "unclaimedOpacity", path, errors, 0);
+}
+function externalReferences(value, path, errors) {
+  if (!Array.isArray(value)) {
+    add(errors, path, "Expected an array.", "invalid_type");
+    return;
+  }
+  value.forEach((item, index) => {
+    const itemPath = `${path}[${index}]`;
+    if (!isRecord2(item)) {
+      add(errors, itemPath, "Expected an object.", "invalid_type");
+      return;
+    }
+    requiredString(item, "type", itemPath, errors);
+    requiredString(item, "id", itemPath, errors);
+    optionalString(item, "url", itemPath, errors);
+  });
+}
+function condition(value, path, errors, isPublic) {
+  if (!isRecord2(value)) {
+    add(errors, path, "Expected a condition object.", "invalid_type");
+    return;
+  }
+  const type = value.type;
+  if (type === "qr") {
+    if (isPublic) {
+      if (hasOwn(value, "secretToken"))
+        add(errors, `${path}.secretToken`, "Private field is not allowed.", "private_field");
+    } else requiredString(value, "secretToken", path, errors);
+    optionalString(value, "qrEntryUrl", path, errors);
+    return;
+  }
+  if (type === "passcode") {
+    if (isPublic) {
+      for (const key of ["code", "caseSensitive"])
+        if (hasOwn(value, key))
+          add(errors, `${path}.${key}`, "Private field is not allowed.", "private_field");
+    } else {
+      requiredString(value, "code", path, errors);
+      optionalBoolean(value, "caseSensitive", path, errors);
+    }
+    return;
+  }
+  if (type === "gps") {
+    finiteNumber(value, "latitude", path, errors);
+    finiteNumber(value, "longitude", path, errors);
+    finiteNumber(value, "radiusMeters", path, errors, 0);
+    if (typeof value.latitude === "number" && (value.latitude < -90 || value.latitude > 90))
+      add(errors, `${path}.latitude`, "Expected a latitude between -90 and 90.", "out_of_range");
+    if (typeof value.longitude === "number" && (value.longitude < -180 || value.longitude > 180))
+      add(
+        errors,
+        `${path}.longitude`,
+        "Expected a longitude between -180 and 180.",
+        "out_of_range"
+      );
+    return;
+  }
+  if (type === "nfc") {
+    if (isPublic) {
+      if (hasOwn(value, "tagId"))
+        add(errors, `${path}.tagId`, "Private field is not allowed.", "private_field");
+    } else requiredString(value, "tagId", path, errors);
+    return;
+  }
+  if (type === "custom") {
+    requiredString(value, "validatorName", path, errors);
+    if (isPublic && hasOwn(value, "secretParams"))
+      add(errors, `${path}.secretParams`, "Private field is not allowed.", "private_field");
+    if (!isPublic && hasOwn(value, "secretParams") && !isRecord2(value.secretParams))
+      add(errors, `${path}.secretParams`, "Expected an object.", "invalid_type");
+    return;
+  }
+  add(errors, `${path}.type`, "Unknown condition type.", "invalid_enum");
+}
+function unlockCondition(value, path, errors) {
+  if (!isRecord2(value)) {
+    add(errors, path, "Expected an unlock condition object.", "invalid_type");
+    return;
+  }
+  if (value.type === "stamp_count") {
+    finiteNumber(value, "count", path, errors, 0);
+    return;
+  }
+  if (value.type === "stamps") {
+    if (!Array.isArray(value.stampIds))
+      add(errors, `${path}.stampIds`, "Expected an array.", "invalid_type");
+    else
+      value.stampIds.forEach((item, index) => {
+        if (typeof item !== "string" || item.length === 0)
+          add(
+            errors,
+            `${path}.stampIds[${index}]`,
+            "Expected a non-empty string.",
+            "required_string"
+          );
+      });
+    return;
+  }
+  if (value.type === "all" || value.type === "any") {
+    if (!Array.isArray(value.conditions))
+      add(errors, `${path}.conditions`, "Expected an array.", "invalid_type");
+    else
+      value.conditions.forEach((item, index) => {
+        unlockCondition(item, `${path}.conditions[${index}]`, errors);
+      });
+    return;
+  }
+  add(errors, `${path}.type`, "Unknown unlock condition type.", "invalid_enum");
+}
+function spot(value, path, errors, isPublic) {
+  if (!isRecord2(value)) {
+    add(errors, path, "Expected a spot object.", "invalid_type");
+    return;
+  }
+  requiredString(value, "id", path, errors);
+  finiteNumber(value, "orderIndex", path, errors, 0);
+  if (typeof value.orderIndex === "number" && !Number.isInteger(value.orderIndex))
+    add(errors, `${path}.orderIndex`, "Expected an integer.", "invalid_integer");
+  localizedText(value.name, `${path}.name`, errors);
+  for (const key of ["description", "hint"])
+    if (hasOwn(value, key)) localizedText(value[key], `${path}.${key}`, errors);
+  for (const key of ["imageUrl", "iconUrl", "redirectUrlAfterClaim"])
+    optionalString(value, key, path, errors);
+  if (hasOwn(value, "externalReferences") && value.externalReferences !== void 0)
+    externalReferences(value.externalReferences, `${path}.externalReferences`, errors);
+  if (hasOwn(value, "prerequisites") && value.prerequisites !== void 0) {
+    if (!Array.isArray(value.prerequisites))
+      add(errors, `${path}.prerequisites`, "Expected an array.", "invalid_type");
+    else
+      value.prerequisites.forEach((item, index) => {
+        if (typeof item !== "string" || item.length === 0)
+          add(
+            errors,
+            `${path}.prerequisites[${index}]`,
+            "Expected a non-empty string.",
+            "required_string"
+          );
+      });
+  }
+  if (!Array.isArray(value.conditions))
+    add(errors, `${path}.conditions`, "Expected an array.", "invalid_type");
+  else
+    value.conditions.forEach((item, index) => {
+      condition(item, `${path}.conditions[${index}]`, errors, isPublic);
+    });
+}
+function reward(value, path, errors, isPublic) {
+  if (!isRecord2(value)) {
+    add(errors, path, "Expected a reward object.", "invalid_type");
+    return;
+  }
+  requiredString(value, "id", path, errors);
+  localizedText(value.title, `${path}.title`, errors);
+  if (hasOwn(value, "description")) localizedText(value.description, `${path}.description`, errors);
+  if (value.type !== "digital" && value.type !== "in_person")
+    add(errors, `${path}.type`, "Unknown reward type.", "invalid_enum");
+  if (!["manual_slide", "staff_passcode", "view_only", "server_claim"].includes(
+    String(value.redemptionMethod)
+  ))
+    add(errors, `${path}.redemptionMethod`, "Unknown redemption method.", "invalid_enum");
+  finiteNumber(value, "requiredStampCount", path, errors, 0);
+  for (const key of ["stockLimit", "userClaimLimit"]) {
+    if (hasOwn(value, key) && value[key] !== void 0) {
+      finiteNumber(value, key, path, errors, 0);
+      if (typeof value[key] === "number" && !Number.isInteger(value[key]))
+        add(errors, `${path}.${key}`, "Expected an integer.", "invalid_integer");
+    }
+  }
+  optionalString(value, "validUntil", path, errors);
+  if (typeof value.validUntil === "string" && Number.isNaN(Date.parse(value.validUntil)))
+    add(errors, `${path}.validUntil`, "Expected a valid date string.", "invalid_date");
+  if (isPublic) {
+    for (const key of ["staffPasscode", "digitalContentUrl"])
+      if (hasOwn(value, key))
+        add(errors, `${path}.${key}`, "Private field is not allowed.", "private_field");
+  } else {
+    optionalString(value, "staffPasscode", path, errors);
+    optionalString(value, "digitalContentUrl", path, errors);
+  }
+  if (hasOwn(value, "conditions") && value.conditions !== void 0) {
+    if (!Array.isArray(value.conditions))
+      add(errors, `${path}.conditions`, "Expected an array.", "invalid_type");
+    else
+      value.conditions.forEach((item, index) => {
+        unlockCondition(item, `${path}.conditions[${index}]`, errors);
+      });
+  }
+}
+function validate(value, isPublic) {
+  const errors = [];
+  if (!isRecord2(value)) {
+    add(errors, "$", "Expected a configuration object.", "invalid_type");
+    return errors;
+  }
+  requiredString(value, "id", "$", errors);
+  requiredString(value, "version", "$", errors);
+  localizedText(value.title, "$.title", errors);
+  if (hasOwn(value, "description")) localizedText(value.description, "$.description", errors);
+  if (hasOwn(value, "theme") && value.theme !== void 0) theme(value.theme, "$.theme", errors);
+  if (!Array.isArray(value.spots)) add(errors, "spots", "Expected an array.", "invalid_type");
+  else
+    value.spots.forEach((item, index) => {
+      spot(item, `spots[${index}]`, errors, isPublic);
+    });
+  if (!Array.isArray(value.rewards)) add(errors, "rewards", "Expected an array.", "invalid_type");
+  else
+    value.rewards.forEach((item, index) => {
+      reward(item, `rewards[${index}]`, errors, isPublic);
+    });
+  if (!isPublic) {
+    optionalString(value, "staffPasscode", "$", errors);
+    if (hasOwn(value, "inventory") && value.inventory !== void 0 && !isRecord2(value.inventory))
+      add(errors, "$.inventory", "Expected an object.", "invalid_type");
+    if (hasOwn(value, "serverMetadata") && value.serverMetadata !== void 0 && !isRecord2(value.serverMetadata))
+      add(errors, "$.serverMetadata", "Expected an object.", "invalid_type");
+    optionalString(value, "serverEndpoint", "$", errors);
+  } else {
+    for (const key of ["staffPasscode", "serverMetadata", "inventory"])
+      if (hasOwn(value, key))
+        add(errors, `$.${key}`, "Private field is not allowed.", "private_field");
+    optionalString(value, "serverEndpoint", "$", errors);
+  }
+  return errors;
+}
+function safeParseAdminConfig(input) {
+  const errors = validate(input, false);
+  return errors.length === 0 ? { success: true, data: input } : { success: false, errors };
+}
+function parseAdminConfig(input) {
+  const result = safeParseAdminConfig(input);
+  if (!result.success) throw new ConfigValidationError(result.errors);
+  return result.data;
+}
+function safeParsePublicConfig(input) {
+  const errors = validate(input, true);
+  return errors.length === 0 ? { success: true, data: input } : { success: false, errors };
+}
+function parsePublicConfig(input) {
+  const result = safeParsePublicConfig(input);
+  if (!result.success) throw new ConfigValidationError(result.errors);
+  return result.data;
+}
+
 // src/security/snapshotToken.ts
 var encoder2 = new TextEncoder();
 function cryptoApi2() {
@@ -1732,6 +2055,7 @@ async function verifySnapshotToken(token, secretKey, now = Date.now()) {
   }
 }
 
+exports.ConfigValidationError = ConfigValidationError;
 exports.DEFAULT_SHEET_THEME = DEFAULT_SHEET_THEME;
 exports.InMemoryStorage = InMemoryStorage;
 exports.IndexedDBAdapter = IndexedDBAdapter;
@@ -1761,14 +2085,19 @@ exports.isRewardState = isRewardState;
 exports.isStampRallyState = isStampRallyState;
 exports.issueClaimTicketNumber = issueClaimTicketNumber;
 exports.normalizePasscode = normalizePasscode;
+exports.parseAdminConfig = parseAdminConfig;
+exports.parsePublicConfig = parsePublicConfig;
 exports.processStamp = processStamp;
 exports.readNfcContext = readNfcContext;
 exports.readQrContext = readQrContext;
 exports.reconcileRewardStates = reconcileRewardStates;
 exports.resolveLocalizedText = resolveLocalizedText;
+exports.safeParseAdminConfig = safeParseAdminConfig;
+exports.safeParsePublicConfig = safeParsePublicConfig;
 exports.storageKey = storageKey;
 exports.toLocalizedString = toLocalizedString;
 exports.toPublicConfig = toPublicConfig;
+exports.updateLocalizedField = updateLocalizedField;
 exports.verifyPasscode = verifyPasscode;
 exports.verifySecureToken = verifySecureToken;
 exports.verifySnapshotToken = verifySnapshotToken;