@stacksjs/defaults 0.70.58 → 0.70.59

package/app/Actions/Dashboard/Ci/runner-pressure-monitor.ts

@@ -0,0 +1,259 @@
+/**
+ * Runner-pressure monitor (stacksjs/stacks#1850).
+ *
+ * Bridges the pure `detectRunnerPressure()` from @stacksjs/github
+ * with the persistence layer (`ci_runner_samples` + `ci_runner_alert_states`)
+ * and the notification fan-out from #1849.
+ *
+ * Call from the CI StatusAction after a fresh snapshot resolves:
+ *
+ *   void runRunnerPressureMonitor(snapshot)
+ *
+ * Same fire-and-forget pattern as the failure notifier — never
+ * block the response on the persistence + fan-out round-trips.
+ *
+ * The cycle:
+ *
+ *   1. Skip entirely if `ci.alerts.enabled` is false.
+ *   2. Append a sample row per org from the current snapshot.
+ *   3. Prune samples older than `retentionHours`.
+ *   4. Load the last `windowMinutes` of samples + the current alert
+ *      states.
+ *   5. Run the pure detector.
+ *   6. For each `fire`/`clear` action: update the alert-state row.
+ *      Only `fire` triggers a notification — clearing is silent.
+ */
+
+import type { DashboardData, PressureAction, RunnerAlertState, RunnerSample } from '@stacksjs/github'
+import { dashboard as dashboardConfig } from '@stacksjs/config'
+import { db } from '@stacksjs/database'
+import { detectRunnerPressure } from '@stacksjs/github'
+import { notify } from '@stacksjs/notifications'
+
+interface SampleRow {
+  org: string
+  running: number
+  queued: number
+  cap: number
+  sampled_at: string
+}
+
+interface AlertStateRow {
+  org: string
+  alerting: number
+  last_alerted_at: string | null
+  last_cleared_at: string | null
+}
+
+async function appendSamples(snapshot: DashboardData, nowIso: string): Promise<void> {
+  const runners = snapshot.runners ?? {}
+  const orgs = Object.keys(runners)
+  if (orgs.length === 0)
+    return
+  // Insert one row per org. Cross-dialect multi-row INSERT keeps it
+  // a single round-trip even for the typical 5-org fleet.
+  const rows = orgs.map((org) => {
+    const r = runners[org]
+    return { org, running: r.running, queued: r.queued, cap: r.cap, sampled_at: nowIso }
+  })
+  await db.insertInto('ci_runner_samples').values(rows as any).execute()
+}
+
+async function pruneOldSamples(retentionHours: number, nowMs: number): Promise<void> {
+  const cutoffIso = new Date(nowMs - retentionHours * 60 * 60_000).toISOString()
+  await db.deleteFrom('ci_runner_samples')
+    .where('sampled_at', '<', cutoffIso)
+    .execute()
+}
+
+async function loadWindowSamples(windowMinutes: number, nowMs: number): Promise<RunnerSample[]> {
+  const cutoffIso = new Date(nowMs - windowMinutes * 60_000).toISOString()
+  const rows = await db.unsafe(
+    'SELECT org, running, queued, cap, sampled_at FROM ci_runner_samples WHERE sampled_at >= ? ORDER BY sampled_at ASC',
+    [cutoffIso],
+  ).execute() as SampleRow[]
+
+  return (rows ?? []).map((r): RunnerSample => ({
+    org: r.org,
+    running: Number(r.running),
+    queued: Number(r.queued),
+    cap: Number(r.cap),
+    sampledAt: r.sampled_at,
+  }))
+}
+
+async function loadAlertStates(): Promise<Map<string, RunnerAlertState>> {
+  const rows = await db.unsafe(
+    'SELECT org, alerting, last_alerted_at, last_cleared_at FROM ci_runner_alert_states',
+  ).execute() as AlertStateRow[]
+
+  const map = new Map<string, RunnerAlertState>()
+  for (const r of rows ?? []) {
+    map.set(r.org, {
+      org: r.org,
+      alerting: Number(r.alerting) === 1,
+      lastAlertedAt: r.last_alerted_at,
+      lastClearedAt: r.last_cleared_at,
+    })
+  }
+  return map
+}
+
+async function upsertAlertState(org: string, alerting: boolean, nowIso: string): Promise<void> {
+  // Cross-dialect upsert: SELECT-then-INSERT/UPDATE. Same shape as
+  // the failure-notifier's state writes — keep the patterns
+  // consistent so future maintainers don't second-guess the
+  // dialect choice in one place vs another.
+  const existing = await db.unsafe(
+    'SELECT org FROM ci_runner_alert_states WHERE org = ? LIMIT 1',
+    [org],
+  ).execute() as Array<{ org: string }>
+
+  if (existing?.length) {
+    const set: Record<string, unknown> = {
+      alerting: alerting ? 1 : 0,
+      updated_at: nowIso,
+    }
+    if (alerting) set.last_alerted_at = nowIso
+    else set.last_cleared_at = nowIso
+    await db.updateTable('ci_runner_alert_states').set(set as any).where('org', '=', org).execute()
+  }
+  else {
+    await db.insertInto('ci_runner_alert_states').values({
+      org,
+      alerting: alerting ? 1 : 0,
+      last_alerted_at: alerting ? nowIso : null,
+      last_cleared_at: alerting ? null : nowIso,
+      updated_at: nowIso,
+    } as any).execute()
+  }
+}
+
+function buildPayload(action: PressureAction): { subject: string, body: string, data: Record<string, unknown> } {
+  const { org, current, sustainedMs } = action
+  const minutes = Math.round(sustainedMs / 60_000)
+  const subject = `Runner pressure: ${org} — ${current.queued} queued`
+  const body = [
+    `Org: ${org}`,
+    `Queue depth: ${current.queued} (cap ${current.cap}, ${current.running} running)`,
+    `Sustained for: ${minutes}m`,
+  ].join('\n')
+  return {
+    subject,
+    body,
+    data: {
+      org,
+      running: current.running,
+      queued: current.queued,
+      cap: current.cap,
+      sustainedMs,
+    },
+  }
+}
+
+export async function runRunnerPressureMonitor(snapshot: DashboardData): Promise<void> {
+  const ci = dashboardConfig?.ci
+  const alerts = ci?.alerts
+  if (!alerts?.enabled || !snapshot.runners || Object.keys(snapshot.runners).length === 0)
+    return
+
+  const queuedThreshold = alerts.queuedThreshold ?? 8
+  const windowMinutes = alerts.windowMinutes ?? 10
+  const retentionHours = alerts.retentionHours ?? 24
+  const channels = (alerts.channels ?? ['chat']) as Array<'email' | 'sms' | 'chat' | 'database'>
+  const recipients = alerts.recipients ?? []
+
+  const nowMs = Date.now()
+  const nowIso = new Date(nowMs).toISOString()
+
+  try {
+    // Step 1+2: append the new sample, prune old.
+    await appendSamples(snapshot, nowIso)
+    await pruneOldSamples(retentionHours, nowMs)
+
+    // Step 3+4: load window + alert states.
+    const [windowSamples, states] = await Promise.all([
+      loadWindowSamples(windowMinutes, nowMs),
+      loadAlertStates(),
+    ])
+
+    // Step 5: detect.
+    const actions = detectRunnerPressure(windowSamples, states, {
+      queuedThreshold,
+      windowMinutes,
+      now: nowMs,
+    })
+
+    // Step 6: act on each transition.
+    for (const a of actions) {
+      // State write first so the next refresh has the right baseline
+      // even if the notification fan-out throws.
+      await upsertAlertState(a.org, a.action === 'fire', nowIso)
+
+      if (a.action !== 'fire')
+        continue
+
+      const payload = buildPayload(a)
+      const broadcastChannels = channels.filter(c => c === 'chat')
+      const recipientChannels = channels.filter(c => c !== 'chat')
+
+      if (broadcastChannels.length > 0) {
+        try {
+          await notify({}, payload, broadcastChannels, { ignorePreferences: true })
+        }
+        catch (err) {
+          console.warn('[runner-pressure-monitor] chat broadcast failed:', err)
+        }
+      }
+      if (recipientChannels.length > 0 && recipients.length > 0) {
+        for (const r of recipients) {
+          try {
+            await notify(r, payload, recipientChannels, { ignorePreferences: true })
+          }
+          catch (err) {
+            console.warn('[runner-pressure-monitor] notify failed:', err)
+          }
+        }
+      }
+    }
+  }
+  catch (err) {
+    console.warn('[runner-pressure-monitor] cycle failed:', err)
+  }
+}
+
+/**
+ * Fetch the recent runner-sample history for one org — used by the
+ * sparkline UI. Returns ASC order by `sampledAt` so the SVG path
+ * builder can map index → x without sorting.
+ *
+ * Bounded by `retentionHours` (defaults to 24) so a misconfigured
+ * caller can't accidentally pull the entire table.
+ */
+export async function fetchRunnerHistory(
+  org: string,
+  options: { limit?: number, retentionHours?: number } = {},
+): Promise<RunnerSample[]> {
+  const limit = Math.max(1, Math.min(options.limit ?? 60, 500))
+  const retentionHours = options.retentionHours ?? 24
+  const cutoffIso = new Date(Date.now() - retentionHours * 60 * 60_000).toISOString()
+
+  // ASC-by-newest then re-reverse so we get the N most recent samples
+  // in ASC order (oldest → newest) — what the sparkline path needs.
+  const rows = await db.unsafe(
+    `SELECT org, running, queued, cap, sampled_at
+    FROM ci_runner_samples
+    WHERE org = ? AND sampled_at >= ?
+    ORDER BY sampled_at DESC
+    LIMIT ?`,
+    [org, cutoffIso, limit],
+  ).execute() as SampleRow[]
+
+  return (rows ?? []).reverse().map((r): RunnerSample => ({
+    org: r.org,
+    running: Number(r.running),
+    queued: Number(r.queued),
+    cap: Number(r.cap),
+    sampledAt: r.sampled_at,
+  }))
+}

