tapimo 0.15.1 → 0.18.0

package/src/admin/ui/src/lib/route-policies.test.ts

@@ -0,0 +1,452 @@
+import { describe, expect, it } from 'vitest'
+
+import * as Policies from './route-policies.js'
+
+const route = {
+  sourceChainId: 'eip155:1',
+  sourceTokenId: 'usdc-ethereum',
+  destinationChainId: 'eip155:42161',
+  destinationTokenId: 'usdc-arbitrum',
+  providerId: 'stargate',
+}
+
+describe('serializeScope', () => {
+  it('serializes the full scope without undefined fields', () => {
+    expect(
+      Policies.serializeScope({
+        orgId: 'org with spaces',
+        projectId: 'project/one',
+        apiKeyId: 'key+one',
+        environment: 'sandbox',
+      }),
+    ).toMatchInlineSnapshot(
+      `"orgId=org+with+spaces&environment=sandbox&projectId=project%2Fone&apiKeyId=key%2Bone"`,
+    )
+  })
+})
+
+describe('effective', () => {
+  it('resolves asymmetric inherited defaults and provider terms through shared Policy.resolve', () => {
+    const payload: Policies.Payload = {
+      name: 'Project one',
+      scope: { orgId: 'org_1', projectId: 'project_1', environment: 'production' },
+      version: 7,
+      policy: { subsidyEnabled: false },
+      layers: [
+        {
+          scope: { orgId: 'org_1', environment: 'production' },
+          version: 3,
+          policy: { access: [], subsidyEnabled: true, subsidyPayer: 'enterprise', maxAmount: '91' },
+        },
+        {
+          scope: { orgId: 'org_1', projectId: 'project_1', environment: 'production' },
+          version: 7,
+          policy: { subsidyEnabled: false },
+        },
+      ],
+      legacy: { subsidyEnabled: false, subsidyPayer: 'enterprise', maxAmount: '2' },
+      routes: [
+        {
+          ...route,
+          label: 'USDC Ethereum → USDC Arbitrum',
+          sourceChainName: 'Ethereum',
+          sourceTokenSymbol: 'USDC',
+          destinationChainName: 'Arbitrum',
+          destinationTokenSymbol: 'USDC',
+        },
+      ],
+    }
+    expect(
+      Policies.effective(
+        payload,
+        {
+          access: null,
+          subsidyEnabled: true,
+          terms: [{ ...route, subsidyPayer: 'tempo', maxAmount: '17.25' }],
+        },
+        route,
+      ),
+    ).toMatchInlineSnapshot(`
+      {
+        "access": null,
+        "maxAmount": "17.25",
+        "subsidyEligible": true,
+        "subsidyEnabled": true,
+        "subsidyPayer": "tempo",
+        "subsidyRoutes": null,
+        "suspended": false,
+      }
+    `)
+  })
+})
+
+describe('review', () => {
+  it('keeps legacy access for child scopes until the organization opts in, while previewing an explicit organization draft', () => {
+    const scope = { orgId: 'org_legacy', environment: 'production' } as const
+    const payload: Policies.Payload = {
+      name: 'Legacy organization',
+      scope,
+      version: 0,
+      policy: {},
+      layers: [{ scope, policy: {}, version: 0 }],
+      routes: catalog,
+      legacy: { subsidyEnabled: false, maxAmount: '0', subsidyPayer: 'enterprise' },
+    }
+    expect(Policies.review(payload, {}).routes).toEqual([])
+    for (const child of [
+      { ...scope, projectId: 'project_1' },
+      { ...scope, apiKeyId: 'key_1' },
+    ]) {
+      const inherited = { ...payload, scope: child }
+      expect(Policies.review(inherited, {}).routes.map(({ route }) => route)).toEqual(catalog)
+      expect(Policies.review(inherited, { access: [] }).routes).toEqual([])
+      expect(
+        Policies.review(inherited, { access: [Policies.selectedRoute(catalog[0]!)!] }).routes.map(
+          ({ route }) => route,
+        ),
+      ).toEqual([catalog[0]])
+      expect(
+        Policies.review({ ...inherited, layers: [{ scope, policy: {}, version: 1 }] }, {}).routes,
+      ).toEqual([])
+    }
+  })
+
+  it('lists only effective routes and explains per-field inheritance, including equal-valued overrides', () => {
+    const relay = Policies.selectedRoute(catalog[0]!)!
+    const stargate = Policies.selectedRoute(catalog[1]!)!
+    const { providerId: _, ...any } = relay
+    const org = { orgId: 'org_review', environment: 'production' } as const
+    const project = { ...org, projectId: 'project_review' }
+    const scope = { ...project, apiKeyId: 'key_review' }
+    const payload: Policies.Payload = {
+      name: 'Review key',
+      scope,
+      version: 1,
+      policy: { access: [] },
+      routes: catalog,
+      legacy: { subsidyEnabled: false, maxAmount: '1', subsidyPayer: 'enterprise' },
+      layers: [
+        {
+          scope: org,
+          version: 1,
+          policy: {
+            access: [any],
+            terms: [
+              { ...any, subsidyEligible: false, subsidyPayer: 'tempo', maxAmount: '20' },
+              { ...relay, subsidyPayer: 'enterprise', maxAmount: '50' },
+            ],
+          },
+        },
+        {
+          scope: project,
+          version: 1,
+          policy: {
+            maxAmount: '9',
+            subsidyEnabled: true,
+            terms: [
+              { ...any, subsidyEligible: true },
+              { ...stargate, subsidyPayer: 'enterprise' },
+            ],
+          },
+        },
+        { scope, version: 1, policy: { access: [] } },
+      ],
+    }
+    const result = Policies.review(payload, { terms: [{ ...relay, maxAmount: '4' }] })
+    expect(result.accessSource).toBe('Organization')
+    expect(result.defaults).toEqual([{ scope: 'Project', policy: payload.layers[1]!.policy }])
+    expect(
+      result.routes.map(({ route, effective, sources }) => ({
+        provider: route.providerId,
+        cap: effective.maxAmount,
+        payer: effective.subsidyPayer,
+        eligible: effective.subsidyEligible,
+        sources,
+      })),
+    ).toEqual([
+      {
+        provider: 'relay',
+        cap: '4',
+        payer: 'enterprise',
+        eligible: true,
+        sources: {
+          maxAmount: undefined,
+          subsidyEnabled: 'Project · default',
+          subsidyEligible: 'Project · any-provider rule',
+          subsidyPayer: 'Organization · route rule',
+        },
+      },
+      {
+        provider: 'stargate',
+        cap: '9',
+        payer: 'enterprise',
+        eligible: true,
+        sources: {
+          maxAmount: 'Project · default',
+          subsidyEnabled: 'Project · default',
+          subsidyEligible: 'Project · any-provider rule',
+          subsidyPayer: 'Project · route rule',
+        },
+      },
+    ])
+    const override = Policies.review(payload, { access: [stargate], subsidyRoutes: [] })
+    expect(override.accessSource).toBe('API key')
+    expect(
+      override.routes.map(({ route, effective, sources }) => ({
+        provider: route.providerId,
+        eligible: effective.subsidyEligible,
+        source: sources.subsidyEligible,
+      })),
+    ).toEqual([{ provider: 'stargate', eligible: false, source: undefined }])
+    expect(payload.policy).toEqual({ access: [] })
+  })
+
+  it('handles missing policies, legacy wildcards, disabled subsidies, and suspension without inventing allowed routes', () => {
+    const payload: Policies.Payload = {
+      name: 'Review organization',
+      scope: { orgId: 'org_review', environment: 'production' },
+      version: 0,
+      policy: {},
+      layers: [],
+      routes: catalog,
+      legacy: { subsidyEnabled: false, maxAmount: '1', subsidyPayer: 'enterprise' },
+    }
+    expect(Policies.review(payload, {}).routes).toEqual([])
+    const all = Policies.review(payload, { access: null })
+    expect(all.routes.map(({ route }) => route.label)).toEqual([
+      'Base USDC → Tempo USDC.e (relay)',
+      'Base USDC → Tempo USDC.e (stargate)',
+      'Ethereum USDT → Tempo USDT0 (relay)',
+      'Base USDC → Arbitrum USDC (across)',
+    ])
+    expect(all.effective.subsidyEnabled).toBe(false)
+    expect(all.routes[0]?.sources.subsidyEnabled).toBeUndefined()
+    expect(all.routes[0]?.sources.subsidyPayer).toBeUndefined()
+    const child = Policies.review(
+      { ...payload, scope: { ...payload.scope, projectId: 'project_1' } },
+      { access: null },
+    )
+    expect(child.routes[0]?.sources.subsidyPayer).toBe('Organization · legacy default')
+    expect(Policies.review(payload, { access: null, suspended: true }).routes).toEqual([])
+  })
+
+  it('attributes explicit route enablement before legacy eligibility and defaults without changing saved values', () => {
+    const relay = Policies.selectedRoute(catalog[0]!)!
+    const { providerId: _, ...any } = relay
+    const scope = { orgId: 'org_review', environment: 'production' } as const
+    const policy: Policies.Overrides = {
+      access: [any],
+      subsidyEnabled: false,
+      subsidyRoutes: [],
+      maxAmount: '7',
+      terms: [
+        { ...any, subsidyEnabled: false },
+        {
+          ...relay,
+          subsidyEligible: false,
+          subsidyEnabled: true,
+          maxAmount: '0',
+          subsidyPayer: 'tempo',
+        },
+      ],
+    }
+    const payload: Policies.Payload = {
+      name: 'Review organization',
+      scope,
+      version: 1,
+      policy,
+      layers: [{ scope, version: 1, policy }],
+      routes: catalog,
+      legacy: { subsidyEnabled: false, maxAmount: '1', subsidyPayer: 'enterprise' },
+    }
+    const result = Policies.review(payload, policy)
+    expect(
+      result.routes.map(({ effective, sources }) => ({
+        enabled: effective.subsidyEnabled,
+        eligible: effective.subsidyEligible,
+        cap: effective.maxAmount,
+        sources,
+      })),
+    ).toEqual([
+      {
+        enabled: true,
+        eligible: true,
+        cap: '0',
+        sources: {
+          subsidyEnabled: undefined,
+          subsidyEligible: undefined,
+          maxAmount: undefined,
+          subsidyPayer: undefined,
+        },
+      },
+      {
+        enabled: false,
+        eligible: false,
+        cap: '7',
+        sources: {
+          subsidyEnabled: undefined,
+          subsidyEligible: undefined,
+          maxAmount: undefined,
+          subsidyPayer: undefined,
+        },
+      },
+    ])
+    expect(payload.policy.subsidyEnabled).toBe(false)
+    expect(payload.policy.terms?.[1]?.subsidyEligible).toBe(false)
+  })
+})
+
+describe('createSession', () => {
+  it('freezes the opened version and clones its draft across refreshed payloads', () => {
+    const opened = { version: 4, policy: { maxAmount: '11' } }
+    const session = Policies.createSession(opened)
+    opened.policy.maxAmount = '99'
+    expect({ session, changed: Policies.changed(session, opened.policy) }).toMatchInlineSnapshot(`
+      {
+        "changed": true,
+        "session": {
+          "baseVersion": 4,
+          "draft": {
+            "maxAmount": "11",
+          },
+        },
+      }
+    `)
+  })
+})
+
+describe('routeOptions', () => {
+  it('filters in both directions and deduplicates network/token choices across providers', () => {
+    expect(Policies.routeOptions(catalog, {}, 'sourceChainId')).toEqual([
+      { label: 'Base', value: 'eip155:8453' },
+      { label: 'Ethereum', value: 'eip155:1' },
+    ])
+    expect(
+      Policies.routeOptions(catalog, { destinationTokenId: 'usdt0' }, 'sourceChainId'),
+    ).toEqual([{ label: 'Ethereum', value: 'eip155:1' }])
+    expect(Policies.routeOptions(catalog, { providerId: 'across' }, 'destinationChainId')).toEqual([
+      { label: 'Arbitrum', value: 'eip155:42161' },
+    ])
+    expect(Policies.routeOptions(catalog, { sourceTokenId: 'usdt' }, 'destinationTokenId')).toEqual(
+      [{ label: 'USDT0', value: 'usdt0' }],
+    )
+    expect(
+      Policies.routeOptions(
+        catalog,
+        { sourceChainId: 'eip155:8453', destinationChainId: 'eip155:4217' },
+        'providerId',
+      ),
+    ).toEqual([
+      { label: 'relay', value: 'relay' },
+      { label: 'stargate', value: 'stargate' },
+    ])
+  })
+
+  it('ignores its own filter and broadens other choices when a filter is cleared', () => {
+    expect(
+      Policies.routeOptions(
+        catalog,
+        { sourceChainId: 'eip155:8453', providerId: 'relay' },
+        'providerId',
+      ),
+    ).toEqual([
+      { label: 'across', value: 'across' },
+      { label: 'relay', value: 'relay' },
+      { label: 'stargate', value: 'stargate' },
+    ])
+    expect(
+      Policies.routeOptions(
+        catalog,
+        { destinationTokenId: undefined, providerId: 'relay' },
+        'sourceTokenId',
+      ),
+    ).toEqual([
+      { label: 'USDC', value: 'usdc' },
+      { label: 'USDT', value: 'usdt' },
+    ])
+    expect(
+      Policies.routeOptions(
+        catalog,
+        { sourceTokenId: 'usdt', providerId: 'stargate' },
+        'destinationChainId',
+      ),
+    ).toEqual([])
+    expect(Policies.routeOptions([], {}, 'sourceChainId')).toEqual([])
+  })
+})
+
+describe('selectedRoute', () => {
+  it('requires both networks and tokens and preserves only policy identifiers', () => {
+    expect(
+      Policies.selectedRoute({
+        sourceChainId: 'eip155:8453',
+        sourceTokenId: 'usdc',
+        destinationChainId: 'eip155:4217',
+      }),
+    ).toBeUndefined()
+    expect(Policies.selectedRoute({ ...catalog[0]!, providerId: '' })).toEqual({
+      sourceChainId: 'eip155:8453',
+      sourceTokenId: 'usdc',
+      destinationChainId: 'eip155:4217',
+      destinationTokenId: 'usdce',
+    })
+    expect(Policies.selectedRoute(catalog[1]!)).toEqual({
+      sourceChainId: 'eip155:8453',
+      sourceTokenId: 'usdc',
+      destinationChainId: 'eip155:4217',
+      destinationTokenId: 'usdce',
+      providerId: 'stargate',
+    })
+  })
+})
+
+const catalog: Policies.Payload['routes'] = [
+  {
+    sourceChainId: 'eip155:8453',
+    sourceChainName: 'Base',
+    sourceTokenId: 'usdc',
+    sourceTokenSymbol: 'USDC',
+    destinationChainId: 'eip155:4217',
+    destinationChainName: 'Tempo',
+    destinationTokenId: 'usdce',
+    destinationTokenSymbol: 'USDC.e',
+    providerId: 'relay',
+    label: 'Base USDC → Tempo USDC.e (relay)',
+  },
+  {
+    sourceChainId: 'eip155:8453',
+    sourceChainName: 'Base',
+    sourceTokenId: 'usdc',
+    sourceTokenSymbol: 'USDC',
+    destinationChainId: 'eip155:4217',
+    destinationChainName: 'Tempo',
+    destinationTokenId: 'usdce',
+    destinationTokenSymbol: 'USDC.e',
+    providerId: 'stargate',
+    label: 'Base USDC → Tempo USDC.e (stargate)',
+  },
+  {
+    sourceChainId: 'eip155:1',
+    sourceChainName: 'Ethereum',
+    sourceTokenId: 'usdt',
+    sourceTokenSymbol: 'USDT',
+    destinationChainId: 'eip155:4217',
+    destinationChainName: 'Tempo',
+    destinationTokenId: 'usdt0',
+    destinationTokenSymbol: 'USDT0',
+    providerId: 'relay',
+    label: 'Ethereum USDT → Tempo USDT0 (relay)',
+  },
+  {
+    sourceChainId: 'eip155:8453',
+    sourceChainName: 'Base',
+    sourceTokenId: 'usdc',
+    sourceTokenSymbol: 'USDC',
+    destinationChainId: 'eip155:42161',
+    destinationChainName: 'Arbitrum',
+    destinationTokenId: 'usdc',
+    destinationTokenSymbol: 'USDC',
+    providerId: 'across',
+    label: 'Base USDC → Arbitrum USDC (across)',
+  },
+]

