@stamprally/server 0.6.0 → 0.8.0

package/dist/index.d.cts

@@ -1,6 +1,101 @@
-import { RallyConfig, SecureTokenSecretKey, StampRallyState, VerificationContext } from '@stamprally/core';
+import { AdminRallyConfig as AdminRallyConfig$1, VerificationCondition, RallyConfig, SecureTokenSecretKey, StampRallyState, VerificationContext } from '@stamprally/core';
 export { StampError, StampRecord } from '@stamprally/core';
 
+/** Persistence contract for implementations backed by Redis, SQL, or another RDB. */
+interface ServerPersistenceAdapter {
+    acquireLock(lockKey: string, ttlMs: number): Promise<boolean>;
+    releaseLock(lockKey: string): Promise<void>;
+    decrementRewardStock(rewardId: string): Promise<{
+        success: boolean;
+        remainingStock: number;
+    }>;
+    getIdempotentResult<T>(idempotencyKey: string): Promise<T | null>;
+    saveIdempotentResult<T>(idempotencyKey: string, result: T, ttlMs: number): Promise<void>;
+    getUserState(rallyId: string, userId: string): Promise<UserRallyState | null>;
+    saveUserState(rallyId: string, userId: string, state: UserRallyState): Promise<void>;
+    recordAuditLog(log: RallyAuditLog): Promise<void>;
+}
+interface InMemoryServerPersistenceOptions {
+    readonly stocks?: Readonly<Record<string, number>>;
+}
+/** Deterministic adapter for tests and small single-process deployments. */
+declare class InMemoryServerPersistenceAdapter implements ServerPersistenceAdapter {
+    #private;
+    constructor(options?: InMemoryServerPersistenceOptions);
+    acquireLock(lockKey: string, ttlMs: number): Promise<boolean>;
+    releaseLock(lockKey: string): Promise<void>;
+    decrementRewardStock(rewardId: string): Promise<{
+        success: boolean;
+        remainingStock: number;
+    }>;
+    getIdempotentResult<T>(idempotencyKey: string): Promise<T | null>;
+    saveIdempotentResult<T>(idempotencyKey: string, result: T, ttlMs: number): Promise<void>;
+    getUserState(rallyId: string, userId: string): Promise<UserRallyState | null>;
+    saveUserState(rallyId: string, userId: string, state: UserRallyState): Promise<void>;
+    recordAuditLog(log: RallyAuditLog): Promise<void>;
+    getAuditLogs(): ReadonlyArray<RallyAuditLog>;
+}
+
+type UniversalVerificationContext = {
+    readonly type: "qr";
+    readonly token: string;
+} | {
+    readonly type: "passcode";
+    readonly code: string;
+} | {
+    readonly type: "gps";
+    readonly latitude: number;
+    readonly longitude: number;
+} | {
+    readonly type: "custom";
+    readonly value: unknown;
+};
+interface UniversalCheckInRequest {
+    readonly rallyId: string;
+    readonly userId: string;
+    readonly spotId: string;
+    readonly context: UniversalVerificationContext;
+    readonly idempotencyKey: string;
+    readonly now?: string;
+}
+interface UniversalClaimRewardRequest {
+    readonly rallyId: string;
+    readonly userId: string;
+    readonly rewardId: string;
+    readonly idempotencyKey: string;
+    readonly staffPasscode?: string;
+    readonly staffId?: string;
+    readonly now?: string;
+}
+type UniversalCheckInResult = {
+    readonly ok: true;
+    readonly state: UserRallyState;
+} | {
+    readonly ok: false;
+    readonly code: string;
+    readonly message: string;
+};
+interface UniversalRallyServerOptions {
+    readonly idempotencyTtlMs?: number;
+    readonly lockTtlMs?: number;
+    readonly customValidators?: Readonly<Record<string, (value: unknown, condition: VerificationCondition) => boolean>>;
+    readonly now?: () => string;
+    /** Extract the authenticated identity; request-body userId is never trusted when this is set. */
+    readonly authenticate?: (request: Request) => Promise<string | null> | string | null;
+}
+/** Atomic, adapter-backed check-in service for the universal model. */
+declare class UniversalRallyServer {
+    #private;
+    constructor(config: AdminRallyConfig$1, persistence: ServerPersistenceAdapter, options?: UniversalRallyServerOptions);
+    /** Web Standard endpoint handler. Authentication, when configured, supplies the user identity. */
+    handleCheckIn(request: Request): Promise<Response>;
+    handleClaimReward(request: Request): Promise<Response>;
+    handleSync(request: Request): Promise<Response>;
+    handle(request: Request): Promise<Response>;
+    checkIn(request: UniversalCheckInRequest): Promise<UniversalCheckInResult>;
+    sync(rallyId: string, userId: string): Promise<UserRallyState>;
+}
+
 interface UserRallyState extends StampRallyState {
     readonly userId?: string;
 }
