A reward feels better when it can become someone's moment.

// Merchant backend: separate purpose-bound authorities
const gifts = new LoyumiRewardGiftExperienceFramework({
  valueClient, widgetClient, deliveryClient, fulfillmentClient,
  senderIdentity, recipientIdentity,
  widget: { deploymentId, origin: merchantOrigin }
});
const dispatcher = new RewardGiftDeliveryDispatcher({
  ...deliveryRuntime, // store, adapters, content, readiness guard
  outcomes: new LoyumiRewardGiftDeliveryOutcomeRecorder(deliveryClient)
});

// Durable pre-value invitation; no claim authority is created
const invited = await gifts.createInvitation({
  operationId, programId, rewardIds,
  personalization, delivery,
  senderContext, recipientContext
}, {
  onCheckpoint: saveEncrypted
});
await saveEncrypted(invited.checkpoint);

const readiness = await gifts.refreshReadiness(
  invited.checkpoint,
  readinessGeneration
);
if (readiness.readiness.nextAction !== "quote_and_approve") {
  await gifts.scheduleAndEnqueueDelivery(
    invited.checkpoint,
    { phase: "onboarding_notice", kind: "initial" },
    "onboarding-1", dispatcher,
    { templateId: "gift-onboarding" }
  );
  return renderReadiness(readiness);
}

// Capability issuance always re-resolves the live authenticated sender
const sender = await requireAuthenticatedSender(request);
const approval = await gifts.prepareSenderApproval(
  invited.checkpoint,
  sender,
  { onCheckpoint: saveEncrypted }
);

// Browser: callback is a hint, never proof of approval
mountRewardGiftSenderFrame({
  container,
  handoff: approval.senderHandoff,
  onApproved: intent => notifyBackend(intent.id)
});

// Backend reloads the checkpoint and independently revalidates intent
const reserve = gifts.createReservationCheckpoint(
  storedApprovalCheckpoint,
  intentId
);
await saveEncrypted(reserve);
const reserved = await gifts.reserveGift(reserve, {
  onCheckpoint: saveEncrypted
});

// Delivery contains only the merchant's authenticated invite URL
const delivery = await gifts.scheduleAndEnqueueDelivery(
  reserved.checkpoint,
  { phase: "gift_ready", kind: "initial", scheduledFor },
  "gift-ready-1", dispatcher,
  { templateId: "gift-ready" }
);

// Worker sends and attests the provider outcome with delivery authority
const dispatched = await dispatcher.dispatch(delivery.queued.delivery.id);
if (dispatched.outcome !== "delivered") {
  return renderDeliveryPending(dispatched.delivery);
}

// A later merchant arrival handler must authenticate the intended recipient
const recipient = await requireAuthenticatedRecipient(request);
if (recipient.externalCustomerId !==
    reserved.checkpoint.recipientExternalCustomerId) {
  throw new Error("Gift recipient does not match this session");
}

// Only now mint the 60-second recipient handoff just in time
const arrivalCheckpoint = gifts.createArrivalCheckpoint(
  reserved.checkpoint,
  delivery.scheduled.delivery.id
);
await saveEncrypted(arrivalCheckpoint);
const arrival = await gifts.prepareRecipientArrival(
  arrivalCheckpoint,
  recipient,
  { onCheckpoint: saveEncrypted }
);

mountRewardGiftRecipientFrame({
  container,
  handoff: arrival.recipientHandoff,
  onDecisionCompleted: refreshFromBackend
});

// First-party wallet reveals no customer data to merchant JS
const wallet = await gifts.prepareWallet({
  role: "recipient", operationId: "wallet-1",
  programId, context: recipient
});
mountRewardGiftWalletFrame({ container: walletHost, handoff: wallet });

// In a later fulfillment handler, after acceptance and observed use:
const accepted = await gifts.getReceipt(reserved.rewardGift.id);
if (accepted.rewardGift.state !== "fulfilled" ||
    accepted.rewardGift.entitlement?.state !== "available") {
  return renderReceipt(accepted.rewardGift);
}
await gifts.recordEntitlementUse(reserved.rewardGift.id, {
  sourceReference: useReference,
  occurredAt: new Date().toISOString()
}, { idempotencyKey: useOperationId });
const receipt = await gifts.getReceipt(reserved.rewardGift.id);