package/app/Actions/Dashboard/Cloud/CloudIndexAction.ts

@@ -0,0 +1,61 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'CloudIndexAction',
+  description: 'Returns cloud services overview for the dashboard.',
+  method: 'GET',
+  async handle() {
+    const providers = [
+      { name: 'AWS', status: 'connected', resources: 24, spend: '$1,234/mo', region: 'us-east-1' },
+      { name: 'DigitalOcean', status: 'connected', resources: 8, spend: '$456/mo', region: 'nyc1' },
+      { name: 'Cloudflare', status: 'connected', resources: 12, spend: '$89/mo', region: 'Global' },
+      { name: 'Vercel', status: 'connected', resources: 5, spend: '$0/mo', region: 'Global' },
+    ]
+
+    const stats = [
+      { label: 'Monthly Spend', value: '$1,779' },
+      { label: 'Resources', value: '49' },
+      { label: 'Regions', value: '4' },
+      { label: 'Uptime', value: '99.99%' },
+    ]
+
+    const resources = [
+      { name: 'web-server-1', type: 'EC2', provider: 'AWS', status: 'running', cost: '$45/mo' },
+      { name: 'database-primary', type: 'RDS', provider: 'AWS', status: 'running', cost: '$234/mo' },
+      { name: 'cdn-assets', type: 'CloudFront', provider: 'AWS', status: 'active', cost: '$12/mo' },
+      { name: 'app-droplet', type: 'Droplet', provider: 'DigitalOcean', status: 'running', cost: '$48/mo' },
+      { name: 'stacks-site', type: 'Pages', provider: 'Cloudflare', status: 'active', cost: '$0/mo' },
+    ]
+
+    const functions = [
+      { name: 'api-handler', runtime: 'Node.js 20', invocations: '45.2K', avgDuration: '45ms', errors: 12, status: 'active' },
+      { name: 'image-processor', runtime: 'Node.js 20', invocations: '12.3K', avgDuration: '234ms', errors: 3, status: 'active' },
+      { name: 'email-sender', runtime: 'Node.js 20', invocations: '8.9K', avgDuration: '89ms', errors: 0, status: 'active' },
+      { name: 'webhook-handler', runtime: 'Node.js 20', invocations: '23.4K', avgDuration: '56ms', errors: 5, status: 'active' },
+      { name: 'cron-job', runtime: 'Node.js 20', invocations: '720', avgDuration: '1.2s', errors: 2, status: 'active' },
+    ]
+
+    const serverlessStats = [
+      { label: 'Total Functions', value: '5' },
+      { label: 'Invocations (24h)', value: '90.5K' },
+      { label: 'Avg Duration', value: '85ms' },
+      { label: 'Error Rate', value: '0.02%' },
+    ]
+
+    const edges = [
+      { region: 'US East', latency: '12ms', requests: '34.5K' },
+      { region: 'US West', latency: '45ms', requests: '12.3K' },
+      { region: 'Europe', latency: '89ms', requests: '23.4K' },
+      { region: 'Asia', latency: '156ms', requests: '8.9K' },
+    ]
+
+    return {
+      providers,
+      stats,
+      resources,
+      functions,
+      serverlessStats,
+      edges,
+    }
+  },
+})

