payment-kit 1.18.38 → 1.18.40

package/api/src/integrations/stripe/handlers/invoice.ts

@@ -19,6 +19,7 @@ import {
   TEventExpanded,
   TInvoiceItem,
 } from '../../../store/models';
+import { handleSubscriptionOnPaymentFailure } from './subscription';
 
 export async function handleStripeInvoicePaid(invoice: Invoice, event: TEventExpanded) {
   logger.info('invoice paid on stripe event', { locale: invoice.id });
@@ -91,6 +92,16 @@ export async function syncStripeInvoice(invoice: Invoice) {
       )
     );
     logger.info('stripe invoice synced', { locale: invoice.id, remote: stripeInvoice.id });
+    const failedStatuses = ['uncollectible', 'finalization_failed', 'payment_failed'];
+    if (failedStatuses.includes(stripeInvoice.status || '')) {
+      logger.info('Invoice failed', { invoiceId: invoice.id });
+      if (invoice.subscription_id) {
+        const subscription = await Subscription.findByPk(invoice.subscription_id);
+        if (subscription) {
+          handleSubscriptionOnPaymentFailure(subscription, 'syncStripeInvoice', client);
+        }
+      }
+    }
   }
 }
 
@@ -376,4 +387,15 @@ export async function handleInvoiceEvent(event: TEventExpanded, client: Stripe)
     await invoice.update({ status: 'payment_failed' });
     logger.info('invoice payment failed on stripe event', { locale: invoice.id });
   }
+
+  const failedEvents = ['invoice.marked_uncollectible', 'invoice.finalization_failed', 'invoice.payment_failed'];
+  if (failedEvents.includes(event.type)) {
+    logger.info('Invoice failed', { invoiceId: invoice.id });
+    if (invoice.subscription_id) {
+      const subscription = await Subscription.findByPk(invoice.subscription_id);
+      if (subscription) {
+        handleSubscriptionOnPaymentFailure(subscription, event.type, client);
+      }
+    }
+  }
 }

package/api/src/integrations/stripe/handlers/payment-intent.ts

@@ -7,9 +7,10 @@ import type Stripe from 'stripe';
 import dayjs from '../../../libs/dayjs';
 import logger from '../../../libs/logger';
 import { handlePaymentSucceed } from '../../../queues/payment';
-import { Invoice, PaymentIntent, PaymentMethod, TEventExpanded } from '../../../store/models';
+import { Invoice, PaymentIntent, PaymentMethod, Subscription, TEventExpanded } from '../../../store/models';
 import { handleStripeInvoiceCreated } from './invoice';
 import { events } from '../../../libs/event';
+import { handleSubscriptionOnPaymentFailure } from './subscription';
 
 export async function handleStripePaymentSucceed(paymentIntent: PaymentIntent, event?: TEventExpanded) {
   const triggerRenew = paymentIntent.status !== 'succeeded';
@@ -184,6 +185,13 @@ export async function handlePaymentIntentEvent(event: TEventExpanded, client: St
           attempted: true,
           status_transitions: { ...invoice.status_transitions, marked_uncollectible_at: dayjs().unix() },
         });
+
+        if (invoice.subscription_id) {
+          const subscription = await Subscription.findByPk(invoice.subscription_id);
+          if (subscription) {
+            handleSubscriptionOnPaymentFailure(subscription, event.type, client);
+          }
+        }
       }
     }
   }

package/api/src/integrations/stripe/handlers/subscription.ts

@@ -1,8 +1,15 @@
 import pick from 'lodash/pick';
 import type Stripe from 'stripe';
 
+import dayjs from '../../../libs/dayjs';
 import logger from '../../../libs/logger';
-import { finalizeStripeSubscriptionUpdate } from '../../../libs/subscription';
+import {
+  finalizeStripeSubscriptionUpdate,
+  getDaysUntilCancel,
+  getDaysUntilDue,
+  getDueUnit,
+  shouldCancelSubscription,
+} from '../../../libs/subscription';
 import { CheckoutSession, PaymentMethod, Subscription, TEventExpanded } from '../../../store/models';
 import { getCheckoutSessionSubscriptionIds } from '../../../libs/session';
 import { createEvent } from '../../../libs/audit';
@@ -139,3 +146,132 @@ export async function handleSubscriptionEvent(event: TEventExpanded, _: Stripe)
     }
   }
 }
