mppx 0.8.15 → 0.8.18

package/dist/tempo/server/Methods.d.ts

@@ -1,31 +1,26 @@
-import { session as sessionLegacy_, settle as settleLegacy_ } from '../legacy/server/index.js';
 import { charge as sessionCharge_, session as session_, settle as settle_, settleBatch as settleBatch_ } from '../session/server/Session.js';
 import type { SessionController as SessionController_ } from '../session/server/Sse.js';
 import * as Ws_ from '../session/server/Ws.js';
 import { charge as charge_ } from './Charge.js';
 import type * as Relay_ from './Relay.js';
 import { renew as renewSubscription_, subscription as subscription_ } from './Subscription.js';
-declare function createSessionLegacyMethod<const parameters extends NonNullable<Parameters<typeof sessionLegacy_>[0]>>(parameters?: parameters): never;
-/** Creates a legacy contract-backed Tempo `session` server method. */
-export declare const sessionLegacy: typeof createSessionLegacyMethod & {
-    settle: typeof settleLegacy_;
-    Ws: typeof Ws_;
-};
-/** Settles a legacy contract-backed Tempo session channel. */
-export declare const settleLegacy: typeof settleLegacy_;
 /**
  * Creates the common Tempo `charge` and `session` methods from shared parameters.
  *
- * When configured, `relay` applies to the `charge` method. Session vouchers
- * remain local state transitions and session relay delegation will be added
- * with its action-specific lifecycle support.
+ * `machineTokenEnabled` lets compatible clients fund either method with the
+ * first-party machine token while the merchant continues to request its payout
+ * currency and recipient normally.
  *
  * @example
  * ```ts
  * import { Mppx, tempo } from 'mppx/server'
  *
  * const mppx = Mppx.create({
- *   methods: [tempo.common({ currency: '0x...', recipient: '0x...' })],
+ *   methods: tempo({
+ *     currency: '0x...',
+ *     machineTokenEnabled: true,
+ *     recipient: '0x...',
+ *   }),
  * })
  * ```
  */
@@ -33,8 +28,8 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
     readonly name: "tempo";
     readonly intent: "charge";
     readonly schema: {
-        readonly credential: {
-            readonly payload: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
+        credential: {
+            payload: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
                 hash: import("zod/mini").ZodMiniString<string>;
                 type: import("zod/mini").ZodMiniLiteral<"hash">;
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
@@ -45,7 +40,8 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                 type: import("zod/mini").ZodMiniLiteral<"proof">;
             }, import("zod/v4/core").$strip>], "type">;
         };
-        readonly request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
+        request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
+            machineTokenEnabled: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniBoolean<boolean>>;
             amount: import("zod/mini").ZodMiniString<string>;
             chainId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
             currency: import("zod/mini").ZodMiniString<string>;
@@ -61,31 +57,33 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                 recipient: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<`0x${string}`, string>>;
             }, import("zod/v4/core").$strip>>>;
             supportedModes: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniArray<import("zod/mini").ZodMiniEnum<{
-                push: "push";
                 pull: "pull";
+                push: "push";
             }>>>;
         }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
+            currency: string;
+            description?: string | undefined;
+            externalId?: string | undefined;
+            recipient?: string | undefined;
+            amount: string;
             methodDetails?: {
-                supportedModes?: ("push" | "pull")[] | undefined;
+                machineTokenEnabled?: boolean | undefined;
+                chainId?: number | undefined;
+                feePayer?: boolean | undefined;
+                memo?: string | undefined;
                 splits?: {
-                    amount: string;
-                    recipient: `0x${string}`;
                     memo?: string | undefined;
+                    recipient: `0x${string}`;
+                    amount: string;
                 }[] | undefined;
-                memo?: string | undefined;
-                feePayer?: boolean | undefined;
-                chainId?: number | undefined;
+                supportedModes?: ("pull" | "push")[] | undefined;
             } | undefined;