@@ -88,4 +183,4 @@ declare class StampRallyServer {
     syncProgress(request: Request): Promise<Response>;
 }
 
-export { type AdminRallyConfig, type CheckInRequest, type ClaimRewardRequest, InMemoryServerStorage, type InMemoryServerStorageOptions, type RallyAuditLog, type ServerStorageAdapter, type StampClaimProof, StampRallyServer, type SyncCheckInOperation, type SyncRequest, type UserRallyState };
+export { type AdminRallyConfig, type CheckInRequest, type ClaimRewardRequest, InMemoryServerPersistenceAdapter, type InMemoryServerPersistenceOptions, InMemoryServerStorage, type InMemoryServerStorageOptions, type RallyAuditLog, type ServerPersistenceAdapter, type ServerStorageAdapter, type StampClaimProof, StampRallyServer, type SyncCheckInOperation, type SyncRequest, type UniversalCheckInRequest, type UniversalCheckInResult, type UniversalClaimRewardRequest, UniversalRallyServer, type UniversalRallyServerOptions, type UniversalVerificationContext, type UserRallyState };

package/dist/index.d.ts

@@ -1,6 +1,101 @@
-import { RallyConfig, SecureTokenSecretKey, StampRallyState, VerificationContext } from '@stamprally/core';
+import { AdminRallyConfig as AdminRallyConfig$1, VerificationCondition, RallyConfig, SecureTokenSecretKey, StampRallyState, VerificationContext } from '@stamprally/core';
 export { StampError, StampRecord } from '@stamprally/core';
 