+
+export async function syncStripeSubscriptionAfterRecovery(subscription: Subscription, paymentIntentId: string) {
+  if (!subscription.payment_details?.stripe?.subscription_id) {
+    return;
+  }
+
+  try {
+    const method = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+    if (method && method.type === 'stripe') {
+      const client = await method.getStripeClient();
+      await client.subscriptions.update(subscription.payment_details.stripe.subscription_id, {
+        cancel_at_period_end: false,
+        cancel_at: null,
+      });
+
+      logger.info('Removed cancellation settings in Stripe after payment success', {
+        subscription: subscription.id,
+        stripeSubscription: subscription.payment_details.stripe.subscription_id,
+        paymentIntent: paymentIntentId,
+      });
+    }
+  } catch (err) {
+    logger.error('Failed to update Stripe subscription after payment success', {
+      error: err,
+      subscription: subscription.id,
+      paymentIntent: paymentIntentId,
+    });
+  }
+}
+
+export async function handleSubscriptionOnPaymentFailure(
+  subscription: Subscription,
+  eventType: string,
+  client: Stripe
+) {
+  if (!subscription || !subscription.isActive()) {
+    logger.warn('Subscription is not active or not found', { subscription: subscription.id });
+    return;
+  }
+
+  const now = dayjs().unix();
+  const { interval } = subscription.pending_invoice_item_interval;
+  const dueUnit = getDueUnit(interval);
+  const cancelUpdates: { [key: string]: any } = {};
+  const daysUntilCancel = getDaysUntilCancel(subscription);
+  const cancelSubscription = shouldCancelSubscription(subscription);
+
+  if (daysUntilCancel > 0) {
+    cancelUpdates.cancel_at = subscription.current_period_start + daysUntilCancel * dueUnit;
+  } else {
+    cancelUpdates.cancel_at_period_end = true;
+  }
+
+  if (cancelSubscription) {
+    await subscription.update({
+      status: 'canceled',
+      canceled_at: now,
+      cancelation_details: {
+        comment: 'exceed_current_period',
+        feedback: 'other',
+        reason: 'payment_failed',
+      },
+    });
+    logger.warn(`[${eventType}] Subscription moved to canceled after payment failed`, {
+      subscription: subscription.id,
+    });
+  } else {
+    // check grace period
+    const daysUntilDue = getDaysUntilDue(subscription);
+    if (typeof daysUntilDue === 'number') {
+      const gracePeriodStart = subscription.current_period_start;
+      const graceDuration = daysUntilDue ? daysUntilDue * dueUnit : 0;
+
+      if (gracePeriodStart + graceDuration <= now) {
+        // past grace period, set to past_due
+        await subscription.update({
+          status: 'past_due',
+          ...cancelUpdates,
+          cancelation_details: {
+            comment: 'past_due',
+            feedback: 'other',
+            reason: 'payment_failed',
+          },
+        });
+        logger.warn(`[${eventType}] Subscription moved to past_due after payment failed`, {
+          subscription: subscription.id,
+        });
+      }
+    }
+  }
+
+  // sync to stripe
+  if (subscription.payment_details?.stripe?.subscription_id && client) {
+    try {
+      const method = await PaymentMethod.findByPk(subscription.default_payment_method_id);
+      if (method && method.type === 'stripe') {
+        const stripeUpdates: any = {
+          cancellation_details: {
+            comment: 'past_due',
+            feedback: 'other',
+            reason: 'payment_failed',
+          },
+        };
+
+        if (cancelUpdates.cancel_at) {
+          stripeUpdates.cancel_at = cancelUpdates.cancel_at;
+        } else if (cancelUpdates.cancel_at_period_end) {
+          stripeUpdates.cancel_at_period_end = true;
+        }
+        if (cancelSubscription) {
+          stripeUpdates.cancel_at = now;
+          stripeUpdates.cancel_at_period_end = false;
+        }
+
+        await client.subscriptions.update(subscription.payment_details.stripe.subscription_id, stripeUpdates);
+        logger.info(`[${eventType}] Updated subscription in Stripe after payment failed`, {
+          subscription: subscription.id,
+          stripeSubscription: subscription.payment_details.stripe.subscription_id,
+          updates: stripeUpdates,
+        });
+      }
+    } catch (err) {
+      logger.error(`[${eventType}] Failed to update subscription in Stripe`, {
+        error: err,
+        subscription: subscription.id,
+      });
+    }
+  }
+}

