mppx 0.6.31 → 0.7.0

package/src/tempo/{session → legacy/session}/Chain.test.ts

@@ -10,7 +10,7 @@ import {
 import { prepareTransactionRequest, signTransaction, waitForTransactionReceipt } from 'viem/actions'
 import { Addresses, Transaction } from 'viem/tempo'
 import { beforeAll, describe, expect, test } from 'vp/test'
-import { nodeEnv } from '~test/config.js'
+import { tempoNetwork } from '~test/config.js'
 import {
   closeChannelOnChain,
   deployEscrow,
@@ -18,7 +18,7 @@ import {
   signOpenChannel,
   signTopUpChannel,
   topUpChannel,
-} from '~test/tempo/session.js'
+} from '~test/tempo/legacy/session.js'
 import { accounts, asset, chain, client, fundAccount } from '~test/tempo/viem.js'
 
 import {
@@ -33,9 +33,8 @@ import {
 import * as Channel from './Channel.js'
 import { signVoucher } from './Voucher.js'
 
-const isLocalnet = nodeEnv === 'localnet'
-
 const UINT128_MAX = 2n ** 128n - 1n
+const isLocalnet = tempoNetwork === 'localnet'
 
 describe('assertUint128 (via settleOnChain / closeOnChain)', () => {
   const mockClient = { chain: { id: 42431 } } as any

package/src/tempo/{session → legacy/session}/Chain.ts

@@ -20,23 +20,28 @@ import {
 } from 'viem/actions'
 import { Transaction } from 'viem/tempo'
 
-import { BadRequestError, ChannelClosedError, VerificationFailedError } from '../../Errors.js'
-import * as TempoAddress from '../internal/address.js'
-import * as defaults from '../internal/defaults.js'
-import * as FeePayer from '../internal/fee-payer.js'
-import { resolveFeeToken } from '../internal/fee-token.js'
+import { BadRequestError, ChannelClosedError, VerificationFailedError } from '../../../Errors.js'
+import * as TempoAddress from '../../internal/address.js'
+import * as defaults from '../../internal/defaults.js'
+import * as FeePayer from '../../internal/fee-payer.js'
+import { resolveFeeToken } from '../../internal/fee-token.js'
 import * as Channel from './Channel.js'
 import { escrowAbi } from './escrow.abi.js'
-import type { SignedVoucher } from './Types.js'
+import type { LegacySignedVoucher } from './Types.js'
 
 export { escrowAbi }
 
+type SenderSignedTransaction = {
+  from?: Address | undefined
+  signature?: unknown
+}
+
 /**
  * Asserts that a deserialized transaction has an existing sender signature —
  * required before fee payer co-signing to prevent the fee payer from becoming
  * the sender.
  */
-function assertSenderSigned(transaction: any): void {
+function assertSenderSigned(transaction: SenderSignedTransaction): void {
   if (!transaction.signature || !transaction.from)
     throw new BadRequestError({
       reason: 'Transaction must be signed by the sender before fee payer co-signing',
@@ -109,7 +114,7 @@ export type SettleOptions =
 export async function settleOnChain(
   client: Client,
   escrowContract: Address,
-  voucher: SignedVoucher,
+  voucher: LegacySignedVoucher,
   options?: SettleOptions,
 ): Promise<Hex> {
   assertUint128(voucher.cumulativeAmount)
@@ -160,7 +165,7 @@ export type CloseOptions =
 export async function closeOnChain(
   client: Client,
   escrowContract: Address,
-  voucher: SignedVoucher,
+  voucher: LegacySignedVoucher,
   options?: CloseOptions,
 ): Promise<Hex> {
   assertUint128(voucher.cumulativeAmount)
@@ -298,11 +303,75 @@ const erc20ApproveSelector = /*#__PURE__*/ toFunctionSelector(
   'function approve(address spender, uint256 amount)',
 )
 
+/** Result returned after a legacy open transaction is broadcast or recovered from on-chain state. */
 export type BroadcastResult = {
   txHash: Hex | undefined
   onChain: OnChainChannel
 }
 
+/** Inputs for validating an ERC-20 approve call inside a fee-sponsored legacy channel transaction. */
+type SponsoredApproveCallParameters = {
+  action: 'open' | 'topUp'
+  call: TempoCall
+  currency: Address
+  escrowContract: Address
+  expectedAmount: bigint
+}
+
+/** Inputs for extracting the escrow open call from a fee-sponsored legacy channel transaction. */
+type SponsoredOpenCallsParameters = {
+  calls: readonly TempoCall[]
+  currency: Address
+  deposit: bigint
+  escrowContract: Address
+}
+
+/** Inputs for extracting the escrow top-up call from a fee-sponsored legacy channel transaction. */
+type SponsoredTopUpCallsParameters = {
+  calls: readonly TempoCall[]
+  currency: Address
+  escrowContract: Address
+  topUpAmount: bigint
+}
+
+/** Inputs for broadcasting and validating a legacy contract-backed open transaction. */
+export type BroadcastOpenTransactionParameters = {
+  beforeBroadcast?: ((onChain: OnChainChannel) => Promise<void> | void) | undefined
+  challengeExpires?: string | undefined
+  channelId: Hex
+  client: Client
+  currency: Address
+  escrowContract: Address
+  feePayer?: Account | undefined
+  feePayerPolicy?: Partial<FeePayer.Policy> | undefined
+  isSponsored?: boolean | undefined
+  recipient: Address
+  serializedTransaction: Hex
+  /** When false, simulates instead of waiting for confirmation and returns derived on-chain state. @default true */
+  waitForConfirmation?: boolean | undefined
+}
+
+/** Inputs for broadcasting and validating a legacy contract-backed top-up transaction. */
+export type BroadcastTopUpTransactionParameters = {
+  challengeExpires?: string | undefined
+  channelId: Hex
+  client: Client
+  currency: Address
+  declaredDeposit: bigint
+  escrowContract: Address
+  feePayer?: Account | undefined
+  feePayerPolicy?: Partial<FeePayer.Policy> | undefined
+  isSponsored?: boolean | undefined
+  previousDeposit: bigint
+  serializedTransaction: Hex
+}
+
+/** Result returned after a legacy top-up transaction is broadcast and verified. */
+export type BroadcastTopUpTransactionResult = {
+  newDeposit: bigint
+  txHash: Hex
+}
+
 type TempoCall = NonNullable<ReturnType<(typeof Transaction)['deserialize']>['calls']>[number]
 
 function assertCallHasTargetAndData(call: TempoCall): { to: Address; data: Hex } {
@@ -314,13 +383,7 @@ function assertCallHasTargetAndData(call: TempoCall): { to: Address; data: Hex }
   return { to: call.to, data: call.data }
 }
 
-function validateSponsoredApproveCall(parameters: {
-  action: 'open' | 'topUp'
-  call: TempoCall
-  currency: Address
-  escrowContract: Address
-  expectedAmount: bigint
-}) {
+function validateSponsoredApproveCall(parameters: SponsoredApproveCallParameters) {
   const { action, call, currency, escrowContract, expectedAmount } = parameters
   const { to, data } = assertCallHasTargetAndData(call)
 
@@ -346,12 +409,7 @@ function validateSponsoredApproveCall(parameters: {
   }
 }
 
-function validateSponsoredOpenCalls(parameters: {
-  calls: readonly TempoCall[]
-  currency: Address
-  escrowContract: Address
-  deposit: bigint
-}) {
+function validateSponsoredOpenCalls(parameters: SponsoredOpenCallsParameters) {
   const { calls, currency, escrowContract, deposit } = parameters
 
   let openCall: TempoCall | undefined
@@ -401,12 +459,7 @@ function validateSponsoredOpenCalls(parameters: {
   return openCall
 }
 
-function validateSponsoredTopUpCalls(parameters: {
-  calls: readonly TempoCall[]
-  currency: Address
-  escrowContract: Address
-  topUpAmount: bigint
-}) {
+function validateSponsoredTopUpCalls(parameters: SponsoredTopUpCallsParameters) {
   const { calls, currency, escrowContract, topUpAmount } = parameters
 
   let topUpCall: TempoCall | undefined
@@ -456,21 +509,9 @@ function validateSponsoredTopUpCalls(parameters: {
   return topUpCall
 }
 
-export async function broadcastOpenTransaction(parameters: {
-  client: Client
-  serializedTransaction: Hex
-  escrowContract: Address
-  channelId: Hex
-  recipient: Address
-  currency: Address
-  challengeExpires?: string | undefined
-  feePayerPolicy?: Partial<FeePayer.Policy> | undefined
-  feePayer?: Account | undefined
-  isSponsored?: boolean | undefined
-  beforeBroadcast?: ((onChain: OnChainChannel) => Promise<void> | void) | undefined
-  /** When false, simulates instead of waiting for confirmation and returns derived on-chain state. @default true */
-  waitForConfirmation?: boolean | undefined
-}): Promise<BroadcastResult> {
+export async function broadcastOpenTransaction(
+  parameters: BroadcastOpenTransactionParameters,
+): Promise<BroadcastResult> {
   const {
     client,
     serializedTransaction,
@@ -569,8 +610,8 @@ export async function broadcastOpenTransaction(parameters: {
       reason: 'open transaction does not match claimed channelId',
     })
 
-  const resolvedFeeToken =
-    transaction.feeToken ?? defaults.currency[client.chain?.id as keyof typeof defaults.currency]
+  const defaultFeeToken = defaults.currency[client.chain?.id as keyof typeof defaults.currency]
+  const resolvedFeeToken = transaction.feeToken ?? defaultFeeToken
 
   const pendingOnChain = {
     finalized: false,
@@ -594,10 +635,10 @@ export async function broadcastOpenTransaction(parameters: {
 
       const sponsored = FeePayer.prepareSponsoredTransaction({
         account: feePayer,
+        allowedFeeTokens: defaultFeeToken ? [defaultFeeToken] : undefined,
         challengeExpires,
         chainId: client.chain!.id,
         details: { channelId, currency, recipient },
-        expectedFeeToken: defaults.currency[client.chain?.id as keyof typeof defaults.currency],
         policy: feePayerPolicy,
         transaction: {
           ...transaction,
@@ -660,19 +701,9 @@ export async function broadcastOpenTransaction(parameters: {
   return { txHash, onChain }
 }
 
-export async function broadcastTopUpTransaction(parameters: {
-  client: Client
-  serializedTransaction: Hex
-  escrowContract: Address
-  channelId: Hex
-  currency: Address
-  declaredDeposit: bigint
-  previousDeposit: bigint
-  challengeExpires?: string | undefined
-  feePayerPolicy?: Partial<FeePayer.Policy> | undefined
-  feePayer?: Account | undefined
-  isSponsored?: boolean | undefined
-}): Promise<{ txHash: Hex; newDeposit: bigint }> {
+export async function broadcastTopUpTransaction(
+  parameters: BroadcastTopUpTransactionParameters,
+): Promise<BroadcastTopUpTransactionResult> {
   const {
     client,
     serializedTransaction,
@@ -743,9 +774,10 @@ export async function broadcastTopUpTransaction(parameters: {
           reason: 'transaction does not contain a valid escrow topUp call',
         })
 
-      const expectedFeeToken = defaults.currency[client.chain?.id as keyof typeof defaults.currency]
+      const defaultFeeToken = defaults.currency[client.chain?.id as keyof typeof defaults.currency]
       const sponsored = FeePayer.prepareSponsoredTransaction({
         account: feePayer,
+        allowedFeeTokens: defaultFeeToken ? [defaultFeeToken] : undefined,
         challengeExpires,
         chainId: client.chain!.id,
         details: {
@@ -753,12 +785,11 @@ export async function broadcastTopUpTransaction(parameters: {
           channelId,
           currency,
         },
-        expectedFeeToken,
         policy: feePayerPolicy,
         transaction: {
           ...transaction,
-          ...((transaction.feeToken ?? expectedFeeToken)
-            ? { feeToken: transaction.feeToken ?? expectedFeeToken }
+          ...((transaction.feeToken ?? defaultFeeToken)
+            ? { feeToken: transaction.feeToken ?? defaultFeeToken }
             : {}),
         },
       })

package/src/tempo/{session → legacy/session}/Channel.ts

@@ -30,6 +30,7 @@ export function computeId(parameters: computeId.Parameters): Hex.Hex {
   return Hash.keccak256(encoded)
 }
 
+/** Type helpers for {@link computeId}. */
 export declare namespace computeId {
   type Parameters = {
     /** Address authorized to sign vouchers on behalf of the payer. */

package/src/tempo/legacy/session/ChannelStore.test.ts

@@ -0,0 +1,58 @@
+import type { Address, Hex } from 'viem'
+import { describe, expect, test } from 'vp/test'
+
+import * as Store from '../../../Store.js'
+import { chainId, escrowContract as escrowContractDefaults } from '../../internal/defaults.js'
+import * as ChannelStore from './ChannelStore.js'
+
+const channelId = '0x0000000000000000000000000000000000000000000000000000000000000001' as Hex
+
+function legacyChannel(
+  overrides: Partial<ChannelStore.LegacyState> = {},
+): ChannelStore.LegacyState {
+  return {
+    channelId,
+    payer: '0x0000000000000000000000000000000000000001' as Address,
+    payee: '0x0000000000000000000000000000000000000002' as Address,
+    token: '0x0000000000000000000000000000000000000003' as Address,
+    authorizedSigner: '0x0000000000000000000000000000000000000004' as Address,
+    chainId: 42431,
+    escrowContract: escrowContractDefaults[chainId.testnet] as Address,
+    deposit: 10_000_000n,
+    settledOnChain: 0n,
+    highestVoucherAmount: 10_000_000n,
+    highestVoucher: null,
+    spent: 0n,
+    units: 0,
+    closeRequestedAt: 0n,
+    finalized: false,
+    createdAt: '2025-01-01T00:00:00.000Z',
+    ...overrides,
+  }
+}
+
+describe('legacy ChannelStore', () => {
+  test('keeps existing contract-backed channels compatible when backend fields are absent', async () => {
+    const store = ChannelStore.fromStore(Store.memory())
+    await store.updateChannel(channelId, () => legacyChannel())
+
+    const loaded = await store.getChannel(channelId)
+    expect(loaded).not.toBeNull()
+    expect(ChannelStore.isContractState(loaded!)).toBe(true)
+    expect(loaded!.backend).toBeUndefined()
+    expect('operator' in loaded!).toBe(false)
+    expect('salt' in loaded!).toBe(false)
+    expect('expiringNonceHash' in loaded!).toBe(false)
+    expect('descriptor' in loaded!).toBe(false)
+  })
+
+  test('supports explicit contract-backed channel state', async () => {
+    const store = ChannelStore.fromStore(Store.memory())
+    await store.updateChannel(channelId, () => legacyChannel({ backend: 'contract' }))
+
+    const loaded = await store.getChannel(channelId)
+    expect(loaded).not.toBeNull()
+    expect(ChannelStore.isContractState(loaded!)).toBe(true)
+    expect(loaded!.backend).toBe('contract')
+  })
+})

package/src/tempo/legacy/session/ChannelStore.ts

@@ -0,0 +1,39 @@
+/**
+ * Legacy contract-backed session channel-store facade.
+ *
+ * Legacy code imports channel-store types and helpers from this module so the
+ * contract-backed backend stays rooted under `tempo/legacy`. The underlying
+ * store adapter is shared with the TIP-1034 implementation because both
+ * backends persist the same accounting counters.
+ */
+import type * as SharedChannelStore from '../../session/server/ChannelStore.js'
+
+export {
+  deductFromChannel,
+  fromStore,
+  normalizeChannelId,
+  type BackendState,
+  type BaseState,
+  type ChannelStore,
+  type DeductResult,
+  type State,
+} from '../../session/server/ChannelStore.js'
+
+/** State for a legacy smart-contract-backed payment channel. */
+export interface LegacyContractBackendState {
+  /** Channel backend. Omitted for existing legacy records. */
+  backend?: 'contract' | undefined
+}
+
+/** @deprecated Use {@link LegacyContractBackendState}. */
+export type ContractBackendState = LegacyContractBackendState
+
+/** Legacy contract-backed channel state persisted by `tempo.sessionLegacy`. */
+export type LegacyState = SharedChannelStore.BaseState & LegacyContractBackendState
+
+/** Returns whether a channel is backed by the legacy smart contract escrow. */
+export function isContractState(
+  state: SharedChannelStore.State,
+): state is SharedChannelStore.BaseState & LegacyContractBackendState {
+  return state.backend === undefined || state.backend === 'contract'
+}

package/src/tempo/legacy/session/Types.ts

@@ -0,0 +1,91 @@
+import type { Address, Hex } from 'viem'
+
+import type { SessionSignedVoucher, SessionVoucher } from '../../session/precompile/Protocol.js'
+
+/**
+ * Legacy credential payload that opens a smart-contract-backed channel and authorizes initial spend.
+ */
+export type LegacyOpenCredentialPayload = {
+  action: 'open'
+  type: 'transaction'
+  /** Session channel ID. */
+  channelId: Hex
+  /** Signed transaction containing the channel-open call. */
+  transaction: Hex
+  /** Voucher signature for `cumulativeAmount`. */
+  signature: Hex
+  /** Voucher signer selected for the opened channel. */
+  authorizedSigner?: Address | undefined
+  /** Initial cumulative spend authorized by the opening voucher, as raw units. */
+  cumulativeAmount: string
+}
+
+/** Legacy credential payload that adds deposit to an existing smart-contract-backed channel. */
+export type LegacyTopUpCredentialPayload = {
+  action: 'topUp'
+  type: 'transaction'
+  /** Session channel ID being topped up. */
+  channelId: Hex
+  /** Signed transaction containing the channel top-up call. */
+  transaction: Hex
+  /** Additional deposit to add, as raw units. */
+  additionalDeposit: string
+}
+
+/** Legacy credential payload that increases cumulative spend authorization. */
+export type LegacyVoucherCredentialPayload = {
+  action: 'voucher'
+  /** Session channel ID the voucher applies to. */
+  channelId: Hex
+  /** Highest cumulative spend authorized by this voucher, as raw units. */
+  cumulativeAmount: string
+  /** Voucher signature for `cumulativeAmount`. */
+  signature: Hex
+}
+
+/** Legacy credential payload that cooperatively closes a channel at final cumulative spend. */
+export type LegacyCloseCredentialPayload = {
+  action: 'close'
+  /** Session channel ID being closed. */
+  channelId: Hex
+  /** Final cumulative spend authorized at close, as raw units. */
+  cumulativeAmount: string
+  /** Voucher signature for `cumulativeAmount`. */
+  signature: Hex
+}
+
+/**
+ * Legacy smart-contract-backed session credential payload.
+ */
+export type LegacySessionCredentialPayload =
+  | LegacyOpenCredentialPayload
+  | LegacyTopUpCredentialPayload
+  | LegacyVoucherCredentialPayload
+  | LegacyCloseCredentialPayload
+
+/** Legacy smart-contract-backed voucher for cumulative payment. */
+export type LegacyVoucher = SessionVoucher
+
+/** Legacy smart-contract-backed voucher with EIP-712 signature. */
+export type LegacySignedVoucher = SessionSignedVoucher
+
+/** @deprecated Use {@link LegacyVoucher}. */
+export type Voucher = LegacyVoucher
+
+/** @deprecated Use {@link LegacySignedVoucher}. */
+export type SignedVoucher = LegacySignedVoucher
+
+/** @deprecated Use {@link LegacyOpenCredentialPayload}. */
+export type OpenCredentialPayload = LegacyOpenCredentialPayload
+
+/** @deprecated Use {@link LegacyTopUpCredentialPayload}. */
+export type TopUpCredentialPayload = LegacyTopUpCredentialPayload
+
+/** @deprecated Use {@link LegacyVoucherCredentialPayload}. */
+export type VoucherCredentialPayload = LegacyVoucherCredentialPayload
+
+/** @deprecated Use {@link LegacyCloseCredentialPayload}. */
+export type CloseCredentialPayload = LegacyCloseCredentialPayload
+
+/** @deprecated Use {@link LegacySessionCredentialPayload}. */
+export type SessionCredentialPayload = LegacySessionCredentialPayload

package/src/tempo/{session → legacy/session}/Voucher.ts

@@ -4,8 +4,8 @@ import type { Account, Client, Hex } from 'viem'
 import { hashTypedData } from 'viem'
 import { signTypedData } from 'viem/actions'
 
-import { getAccountSignerAddress, isAccessKeyAccount } from '../internal/account.js'
-import type { SignedVoucher, Voucher } from './Types.js'
+import { getAccountSignerAddress, isAccessKeyAccount } from '../../internal/account.js'
+import type { LegacySignedVoucher, LegacyVoucher } from './Types.js'
 
 /** Must match the on-chain TempoStreamChannel DOMAIN_SEPARATOR name. */
 const DOMAIN_NAME = 'Tempo Stream Channel'
@@ -37,14 +37,18 @@ const voucherTypes = {
 
 const acceptTip1020VoucherSignatures = false
 
-function getVoucherMessage(message: Voucher) {
+function getVoucherMessage(message: LegacyVoucher) {
   return {
     channelId: message.channelId,
     cumulativeAmount: message.cumulativeAmount,
   }
 }
 
-function getVoucherDigest(escrowContract: Address.Address, chainId: number, message: Voucher) {
+function getVoucherDigest(
+  escrowContract: Address.Address,
+  chainId: number,
+  message: LegacyVoucher,
+) {
   return hashTypedData({
     domain: getVoucherDomain(escrowContract, chainId),
     types: voucherTypes,
@@ -56,7 +60,7 @@ function getVoucherDigest(escrowContract: Address.Address, chainId: number, mess
 async function signVoucherTypedData(
   client: Client,
   account: Account,
-  message: Voucher,
+  message: LegacyVoucher,
   escrowContract: Address.Address,
   chainId: number,
 ): Promise<Hex> {
@@ -106,7 +110,7 @@ function assertSupportedVoucherEnvelope(envelope: SignatureEnvelope.SignatureEnv
 export async function signVoucher(
   client: Client,
   account: Account,
-  message: Voucher,
+  message: LegacyVoucher,
   escrowContract: Address.Address,
   chainId: number,
   voucherSigner?: Account | undefined,
@@ -143,7 +147,7 @@ export async function signVoucher(
 export async function verifyVoucher(
   escrowContract: Address.Address,
   chainId: number,
-  voucher: SignedVoucher,
+  voucher: LegacySignedVoucher,
   expectedSigner: Address.Address,
 ): Promise<boolean> {
   try {
@@ -170,7 +174,7 @@ export function parseVoucherFromPayload(
   channelId: Hex,
   cumulativeAmount: string,
   signature: Hex,
-): SignedVoucher {
+): LegacySignedVoucher {
   return {
     channelId,
     cumulativeAmount: BigInt(cumulativeAmount),

package/src/tempo/{session → legacy/session}/escrow.abi.ts

@@ -1,3 +1,4 @@
+/** ABI for the legacy contract-backed Tempo stream channel escrow. */
 export const escrowAbi = [
   {
     type: 'function',

package/src/tempo/legacy/session/index.ts

@@ -0,0 +1,8 @@
+/** Legacy contract-backed channel chain helpers. */
+export * as Chain from './Chain.js'
+/** Legacy contract-backed channel ID helpers. */
+export * as Channel from './Channel.js'
+/** Legacy contract-backed session protocol types. */
+export * as Types from './Types.js'
+/** Legacy contract-backed voucher helpers. */
+export * as Voucher from './Voucher.js'

package/src/tempo/server/AtomicStore.test-d.ts

@@ -2,6 +2,7 @@ import { expectTypeOf, test } from 'vp/test'
 
 import { tempo } from '../../server/index.js'
 import * as Store from '../../Store.js'
+import * as Tempo from '../index.js'
 
 test('tempo.charge store parameter requires AtomicStore', () => {
   type ChargeParameters = NonNullable<Parameters<typeof tempo.charge>[0]>
@@ -18,17 +19,6 @@ test('tempo.charge store parameter requires AtomicStore', () => {
   tempo.charge({ store: Store.memory() })
 })
 
-test('tempo.charge validateSender exposes only sender context', () => {
-  tempo.charge({
-    validateSender({ expectedSender, sender, source }) {
-      expectTypeOf(expectedSender).toEqualTypeOf<`0x${string}`>()
-      expectTypeOf(sender).toEqualTypeOf<`0x${string}`>()
-      expectTypeOf(source).toEqualTypeOf<{ address: `0x${string}`; chainId: number } | undefined>()
-      return true
-    },
-  })
-})
-
 test('tempo.session store parameter requires AtomicStore', () => {
   type SessionParameters = NonNullable<Parameters<typeof tempo.session>[0]>
   expectTypeOf<SessionParameters['store']>().toEqualTypeOf<Store.AtomicStore | undefined>()
@@ -43,3 +33,18 @@ test('tempo.session store parameter requires AtomicStore', () => {
   tempo.session({ store: nonAtomic })
   tempo.session({ store: Store.memory() })
 })
+
+test('tempo Session server session store parameter requires AtomicStore', () => {
+  type SessionParameters = NonNullable<Parameters<typeof Tempo.Session.Server.session>[0]>
+  expectTypeOf<SessionParameters['store']>().toEqualTypeOf<Store.AtomicStore | undefined>()
+
+  const nonAtomic = Store.from({
+    get: async () => null,
+    put: async () => {},
+    delete: async () => {},
+  })
+
+  // @ts-expect-error — session state updates require AtomicStore
+  Tempo.Session.Server.session({ store: nonAtomic })
+  Tempo.Session.Server.session({ store: Store.memory() })
+})