+/** Persistence contract for implementations backed by Redis, SQL, or another RDB. */
+interface ServerPersistenceAdapter {
+    acquireLock(lockKey: string, ttlMs: number): Promise<boolean>;
+    releaseLock(lockKey: string): Promise<void>;
+    decrementRewardStock(rewardId: string): Promise<{
+        success: boolean;
+        remainingStock: number;
+    }>;
+    getIdempotentResult<T>(idempotencyKey: string): Promise<T | null>;
+    saveIdempotentResult<T>(idempotencyKey: string, result: T, ttlMs: number): Promise<void>;
+    getUserState(rallyId: string, userId: string): Promise<UserRallyState | null>;
+    saveUserState(rallyId: string, userId: string, state: UserRallyState): Promise<void>;
+    recordAuditLog(log: RallyAuditLog): Promise<void>;
+}
+interface InMemoryServerPersistenceOptions {
+    readonly stocks?: Readonly<Record<string, number>>;
+}
+/** Deterministic adapter for tests and small single-process deployments. */
+declare class InMemoryServerPersistenceAdapter implements ServerPersistenceAdapter {
+    #private;
+    constructor(options?: InMemoryServerPersistenceOptions);
+    acquireLock(lockKey: string, ttlMs: number): Promise<boolean>;
+    releaseLock(lockKey: string): Promise<void>;
+    decrementRewardStock(rewardId: string): Promise<{
+        success: boolean;
+        remainingStock: number;
+    }>;
+    getIdempotentResult<T>(idempotencyKey: string): Promise<T | null>;
+    saveIdempotentResult<T>(idempotencyKey: string, result: T, ttlMs: number): Promise<void>;
+    getUserState(rallyId: string, userId: string): Promise<UserRallyState | null>;
+    saveUserState(rallyId: string, userId: string, state: UserRallyState): Promise<void>;
+    recordAuditLog(log: RallyAuditLog): Promise<void>;
+    getAuditLogs(): ReadonlyArray<RallyAuditLog>;
+}
+
+type UniversalVerificationContext = {
+    readonly type: "qr";
+    readonly token: string;
+} | {
+    readonly type: "passcode";
+    readonly code: string;
+} | {
+    readonly type: "gps";
+    readonly latitude: number;
+    readonly longitude: number;
+} | {
+    readonly type: "custom";
+    readonly value: unknown;
+};
+interface UniversalCheckInRequest {
+    readonly rallyId: string;
+    readonly userId: string;
+    readonly spotId: string;
+    readonly context: UniversalVerificationContext;
+    readonly idempotencyKey: string;
+    readonly now?: string;
+}
+interface UniversalClaimRewardRequest {
+    readonly rallyId: string;
+    readonly userId: string;
+    readonly rewardId: string;
+    readonly idempotencyKey: string;
+    readonly staffPasscode?: string;
+    readonly staffId?: string;
+    readonly now?: string;
+}
+type UniversalCheckInResult = {
+    readonly ok: true;
+    readonly state: UserRallyState;
+} | {
+    readonly ok: false;
+    readonly code: string;
+    readonly message: string;
+};
+interface UniversalRallyServerOptions {
+    readonly idempotencyTtlMs?: number;
+    readonly lockTtlMs?: number;
+    readonly customValidators?: Readonly<Record<string, (value: unknown, condition: VerificationCondition) => boolean>>;
+    readonly now?: () => string;
+    /** Extract the authenticated identity; request-body userId is never trusted when this is set. */
+    readonly authenticate?: (request: Request) => Promise<string | null> | string | null;
+}
+/** Atomic, adapter-backed check-in service for the universal model. */
+declare class UniversalRallyServer {
+    #private;
+    constructor(config: AdminRallyConfig$1, persistence: ServerPersistenceAdapter, options?: UniversalRallyServerOptions);
+    /** Web Standard endpoint handler. Authentication, when configured, supplies the user identity. */
+    handleCheckIn(request: Request): Promise<Response>;
+    handleClaimReward(request: Request): Promise<Response>;
+    handleSync(request: Request): Promise<Response>;
+    handle(request: Request): Promise<Response>;
+    checkIn(request: UniversalCheckInRequest): Promise<UniversalCheckInResult>;
+    sync(rallyId: string, userId: string): Promise<UserRallyState>;
+}
+
 interface UserRallyState extends StampRallyState {
     readonly userId?: string;
 }
@@ -88,4 +183,4 @@ declare class StampRallyServer {
     syncProgress(request: Request): Promise<Response>;
 }
 
-export { type AdminRallyConfig, type CheckInRequest, type ClaimRewardRequest, InMemoryServerStorage, type InMemoryServerStorageOptions, type RallyAuditLog, type ServerStorageAdapter, type StampClaimProof, StampRallyServer, type SyncCheckInOperation, type SyncRequest, type UserRallyState };
+export { type AdminRallyConfig, type CheckInRequest, type ClaimRewardRequest, InMemoryServerPersistenceAdapter, type InMemoryServerPersistenceOptions, InMemoryServerStorage, type InMemoryServerStorageOptions, type RallyAuditLog, type ServerPersistenceAdapter, type ServerStorageAdapter, type StampClaimProof, StampRallyServer, type SyncCheckInOperation, type SyncRequest, type UniversalCheckInRequest, type UniversalCheckInResult, type UniversalClaimRewardRequest, UniversalRallyServer, type UniversalRallyServerOptions, type UniversalVerificationContext, type UserRallyState };