package/api/src/libs/subscription.ts

@@ -1354,126 +1354,136 @@ export async function slashOverdraftProtectionStake(subscription: Subscription,
 
     let slashAmount = new BN(0);
     const slashInvoices: Invoice[] = [];
-    const updatePromises = invoices.map(async (invoice) => {
+    for (const invoice of invoices) {
       if (!invoice.payment_intent_id) {
         await emitAsync(
           'invoice.queued',
           invoice.id,
           { invoiceId: invoice.id, retryOnError: false, justCreate: true },
-          {
-            sync: true,
-          }
+          { sync: true }
         );
         await invoice.reload();
       }
+
       const paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
       if (paymentIntent) {
-        if (paymentIntent.status === 'succeeded' && invoice.status === 'paid') {
+        const isAlreadyPaid = paymentIntent.status === 'succeeded' && invoice.status === 'paid';
+
+        if (!isAlreadyPaid) {
+          const tmp = slashAmount.add(new BN(invoice.amount_remaining));
+          if (tmp.lte(new BN(remainingStake))) {
+            slashAmount = tmp;
+            slashInvoices.push(invoice);
+          } else {
+            break;
+          }
+        } else {
           logger.info('PaymentIntent and Invoice already updated', {
             subscription: subscription.id,
             paymentIntent: paymentIntent.id,
             invoice: invoice.id,
           });
-          return;
         }
-        const tmp = slashAmount.add(new BN(invoice.amount_remaining));
-
-        if (tmp.lte(new BN(remainingStake))) {
-          slashAmount = tmp;
-          slashInvoices.push(invoice);
-          try {
-            const stakeEnough = await checkRemainingStake(
-              paymentMethod,
-              paymentCurrency,
+      }
+    }
+
+    const slashedInvoiceIds: string[] = [];
+    const processInvoice = async (invoice: Invoice): Promise<void> => {
+      const paymentIntent = await PaymentIntent.findByPk(invoice.payment_intent_id);
+      if (!paymentIntent || (paymentIntent.status === 'succeeded' && invoice.status === 'paid')) return;
+
+      try {
+        const stakeEnough = await checkRemainingStake(
+          paymentMethod,
+          paymentCurrency,
+          address,
+          invoice.amount_remaining
+        );
+        if (!stakeEnough.enough) {
+          throw new Error(`Stake slashing aborted because no enough staking for invoice: ${invoice.id}`);
+        }
+        // do the slash
+        const signed = await client.signSlashStakeTx({
+          tx: {
+            itx: {
               address,
-              invoice.amount_remaining
-            );
-            if (!stakeEnough.enough) {
-              throw new Error(`Stake slashing aborted because no enough staking for invoice: ${invoice.id}`);
-            }
-            // do the slash
-            const signed = await client.signSlashStakeTx({
-              tx: {
-                itx: {
-                  address,
-                  outputs: [
-                    {
-                      owner: wallet.address,
-                      tokens: [{ address: paymentCurrency.contract, value: invoice.amount_remaining }],
-                    },
-                  ],
-                  message: 'overdraft_exceeded',
-                  data: {
-                    typeUrl: 'json',
-                    // @ts-ignore
-                    value: {
-                      appId: wallet.address,
-                      reason: 'overdraft_exceeded',
-                      subscriptionId: subscription.id,
-                      invoiceId: invoice.id,
-                      paymentIntentId: paymentIntent.id,
-                    },
-                  },
+              outputs: [
+                {
+                  owner: wallet.address,
+                  tokens: [{ address: paymentCurrency.contract, value: invoice.amount_remaining }],
                 },
-              },
-              wallet,
-            });
-            // @ts-ignore
-            const { buffer } = await client.encodeSlashStakeTx({ tx: signed });
-            // @ts-ignore
-            const txHash = await client.sendSlashStakeTx({ tx: signed, wallet }, getGasPayerExtra(buffer));
-
-            await paymentIntent.update({
-              status: 'succeeded',
-              amount_received: invoice.amount_remaining,
-              capture_method: 'manual',
-              last_payment_error: null,
-              payment_details: {
-                arcblock: {
-                  tx_hash: txHash,
-                  payer:
-                    subscription.overdraft_protection?.payment_details?.arcblock?.payer ||
-                    getSubscriptionPaymentAddress(subscription, 'arcblock'),
-                  type: 'slash',
+              ],
+              message: 'overdraft_exceeded',
+              data: {
+                typeUrl: 'json',
+                // @ts-ignore
+                value: {
+                  appId: wallet.address,
+                  reason: 'overdraft_exceeded',
+                  subscriptionId: subscription.id,
+                  invoiceId: invoice.id,
+                  paymentIntentId: paymentIntent.id,
                 },
               },
-            });
-            logger.info('PaymentIntent updated after stake slash', {
-              subscription: subscription.id,
-              paymentIntent: paymentIntent.id,
-              status: 'succeeded',
-            });
-
-            await invoice.update({
-              status: 'paid',
-              paid: true,
-              amount_paid: invoice.amount_remaining,
-              amount_remaining: '0',
-              attempted: true,
-              attempt_count: invoice.attempt_count + 1,
-              status_transitions: { ...invoice.status_transitions, paid_at: dayjs().unix() },
-            });
-            logger.info('Invoice updated after stake slash', {
-              subscription: subscription.id,
-              invoice: invoice.id,
-              status: 'paid',
-            });
-          } catch (updateError) {
-            logger.error('stake slash failed', {
-              subscription: subscription.id,
-              invoice: invoice.id,
-              error: updateError,
-            });
-            throw updateError;
-          }
-        }
+            },
+          },
+          wallet,
+        });
+        // @ts-ignore
+        const { buffer } = await client.encodeSlashStakeTx({ tx: signed });
+        // @ts-ignore
+        const txHash = await client.sendSlashStakeTx({ tx: signed, wallet }, getGasPayerExtra(buffer));
+
+        await paymentIntent.update({
+          status: 'succeeded',
+          amount_received: invoice.amount_remaining,
+          capture_method: 'manual',
+          last_payment_error: null,
+          payment_details: {
+            arcblock: {
+              tx_hash: txHash,
+              payer:
+                subscription.overdraft_protection?.payment_details?.arcblock?.payer ||
+                getSubscriptionPaymentAddress(subscription, 'arcblock'),
+              type: 'slash',
+            },
+          },
+        });
+        logger.info('PaymentIntent updated after stake slash', {
+          subscription: subscription.id,
+          paymentIntent: paymentIntent.id,
+          status: 'succeeded',
+        });
+
+        await invoice.update({
+          status: 'paid',
+          paid: true,
+          amount_paid: invoice.amount_remaining,
+          amount_remaining: '0',
+          attempted: true,
+          attempt_count: invoice.attempt_count + 1,
+          status_transitions: { ...invoice.status_transitions, paid_at: dayjs().unix() },
+        });
+        logger.info('Invoice updated after stake slash', {
+          subscription: subscription.id,
+          invoice: invoice.id,
+          status: 'paid',
+        });
+        slashedInvoiceIds.push(invoice.id);
+      } catch (updateError) {
+        logger.error('stake slash failed', {
+          subscription: subscription.id,
+          invoice: invoice.id,
+          error: updateError,
+        });
+        throw updateError;
       }
-    });
+    };
 
-    await Promise.all(updatePromises);
-    logger.info(`${slashInvoices.length} invoices updated after stake slash`, {
+    await Promise.all(slashInvoices.map(processInvoice));
+    logger.info(`${slashedInvoiceIds.length} invoices updated after stake slash`, {
       subscription: subscription.id,
-      invoices: slashInvoices.map((x) => x.id),
+      invoices: slashedInvoiceIds,
       slashAmount: slashAmount.toString(),
     });
   } catch (error) {

package/api/src/queues/payment.ts

@@ -41,6 +41,7 @@ import { ensureOverdraftProtectionPrice } from '../libs/overdraft-protection';
 import createQueue from '../libs/queue';
 import { CHARGE_SUPPORTED_CHAIN_TYPES, EVM_CHAIN_TYPES } from '../libs/constants';
 import { getCheckoutSessionSubscriptionIds, getSubscriptionCreateSetup } from '../libs/session';
+import { syncStripeSubscriptionAfterRecovery } from '../integrations/stripe/handlers/subscription';
 
 type PaymentJob = {
   paymentIntentId: string;
@@ -246,6 +247,7 @@ export const handlePaymentSucceed = async (
                 cancelation_details: null,
               });
               logger.info(`Subscription ${subscription.id} recovered on payment done ${paymentIntent.id}: cancel rest`);
+              await syncStripeSubscriptionAfterRecovery(subscription, paymentIntent.id);
               return;
             }
             const subscriptionItems = await SubscriptionItem.findAll({ where: { subscription_id: subscription.id } });
@@ -267,11 +269,13 @@ export const handlePaymentSucceed = async (
             logger.info(
               `Subscription ${subscription.id} recovered on payment done ${paymentIntent.id}: cancel and billing cycle reset`
             );
+            await syncStripeSubscriptionAfterRecovery(subscription, paymentIntent.id);
           } else if (subscription.cancel_at_period_end) {
             // reset cancel_at_period_end if we are recovering from payment failed
             // @ts-ignore
             await subscription.update({ status: 'active', cancel_at_period_end: false, cancelation_details: null });
             logger.info(`Subscription ${subscription.id} recovered on payment done ${paymentIntent.id}: cancel reset`);
+            await syncStripeSubscriptionAfterRecovery(subscription, paymentIntent.id);
           } else {
             await subscription.update({ status: 'active' });
             logger.info(`Subscription ${subscription.id} recovered on payment done ${paymentIntent.id}`);

package/api/src/routes/checkout-sessions.ts

@@ -346,7 +346,9 @@ const SubscriptionDataSchema = Joi.object({
         color: Joi.string().valid('primary', 'secondary', 'success', 'error', 'warning').optional(),
         variant: Joi.string().valid('text', 'contained', 'outlined').optional(),
         text: Joi.object().required(),
-        link: Joi.string().uri().required(),
+        link: Joi.alternatives()
+          .try(Joi.string().uri(), Joi.string().pattern(/^\/[^\s]*$/))
+          .required(),
         type: Joi.string().valid('notification', 'custom').optional(),
         triggerEvents: Joi.array().items(Joi.string()).optional(),
       })

package/api/src/routes/subscriptions.ts

@@ -691,7 +691,9 @@ const updateSchema = Joi.object<{
         color: Joi.string().valid('primary', 'secondary', 'success', 'error', 'warning').optional(),
         variant: Joi.string().valid('text', 'contained', 'outlined').optional(),
         text: Joi.object().required(),
-        link: Joi.string().uri().required(),
+        link: Joi.alternatives()
+          .try(Joi.string().uri(), Joi.string().pattern(/^\/[^\s]*$/))
+          .required(),
         type: Joi.string().valid('notification', 'custom').optional(),
         triggerEvents: Joi.array().items(Joi.string()).optional(),
       })
@@ -1742,30 +1744,37 @@ router.get('/:id/cycle-amount', authPortal, async (req, res) => {
   if (!currency) {
     return res.status(404).json({ error: 'Currency not found' });
   }
-  // get upcoming invoice
-  const result = await getUpcomingInvoiceAmount(subscription.id);
-  // get past invoices
-  const pastMaxAmount = await getPastInvoicesAmount(subscription.id, 'max');
+  try {
+    // get upcoming invoice
+    const result = await getUpcomingInvoiceAmount(subscription.id);
+    // get past invoices
+    const pastMaxAmount = await getPastInvoicesAmount(subscription.id, 'max');
 
-  // return max amount
-  const nextAmount = new BN(result.amount === '0' ? result.minExpectedAmount : result.amount).toString();
+    // return max amount
+    const nextAmount = new BN(result.amount === '0' ? result.minExpectedAmount : result.amount).toString();
 
-  const maxAmount = new BN(pastMaxAmount.amount).lte(new BN(nextAmount)) ? nextAmount : pastMaxAmount.amount;
+    const maxAmount = new BN(pastMaxAmount.amount).lte(new BN(nextAmount)) ? nextAmount : pastMaxAmount.amount;
 
-  if (req.query?.overdraftProtection) {
-    const { price } = await ensureOverdraftProtectionPrice(subscription.livemode);
-    const invoicePrice = (price?.currency_options || []).find((x: any) => x.currency_id === subscription?.currency_id);
-    const gas = invoicePrice?.unit_amount;
+    if (req.query?.overdraftProtection) {
+      const { price } = await ensureOverdraftProtectionPrice(subscription.livemode);
+      const invoicePrice = (price?.currency_options || []).find(
+        (x: any) => x.currency_id === subscription?.currency_id
+      );
+      const gas = invoicePrice?.unit_amount;
+      return res.json({
+        amount: new BN(maxAmount).add(new BN(gas)).toString(),
+        gas,
+        currency,
+      });
+    }
     return res.json({
-      amount: new BN(maxAmount).add(new BN(gas)).toString(),
-      gas,
+      amount: maxAmount,
       currency,
     });
+  } catch (err) {
+    logger.error(err);
+    return res.status(400).json({ error: err.message });
   }
-  return res.json({
-    amount: maxAmount,
-    currency,
-  });
 });
 
 // slash stake

package/blocklet.yml

@@ -14,7 +14,7 @@ repository:
   type: git
   url: git+https://github.com/blocklet/payment-kit.git
 specVersion: 1.2.8
-version: 1.18.38
+version: 1.18.40
 logo: logo.png
 files:
   - dist

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "payment-kit",
-  "version": "1.18.38",
+  "version": "1.18.40",
   "scripts": {
     "dev": "blocklet dev --open",
     "eject": "vite eject",
@@ -45,30 +45,30 @@
   },
   "dependencies": {
     "@abtnode/cron": "^1.16.42",
-    "@arcblock/did": "^1.20.4",
+    "@arcblock/did": "^1.20.6",
     "@arcblock/did-auth-storage-nedb": "^1.7.1",
-    "@arcblock/did-connect": "^2.13.18",
-    "@arcblock/did-util": "^1.20.4",
-    "@arcblock/jwt": "^1.20.4",
-    "@arcblock/ux": "^2.13.18",
-    "@arcblock/validator": "^1.20.4",
-    "@blocklet/did-space-js": "^1.0.48",
+    "@arcblock/did-connect": "^2.13.24",
+    "@arcblock/did-util": "^1.20.6",
+    "@arcblock/jwt": "^1.20.6",
+    "@arcblock/ux": "^2.13.24",
+    "@arcblock/validator": "^1.20.6",
+    "@blocklet/did-space-js": "^1.0.51",
     "@blocklet/js-sdk": "^1.16.42",
     "@blocklet/logger": "^1.16.42",
-    "@blocklet/payment-react": "1.18.38",
+    "@blocklet/payment-react": "1.18.40",
     "@blocklet/sdk": "^1.16.42",
-    "@blocklet/ui-react": "^2.13.18",
-    "@blocklet/uploader": "^0.1.84",
-    "@blocklet/xss": "^0.1.33",
+    "@blocklet/ui-react": "^2.13.24",
+    "@blocklet/uploader": "^0.1.89",
+    "@blocklet/xss": "^0.1.34",
     "@mui/icons-material": "^5.16.6",
     "@mui/lab": "^5.0.0-alpha.173",
     "@mui/material": "^5.16.6",
     "@mui/system": "^5.16.6",
-    "@ocap/asset": "^1.20.4",
-    "@ocap/client": "^1.20.4",
-    "@ocap/mcrypto": "^1.20.4",
-    "@ocap/util": "^1.20.4",
-    "@ocap/wallet": "^1.20.4",
+    "@ocap/asset": "^1.20.6",
+    "@ocap/client": "^1.20.6",
+    "@ocap/mcrypto": "^1.20.6",
+    "@ocap/util": "^1.20.6",
+    "@ocap/wallet": "^1.20.6",
     "@stripe/react-stripe-js": "^2.7.3",
     "@stripe/stripe-js": "^2.4.0",
     "ahooks": "^3.8.0",
@@ -123,7 +123,7 @@
   "devDependencies": {
     "@abtnode/types": "^1.16.42",
     "@arcblock/eslint-config-ts": "^0.3.3",
-    "@blocklet/payment-types": "1.18.38",
+    "@blocklet/payment-types": "1.18.40",
     "@types/cookie-parser": "^1.4.7",
     "@types/cors": "^2.8.17",
     "@types/debug": "^4.1.12",
@@ -169,5 +169,5 @@
       "parser": "typescript"
     }
   },
-  "gitHead": "c273fb068cea55d95017c8b9672f30d5d6c60167"
+  "gitHead": "53abc664b88898a7cb9afa494f4ace333b1afe9c"
 }