@meith/web 0.31.0 → 0.33.0

package/src/components/shell/nav-disclosure-enhancer.tsx

@@ -0,0 +1,36 @@
+'use client'
+
+import { useEffect } from 'react'
+
+const OPEN_DISCLOSURES = '[data-nav-disclosure][open]'
+
+export function NavDisclosureEnhancer() {
+  useEffect(() => {
+    function onPointerDown(event: PointerEvent) {
+      const target = event.target
+      if (!(target instanceof Node)) return
+
+      for (const details of document.querySelectorAll<HTMLDetailsElement>(OPEN_DISCLOSURES)) {
+        if (!details.contains(target)) details.open = false
+      }
+    }
+
+    function onKeyDown(event: KeyboardEvent) {
+      if (event.key !== 'Escape') return
+
+      for (const details of document.querySelectorAll<HTMLDetailsElement>(OPEN_DISCLOSURES)) {
+        details.open = false
+      }
+    }
+
+    document.addEventListener('pointerdown', onPointerDown)
+    document.addEventListener('keydown', onKeyDown)
+
+    return () => {
+      document.removeEventListener('pointerdown', onPointerDown)
+      document.removeEventListener('keydown', onKeyDown)
+    }
+  }, [])
+
+  return null
+}

package/src/components/shell/notice-toast.tsx

@@ -0,0 +1,40 @@
+'use client'
+
+import { useCallback, useEffect, useState } from 'react'
+
+import { Toast, type ToastTone } from '@meith/ui/toast'
+
+import { fromCopy, useCopy } from './copy'
+
+export function NoticeToast({
+  kind,
+  message,
+  dismissHref,
+}: {
+  kind: ToastTone
+  message: string
+  dismissHref: string | null
+}) {
+  const copy = useCopy()
+  const [mounted, setMounted] = useState(false)
+
+  useEffect(() => setMounted(true), [])
+
+  const clearNotice = useCallback(() => {
+    if (dismissHref === null || typeof window === 'undefined') return
+    window.history.replaceState(window.history.state, '', dismissHref)
+  }, [dismissHref])
+
+  if (!mounted) return null
+
+  return (
+    <div
+      data-notice="toast"
+      className="pointer-events-none fixed inset-x-0 bottom-4 z-50 flex justify-center px-4"
+    >
+      <Toast tone={kind} dismissLabel={fromCopy(copy, 'notice.dismiss')} onDismiss={clearNotice}>
+        {message}
+      </Toast>
+    </div>
+  )
+}

package/src/components/shell/notification-menu.tsx

@@ -2,6 +2,7 @@
 
 import { useActionState } from 'react'
 
+import { TextLink } from '@meith/ui'
 import { Popover } from '@meith/ui/popover'
 import { Tabs } from '@meith/ui/tabs'
 
@@ -223,12 +224,13 @@ function Panel({ tab, copy }: { tab: NotificationMenuTab; copy: Copy }) {
       )}
 
       <div className="flex items-center justify-between gap-2 border-t border-border px-2 pt-2">
-        <a
+        <TextLink
           href={tab.allHref}
-          className="rounded-md px-2 py-1 text-xs font-medium text-foreground underline decoration-border underline-offset-2 hover:decoration-foreground focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-ring"
+          size="xs"
+          className="rounded-md px-2 py-1 focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-ring"
         >
           {fromCopy(copy, 'board.notificationMenu.viewAll')}