package/dist/index.js

@@ -1,4 +1,395 @@
-import { processStamp, createSecureToken, consumeReward, reconcileRewardStates } from '@stamprally/core';
+import { consumeReward, processStamp, createSecureToken, reconcileRewardStates } from '@stamprally/core';
+
+// src/index.ts
+
+// src/persistence.ts
+var InMemoryServerPersistenceAdapter = class {
+  #locks = /* @__PURE__ */ new Map();
+  #idempotent = /* @__PURE__ */ new Map();
+  #states = /* @__PURE__ */ new Map();
+  #stocks;
+  #auditLogs = [];
+  constructor(options = {}) {
+    this.#stocks = new Map(Object.entries(options.stocks ?? {}));
+  }
+  async acquireLock(lockKey, ttlMs) {
+    const now2 = Date.now();
+    const expiresAt = this.#locks.get(lockKey);
+    if (expiresAt !== void 0 && expiresAt > now2) return false;
+    this.#locks.set(lockKey, now2 + Math.max(1, ttlMs));
+    return true;
+  }
+  async releaseLock(lockKey) {
+    this.#locks.delete(lockKey);
+  }
+  async decrementRewardStock(rewardId) {
+    const stock = this.#stocks.get(rewardId);
+    if (stock === void 0) return { success: true, remainingStock: Number.POSITIVE_INFINITY };
+    if (stock <= 0) return { success: false, remainingStock: 0 };
+    const remainingStock = stock - 1;
+    this.#stocks.set(rewardId, remainingStock);
+    return { success: true, remainingStock };
+  }
+  async getIdempotentResult(idempotencyKey) {
+    const entry = this.#idempotent.get(idempotencyKey);
+    if (entry === void 0) return null;
+    if (entry.expiresAt <= Date.now()) {
+      this.#idempotent.delete(idempotencyKey);
+      return null;
+    }
+    return structuredClone(entry.value);
+  }
+  async saveIdempotentResult(idempotencyKey, result, ttlMs) {
+    this.#idempotent.set(idempotencyKey, {
+      value: structuredClone(result),
+      expiresAt: Date.now() + Math.max(1, ttlMs)
+    });
+  }
+  async getUserState(rallyId, userId) {
+    const state = this.#states.get(`${rallyId}:${userId}`);
+    return state === void 0 ? null : structuredClone(state);
+  }
+  async saveUserState(rallyId, userId, state) {
+    this.#states.set(`${rallyId}:${userId}`, structuredClone(state));
+  }
+  async recordAuditLog(log) {
+    this.#auditLogs.push(structuredClone(log));
+  }
+  getAuditLogs() {
+    return structuredClone(this.#auditLogs);
+  }
+};
+function distanceMeters(aLat, aLon, bLat, bLon) {
+  const radians = (degrees) => degrees * Math.PI / 180;
+  const dLat = radians(bLat - aLat);
+  const dLon = radians(bLon - aLon);
+  const latA = radians(aLat);
+  const latB = radians(bLat);
+  const value = Math.sin(dLat / 2) ** 2 + Math.cos(latA) * Math.cos(latB) * Math.sin(dLon / 2) ** 2;
+  return 6371e3 * 2 * Math.asin(Math.sqrt(Math.min(1, value)));
+}
+function initialState(config, now2) {
+  return {
+    rallyId: config.id,
+    records: [],
+    rewards: reconcileRewardStates(
+      config.rewards.map((reward) => ({ ...reward, description: reward.description ?? "" })),
+      [],
+      0,
+      now2
+    ),
+    updatedAt: now2
+  };
+}
+function json(body, status = 200) {
+  return new Response(JSON.stringify(body), {
+    status,
+    headers: { "content-type": "application/json; charset=utf-8" }
+  });
+}
+function requestBody(request) {
+  return request.json().then((value) => {
+    if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+    return value;
+  }).catch(() => null);
+}
+function adminReward(reward) {
+  return { ...reward, description: reward.description ?? "" };
+}
+function matchesCondition(condition, context, customValidators) {
+  switch (condition.type) {
+    case "qr":
+      return context.type === "qr" && context.token === condition.secretToken;
+    case "passcode":
+      return context.type === "passcode" && (condition.caseSensitive === false ? context.code.toLocaleLowerCase() === condition.code.toLocaleLowerCase() : context.code === condition.code);
+    case "gps":
+      return context.type === "gps" && distanceMeters(
+        condition.latitude,
+        condition.longitude,
+        context.latitude,
+        context.longitude
+      ) <= condition.radiusMeters;
+    case "custom":
+      return customValidators?.[condition.validatorName]?.(
+        context.type === "custom" ? context.value : void 0,
+        condition
+      ) ?? false;
+  }
+}
+function audit(request, status, now2, errorCode) {
+  return {
+    id: `audit-${globalThis.crypto?.randomUUID?.() ?? `${Date.now()}-${Math.random().toString(36).slice(2)}`}`,
+    timestamp: now2,
+    rallyId: request.rallyId,
+    userId: request.userId,
+    action: "CHECK_IN",
+    resourceId: request.spotId,
+    status,
+    idempotencyKey: request.idempotencyKey,
+    ...errorCode === void 0 ? {} : { metadata: { errorCode } }
+  };
+}
+var UniversalRallyServer = class {
+  #config;
+  #persistence;
+  #options;
+  constructor(config, persistence, options = {}) {
+    this.#config = config;
+    this.#persistence = persistence;
+    this.#options = options;
+  }
+  /** Web Standard endpoint handler. Authentication, when configured, supplies the user identity. */
+  async handleCheckIn(request) {
+    const body = await requestBody(request);
+    const userId = await this.#authenticatedUser(request, body?.userId);
+    if (this.#options.authenticate !== void 0 && userId === null)
+      return json(
+        { ok: false, error: { code: "UNAUTHORIZED", message: "Authentication is required." } },
+        401
+      );
+    if (body === null || userId === null || body.rallyId !== this.#config.id || body.spotId === "" || body.idempotencyKey === "")
+      return json(
+        {
+          ok: false,
+          error: {
+            code: "INVALID_REQUEST",
+            message: "rallyId, spotId, and idempotencyKey are required."
+          }
+        },
+        400
+      );
+    if (body.context === void 0)
+      return json(
+        { ok: false, error: { code: "INVALID_REQUEST", message: "context is required." } },
+        400
+      );
+    const result = await this.checkIn({ ...body, userId });
+    return result.ok ? json(result) : json(result, result.code === "SPOT_NOT_FOUND" ? 404 : 422);
+  }
+  async handleClaimReward(request) {
+    const body = await requestBody(request);
+    const userId = await this.#authenticatedUser(request, body?.userId);
+    if (this.#options.authenticate !== void 0 && userId === null)
+      return json(
+        { ok: false, error: { code: "UNAUTHORIZED", message: "Authentication is required." } },
+        401
+      );
+    if (body === null || userId === null || body.rallyId !== this.#config.id || body.rewardId === "" || body.idempotencyKey === "")
+      return json(
+        {
+          ok: false,
+          error: {
+            code: "INVALID_REQUEST",
+            message: "rallyId, rewardId, and idempotencyKey are required."
+          }
+        },
+        400
+      );
+    const key = `claim-reward:${body.rallyId}:${userId}:${body.rewardId}:${body.idempotencyKey}`;
+    const previous = await this.#persistence.getIdempotentResult(key);
+    if (previous !== null) return json(previous, previous.ok ? 200 : 422);
+    const reward = this.#config.rewards.find((item) => item.id === body.rewardId);
+    if (reward === void 0) {
+      const failure = {
+        ok: false,
+        code: "REWARD_NOT_FOUND",
+        message: "Reward was not found."
+      };
+      return json(await this.#rememberClaim(key, failure, body, userId), 404);
+    }
+    const timestamp = body.now ?? this.#options.now?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+    const current = await this.sync(body.rallyId, userId);
+    const currentReward = current.rewards?.find((item) => item.rewardId === reward.id) ?? {
+      rewardId: reward.id,
+      status: "LOCKED"
+    };
+    const userClaims = await this.#getUserClaimCount(userId, reward.id);
+    const local = consumeReward({
+      reward: adminReward(reward),
+      currentState: currentReward,
+      now: timestamp,
+      userId,
+      userRedemptionCount: userClaims,
+      ...body.staffPasscode === void 0 ? {} : { inputPasscode: body.staffPasscode },
+      ...body.staffId === void 0 ? {} : { staffId: body.staffId }
+    });
+    if (!local.ok)
+      return json(
+        await this.#rememberClaim(
+          key,
+          {
+            ok: false,
+            code: local.error.code,
+            message: "Reward cannot be claimed.",
+            error: local.error
+          },
+          body,
+          userId
+        ),
+        422
+      );
+    const stock = await this.#persistence.decrementRewardStock(reward.id);
+    if (!stock.success)
+      return json(
+        await this.#rememberClaim(
+          key,
+          { ok: false, code: "OUT_OF_STOCK", message: "Reward is out of stock." },
+          body,
+          userId
+        ),
+        422
+      );
+    const next = {
+      ...current,
+      rewards: (current.rewards ?? []).map(
+        (item) => item.rewardId === reward.id ? local.value : item
+      ),
+      updatedAt: timestamp
+    };
+    await this.#persistence.saveUserState(body.rallyId, userId, next);
+    const success = local.value.claimTicketNumber === void 0 ? { ok: true, state: next } : { ok: true, state: next, claimTicketNumber: local.value.claimTicketNumber };
+    await this.#persistence.saveIdempotentResult(
+      key,
+      success,
+      this.#options.idempotencyTtlMs ?? 864e5
+    );
+    await this.#persistence.recordAuditLog({
+      id: `audit-${globalThis.crypto?.randomUUID?.() ?? Date.now()}`,
+      timestamp,
+      rallyId: body.rallyId,
+      userId,
+      action: "CLAIM_REWARD",
+      resourceId: reward.id,
+      status: "SUCCESS",
+      idempotencyKey: body.idempotencyKey
+    });
+    return json(success);
+  }
+  async handleSync(request) {
+    const body = await requestBody(request);
+    const userId = await this.#authenticatedUser(request, body?.userId);
+    if (this.#options.authenticate !== void 0 && userId === null)
+      return json(
+        { ok: false, error: { code: "UNAUTHORIZED", message: "Authentication is required." } },
+        401
+      );
+    if (body === null || userId === null || body.rallyId !== this.#config.id)
+      return json(
+        { ok: false, error: { code: "INVALID_REQUEST", message: "rallyId is required." } },
+        400
+      );
+    return json({ ok: true, state: await this.sync(body.rallyId, userId) });
+  }
+  async handle(request) {
+    if (request.method !== "POST")
+      return json({ ok: false, error: { code: "METHOD_NOT_ALLOWED" } }, 405);
+    const path = new URL(request.url).pathname;
+    if (path.endsWith("/check-in")) return this.handleCheckIn(request);
+    if (path.endsWith("/claim-reward")) return this.handleClaimReward(request);
+    if (path.endsWith("/sync")) return this.handleSync(request);
+    return json({ ok: false, error: { code: "NOT_FOUND" } }, 404);
+  }
+  async checkIn(request) {
+    const key = `check-in:${request.rallyId}:${request.userId}:${request.idempotencyKey}`;
+    const previous = await this.#persistence.getIdempotentResult(key);
+    if (previous !== null) return previous;
+    const lockKey = `state:${request.rallyId}:${request.userId}`;
+    const locked = await this.#persistence.acquireLock(lockKey, this.#options.lockTtlMs ?? 5e3);
+    if (!locked)
+      return { ok: false, code: "CONFLICT", message: "The user state is being updated." };
+    const now2 = request.now ?? this.#options.now?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+    try {
+      const spot = this.#config.spots.find((item) => item.id === request.spotId);
+      if (spot === void 0)
+        return this.#remember(
+          key,
+          { ok: false, code: "SPOT_NOT_FOUND", message: "Spot was not found." },
+          request,
+          now2
+        );
+      const current = await this.#persistence.getUserState(request.rallyId, request.userId) ?? initialState(this.#config, now2);
+      if (current.records.some((record) => record.stampId === request.spotId))
+        return this.#remember(
+          key,
+          { ok: false, code: "ALREADY_CLAIMED", message: "Spot was already claimed." },
+          request,
+          now2
+        );
+      const acquired = new Set(current.records.map((record) => record.stampId));
+      if (spot.prerequisites?.some((id2) => !acquired.has(id2)))
+        return this.#remember(
+          key,
+          {
+            ok: false,
+            code: "PREREQUISITES_NOT_MET",
+            message: "Prerequisite spots are not complete."
+          },
+          request,
+          now2
+        );
+      if (!spot.conditions.every(
+        (condition) => matchesCondition(condition, request.context, this.#options.customValidators)
+      ))
+        return this.#remember(
+          key,
+          { ok: false, code: "INVALID_PROOF", message: "Verification failed." },
+          request,
+          now2
+        );
+      const state = {
+        ...current,
+        records: [...current.records, { stampId: request.spotId, acquiredAt: now2 }],
+        updatedAt: now2
+      };
+      await this.#persistence.saveUserState(request.rallyId, request.userId, state);
+      return this.#remember(key, { ok: true, state }, request, now2);
+    } finally {
+      await this.#persistence.releaseLock(lockKey);
+    }
+  }
+  async sync(rallyId, userId) {
+    const now2 = this.#options.now?.() ?? (/* @__PURE__ */ new Date()).toISOString();
+    return await this.#persistence.getUserState(rallyId, userId) ?? initialState(this.#config, now2);
+  }
+  async #authenticatedUser(request, requestedUserId) {
+    const authenticated = await this.#options.authenticate?.(request);
+    if (this.#options.authenticate !== void 0) return authenticated ?? null;
+    return requestedUserId ?? null;
+  }
+  async #getUserClaimCount(userId, rewardId) {
+    const state = await this.#persistence.getUserState(this.#config.id, userId);
+    return state?.rewards?.find((item) => item.rewardId === rewardId)?.userRedemptionCount ?? 0;
+  }
+  async #rememberClaim(key, result, request, userId) {
+    await this.#persistence.saveIdempotentResult(
+      key,
+      result,
+      this.#options.idempotencyTtlMs ?? 864e5
+    );
+    await this.#persistence.recordAuditLog({
+      id: `audit-${globalThis.crypto?.randomUUID?.() ?? Date.now()}`,
+      timestamp: request.now ?? this.#options.now?.() ?? (/* @__PURE__ */ new Date()).toISOString(),
+      rallyId: request.rallyId,
+      userId,
+      action: "CLAIM_REWARD",
+      resourceId: request.rewardId,
+      status: "REJECTED",
+      idempotencyKey: request.idempotencyKey
+    });
+    return result;
+  }
+  async #remember(key, result, request, now2) {
+    await this.#persistence.recordAuditLog(
+      audit(request, result.ok ? "SUCCESS" : "REJECTED", now2, result.ok ? void 0 : result.code)
+    );
+    await this.#persistence.saveIdempotentResult(
+      key,
+      result,
+      this.#options.idempotencyTtlMs ?? 864e5
+    );
+    return result;
+  }
+};
 
 // src/index.ts
 var InMemoryServerStorage = class {
@@ -367,6 +758,6 @@ function emptyState(config, timestamp) {
   };
 }
 
-export { InMemoryServerStorage, StampRallyServer };
+export { InMemoryServerPersistenceAdapter, InMemoryServerStorage, StampRallyServer, UniversalRallyServer };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map