package/app/Actions/Dashboard/Commands/CreateCommand.ts

@@ -0,0 +1,11 @@
+import { Action } from '@stacksjs/actions'
+
+export default new Action({
+  name: 'CreateFunction',
+  description: 'Creates a new function.',
+  apiResponse: true,
+
+  async handle() {
+    //
+  },
+})

package/app/Actions/Dashboard/Commands/GetAverageCommandTime.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Command } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetAverageCommandTime',
+  description: 'Gets the average command time of your application.',
+  apiResponse: true,
+
+  async handle() {
+    // return Command.averageDuration()
+  },
+})

package/app/Actions/Dashboard/Commands/GetCommandCount.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Command } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetCommandCount',
+  description: 'Gets the total number of commands.',
+  apiResponse: true,
+
+  async handle() {
+    // return Command.count()
+  },
+})

package/app/Actions/Dashboard/Commands/GetCommandSuccessRate.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Command } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetCommandSuccessRate',
+  description: 'Gets the command success rate of your application.',
+  apiResponse: true,
+
+  async handle() {
+    // return Command.successRate()
+  },
+})

package/app/Actions/Dashboard/Commands/GetCommands.ts

@@ -0,0 +1,12 @@
+import { Action } from '@stacksjs/actions'
+// import { Command } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'GetCommands',
+  description: 'Gets your application commands.',
+  apiResponse: true,
+
+  async handle() {
+    // return Command.all()
+  },
+})