-            amount: string;
-            currency: string;
-            description?: string | undefined;
-            externalId?: string | undefined;
-            recipient?: string | undefined;
         }, {
+            machineTokenEnabled?: boolean | undefined;
             amount: string;
+            chainId?: number | undefined;
             currency: string;
             decimals: number;
-            chainId?: number | undefined;
             description?: string | undefined;
             externalId?: string | undefined;
             feePayer?: boolean | undefined;
@@ -93,19 +91,20 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
             recipient?: string | undefined;
             splits?: {
                 amount: string;
-                recipient: `0x${string}`;
                 memo?: string | undefined;
+                recipient: `0x${string}`;
             }[] | undefined;
-            supportedModes?: ("push" | "pull")[] | undefined;
+            supportedModes?: ("pull" | "push")[] | undefined;
         }>>;
     };
 }, charge_.DeriveDefaults<parameters>, undefined, {}, string | undefined>, import("../../Method.js").Server<{
     readonly name: "tempo";
     readonly intent: "session";
     readonly schema: {
-        readonly credential: {
-            readonly payload: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
+        credential: {
+            payload: import("zod/mini").ZodMiniDiscriminatedUnion<[import("zod/mini").ZodMiniObject<{
                 action: import("zod/mini").ZodMiniLiteral<"open">;
+                authorizationSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 authorizedSigner: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 channelId: import("zod/mini").ZodMiniString<string>;
                 cumulativeAmount: import("zod/mini").ZodMiniString<string>;
@@ -122,19 +121,22 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
                 type: import("zod/mini").ZodMiniLiteral<"transaction">;
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 action: import("zod/mini").ZodMiniLiteral<"voucher">;
+                authorizationSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 channelId: import("zod/mini").ZodMiniString<string>;
                 cumulativeAmount: import("zod/mini").ZodMiniString<string>;
                 descriptor: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<import("../session/precompile/Protocol.js").ChannelDescriptor, import("../session/precompile/Protocol.js").ChannelDescriptor>>;
                 signature: import("zod/mini").ZodMiniString<string>;
             }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniObject<{
                 action: import("zod/mini").ZodMiniLiteral<"close">;
+                authorizationSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 channelId: import("zod/mini").ZodMiniString<string>;
                 cumulativeAmount: import("zod/mini").ZodMiniString<string>;
                 descriptor: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniCustom<import("../session/precompile/Protocol.js").ChannelDescriptor, import("../session/precompile/Protocol.js").ChannelDescriptor>>;
+                refundSignature: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
                 signature: import("zod/mini").ZodMiniString<string>;
             }, import("zod/v4/core").$strip>], "action">;
         };
-        readonly request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
+        request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
             amount: import("zod/mini").ZodMiniString<string>;
             chainId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniNumber<number>>;
             channelId: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
@@ -142,6 +144,8 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
             decimals: import("zod/mini").ZodMiniNumber<number>;
             escrowContract: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             feePayer: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniBoolean<boolean>, import("zod/mini").ZodMiniCustom<import("viem").Account, import("viem").Account>]>, import("zod/mini").ZodMiniTransform<boolean, boolean | import("viem").Account>>>;
+            feeToken: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
+            machineTokenEnabled: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniBoolean<boolean>>;
             minVoucherDelta: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             operator: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             recipient: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
@@ -153,39 +157,43 @@ export declare function tempo<const parameters extends tempo.Parameters>(paramet
             suggestedDeposit: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniString<string>>;
             unitType: import("zod/mini").ZodMiniString<string>;
         }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
+            currency: string;
+            recipient?: string | undefined;
+            unitType: string;
+            amount: string;
+            suggestedDeposit?: string | undefined;
             methodDetails: {
-                sessionSnapshot?: import("../session/Snapshot.js").SessionSnapshot | undefined;
-                sessionProtocol?: "v1" | "v2" | undefined;
-                operator?: string | undefined;
-                feePayer?: boolean | undefined;
-                chainId?: number | undefined;
-                minVoucherDelta?: string | undefined;
-                channelId?: string | undefined;
                 escrowContract: string | undefined;
+                channelId?: string | undefined;
+                minVoucherDelta?: string | undefined;
+                chainId?: number | undefined;
+                feePayer?: boolean | undefined;
+                feeToken?: string | undefined;
+                machineTokenEnabled?: boolean | undefined;
+                operator?: string | undefined;
+                sessionProtocol?: "v1" | "v2" | undefined;
+                sessionSnapshot?: import("../session/Snapshot.js").SessionSnapshot | undefined;
             };
-            suggestedDeposit?: string | undefined;
-            amount: string;
-            currency: string;
-            unitType: string;
-            recipient?: string | undefined;
         }, {
             amount: string;
-            currency: string;
-            decimals: number;
-            unitType: string;
             chainId?: number | undefined;
             channelId?: string | undefined;
+            currency: string;
+            decimals: number;
             escrowContract?: string | undefined;
             feePayer?: boolean | undefined;
+            feeToken?: string | undefined;
+            machineTokenEnabled?: boolean | undefined;
             minVoucherDelta?: string | undefined;
             operator?: string | undefined;
             recipient?: string | undefined;
             sessionProtocol?: "v1" | "v2" | undefined;
             sessionSnapshot?: import("../session/Snapshot.js").SessionSnapshot | undefined;
             suggestedDeposit?: string | undefined;
+            unitType: string;
         }>>;
     };
