mppx 0.8.14 → 0.8.17

package/src/x402/Exact.e2e.test.ts

@@ -4,6 +4,7 @@ import { describe, expect, test } from 'vp/test'
 import * as Http from '~test/Http.js'
 import { accounts, asset, client } from '~test/tempo/viem.js'
 
+import * as evm_Types from '../evm/Types.js'
 import * as Header from './Header.js'
 import * as RouteBinding from './internal/RouteBinding.js'
 import * as Types from './Types.js'
@@ -157,22 +158,8 @@ describe('x402 exact e2e', () => {
     const paymentRequired = Header.decodePaymentRequired(
       routeAChallenge.challenge.headers.get(Types.paymentRequiredHeader)!,
     )
-    const accepted = paymentRequired.accepts[0]!
-    const paymentSignature = Header.encodePaymentSignature({
-      accepted,
-      payload: {
-        authorization: {
-          from: accounts[0].address,
-          nonce: `0x${'1'.repeat(64)}`,
-          to: accepted.payTo as `0x${string}`,
-          validAfter: '0',
-          validBefore: '9999999999',
-          value: accepted.amount,
-        },
-        signature: `0x${'2'.repeat(130)}`,
-      },
-      resource: paymentRequired.resource,
-      x402Version: 2,
+    const paymentSignature = await standardPaymentSignature(paymentRequired, {
+      nonce: `0x${'1'.repeat(64)}`,
     })
 
     const result = await route(
@@ -185,7 +172,7 @@ describe('x402 exact e2e', () => {
     expect(verifyCalls).toBe(0)
   })
 
-  test('rejects x402 route extensions with extra binding fields', async () => {
+  test('rejects invalid x402 route bindings', async () => {
     let verifyCalls = 0
     const payment = ServerMppx.create({
       methods: [
@@ -223,49 +210,54 @@ describe('x402 exact e2e', () => {
     const accepted = paymentRequired.accepts[0]!
     const mppxExtension = paymentRequired.extensions!.mppx
     if (!mppxExtension) throw new Error()
-    const extensions: Types.Extensions = {
+    const extensionsWithExtra: Types.Extensions = {
       ...paymentRequired.extensions!,
       mppx: {
         schema: mppxExtension.schema,
         info: {
           ...mppxExtension.info,
           extra: 'not allowed',
+          nonce: '1'.repeat(64),
         },
       },
     }
-    const paymentSignature = Header.encodePaymentSignature({
-      accepted,
-      extensions,
-      payload: {
-        authorization: {
-          from: accounts[0].address,
-          nonce: RouteBinding.nonce({
-            accepted,
-            extensions,
-            resource: paymentRequired.resource,
-          }),
-          to: accepted.payTo as `0x${string}`,
-          validAfter: '0',
-          validBefore: '9999999999',
-          value: accepted.amount,
+    const extensionsWithNonce: Types.Extensions = {
+      ...paymentRequired.extensions!,
+      mppx: {
+        schema: mppxExtension.schema,
+        info: {
+          ...mppxExtension.info,
+          nonce: 'client-salt',
         },
-        signature: `0x${'2'.repeat(130)}`,
       },
-      resource: paymentRequired.resource,
-      x402Version: 2,
-    })
-
-    const result = await route(
-      new Request('https://example.com/a', {
-        headers: { [Types.paymentSignatureHeader]: paymentSignature },
+    }
+    const paymentSignatures = await Promise.all([
+      standardPaymentSignature(paymentRequired, {
+        extensions: extensionsWithExtra,
+        nonce: RouteBinding.nonce({
+          accepted,
+          extensions: extensionsWithExtra,
+          resource: paymentRequired.resource,
+        }),
       }),
-    )
+      standardPaymentSignature(paymentRequired, {
+        extensions: extensionsWithNonce,
+        nonce: `0x${'5'.repeat(64)}`,
+      }),
+    ])
 
-    expect(result.status).toBe(402)
+    for (const paymentSignature of paymentSignatures) {
+      const result = await route(
+        new Request('https://example.com/a', {
+          headers: { [Types.paymentSignatureHeader]: paymentSignature },
+        }),
+      )
+      expect(result.status).toBe(402)
+    }
     expect(verifyCalls).toBe(0)
   })
 
-  test('does not advertise x402 for body-bearing requests without a digest', async () => {
+  test('accepts standard x402 payments for body-bearing requests without a digest', async () => {
     let verifyCalls = 0
     const payment = ServerMppx.create({
       methods: [
@@ -292,56 +284,57 @@ describe('x402 exact e2e', () => {
       secretKey,
     })
     const route = payment.evm.charge({ amount: '0.01' })
+    const body = JSON.stringify({ a: 1 })
 
-    const result = await route(
+    const first = await route(
       new Request('https://example.com/body', {
-        body: JSON.stringify({ a: 1 }),
+        body,
         method: 'POST',
       }),
     )
 
-    expect(result.status).toBe(402)
-    if (result.status !== 402) throw new Error()
-    expect(result.challenge.headers.has('WWW-Authenticate')).toBe(true)
-    expect(result.challenge.headers.has(Types.paymentRequiredHeader)).toBe(false)
-
-    const getChallenge = await route(new Request('https://example.com/body'))
-    expect(getChallenge.status).toBe(402)
-    if (getChallenge.status !== 402) throw new Error()
+    expect(first.status).toBe(402)
+    if (first.status !== 402) throw new Error()
+    expect(first.challenge.headers.has('WWW-Authenticate')).toBe(true)
+    expect(first.challenge.headers.has(Types.paymentRequiredHeader)).toBe(true)
     const paymentRequired = Header.decodePaymentRequired(
-      getChallenge.challenge.headers.get(Types.paymentRequiredHeader)!,
+      first.challenge.headers.get(Types.paymentRequiredHeader)!,
     )
-    const accepted = paymentRequired.accepts[0]!
-    const paymentSignature = Header.encodePaymentSignature({
-      accepted,
-      extensions: paymentRequired.extensions,
-      payload: {
-        authorization: {
-          from: accounts[0].address,
-          nonce: RouteBinding.nonce({
-            accepted,
-            extensions: paymentRequired.extensions!,
-            resource: paymentRequired.resource,
-          }),
-          to: accepted.payTo as `0x${string}`,
-          validAfter: '0',
-          validBefore: '9999999999',
-          value: accepted.amount,
-        },
-        signature: `0x${'2'.repeat(130)}`,
-      },
-      resource: paymentRequired.resource,
-      x402Version: 2,
+
+    const paymentSignatures = await Promise.all([
+      standardPaymentSignature(paymentRequired, {
+        nonce: `0x${'3'.repeat(64)}`,
+      }),
+      standardPaymentSignature(paymentRequired, {
+        extensions: paymentRequired.extensions,
+        nonce: `0x${'4'.repeat(64)}`,
+      }),
+    ])
+    for (const paymentSignature of paymentSignatures) {
+      const result = await route(
+        new Request('https://example.com/body', {
+          body,
+          headers: { [Types.paymentSignatureHeader]: paymentSignature },
+          method: 'POST',
+        }),
+      )
+      expect(result.status).toBe(200)
+    }
+    expect(verifyCalls).toBe(2)
+
+    const scopedRoute = payment.evm.charge({
+      amount: '0.01',
+      scope: 'POST /body',
     })
-    const replay = await route(
+    const scopedResult = await scopedRoute(
       new Request('https://example.com/body', {
-        body: JSON.stringify({ a: 2 }),
-        headers: { [Types.paymentSignatureHeader]: paymentSignature },
+        body,
+        headers: { [Types.paymentSignatureHeader]: paymentSignatures[0]! },
         method: 'POST',
       }),
     )
-    expect(replay.status).toBe(402)
-    expect(verifyCalls).toBe(0)
+    expect(scopedResult.status).toBe(402)
+    expect(verifyCalls).toBe(2)
   })
 
   test('serves tempo and x402 from one composed live endpoint', async () => {
@@ -438,6 +431,53 @@ function payerOf(paymentPayload: Types.PaymentPayload): string {
   return paymentPayload.payload.permit2Authorization.from
 }
 
+async function standardPaymentSignature(
+  paymentRequired: Types.PaymentRequired,
+  options: {
+    extensions?: Types.Extensions | undefined
+    nonce: `0x${string}`
+  },
+): Promise<string> {
+  const accepted = paymentRequired.accepts[0]!
+  const name = accepted.extra?.name
+  const version = accepted.extra?.version
+  if (typeof name !== 'string' || typeof version !== 'string') throw new Error()
+  const authorization = {
+    from: accounts[0].address,
+    nonce: options.nonce,
+    to: accepted.payTo as `0x${string}`,
+    validAfter: '0',
+    validBefore: '9999999999',
+    value: accepted.amount,
+  }
+  const signature = await accounts[0].signTypedData({
+    domain: {
+      chainId: Number(accepted.network.slice('eip155:'.length)),
+      name,
+      verifyingContract: accepted.asset as `0x${string}`,
+      version,
+    },
+    message: {
+      ...authorization,
+      validAfter: BigInt(authorization.validAfter),
+      validBefore: BigInt(authorization.validBefore),
+      value: BigInt(authorization.value),
+    },
+    primaryType: 'TransferWithAuthorization',
+    types: evm_Types.authorizationTypes,
+  })
+  return Header.encodePaymentSignature({
+    accepted,
+    ...(options.extensions ? { extensions: options.extensions } : {}),
+    payload: {
+      authorization,
+      signature,
+    },
+    resource: paymentRequired.resource,
+    x402Version: 2,
+  })
+}
+
 function pureX402Challenge(response: Response): Response {
   const paymentRequired = response.headers.get(Types.paymentRequiredHeader)
   if (!paymentRequired) throw new Error('Missing PAYMENT-REQUIRED header.')

package/src/x402/Exact.localnet.test.ts

@@ -115,7 +115,7 @@ describeLocalnet('x402 exact localnet settlement', () => {
     }
   })
 
-  test('rejects replayed localnet x402 payment', async () => {
+  test('rejects replayed localnet x402 payment', { timeout: 60_000 }, async () => {
     const harness = await setupHarness()
     const paidServer = await createPaidServer(harness)
 

package/src/x402/server/EvmCharge.ts

@@ -111,27 +111,48 @@ export function createPath(config: ResolvedOptions): Path {
         })
 
       const expectedResource = { url: input.url }
-      if (!isDeepStrictEqual(paymentPayload.resource, expectedResource))
+      const clientNonce = paymentPayload.extensions?.[mppxExtensionKey]?.info.nonce
+      const isRouteBound = clientNonce !== undefined
+      const routeRequiresBinding =
+        challenge.digest !== undefined ||
+        challenge.opaque !== undefined ||
+        challenge.meta !== undefined
+      if (routeRequiresBinding && !isRouteBound)
         throw new VerificationFailedError({
-          reason: 'x402 payment payload resource does not match route resource',
+          reason: 'x402 payment payload does not bind required route metadata',
         })
 
-      const expectedExtensions = routeExtensions(challenge, input)
-      if (!containsExtensions(paymentPayload.extensions, expectedExtensions))
+      if (isRouteBound) {
+        if (!isDeepStrictEqual(paymentPayload.resource, expectedResource))
+          throw new VerificationFailedError({
+            reason: 'x402 payment payload resource does not match route resource',
+          })
+
+        const expectedExtensions = routeExtensions(challenge, input)
+        if (!containsExtensions(paymentPayload.extensions, expectedExtensions))
+          throw new VerificationFailedError({
+            reason: 'x402 payment payload extensions do not match route binding',
+          })
+      } else if (
+        paymentPayload.resource !== undefined &&
+        paymentPayload.resource.url !== expectedResource.url
+      )
         throw new VerificationFailedError({
-          reason: 'x402 payment payload extensions do not match route binding',
+          reason: 'x402 payment payload resource does not match route resource',
         })
 
       const payload = payloadToAuthorization(paymentPayload)
-      const expectedNonce = x402_RouteBinding.nonce({
-        accepted: paymentRequirements,
-        extensions: paymentPayload.extensions!,
-        resource: expectedResource,
-      })
-      if (payload.nonce !== expectedNonce)
-        throw new VerificationFailedError({
-          reason: 'x402 authorization nonce does not match route binding',
+      if (isRouteBound) {
+        const expectedNonce = x402_RouteBinding.nonce({
+          accepted: paymentRequirements,
+          extensions: paymentPayload.extensions!,
+          resource: expectedResource,
         })
+        if (payload.nonce !== expectedNonce)
+          throw new VerificationFailedError({
+            reason: 'x402 authorization nonce does not match route binding',
+          })
+      }
 
       return markCredential(
         Credential_.from({
@@ -147,7 +168,6 @@ export function createPath(config: ResolvedOptions): Path {
 
     respondChallenge(options, response) {
       if (!response) throw new Error('x402 path requires a base challenge response.')
-      if (options.input.body !== null && options.challenge.digest === undefined) return response
       const headers = new Headers(response.headers)
       const request = options.challenge.request as Types.ChargeRequest
       headers.set(
@@ -354,11 +374,7 @@ function stripClientNonce(info: Record<string, unknown>): Record<string, unknown
 }
 
 async function assertBodyDigest(challenge: Challenge.Challenge, input: Request): Promise<void> {
-  if (input.body === null) return
-  if (challenge.digest === undefined)
-    throw new VerificationFailedError({
-      reason: 'x402 payment requires a body digest for body-bearing requests',
-    })
+  if (input.body === null || challenge.digest === undefined) return
   let body: string
   try {
     body = await input.clone().text()

package/dist/tempo/legacy/server/Session.d.ts

@@ -1,208 +0,0 @@
-/**
- * Server-side session payment method for request/response flows.
- *
- * Handles the full channel lifecycle (open, voucher, top-up, close) and
- * one-shot settlement. Each incoming request carries a session credential
- * with a cumulative voucher that the server validates and records.
- *
- * Use `session()` for standard HTTP request/response patterns where each
- * request is a discrete paid unit (for example, a page scrape or API call).
- * For long-lived connections that emit multiple paid events over a single
- * request, use {@link ../session/Sse} instead.
- */
-import { type Address, type Hex, type Account as viem_Account, type Client as viem_Client } from 'viem';
-import type { LooseOmit, NoExtraKeys } from '../../../internal/types.js';
-import * as Method from '../../../Method.js';
-import * as Store from '../../../Store.js';
-import * as Client from '../../../viem/Client.js';
-import type * as z from '../../../zod.js';
-import * as Account from '../../internal/account.js';
-import * as FeePayer from '../../internal/fee-payer.js';
-import type * as types from '../../internal/types.js';
-import * as Methods from '../../Methods.js';
-import * as Transport from '../../server/internal/transport.js';
-import * as ChannelStore from '../session/ChannelStore.js';
-/**
- * Creates a session payment server using the Method.toServer() pattern.
- *
- * @example
- * ```ts
- * import { Mppx, tempo } from 'mppx/server'
- *
- * const mppx = Mppx.create({
- *   methods: [
- *     tempo.session({
- *       store: myStore,
- *       recipient: '0x...',
- *       currency: '0x...',
- *       escrowContract: '0x...',
- *     }),
- *   ],
- *   realm: 'my-app',
- *   secretKey: '...',
- * })
- * ```
- */
-export declare function session<const parameters extends session.Parameters>(p?: NoExtraKeys<parameters, session.Parameters>): Method.Server<{
-    readonly name: "tempo";
-    readonly intent: "session";
-    readonly schema: {
-        readonly credential: {
-            readonly payload: z.ZodMiniDiscriminatedUnion<[z.ZodMiniObject<{
-                action: z.ZodMiniLiteral<"open">;
-                authorizedSigner: z.ZodMiniOptional<z.ZodMiniString<string>>;
-                channelId: z.ZodMiniString<string>;
-                cumulativeAmount: z.ZodMiniString<string>;
-                descriptor: z.ZodMiniOptional<z.ZodMiniCustom<import("../../session/precompile/Protocol.js").ChannelDescriptor, import("../../session/precompile/Protocol.js").ChannelDescriptor>>;
-                signature: z.ZodMiniString<string>;
-                transaction: z.ZodMiniString<string>;
-                type: z.ZodMiniLiteral<"transaction">;
-            }, z.core.$strip>, z.ZodMiniObject<{
-                action: z.ZodMiniLiteral<"topUp">;
-                additionalDeposit: z.ZodMiniString<string>;
-                channelId: z.ZodMiniString<string>;
-                descriptor: z.ZodMiniOptional<z.ZodMiniCustom<import("../../session/precompile/Protocol.js").ChannelDescriptor, import("../../session/precompile/Protocol.js").ChannelDescriptor>>;
-                transaction: z.ZodMiniString<string>;
-                type: z.ZodMiniLiteral<"transaction">;
-            }, z.core.$strip>, z.ZodMiniObject<{
-                action: z.ZodMiniLiteral<"voucher">;
-                channelId: z.ZodMiniString<string>;
-                cumulativeAmount: z.ZodMiniString<string>;
-                descriptor: z.ZodMiniOptional<z.ZodMiniCustom<import("../../session/precompile/Protocol.js").ChannelDescriptor, import("../../session/precompile/Protocol.js").ChannelDescriptor>>;
-                signature: z.ZodMiniString<string>;
-            }, z.core.$strip>, z.ZodMiniObject<{
-                action: z.ZodMiniLiteral<"close">;
-                channelId: z.ZodMiniString<string>;
-                cumulativeAmount: z.ZodMiniString<string>;
-                descriptor: z.ZodMiniOptional<z.ZodMiniCustom<import("../../session/precompile/Protocol.js").ChannelDescriptor, import("../../session/precompile/Protocol.js").ChannelDescriptor>>;
-                signature: z.ZodMiniString<string>;
-            }, z.core.$strip>], "action">;
-        };
-        readonly request: z.ZodMiniPipe<z.ZodMiniObject<{
-            amount: z.ZodMiniString<string>;
-            chainId: z.ZodMiniOptional<z.ZodMiniNumber<number>>;
-            channelId: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            currency: z.ZodMiniString<string>;
-            decimals: z.ZodMiniNumber<number>;
-            escrowContract: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            feePayer: z.ZodMiniOptional<z.ZodMiniPipe<z.ZodMiniUnion<readonly [z.ZodMiniBoolean<boolean>, z.ZodMiniCustom<viem_Account, viem_Account>]>, z.ZodMiniTransform<boolean, boolean | viem_Account>>>;
-            minVoucherDelta: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            operator: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            recipient: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            sessionProtocol: z.ZodMiniOptional<z.ZodMiniEnum<{
-                v1: "v1";
-                v2: "v2";
-            }>>;
-            sessionSnapshot: z.ZodMiniOptional<z.ZodMiniCustom<import("../../session/Snapshot.js").SessionSnapshot, import("../../session/Snapshot.js").SessionSnapshot>>;
-            suggestedDeposit: z.ZodMiniOptional<z.ZodMiniString<string>>;
-            unitType: z.ZodMiniString<string>;
-        }, z.core.$strip>, z.ZodMiniTransform<{
-            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;
-            };
-            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;
-            escrowContract?: string | undefined;
-            feePayer?: 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;
-        }>>;
-    };
-}, session.DeriveDefaults<parameters>, parameters["sse"] extends false | undefined ? undefined : Transport.Sse, {}, undefined>;
-/** Type helpers for the legacy contract-backed session server method. */
-export declare namespace session {
-    type Defaults = LooseOmit<Method.RequestDefaults<typeof Methods.session>, 'feePayer' | 'recipient'>;
-    type FeePayerPolicy = Partial<FeePayer.Policy>;
-    type Parameters = {
-        /** TTL in milliseconds for cached on-chain channel state. After this duration, the server re-queries on-chain state during voucher handling to detect forced close requests. @default 5_000 */
-        channelStateTtl?: number | undefined;
-        /** Override the fee-sponsor policy used for sponsored open/topUp transactions. */
-        feePayerPolicy?: FeePayerPolicy | undefined;
-        /** Minimum voucher delta to accept (numeric string, default: "0"). */
-        minVoucherDelta?: string | undefined;
-        /**
-         * Whether to wait for the open transaction to confirm on-chain before
-         * responding. @default true
-         *
-         * When `false`, the transaction is simulated via `eth_estimateGas` and
-         * broadcast without waiting for inclusion. The receipt will optimistically
-         * report `status: 'success'` based on simulation alone — if the
-         * transaction reverts on-chain after broadcast (e.g. due to a state
-         * change between simulation and inclusion), the receipt will not reflect
-         * the failure.
-         */
-        waitForConfirmation?: boolean | undefined;
-        /**
-         * Atomic store backend for channel state.
-         *
-         * Session state mutations must be linearizable across instances, so this
-         * requires a {@link Store.AtomicStore}. Use `Store.memory()` for tests or
-         * local single-process usage.
-         */
-        store?: Store.AtomicStore | undefined;
-        /**
-         * Prefix prepended to channel state store keys.
-         *
-         * By default, no prefix is applied.
-         */
-        storeKeyPrefix?: string | undefined;
-        /**
-         * Enable SSE streaming.
-         *
-         * Pass `true` to enable with defaults, or an options object
-         * to configure SSE (e.g. `{ poll: true }` for
-         * Cloudflare Workers compatibility).
-         */
-        sse?: boolean | Transport.sse.Options | undefined;
-        /** Testnet mode. */
-        testnet?: boolean | undefined;
-    } & Account.resolve.Parameters & Client.getResolver.Parameters & Defaults;
-    type DeriveDefaults<parameters extends Parameters> = types.DeriveDefaults<parameters, Defaults, {
-        currency: string;
-        decimals: number;
-    }>;
-}
-/**
- * One-shot settle: reads highest voucher from store and submits on-chain.
- */
-export declare function settle(store: ChannelStore.ChannelStore, client: viem_Client, channelId: Hex, options?: {
-    escrowContract?: Address | undefined;
-} & ({
-    feePayer: viem_Account;
-    account: viem_Account;
-} | {
-    feePayer?: undefined;
-    account?: viem_Account | undefined;
-})): Promise<Hex>;
-/**
- * Charge against a channel's balance.
- *
- * Exported so consumers can deduct from a channel outside the `session()`
- * handler (e.g., custom middleware, the SSE `serve()` loop, or direct tests).
- *
- * Delegates to the shared `deductFromChannel` atomic helper and translates
- * failure modes into typed errors (`InsufficientBalanceError`, `ChannelClosedError`).
- */
-export declare function charge(store: ChannelStore.ChannelStore, channelId: Hex, amount: bigint): Promise<ChannelStore.State>;
-//# sourceMappingURL=Session.d.ts.map

package/dist/tempo/legacy/server/Session.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"Session.d.ts","sourceRoot":"","sources":["../../../../src/tempo/legacy/server/Session.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,GAAG,EAGR,KAAK,OAAO,IAAI,YAAY,EAC5B,KAAK,MAAM,IAAI,WAAW,EAC3B,MAAM,MAAM,CAAA;AAeb,OAAO,KAAK,EAAE,SAAS,EAAE,WAAW,EAAE,MAAM,4BAA4B,CAAA;AACxE,OAAO,KAAK,MAAM,MAAM,oBAAoB,CAAA;AAC5C,OAAO,KAAK,KAAK,MAAM,mBAAmB,CAAA;AAC1C,OAAO,KAAK,MAAM,MAAM,yBAAyB,CAAA;AACjD,OAAO,KAAK,KAAK,CAAC,MAAM,iBAAiB,CAAA;AACzC,OAAO,KAAK,OAAO,MAAM,2BAA2B,CAAA;AAEpD,OAAO,KAAK,QAAQ,MAAM,6BAA6B,CAAA;AACvD,OAAO,KAAK,KAAK,KAAK,MAAM,yBAAyB,CAAA;AACrD,OAAO,KAAK,OAAO,MAAM,kBAAkB,CAAA;AAK3C,OAAO,KAAK,SAAS,MAAM,oCAAoC,CAAA;AAW/D,OAAO,KAAK,YAAY,MAAM,4BAA4B,CAAA;AAc1D;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,OAAO,CAAC,KAAK,CAAC,UAAU,SAAS,OAAO,CAAC,UAAU,EACjE,CAAC,CAAC,EAAE,WAAW,CAAC,UAAU,EAAE,OAAO,CAAC,UAAU,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;+HAkPhD;AAMD,yEAAyE;AACzE,MAAM,CAAC,OAAO,WAAW,OAAO,CAAC;IAC/B,KAAK,QAAQ,GAAG,SAAS,CACvB,MAAM,CAAC,eAAe,CAAC,OAAO,OAAO,CAAC,OAAO,CAAC,EAC9C,UAAU,GAAG,WAAW,CACzB,CAAA;IAED,KAAK,cAAc,GAAG,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAA;IAE9C,KAAK,UAAU,GAAG;QAChB,+LAA+L;QAC/L,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QACpC,kFAAkF;QAClF,cAAc,CAAC,EAAE,cAAc,GAAG,SAAS,CAAA;QAC3C,sEAAsE;QACtE,eAAe,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QACpC;;;;;;;;;;WAUG;QACH,mBAAmB,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;QACzC;;;;;;WAMG;QACH,KAAK,CAAC,EAAE,KAAK,CAAC,WAAW,GAAG,SAAS,CAAA;QACrC;;;;WAIG;QACH,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAA;QACnC;;;;;;WAMG;QACH,GAAG,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC,GAAG,CAAC,OAAO,GAAG,SAAS,CAAA;QACjD,oBAAoB;QACpB,OAAO,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;KAC9B,GAAG,OAAO,CAAC,OAAO,CAAC,UAAU,GAC5B,MAAM,CAAC,WAAW,CAAC,UAAU,GAC7B,QAAQ,CAAA;IAEV,KAAK,cAAc,CAAC,UAAU,SAAS,UAAU,IAAI,KAAK,CAAC,cAAc,CACvE,UAAU,EACV,QAAQ,EACR;QACE,QAAQ,EAAE,MAAM,CAAA;QAChB,QAAQ,EAAE,MAAM,CAAA;KACjB,CACF,CAAA;CACF;AAkBD;;GAEG;AACH,wBAAsB,MAAM,CAC1B,KAAK,EAAE,YAAY,CAAC,YAAY,EAChC,MAAM,EAAE,WAAW,EACnB,SAAS,EAAE,GAAG,EACd,OAAO,CAAC,EAAE;IACR,cAAc,CAAC,EAAE,OAAO,GAAG,SAAS,CAAA;CACrC,GAAG,CACA;IAAE,QAAQ,EAAE,YAAY,CAAC;IAAC,OAAO,EAAE,YAAY,CAAA;CAAE,GACjD;IAAE,QAAQ,CAAC,EAAE,SAAS,CAAC;IAAC,OAAO,CAAC,EAAE,YAAY,GAAG,SAAS,CAAA;CAAE,CAC/D,GACA,OAAO,CAAC,GAAG,CAAC,CAkCd;AAED;;;;;;;;GAQG;AACH,wBAAsB,MAAM,CAC1B,KAAK,EAAE,YAAY,CAAC,YAAY,EAChC,SAAS,EAAE,GAAG,EACd,MAAM,EAAE,MAAM,GACb,OAAO,CAAC,YAAY,CAAC,KAAK,CAAC,CAiB7B"}