package/app/Actions/Dashboard/Commerce/CommerceCouponsAction.ts

@@ -0,0 +1,48 @@
+import { Action } from '@stacksjs/actions'
+import { Coupon } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'CommerceCoupons',
+  description: 'Returns coupons list with stats.',
+  method: 'GET',
+  async handle() {
+    try {
+      const allCoupons = await Coupon.orderByDesc('id').limit(50).get()
+
+      const coupons = allCoupons.map(r => ({
+        code: String(r.get('code') || ''),
+        type: String(r.get('type') || ''),
+        value: String(r.get('value') || ''),
+        uses: Number(r.get('uses') || 0),
+        limit: r.get('usage_limit') || null,
+        expires: String(r.get('expires_at') || 'Never'),
+        status: String(r.get('status') || 'active'),
+      }))
+
+      // eslint-disable-next-line pickier/no-unused-vars
+      const totalCoupons = coupons.length
+      const activeCount = coupons.filter(c => c.status === 'active').length
+      const totalUses = coupons.reduce((s, c) => s + c.uses, 0)
+
+      const stats = [
+        { label: 'Active Coupons', value: String(activeCount) },
+        { label: 'Total Uses', value: String(totalUses) },
+        { label: 'Revenue Impact', value: '-' },
+        { label: 'Avg Discount', value: '-' },
+      ]
+
+      return { coupons, stats }
+    }
+    catch {
+      return {
+        coupons: [],
+        stats: [
+          { label: 'Active Coupons', value: '0' },
+          { label: 'Total Uses', value: '0' },
+          { label: 'Revenue Impact', value: '-' },
+          { label: 'Avg Discount', value: '-' },
+        ],
+      }
+    }
+  },
+})

package/app/Actions/Dashboard/Commerce/CommerceCustomersAction.ts