package/src/admin/ui/src/lib/route-policies.ts

@@ -0,0 +1,232 @@
+import * as ReactQuery from '@tanstack/react-query'
+import * as z from 'zod/mini'
+
+import type * as AdminPolicies from '../../../apps/route-policies.js'
+import * as Policy from '../../../../internal/routes/Policy.js'
+import * as Response from './response.js'
+
+export type Environment = Policy.Scope['environment']
+export type Payer = Policy.Payer
+export type Rule = Policy.Rule
+export type Overrides = Policy.Overrides
+export type Scope = Policy.Scope
+export type Payload = {
+  name: string | null
+  scope: Scope
+  version: number
+  policy: Overrides
+  layers: Array<{ scope: Scope; version: number; policy: Overrides }>
+  legacy: Policy.Legacy
+  routes: Array<z.output<typeof AdminPolicies.schema.Route>>
+}
+
+/** Partial catalog filters, not policy wildcards. */
+export type RouteSelection = { [field in keyof Rule]?: Rule[field] | undefined }
+
+/** Options matching every active filter except the field being edited. */
+export function routeOptions(
+  routes: Payload['routes'],
+  selection: RouteSelection,
+  field: keyof Rule,
+) {
+  const labels = {
+    destinationChainId: 'destinationChainName',
+    destinationTokenId: 'destinationTokenSymbol',
+    providerId: 'providerId',
+    sourceChainId: 'sourceChainName',
+    sourceTokenId: 'sourceTokenSymbol',
+  } as const
+  const options = new Map<string, string>()
+  for (const route of routes) {
+    if (
+      !Object.entries(selection).every(
+        ([key, value]) => key === field || !value || route[key as keyof Rule] === value,
+      )
+    )
+      continue
+    const value = route[field]
+    if (value) options.set(value, route[labels[field]] ?? value)
+  }
+  return [...options]
+    .map(([value, label]) => ({ label, value }))
+    .sort((a, b) => a.label.localeCompare(b.label))
+}
+
+/** Converts a complete selection to a rule, excluding display metadata and unset provider. */
+export function selectedRoute(selection: RouteSelection): Rule | undefined {
+  const { sourceChainId, sourceTokenId, destinationChainId, destinationTokenId, providerId } =
+    selection
+  if (!sourceChainId || !sourceTokenId || !destinationChainId || !destinationTokenId)
+    return undefined
+  return {
+    destinationChainId,
+    destinationTokenId,
+    ...(providerId ? { providerId } : {}),
+    sourceChainId,
+    sourceTokenId,
+  }
+}
+
+export const search = z.object({
+  orgId: z.string().check(z.minLength(1)),
+  environment: z.catch(z.optional(z.enum(['sandbox', 'production'])), undefined),
+  projectId: z.catch(z.optional(z.string()), undefined),
+  apiKeyId: z.catch(z.optional(z.string()), undefined),
+})
+
+export type EditSession = { baseVersion: number; draft: Overrides }
+
+export function createSession(payload: Pick<Payload, 'version' | 'policy'>): EditSession {
+  return { baseVersion: payload.version, draft: structuredClone(payload.policy) }
+}
+
+export function serializeScope(scope: Scope) {
+  const query = new URLSearchParams()
+  query.set('orgId', scope.orgId)
+  query.set('environment', scope.environment)
+  if (scope.projectId) query.set('projectId', scope.projectId)
+  if (scope.apiKeyId) query.set('apiKeyId', scope.apiKeyId)
+  return query.toString()
+}
+
+export function effective(
+  payload: Pick<Payload, 'layers' | 'legacy' | 'scope'>,
+  draft: Overrides,
+  route?: Rule,
+) {
+  const organization = payload.layers.find(({ scope }) => !scope.projectId && !scope.apiKeyId)
+  return Policy.resolve({
+    ...((payload.scope.projectId || payload.scope.apiKeyId) && !organization?.version
+      ? { defaultAccess: null }
+      : {}),
+    layers: policyLayers(payload, draft).map((layer) => layer.policy),
+    legacy: payload.legacy,
+    ...(route ? { route } : {}),
+  })
+}
+
+/** Summarizes currently allowed catalog routes and the winning scope for each field. */
+export function review(payload: Payload, draft: Overrides) {
+  const layers = policyLayers(payload, draft).toReversed()
+  const resolved = effective(payload, draft)
+  const access = layers.find((layer) => layer.policy.access !== undefined)
+  function source(
+    route: Rule,
+    field: 'subsidyEnabled' | 'subsidyEligible' | 'subsidyPayer' | 'maxAmount',
+  ) {
+    for (const layer of layers) {
+      const terms = layer.policy.terms?.filter((term) => Policy.allows([term], route))
+      const hasValue = (term: NonNullable<Overrides['terms']>[number]) =>
+        term[field] !== undefined ||
+        (field === 'subsidyEligible' && term.subsidyEnabled !== undefined)
+      const term =
+        terms?.find((term) => term.providerId !== undefined && hasValue(term)) ??
+        terms?.find((term) => term.providerId === undefined && hasValue(term))
+      const current = serializeScope(layer.scope) === serializeScope(payload.scope)
+      if (term)
+        return current
+          ? undefined
+          : `${scopeLabel(layer.scope)} · ${term.providerId ? 'route rule' : 'any-provider rule'}`
+      const key = field === 'subsidyEligible' ? 'subsidyRoutes' : field
+      if (layer.policy[key] !== undefined)
+        return current
+          ? undefined
+          : `${scopeLabel(layer.scope)} · ${field === 'subsidyEligible' ? 'eligibility list' : 'default'}`
+    }
+    // Legacy financial defaults belong to the organization, not the viewed child.
+    return field !== 'subsidyEligible' && (payload.scope.projectId || payload.scope.apiKeyId)
+      ? 'Organization · legacy default'
+      : undefined
+  }
+  return {
+    accessSource: access
+      ? scopeLabel(access.scope)
+      : resolved.access === null
+        ? 'Organization · legacy access'
+        : 'Default (no routes)',
+    defaults: layers
+      .filter(
+        ({ policy }) =>
+          policy.subsidyEnabled !== undefined ||
+          policy.subsidyPayer !== undefined ||
+          policy.maxAmount !== undefined ||
+          policy.subsidyRoutes !== undefined,
+      )
+      .map(({ scope, policy }) => ({ scope: scopeLabel(scope), policy })),
+    effective: resolved,
+    routes: payload.routes
+      .filter((route) => !resolved.suspended && Policy.allows(resolved.access, route))
+      .map((route) => ({
+        route,
+        effective: effective(payload, draft, route),
+        sources: {
+          maxAmount: source(route, 'maxAmount'),
+          subsidyEnabled: source(route, 'subsidyEnabled'),
+          subsidyEligible: source(route, 'subsidyEligible'),
+          subsidyPayer: source(route, 'subsidyPayer'),
+        },
+      })),
+  }
+}
+
+function scopeLabel(scope: Scope) {
+  return scope.apiKeyId ? 'API key' : scope.projectId ? 'Project' : 'Organization'
+}
+
+function policyLayers(payload: Pick<Payload, 'layers' | 'scope'>, draft: Overrides) {
+  const layers = payload.layers.map((layer) => ({
+    ...layer,
+    policy: serializeScope(layer.scope) === serializeScope(payload.scope) ? draft : layer.policy,
+  }))
+  if (
+    !payload.layers.some((layer) => serializeScope(layer.scope) === serializeScope(payload.scope))
+  )
+    layers.push({ scope: payload.scope, policy: draft, version: 0 })
+  return layers
+}
+
+export function changed(session: EditSession, original: Overrides) {
+  return JSON.stringify(session.draft) !== JSON.stringify(original)
+}
+
+function url(scope: Scope) {
+  const query = serializeScope(scope)
+  return `route-policies?${query}`
+}
+
+export namespace get {
+  export const key = (scope: Scope) => ['route-policies', scope] as const
+  export async function fn(scope: Scope) {
+    const response = await fetch(url(scope))
+    if (!response.ok)
+      throw new Error(
+        await Response.errorMessage(response, { fallback: 'Failed to load route policy.' }),
+      )
+    return (await response.json()) as Payload
+  }
+  export const options = (scope: Scope) =>
+    ReactQuery.queryOptions({ queryKey: key(scope), queryFn: () => fn(scope) })
+}
+
+export namespace put {
+  export async function fn(input: Pick<Payload, 'scope' | 'version' | 'policy'>) {
+    const response = await fetch(url(input.scope), {
+      method: 'PUT',
+      headers: { 'content-type': 'application/json' },
+      body: JSON.stringify(input),
+    })
+    if (response.status === 409) throw new StalePolicyError()
+    if (!response.ok)
+      throw new Error(
+        await Response.errorMessage(response, { fallback: 'Failed to save route policy.' }),
+      )
+    return (await response.json()) as Payload
+  }
+}
+
+export class StalePolicyError extends Error {
+  constructor() {
+    super('This policy changed after you opened it. Reload the latest version before saving.')
+    this.name = 'StalePolicyError'
+  }
+}