-        </a>
+        </TextLink>
 
         {unreadRows.length > 0 && (
           <SeenForm

package/src/components/shell/page-shell.tsx

@@ -4,6 +4,7 @@ import { requireSlot, slotCopy } from '@meith/theme-kit'
 
 import { LogoutForm } from '@/components/account/logout-form'
 import { InstallBanner } from '@/components/shell/install-banner'
+import { NavDisclosureEnhancer } from '@/components/shell/nav-disclosure-enhancer'
 import { NotificationMenu } from '@/components/shell/notification-menu'
 import { OnboardingBanner } from '@/components/shell/onboarding-banner'
 import { ThemeSwitcher } from '@/components/shell/theme-switcher'
@@ -152,6 +153,8 @@ export async function PageShell({ actor, children }: { actor: Actor; children: R
         </UserPanel>
       </Header>
 
+      <NavDisclosureEnhancer />
+
       {await boardRegion('header.notice', actor)}
 
       {install !== null && <InstallBanner {...install} />}

package/src/components/shell/scheme-toggle.tsx

@@ -0,0 +1,72 @@
+'use client'
+
+import { useActionState } from 'react'
+
+import { setSchemeAction } from '@/server/appearance-actions'
+import {
+  COLOUR_SCHEMES,
+  type ColourSchemePreference,
+  colorSchemeProperty,
+  schemeClass,
+} from '@/view/theme-preference'
+
+import { PendingButton } from '../auth/form-controls'
+import { ProgressiveMarker } from '../content/progressive-marker'
+
+const EMPTY: { scheme?: ColourSchemePreference } = {}
+
+function applySchemeImmediately(scheme: ColourSchemePreference): void {
+  const root = document.documentElement
+  root.classList.remove('light', 'dark')
+  const applied = schemeClass(scheme)
+  if (applied !== '') root.classList.add(applied)
+  root.style.colorScheme = colorSchemeProperty(scheme)
+}
+
+export function SchemeToggle({
+  scheme,
+  groupLabel,
+  labels,
+  icons,
+}: {
+  scheme: ColourSchemePreference
+  groupLabel: string
+  labels: Readonly<Record<ColourSchemePreference, string>>
+  icons: Readonly<Record<ColourSchemePreference, React.ReactNode>>
+}) {
+  const [state, action] = useActionState(setSchemeAction, EMPTY)
+  const current = state.scheme ?? scheme
+
+  return (
+    <form action={action}>
+      <ProgressiveMarker />
+      <span
+        role="group"
+        aria-label={groupLabel}
+        className="inline-flex items-center overflow-hidden rounded-md border border-border text-muted-foreground"
+      >
+        {COLOUR_SCHEMES.map((option) => {
+          const selected = current === option
+          return (
+            <PendingButton
+              key={option}
+              name="scheme"
+              value={option}
+              title={labels[option]}
+              aria-pressed={selected}
+              onClick={() => applySchemeImmediately(option)}
+              className={`inline-flex h-8 items-center justify-center border-border px-2.5 transition-colors [&:not(:first-child)]:border-l focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-ring ${
+                selected
+                  ? 'bg-primary text-primary-foreground'
+                  : 'bg-background hover:bg-accent hover:text-accent-foreground'
+              }`}
+            >
+              {icons[option]}
+              <span className="sr-only">{labels[option]}</span>
+            </PendingButton>
+          )
+        })}
+      </span>
+    </form>
+  )
+}

package/src/components/shell/theme-switcher.tsx

@@ -1,17 +1,12 @@
 import { PendingButton } from '@/components/auth/form-controls'
 import { MonitorIcon, MoonIcon, SunIcon } from '@/components/shell/appearance-icons'
+import { SchemeToggle } from '@/components/shell/scheme-toggle'
 import { setAppearanceAction } from '@/server/appearance-actions'
 import { getTranslator } from '@/server/i18n'
 import { currentColourScheme, currentThemeKey } from '@/server/theme'
 import { getBoardThemeStyle } from '@/server/theme-runtime'
 import { COLOUR_SCHEMES, type ColourSchemePreference } from '@/view/theme-preference'
 
-const SCHEME_ICON: Record<ColourSchemePreference, () => React.ReactNode> = {
-  light: SunIcon,
-  system: MonitorIcon,
-  dark: MoonIcon,
-}
-
 const SCHEME_LABEL_KEY: Record<ColourSchemePreference, string> = {
   system: 'appearance.scheme.system',
   light: 'appearance.scheme.light',
@@ -29,6 +24,15 @@ export async function ThemeSwitcher() {
     getTranslator(),
   ])
 
+  const icons: Record<ColourSchemePreference, React.ReactNode> = {
+    light: <SunIcon />,
+    system: <MonitorIcon />,
+    dark: <MoonIcon />,
+  }
+  const labels = Object.fromEntries(
+    COLOUR_SCHEMES.map((option) => [option, t.t(SCHEME_LABEL_KEY[option])]),
+  ) as Record<ColourSchemePreference, string>
+
   return (
     <section
       aria-label={t.t('appearance.section')}
@@ -55,36 +59,12 @@ export async function ThemeSwitcher() {
         </form>
       )}
 
-      <form action={setAppearanceAction}>
-        <span
-          role="group"
-          aria-label={t.t('appearance.schemeGroup')}
-          className="inline-flex items-center overflow-hidden rounded-md border border-border text-muted-foreground"
-        >
-          {COLOUR_SCHEMES.map((option) => {
-            const Icon = SCHEME_ICON[option]
-            const label = t.t(SCHEME_LABEL_KEY[option])
-            const selected = scheme === option
-            return (
-              <PendingButton
-                key={option}
-                name="scheme"
-                value={option}
-                title={label}
-                aria-pressed={selected}
-                className={`inline-flex h-8 items-center justify-center border-border px-2.5 transition-colors [&:not(:first-child)]:border-l focus-visible:outline-2 focus-visible:-outline-offset-2 focus-visible:outline-ring ${
-                  selected
-                    ? 'bg-primary text-primary-foreground'
-                    : 'bg-background hover:bg-accent hover:text-accent-foreground'
-                }`}
-              >
-                <Icon />
-                <span className="sr-only">{label}</span>
-              </PendingButton>
-            )
-          })}
-        </span>
-      </form>
+      <SchemeToggle
+        scheme={scheme}
+        groupLabel={t.t('appearance.schemeGroup')}
+        labels={labels}
+        icons={icons}
+      />
     </section>
   )
 }

package/src/components/shell/view-tabs.tsx

@@ -35,7 +35,7 @@ export function ViewTabs({
                 'inline-flex h-8 items-center gap-1.5 rounded-md px-3 text-sm whitespace-nowrap transition-colors',
                 'focus-visible:outline-2 focus-visible:outline-offset-2 focus-visible:outline-ring',
                 tab.isCurrent
-                  ? 'bg-card font-semibold text-foreground shadow-sm'
+                  ? 'bg-card font-semibold text-primary shadow-sm'
                   : 'font-medium text-muted-foreground hover:text-foreground',
               )}
             >

package/src/server/admin-actions.ts

@@ -3,11 +3,20 @@
 import { redirect } from 'next/navigation'
 
 import { generateToken, hashToken, verifyPassword } from '@meith/accounts'
-import { ipAllowed } from '@meith/admin'
+import { type AdminService, ipAllowed } from '@meith/admin'
 import { ForbiddenError, logger, ValidationError } from '@meith/core'
 import { msg } from '@meith/i18n'
 
-import { adminAllowlist, adminService, recordAdminAction, resolveAdmin } from './admin'
+import {
+  abandonAdminSecondFactor,
+  adminAllowlist,
+  adminService,
+  holdAdminSecondFactor,
+  pendingAdminSecondFactor,
+  recordAdminAction,
+  redeemAdminSecondFactor,
+  resolveAdmin,
+} from './admin'
 import { boardAuthConfig } from './auth-config'
 import type { FormState } from './auth-form-state'
 import { getContainer } from './container'
@@ -71,31 +80,21 @@ export async function adminSignInAction(_prev: FormState, form: FormData): Promi
       throw new ForbiddenError(msg('error.app.password-right'))
     }
 
-    try {
-      await assertSecondFactorGiven({ userId: actor.userId, form })
-    } catch (err) {
-      await failAttempt()
-      throw err
-    }
+    const next = safeAdminReturn(text(form, 'next'))
+    const twoFactor = twoFactorService()
 
-    await accountStore.loginAttempts.clear(attemptBucket)
-
-    const existing = await resolveAdmin()
-    if ('context' in existing) {
-      await service.markReauthenticated(existing.context.session.id)
-      await recordAdminAction({ action: 'admin.reauthenticated' })
+    if (twoFactor !== null && (await twoFactor.isEnrolled(actor.userId))) {
+      await holdAdminSecondFactor(actor.userId, next)
+      target = '/admin'
     } else {
-      const token = generateToken()
-      const session = await service.start({
-        userId: actor.userId,
-        tokenHash: await hashToken(token),
-        ipPrefix: await retainedIpPrefix(),
-      })
-      await setAdminCookie(token, session.expiresAt)
-      await recordAdminAction({ action: 'admin.signed_in' })
-    }
+      if (twoFactor !== null && (await twoFactorRequiredForStaff())) {
+        await failAttempt()
+        throw new ForbiddenError(msg('adminAction.twoFactorRequired'))
+      }
 
-    target = safeAdminReturn(text(form, 'next'))
+      await accountStore.loginAttempts.clear(attemptBucket)
+      target = await startAdminSession(service, actor.userId, next)
+    }
   } catch (err) {
     return toFormState(err)
   }