@@ -0,0 +1,48 @@
+import { Action } from '@stacksjs/actions'
+import { Customer } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'CommerceCustomers',
+  description: 'Returns customers list with stats.',
+  method: 'GET',
+  async handle() {
+    try {
+      const allCustomers = await Customer.all()
+      const totalCustomers = await Customer.count()
+
+      const customers = allCustomers.map(c => ({
+        name: String(c.get('name') || 'Unknown'),
+        email: String(c.get('email') || 'N/A'),
+        orders: Number(c.get('order_count') || 0),
+        spent: `$${(Number(c.get('total_spent') || 0)).toFixed(2)}`,
+        lastOrder: 'Recently',
+        status: (Number(c.get('total_spent') || 0)) > 500 ? 'vip' : (Number(c.get('order_count') || 0)) > 0 ? 'active' : 'inactive',
+      }))
+
+      const activeCustomers = customers.filter(c => c.status === 'active' || c.status === 'vip').length
+      const vipCustomers = customers.filter(c => c.status === 'vip').length
+      const totalSpent = allCustomers.reduce((sum, c) => sum + (Number(c.get('total_spent') || 0)), 0)
+      const avgLifetimeValue = totalCustomers > 0 ? totalSpent / totalCustomers : 0
+
+      const stats = [
+        { label: 'Total Customers', value: String(totalCustomers) },
+        { label: 'Active', value: String(activeCustomers) },
+        { label: 'VIP', value: String(vipCustomers) },
+        { label: 'Avg Lifetime Value', value: `$${avgLifetimeValue.toFixed(2)}` },
+      ]
+
+      return { customers, stats }
+    }
+    catch {
+      return {
+        customers: [],
+        stats: [
+          { label: 'Total Customers', value: '0' },
+          { label: 'Active', value: '0' },
+          { label: 'VIP', value: '0' },
+          { label: 'Avg Lifetime Value', value: '$0.00' },
+        ],
+      }
+    }
+  },
+})

package/app/Actions/Dashboard/Commerce/CommerceDashboardAction.ts

@@ -0,0 +1,98 @@
+import { Action } from '@stacksjs/actions'
+import { orders, payments } from '@stacksjs/commerce'
+
+interface ComparisonShape {
+  is_increase: boolean
+  percentage: number
+}
+
+function formatChange(comparison?: ComparisonShape): string {
+  if (!comparison) return ''
+  const sign = comparison.is_increase ? '+' : '-'
+  return `${sign}${Number(comparison.percentage).toFixed(1)}%`
+}
+
+function formatUSD(amount: number): string {
+  return `$${Number(amount || 0).toLocaleString('en-US', { minimumFractionDigits: 2, maximumFractionDigits: 2 })}`
+}
+
+function formatRelativeTime(iso: string | null | undefined): string {
+  if (!iso) return ''
+  const then = new Date(iso).getTime()
+  if (Number.isNaN(then)) return ''
+  const diff = Date.now() - then
+  const minutes = Math.floor(diff / 60000)
+  if (minutes < 1) return 'just now'
+  if (minutes < 60) return `${minutes}m ago`
+  const hours = Math.floor(minutes / 60)
+  if (hours < 24) return `${hours}h ago`
+  const days = Math.floor(hours / 24)
+  return `${days}d ago`
+}
+
+export default new Action({
+  name: 'CommerceDashboard',
+  description: 'Returns commerce dashboard stats, recent orders, and top products for the last 30 days.',
+  method: 'GET',
+  async handle() {
+    try {
+      const [paymentStats, orderStats] = await Promise.all([
+        payments.fetchPaymentStats(30),
+        orders.fetchStats(),
+      ])
+
+      // KPI tiles. The first three are real aggregates with period-over-period
+      // change. Conversion rate is intentionally a placeholder until we wire a
+      // session-tracking source — see TODO at the bottom of this file.
+      const stats = [
+        {
+          label: 'Revenue (30d)',
+          value: formatUSD(paymentStats.total_revenue),
+          change: formatChange(paymentStats.comparison?.revenue),
+        },
+        {
+          label: 'Orders',
+          value: String(orderStats.total),
+          change: formatChange(paymentStats.comparison?.transactions),
+        },
+        {
+          label: 'Avg Order Value',
+          value: formatUSD(paymentStats.average_transaction),
+          change: formatChange(paymentStats.comparison?.average),
+        },
+        // Conversion rate stays canned — we don't track sessions yet,
+        // so we cannot compute orders / sessions. See TODO below.
+        { label: 'Conversion Rate', value: '—', change: '' },
+      ]
+
+      const recentOrders = (orderStats.recent ?? []).slice(0, 5).map((o: any) => ({
+        id: `ORD-${String(o.id).padStart(4, '0')}`,
+        customer: o.customer_id ? `#${o.customer_id}` : '—',
+        total: formatUSD(Number(o.total_amount) || 0),
+        status: String(o.status || 'pending'),
+        time: formatRelativeTime(o.created_at),
+      }))
+
+      // TODO: top products needs an order_items × products aggregation
+      // (sum of quantity grouped by product, ordered desc, top N). The
+      // existing `Product.orderByDesc('price')` was wrong — that returns
+      // most-expensive products, not best sellers. Until that helper is
+      // written, return an empty list rather than misleading data.
+      const topProducts: Array<{ name: string, sales: number, revenue: string }> = []
+
+      return { stats, recentOrders, topProducts }
+    }
+    catch {
+      return {
+        stats: [
+          { label: 'Revenue (30d)', value: '$0.00', change: '' },
+          { label: 'Orders', value: '0', change: '' },
+          { label: 'Avg Order Value', value: '$0.00', change: '' },
+          { label: 'Conversion Rate', value: '—', change: '' },
+        ],
+        recentOrders: [],
+        topProducts: [],
+      }
+    }
+  },
+})

