mppx 0.17.1 → 0.17.3

package/dist/tempo/session/server/Sse.js

@@ -1,7 +1,58 @@
 import * as Constants from '../../../Constants.js';
 import * as Credential from '../../../Credential.js';
 import { createSessionReceipt, extractData, formatMessageEvent, formatNeedVoucherEvent, formatReceiptEvent, readSessionChallengeAmount, requireSessionCredentialContext, } from '../precompile/Protocol.js';
+import * as ChannelStore from './ChannelStore.js';
 import { meterIterable, } from './MeteredStream.js';
+/** Exposes durable retry information when no refund hook is configured or it fails. */
+export class PrepaidRefundError extends Error {
+    refund;
+    name = 'PrepaidRefundError';
+    constructor(refund) {
+        super('Prepaid stream delivery failed and requires merchant refund reconciliation.');
+        this.refund = refund;
+    }
+}
+/** Maximum retained automatic refund operations per channel. Never evict live retry keys. */
+export const maxPrepaidRefunds = 128;
+/**
+ * Persist a delivery obligation before returning a managed response. Failed hook deliveries remain
+ * in `channel.prepaidRefunds` for a merchant worker. Pending entries require manual delivery
+ * reconciliation; failed entries may retry the credit with their original terms within 24 hours.
+ * Acknowledging the hook means the merchant has durably accepted responsibility for the job.
+ */
+export async function preparePrepaidRefund(options) {
+    if (!options.autoCreditPrepaid || !options.prepaidUnits || options.tickCost === 0n)
+        return;
+    if (!options.refundIdempotencyKey)
+        throw new Error('Automatic refunds require a stable refundIdempotencyKey');
+    const key = options.refundIdempotencyKey;
+    const amount = (BigInt(options.prepaidUnits) * options.tickCost).toString();
+    await options.store.updateChannel(options.channelId, (current) => {
+        if (!current)
+            throw new Error('Cannot prepare prepaid refund: channel not found');
+        const existing = current.prepaidRefunds?.[key];
+        if (existing) {
+            if (existing.amount !== amount || existing.units !== options.prepaidUnits)
+                throw new Error('Prepaid refund key conflicts with an existing delivery');
+            return current;
+        }
+        const liveMarkers = Object.values(current.idempotencyMarkers ?? {}).filter((marker) => marker.expiresAt > Date.now()).length;
+        if (Object.keys(current.prepaidRefunds ?? {}).length + liveMarkers >= maxPrepaidRefunds)
+            throw new Error('Prepaid refund capacity reached; reconcile outstanding deliveries');
+        return {
+            ...current,
+            prepaidRefunds: {
+                ...current.prepaidRefunds,
+                [key]: {
+                    amount,
+                    units: options.prepaidUnits,
+                    status: 'pending',
+                    createdAt: Date.now(),
+                },
+            },
+        };
+    });
+}
 /**
  * SSE (Server-Sent Events) utilities for metered streaming payments.
  *
@@ -30,6 +81,9 @@ export { extractData, formatMessageEvent, formatNeedVoucherEvent, formatReceiptE
  *    `stream.charge()` resolves, retaining them on cancellation or failure.
  * 5. On generator completion, emits a final `event: payment-receipt`.
  *
+ * With `autoCreditPrepaid`, a failure before a prepaid item is enqueued attempts an idempotent credit.
+ * If credit is declined or uncertain, `onRefundRequired` handles merchant reconciliation.
+ *
  * Returns a `ReadableStream<Uint8Array>` suitable for use as an HTTP response body.
  */
 export function serve(options) {
@@ -38,11 +92,100 @@ export function serve(options) {
     const abortController = new AbortController();
     let streamController;
     let terminal = false;
+    let preparation = Promise.resolve();
+    let termination;
+    let committedPrepaidAwaitingDelivery = 0;
+    let undeliveredPrepaidUnits = options.prepaidUnits ?? 0;
+    if (!Number.isSafeInteger(undeliveredPrepaidUnits) || undeliveredPrepaidUnits < 0)
+        throw new Error('prepaidUnits must be a non-negative safe integer');
+    const refundIdempotencyKey = options.refundIdempotencyKey ?? `stream:${globalThis.crypto.randomUUID()}`;
+    ChannelStore.assertIdempotencyOptions({ idempotencyKey: refundIdempotencyKey });
+    const refundOptions = { ...options, refundIdempotencyKey };
+    const clearObligation = async () => {
+        if (!options.autoCreditPrepaid)
+            return;
+        await store.updateChannel(channelId, (current) => {
+            if (!current?.prepaidRefunds?.[refundIdempotencyKey])
+                return current;
+            const prepaidRefunds = { ...current.prepaidRefunds };
+            delete prepaidRefunds[refundIdempotencyKey];
+            return { ...current, prepaidRefunds };
+        });
+    };
+    const creditFailedDelivery = async () => {
+        if (!options.autoCreditPrepaid)
+            return;
+        if (undeliveredPrepaidUnits === 0 || tickCost === 0n) {
+            await clearObligation();
+            return;
+        }
+        const recordFailure = await store
+            .updateChannel(channelId, (current) => {
+            if (!current?.prepaidRefunds?.[refundIdempotencyKey])
+                throw new Error('Prepaid refund obligation missing');
+            return {
+                ...current,
+                prepaidRefunds: {
+                    ...current.prepaidRefunds,
+                    [refundIdempotencyKey]: {
+                        ...current.prepaidRefunds[refundIdempotencyKey],
+                        status: 'failed',
+                        amount: (BigInt(undeliveredPrepaidUnits) * tickCost).toString(),
+                        units: undeliveredPrepaidUnits,
+                    },
+                },
+            };
+        })
+            .then(() => undefined, (error) => ({ error }));
+        const amount = BigInt(undeliveredPrepaidUnits) * tickCost;
+        const result = recordFailure
+            ? { status: 'failed', error: recordFailure.error }
+            : await ChannelStore.creditChannel(store, channelId, amount, {
+                idempotencyKey: refundIdempotencyKey,
+                units: undeliveredPrepaidUnits,
+                maxMarkers: maxPrepaidRefunds,
+            }).catch((error) => ({ status: 'failed', error }));
+        if (result.status === 'credited') {
+            await clearObligation();
+            return;
+        }
+        let externalRefundAmount = null;
+        if (result.status === 'declined' && result.reason === 'finalized') {
+            const captured = result.channel.settledOnChain - (result.channel.spent - amount);
+            externalRefundAmount = captured < 0n ? 0n : captured > amount ? amount : captured;
+            if (externalRefundAmount === 0n) {
+                await clearObligation();
+                return;
+            }
+        }
+        const refund = {
+            channelId,
+            amount,
+            externalRefundAmount,
+            units: undeliveredPrepaidUnits,
+            idempotencyKey: refundIdempotencyKey,
+            credit: result,
+        };
+        if (!options.onRefundRequired)
+            throw new PrepaidRefundError(refund);
+        try {
+            await options.onRefundRequired(refund);
+            await clearObligation();
+        }
+        catch {
+            throw new PrepaidRefundError(refund);
+        }
+    };
     const iterator = meterIterable({
         store,
         channelId,
         tickCost,
         generate,
+        chargeOnce: options.chargeOnce,
+        onPrepaidChargeCommitted() {
+            undeliveredPrepaidUnits = Math.max(0, undeliveredPrepaidUnits - 1);
+            committedPrepaidAwaitingDelivery += 1;
+        },
         beforeCharge: options.beforeCharge,
         onChargeCommitted: options.onChargeCommitted,
         pollIntervalMs,
@@ -54,23 +197,33 @@ export function serve(options) {
     const cleanup = () => signal?.removeEventListener('abort', abort);
     const terminate = (reason) => {
         if (terminal)
-            return;
+            return termination;
         terminal = true;
         abortController.abort(reason);
         cleanup();
         void Promise.resolve()
             .then(() => iterator.return?.(undefined))
             .catch(() => { });
-        try {
-            streamController?.close();
-        }
-        catch { }
+        termination = preparation
+            .catch(() => { })
+            .then(clearObligation)
+            .finally(() => {
+            try {
+                streamController?.close();
+            }
+            catch { }
+        });
+        return termination;
+    };
+    const abort = () => {
+        void terminate(signal?.reason)?.catch(() => { });
     };
-    const abort = () => terminate(signal?.reason);
     signal?.addEventListener('abort', abort, { once: true });
     return new ReadableStream({
-        start(controller) {
+        async start(controller) {
             streamController = controller;
+            preparation = preparePrepaidRefund(refundOptions);
+            await preparation;
             if (signal?.aborted)
                 abort();
         },
@@ -86,8 +239,13 @@ export function serve(options) {
                         return;
                     const value = next.value;
                     controller.enqueue(encoder.encode(formatMessageEvent(value)));
+                    if (committedPrepaidAwaitingDelivery > 0)
+                        committedPrepaidAwaitingDelivery -= 1;
+                    else
+                        undeliveredPrepaidUnits = Math.max(0, undeliveredPrepaidUnits - 1);
                     return;
                 }
+                await clearObligation();
                 if (!abortController.signal.aborted) {
                     const channel = await store.getChannel(channelId);
                     if (channel) {
@@ -114,14 +272,21 @@ export function serve(options) {
                     return;
                 terminal = true;
                 cleanup();
-                if (!abortController.signal.aborted)
-                    controller.error(e);
+                if (!abortController.signal.aborted) {
+                    try {
+                        await creditFailedDelivery();
+                        controller.error(e);
+                    }
+                    catch (refundError) {
+                        controller.error(new AggregateError([e, refundError], 'Stream delivery and prepaid refund failed.'));
+                    }
+                }
                 else
                     controller.close();
             }
         },
         cancel(reason) {
-            terminate(reason);
+            return terminate(reason);
         },
     });
 }

package/dist/zod.d.ts

@@ -1,4 +1,5 @@
-import { type ZodMiniType, z } from 'zod/mini';
+import type { ZodMiniType } from 'zod/mini';
+import * as z from 'zod/mini';
 export * from 'zod/mini';
 export type DatetimeInput = string | Date;
 /** Numeric string amount (e.g., "1", "1.5", "1000000"). */

package/dist/zod.js

@@ -1,4 +1,4 @@
-import { z } from 'zod/mini';
+import * as z from 'zod/mini';
 export * from 'zod/mini';
 /** Numeric string amount (e.g., "1", "1.5", "1000000"). */
 export function amount() {

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "mppx",
   "type": "module",
-  "version": "0.17.1",
+  "version": "0.17.3",
   "main": "./dist/index.js",
   "license": "MIT",
   "homepage": "https://github.com/wevm/mppx#readme",
@@ -206,8 +206,6 @@
     }
   },
   "dependencies": {
-    "@stripe/stripe-js": "9.17.0",
-    "eventsource-parser": "4.1.1",
     "ox": "0.14.45",
     "structured-headers": "2.1.0",
     "zod": "^4.6.7"

package/dist/stripe/server/internal/html/types.d.ts

@@ -1,2 +0,0 @@
-export type { CreatePaymentMethodFromElements, StripeElementsOptionsMode, StripePaymentElementOptions, } from '@stripe/stripe-js';
-//# sourceMappingURL=types.d.ts.map

package/dist/stripe/server/internal/html/types.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=types.js.map