@@ -103,39 +102,109 @@ export async function adminSignInAction(_prev: FormState, form: FormData): Promi
   redirect(target)
 }
 
-async function adminReauthenticationBucket(userId: number): Promise<string> {
-  const prefix = await retainedIpPrefix()
-  return prefix === null ? `admin-reauth:${userId}` : `admin-reauth:${userId}@${prefix}`
-}
+export async function adminVerifySecondFactorAction(
+  _prev: FormState,
+  form: FormData,
+): Promise<FormState> {
+  let target: string
 
-async function assertSecondFactorGiven(input: {
-  readonly userId: number
-  readonly form: FormData
-}): Promise<void> {
-  const service = twoFactorService()
-  if (service === null) return
+  try {
+    if (!ipAllowed(await remoteAddress(), await adminAllowlist())) {
+      throw new ForbiddenError(msg('error.app.control-panel-available-from-address'))
+    }
 
-  const enrolled = await service.isEnrolled(input.userId)
+    const service = adminService()
+    if (service === null) {
+      throw new ForbiddenError(msg('error.app.board-running-in-memory-sample-data-25'))
+    }
 
-  if (!enrolled) {
-    if (await twoFactorRequiredForStaff()) {
-      throw new ForbiddenError(msg('adminAction.twoFactorRequired'))
+    const actor = await getActor()
+    const { authorizer, accountStore } = getContainer()
+    if (actor.userId === null || !authorizer.can(actor, 'admincp.access')) {
+      throw new ForbiddenError(msg('error.app.reach-control-panel'))
     }
-    return
-  }
 
-  const code = text(input.form, 'code')
-  if (code === '') {
-    throw new ValidationError(msg('error.app.enter-code-from-authenticator-app'))
-  }
+    const twoFactor = twoFactorService()
+    const pending = await pendingAdminSecondFactor()
+    if (twoFactor === null || pending === null) {
+      throw new ForbiddenError(msg('adminAction.twoFactorExpired'))
+    }
+
+    const config = await boardAuthConfig()
+    const attemptBucket = await adminReauthenticationBucket(actor.userId)
+    const attemptSince = new Date(Date.now() - config.lockoutMinutes * 60_000)
+    if (
+      config.maxLoginAttempts > 0 &&
+      (await accountStore.loginAttempts.countFailuresSince(attemptBucket, attemptSince)) >=
+        config.maxLoginAttempts
+    ) {
+      throw new ForbiddenError(msg('error.accounts.too-many-failed-attempts-please'))
+    }
 
-  const outcome = await service.verify({ userId: input.userId, code })
-  if (outcome.status !== 'ok') {
-    if (outcome.status === 'replayed') {
-      throw new ForbiddenError(msg('adminAction.codeReplayed'))
+    const failAttempt = async (): Promise<void> => {
+      await accountStore.loginAttempts.record(attemptBucket, false, new Date())
+      await recordAdminAction({ action: 'admin.signin_failed' })
     }
-    throw new ForbiddenError(msg('adminAction.codeWrong'))
+
+    const code = text(form, 'code')
+    if (code === '') {
+      await failAttempt()
+      throw new ValidationError(msg('error.app.enter-code-from-authenticator-app'))
+    }
+
+    const outcome = await twoFactor.verify({ userId: pending.userId, code })
+    if (outcome.status !== 'ok') {
+      await failAttempt()
+      throw new ForbiddenError(
+        msg(outcome.status === 'replayed' ? 'adminAction.codeReplayed' : 'adminAction.codeWrong'),
+      )
+    }
+
+    const redeemed = await redeemAdminSecondFactor()
+    if (redeemed === null) {
+      throw new ForbiddenError(msg('adminAction.twoFactorExpired'))
+    }
+
+    await accountStore.loginAttempts.clear(attemptBucket)
+    target = await startAdminSession(service, pending.userId, safeAdminReturn(redeemed.next))
+  } catch (err) {
+    return toFormState(err)
+  }
+
+  redirect(target)
+}
+
+export async function adminAbandonSecondFactorAction(): Promise<void> {
+  await abandonAdminSecondFactor()
+  redirect('/admin')
+}
+
+async function startAdminSession(
+  service: AdminService,
+  userId: number,
+  target: string,
+): Promise<string> {
+  const existing = await resolveAdmin()
+  if ('context' in existing) {
+    await service.markReauthenticated(existing.context.session.id)
+    await recordAdminAction({ action: 'admin.reauthenticated' })
+  } else {
+    const token = generateToken()
+    const session = await service.start({
+      userId,
+      tokenHash: await hashToken(token),
+      ipPrefix: await retainedIpPrefix(),
+    })
+    await setAdminCookie(token, session.expiresAt)
+    await recordAdminAction({ action: 'admin.signed_in' })
   }
+
+  return target
+}
+
+async function adminReauthenticationBucket(userId: number): Promise<string> {
+  const prefix = await retainedIpPrefix()
+  return prefix === null ? `admin-reauth:${userId}` : `admin-reauth:${userId}@${prefix}`
 }
 
 export async function adminSignOutAction(): Promise<void> {

package/src/server/admin-settings-actions.ts

@@ -18,6 +18,7 @@ import { recordAdminAction, requireAdmin } from './admin'
 import type { FormState } from './auth-form-state'
 import { tr } from './i18n'
 import { emitEvent } from './plugin-view'
+import { searchProvider } from './search'
 import { getSettings } from './settings'
 
 function submittedKeys(form: FormData): readonly SettingDefinition[] {
@@ -59,6 +60,10 @@ export async function saveAdminSettingsAction(
       await getSettings(),
     )
 
+    if (result.changed.includes('search.language')) {
+      await searchProvider()?.markForReindex()
+    }
+
     if (result.changed.length > 0) {
       const tags = [CacheTags.settings(), ...result.invalidates]
       await drivers().cache.invalidateTags(tags)

package/src/server/admin.ts

@@ -4,14 +4,20 @@ import 'server-only'
 import { notFound } from 'next/navigation'
 import { cache } from 'react'
 
-import { hashToken } from '@meith/accounts'
+import { generateToken, hashToken } from '@meith/accounts'
 import { type AdminContext, AdminService, ipAllowed, parseAllowlist } from '@meith/admin'
 import { env, ForbiddenError } from '@meith/core'
 
 import { getContainer } from './container'
 import { getActor } from './context'
+import { ADMIN_SECOND_FACTOR_MINUTES } from './cookies'
 import { remoteAddress, retainedIpPrefix } from './request-fingerprint'
-import { readAdminToken } from './session-cookies'
+import {
+  clearAdminSecondFactorCookie,
+  readAdminSecondFactorToken,
+  readAdminToken,
+  setAdminSecondFactorCookie,
+} from './session-cookies'
 
 export type AdminDenial = 'address' | 'permission' | 'signin' | 'expired' | 'unavailable'
 
@@ -69,6 +75,68 @@ export function askForPassword(denied: AdminDenial): boolean {
   return denied === 'signin' || denied === 'expired'
 }
 
+export interface AdminSecondFactorHold {
+  readonly userId: number
+  readonly next: string
+}
+
+export async function holdAdminSecondFactor(userId: number, next: string): Promise<void> {
+  const { tokens } = getContainer().accountStore
+  await tokens.revokeAllForUser(userId, 'admin_second_factor')
+
+  const token = generateToken()
+  const expiresAt = new Date(Date.now() + ADMIN_SECOND_FACTOR_MINUTES * 60_000)
+  await tokens.issue({
+    tokenHash: await hashToken(token),
+    userId,
+    purpose: 'admin_second_factor',
+    payload: next,
+    expiresAt,
+  })
+
+  await setAdminSecondFactorCookie(token, expiresAt)
+}
+
+export async function pendingAdminSecondFactor(): Promise<AdminSecondFactorHold | null> {
+  const token = await readAdminSecondFactorToken()
+  if (token === null || token === '') return null
+
+  const held = await getContainer().accountStore.tokens.peek(
+    await hashToken(token),
+    'admin_second_factor',
+    new Date(),
+  )
+  if (held === null) return null
+
+  const actor = await getActor()
+  if (actor.userId === null || held.userId !== actor.userId) return null
+
+  return { userId: held.userId, next: held.payload ?? '/admin' }
+}
+
+export async function redeemAdminSecondFactor(): Promise<AdminSecondFactorHold | null> {
+  const token = await readAdminSecondFactorToken()
+  await clearAdminSecondFactorCookie()
+  if (token === null || token === '') return null
+
+  const redeemed = await getContainer().accountStore.tokens.consume(
+    await hashToken(token),
+    'admin_second_factor',
+    new Date(),
+  )
+  if (redeemed === null) return null
+
+  return { userId: redeemed.userId, next: redeemed.payload ?? '/admin' }
+}
+
+export async function abandonAdminSecondFactor(): Promise<void> {
+  const actor = await getActor()
+  if (actor.userId !== null) {
+    await getContainer().accountStore.tokens.revokeAllForUser(actor.userId, 'admin_second_factor')
+  }
+  await clearAdminSecondFactorCookie()
+}
+
 export async function adminPageContext(): Promise<AdminContext | null> {
   const resolved = await resolveAdmin()
   if ('context' in resolved) return resolved.context

package/src/server/api/search.ts

@@ -13,7 +13,13 @@ import {
 
 import { filterWords } from '../../view/word-filter'
 import { activeWordFilter } from '../content-admin'
-import { requireSearch, requireSearchEnabled, searchMinWordLength, searchScopeFor } from '../search'
+import {
+  requireSearch,
+  requireSearchEnabled,
+  searchLanguage,
+  searchMinWordLength,
+  searchScopeFor,
+} from '../search'
 import {
   type ApiResult,
   type ApiRoutes,
@@ -55,7 +61,7 @@ export const SEARCH_HANDLERS: ApiRoutes = [
       const forumIds = ids('forum')
       const authorUserIds = ids('by')
 
-      const results = await requireSearch().search(
+      const results = await requireSearch(await searchLanguage()).search(
         searchQueryFrom(
           parsed.terms,
           {

package/src/server/api-token-actions.ts

@@ -8,6 +8,7 @@ import { msg } from '@meith/i18n'
 import { recordAdminAction, requireAdmin, requireFreshAdmin } from './admin'
 import { apiTokenStore, issueApiToken } from './api-tokens-admin'
 import type { FormState } from './auth-form-state'
+import { requireConfirmation } from './confirm'
 import { getMessageResolver, tr } from './i18n'
 
 function field(form: FormData, name: string): string {
@@ -69,6 +70,9 @@ export async function revokeApiTokenAction(_prev: FormState, form: FormData): Pr
     const id = Number(field(form, 'tokenId'))
     if (!Number.isSafeInteger(id) || id <= 0) return { error: await tr('notice.app.such-token') }
 
+    const confirm = requireConfirmation(form, await tr('adminPanel.token.confirmRevoke'))
+    if (confirm !== null) return confirm
+
     const store = apiTokenStore()
     if (store === null) return { error: await tr('notice.app.board-database-api') }
 

package/src/server/appearance-actions.ts

@@ -2,7 +2,9 @@
 
 import { cookies } from 'next/headers'
 
+import { isEnhancedSubmit } from '@/view/progressive-enhancement'
 import {
+  type ColourSchemePreference,
   isColourScheme,
   PREFERENCE_COOKIE_MAX_AGE,
   SCHEME_COOKIE,
@@ -37,3 +39,22 @@ export async function setAppearanceAction(form: FormData): Promise<void> {
 
   await redirectToCurrentPath()
 }
+
+export interface SchemeState {
+  readonly scheme?: ColourSchemePreference | undefined
+}
+
+export async function setSchemeAction(_prev: SchemeState, form: FormData): Promise<SchemeState> {
+  const raw = form.get('scheme')
+  const scheme = typeof raw === 'string' && isColourScheme(raw) ? raw : null
+
+  if (scheme !== null) {
+    const jar = await cookies()
+    jar.set(SCHEME_COOKIE, scheme, COOKIE_OPTIONS)
+  }
+
+  if (isEnhancedSubmit(form)) return { scheme: scheme ?? undefined }
+
+  await redirectToCurrentPath()
+  return {}
+}