package/app/Actions/Dashboard/Commerce/CommerceDeliveryAction.ts

@@ -0,0 +1,65 @@
+import { Action } from '@stacksjs/actions'
+import { ShippingMethod, DeliveryRoute, ShippingZone } from '@stacksjs/orm'
+
+export default new Action({
+  name: 'CommerceDelivery',
+  description: 'Returns shipping/delivery data including shipments, carriers, and zones.',
+  method: 'GET',
+  async handle() {
+    try {
+      const [allMethods, allRoutes, allZones] = await Promise.all([
+        ShippingMethod.all(),
+        DeliveryRoute.all(),
+        ShippingZone.all(),
+      ])
+
+      const carriers = allMethods.map(m => ({
+        name: String(m.get('name') || ''),
+        shipments: Number(m.get('shipment_count') || 0),
+        onTime: '-',
+        status: String(m.get('status') || 'active'),
+      }))
+
+      const shipments = allRoutes.map(r => ({
+        id: `SHP-${String(r.get('id')).padStart(4, '0')}`,
+        order: String(r.get('order_id') ? `ORD-${r.get('order_id')}` : '-'),
+        carrier: String(r.get('carrier') || r.get('name') || ''),
+        tracking: String(r.get('tracking_number') || '-'),
+        status: String(r.get('status') || 'processing'),
+        eta: String(r.get('estimated_delivery') || '-'),
+      }))
+
+      const zones = allZones.map(z => ({
+        name: String(z.get('name') || ''),
+        rate: String(z.get('rate') || '-'),
+        delivery: String(z.get('delivery_time') || '-'),
+      }))
+
+      const inTransit = shipments.filter(s => s.status === 'in_transit').length
+      const delivered = shipments.filter(s => s.status === 'delivered').length
+      const exceptions = shipments.filter(s => s.status === 'exception').length
+
+      const stats = [
+        { label: 'In Transit', value: String(inTransit) },
+        { label: 'Delivered Today', value: String(delivered) },
+        { label: 'Exceptions', value: String(exceptions) },
+        { label: 'Avg Delivery Time', value: '-' },
+      ]
+
+      return { shipments, stats, carriers, zones }
+    }
+    catch {
+      return {
+        shipments: [],
+        stats: [
+          { label: 'In Transit', value: '0' },
+          { label: 'Delivered Today', value: '0' },
+          { label: 'Exceptions', value: '0' },
+          { label: 'Avg Delivery Time', value: '-' },
+        ],
+        carriers: [],
+        zones: [],
+      }
+    }
+  },
+})