-}, session_.DeriveDefaults<parameters>, parameters["sse"] extends false | undefined ? undefined : import("./internal/transport.js").Sse, {}, undefined>];
+}, session_.DeriveDefaults<parameters>, parameters["sse"] extends false | undefined ? undefined : import("./internal/transport.js").Sse, session_.Extensions, undefined>];
 export declare namespace tempo {
     type Parameters = charge_.Parameters & session_.Parameters;
     /** Tempo API relay configuration for server-side charges. */
@@ -204,11 +212,6 @@ export declare namespace tempo {
         settle: typeof settle_;
         settleBatch: typeof settleBatch_;
     };
-    /** @deprecated Use `tempo.session()` for the TIP-1034 session server method. */
-    const sessionLegacy: typeof createSessionLegacyMethod & {
-        settle: typeof settleLegacy_;
-        Ws: typeof Ws_;
-    };
     /** Creates a Tempo `subscription` method for recurring TIP-20 token payments. */
     const subscription: typeof subscription_;
     /** Renews an overdue Tempo subscription outside of the HTTP request path. */
@@ -225,5 +228,4 @@ export declare namespace tempo {
     /** Experimental websocket helpers for Tempo sessions. */
     const Ws: typeof Ws_;
 }
-export {};
 //# sourceMappingURL=Methods.d.ts.map

package/dist/tempo/server/Methods.js

@@ -1,4 +1,3 @@
-import { session as sessionLegacy_, settle as settleLegacy_ } from '../legacy/server/index.js';
 import { charge as sessionCharge_, session as session_, settle as settle_, settleBatch as settleBatch_, } from '../session/server/Session.js';
 import * as Ws_ from '../session/server/Ws.js';
 import { charge as charge_ } from './Charge.js';
@@ -8,17 +7,6 @@ const sessionServer = Object.assign(session_, {
     settle: settle_,
     settleBatch: settleBatch_,
 });
-function createSessionLegacyMethod(parameters) {
-    return Object.assign(sessionLegacy_(parameters), { alias: 'sessionLegacy' });
-}
-const sessionLegacyServer = Object.assign(createSessionLegacyMethod, {
-    settle: settleLegacy_,
-    Ws: Ws_,
-});
-/** Creates a legacy contract-backed Tempo `session` server method. */
-export const sessionLegacy = sessionLegacyServer;
-/** Settles a legacy contract-backed Tempo session channel. */
-export const settleLegacy = settleLegacy_;
 function createChargeMethod(parameters) {
     // `tempo()` accepts the intersection of charge/session parameters, then
     // forwards only the fields each method understands. Preserve the inferred
@@ -32,16 +20,20 @@ function createSessionMethod(parameters) {
 /**
  * Creates the common Tempo `charge` and `session` methods from shared parameters.
  *
- * When configured, `relay` applies to the `charge` method. Session vouchers
- * remain local state transitions and session relay delegation will be added
- * with its action-specific lifecycle support.
+ * `machineTokenEnabled` lets compatible clients fund either method with the
+ * first-party machine token while the merchant continues to request its payout
+ * currency and recipient normally.
  *
  * @example
  * ```ts
  * import { Mppx, tempo } from 'mppx/server'
  *
  * const mppx = Mppx.create({
- *   methods: [tempo.common({ currency: '0x...', recipient: '0x...' })],
+ *   methods: tempo({
+ *     currency: '0x...',
+ *     machineTokenEnabled: true,
+ *     recipient: '0x...',
+ *   }),
  * })
  * ```
  */
@@ -55,8 +47,6 @@ export function tempo(parameters) {
     tempo.common = tempo;
     /** Creates a TIP-1034 Tempo `session` method for session-based TIP-20 token payments. */
     tempo.session = sessionServer;
-    /** @deprecated Use `tempo.session()` for the TIP-1034 session server method. */
-    tempo.sessionLegacy = sessionLegacyServer;
     /** Creates a Tempo `subscription` method for recurring TIP-20 token payments. */
     tempo.subscription = subscription_;
     /** Renews an overdue Tempo subscription outside of the HTTP request path. */

package/dist/tempo/server/Relay.d.ts

@@ -1,5 +1,5 @@
 import type * as Method from '../../Method.js';
-declare const relayErrorCode: readonly ["already_used", "broadcast_failed", "expired", "invalid_payment", "insufficient_funds", "policy_denied", "screen_rejected", "simulation_failed", "temporarily_unavailable", "unsupported", "unknown"];
+declare const relayErrorCode: readonly ['already_used', 'broadcast_failed', 'expired', 'invalid_payment', 'insufficient_funds', 'policy_denied', 'screen_rejected', 'simulation_failed', 'temporarily_unavailable', 'unsupported', 'unknown'];
 type RelayErrorCode = (typeof relayErrorCode)[number];
 /**
  * Configures a Tempo payment method to use Tempo API's MPP relay.

package/dist/tempo/server/Relay.js

@@ -125,10 +125,10 @@ function idempotencyKey(input) {
         typeof payload.signature === 'string' &&
         Hex.validate(payload.signature)) {
         const transactionHash = Hash.keccak256(Hex.toBytes(payload.signature), { as: 'Hex' });
-        return `mppx_${transactionHash}`;
+        return `mpp_${transactionHash}`;
     }
     const hash = Hash.sha256(Bytes.fromString(Json.canonicalize(input)), { as: 'Hex' });
-    return `mppx_${hash}`;
+    return `mpp_${hash}`;
 }
 function failure(value) {
     const code = relayErrorCodeFrom(value);

package/dist/tempo/server/Subscription.d.ts

@@ -18,19 +18,19 @@ export declare function subscription<const parameters extends subscription.Param
     readonly name: "tempo";
     readonly intent: "subscription";
     readonly schema: {
-        readonly credential: {
-            readonly payload: import("zod/mini").ZodMiniObject<{
+        credential: {
+            payload: import("zod/mini").ZodMiniObject<{
                 signature: import("zod/mini").ZodMiniString<string>;
                 type: import("zod/mini").ZodMiniLiteral<"keyAuthorization">;
             }, import("zod/v4/core").$strip>;
         };
-        readonly request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
+        request: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniObject<{
             amount: import("zod/mini").ZodMiniString<string>;
             accessKey: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniObject<{
                 accessKeyAddress: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<`0x${string}`, string>>;
                 keyType: import("zod/mini").ZodMiniEnum<{
-                    secp256k1: "secp256k1";
                     p256: "p256";
+                    secp256k1: "secp256k1";
                     webAuthn: "webAuthn";
                 }>;
             }, import("zod/v4/core").$strip>>;
@@ -43,8 +43,8 @@ export declare function subscription<const parameters extends subscription.Param
                 accessKey: import("zod/mini").ZodMiniOptional<import("zod/mini").ZodMiniObject<{
                     accessKeyAddress: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<`0x${string}`, string>>;
                     keyType: import("zod/mini").ZodMiniEnum<{
-                        secp256k1: "secp256k1";
                         p256: "p256";
+                        secp256k1: "secp256k1";
                         webAuthn: "webAuthn";
                     }>;
                 }, import("zod/v4/core").$strip>>;
@@ -52,54 +52,54 @@ export declare function subscription<const parameters extends subscription.Param
             }, import("zod/v4/core").$strip>>;
             periodCount: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniBigInt<bigint>, import("zod/mini").ZodMiniCustom<number, number>]>, import("zod/mini").ZodMiniTransform<string, string | number | bigint>>;
             periodUnit: import("zod/mini").ZodMiniEnum<{
-                dev_second: "dev_second";
                 day: "day";
+                dev_second: "dev_second";
                 week: "week";
             }>;
             recipient: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<`0x${string}`, string>>;
             subscriptionExpires: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniUnion<readonly [import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniCustom<Date, Date>]>, import("zod/mini").ZodMiniTransform<Date, import("../../zod.js").DatetimeInput>>;
         }, import("zod/v4/core").$strip>, import("zod/mini").ZodMiniTransform<{
+            currency: `0x${string}`;
+            description?: string | undefined;
+            externalId?: string | undefined;
+            periodCount: string;
+            periodUnit: "day" | "dev_second" | "week";
+            recipient: `0x${string}`;
+            amount: string;
+            subscriptionExpires: string;
             methodDetails?: {
-                accessKey?: import("zod").infer<import("zod/mini").ZodMiniObject<{
+                accessKey?: import("zod").output<import("zod/mini").ZodMiniObject<{
                     accessKeyAddress: import("zod/mini").ZodMiniPipe<import("zod/mini").ZodMiniString<string>, import("zod/mini").ZodMiniTransform<`0x${string}`, string>>;
                     keyType: import("zod/mini").ZodMiniEnum<{
-                        secp256k1: "secp256k1";
                         p256: "p256";
+                        secp256k1: "secp256k1";
                         webAuthn: "webAuthn";
                     }>;
                 }, import("zod/v4/core").$strip>> | undefined;
                 chainId?: number | undefined;
             } | undefined;
-            amount: string;
-            subscriptionExpires: string;
-            currency: `0x${string}`;
-            periodCount: string;
-            periodUnit: "dev_second" | "day" | "week";
-            recipient: `0x${string}`;
-            description?: string | undefined;
-            externalId?: string | undefined;
         }, {
             amount: string;
-            currency: `0x${string}`;
-            decimals: number;
-            periodCount: string;
-            periodUnit: "dev_second" | "day" | "week";
-            recipient: `0x${string}`;
-            subscriptionExpires: Date;
             accessKey?: {
                 accessKeyAddress: `0x${string}`;
-                keyType: "secp256k1" | "p256" | "webAuthn";
+                keyType: "p256" | "secp256k1" | "webAuthn";
             } | undefined;
             chainId?: number | undefined;
+            currency: `0x${string}`;
+            decimals: number;
             description?: string | undefined;
             externalId?: string | undefined;
             methodDetails?: {
                 accessKey?: {
                     accessKeyAddress: `0x${string}`;
-                    keyType: "secp256k1" | "p256" | "webAuthn";
+                    keyType: "p256" | "secp256k1" | "webAuthn";
                 } | undefined;
                 chainId?: number | undefined;
             } | undefined;
+            periodCount: string;
+            periodUnit: "day" | "dev_second" | "week";
+            recipient: `0x${string}`;
+            subscriptionExpires: Date;
         }>>;
     };
 }, subscription.DeriveDefaults<parameters>, undefined, subscription.Extensions, undefined>;
@@ -250,7 +250,7 @@ export declare namespace subscription {
         storeKeyPrefix?: string | undefined;
         testnet?: boolean | undefined;
         waitForConfirmation?: boolean | undefined;
-    } & Defaults;
+    } & Defaults & Method.ComposableHooks<typeof Methods.subscription>;
     /** Derived defaults after account and chain configuration are applied. */
     type DeriveDefaults<parameters extends Parameters> = types.DeriveDefaults<parameters, Defaults, {
         currency: string;

package/dist/tempo/server/Subscription.js

@@ -40,6 +40,8 @@ export function subscription(p) {
     });
     const { feePayer, feePayerPolicy, getClient, store, waitForConfirmation } = context;
     const method = Method.toServer(Methods.subscription, {
+        canOffer: parameters.canOffer,
+        onPaymentSuccess: parameters.onPaymentSuccess,
         defaults: {
             amount,
             currency,

package/dist/tempo/server/index.d.ts

@@ -2,7 +2,7 @@ export * as ChannelStore from '../session/server/ChannelStore.js';
 export * as Sse from '../session/server/Sse.js';
 export * as Ws from '../session/server/Ws.js';
 export { charge } from './Charge.js';
-export { sessionLegacy, settleLegacy, tempo } from './Methods.js';
+export { tempo } from './Methods.js';
 export { session, settle, settleBatch } from '../session/server/Session.js';
 export type { OnSessionSettlement, SessionSettlementContext, SettlementSchedule, } from '../session/server/Session.js';
 export { renew as renewSubscription, subscription } from './Subscription.js';

package/dist/tempo/server/index.js

@@ -2,7 +2,7 @@ export * as ChannelStore from '../session/server/ChannelStore.js';
 export * as Sse from '../session/server/Sse.js';
 export * as Ws from '../session/server/Ws.js';
 export { charge } from './Charge.js';
-export { sessionLegacy, settleLegacy, tempo } from './Methods.js';
+export { tempo } from './Methods.js';
 export { session, settle, settleBatch } from '../session/server/Session.js';
 export { renew as renewSubscription, subscription } from './Subscription.js';
 //# sourceMappingURL=index.js.map