@seed-ship/mcp-ui-solid 5.1.0 → 5.3.0

package/src/components/FeedbackInline.tsx

@@ -0,0 +1,143 @@
+/**
+ * FeedbackInline — per-message inline feedback (thumbs up/down)
+ *
+ * @experimental
+ * @since v5.2.0
+ *
+ * A small, non-blocking per-message feedback primitive. Sits next to an
+ * assistant message, captures a rating, calls back to the consumer for
+ * persistence. Best-effort by design — no retry UX, no revision UX.
+ *
+ * ## When to use vs other feedback primitives
+ *
+ * - **`FeedbackInline`** (this) → per-message thumb-up/down, non-blocking,
+ *   many can coexist.
+ * - **`ChatPrompt` (type=choice)** → modal, one-at-a-time above the input,
+ *   used when the agent needs a blocking answer.
+ * - **`ScratchpadPanel` feedback section** → structured feedback bound to a
+ *   scratchpad turn, panel-side.
+ *
+ * ## Persistence is the consumer's job
+ *
+ * The component flips to "submitted" state *optimistically* on click and
+ * calls `onSubmit(rating, context)`. Network failures do not revert the UI —
+ * feedback is best-effort. If you need stricter semantics (offline retry,
+ * revision, ...) wrap this in your own component.
+ *
+ * @example
+ * ```tsx
+ * <FeedbackInline
+ *   messageHash={msg.hash}
+ *   context={{ intent: msg.intent, confidenceBand: msg.band }}
+ *   onSubmit={(rating, ctx) =>
+ *     fetch('/api/feedback', {
+ *       method: 'POST',
+ *       headers: { 'Content-Type': 'application/json' },
+ *       body: JSON.stringify({ message_hash: msg.hash, rating, ...ctx }),
+ *     })
+ *   }
+ * />
+ * ```
+ */
+
+import { Component, Show, createSignal } from 'solid-js'
+
+export interface FeedbackInlineContext {
+  intent?: string
+  confidenceBand?: string
+  tags?: string[]
+  [key: string]: unknown
+}
+
+export interface FeedbackInlineProps {
+  /** Stable identifier for the message being rated. */
+  messageHash?: string
+  /**
+   * Called on click. Consumer is responsible for persistence (HTTP, store,
+   * localStorage). Return value ignored.
+   */
+  onSubmit: (rating: 'positive' | 'negative', context?: FeedbackInlineContext) => void | Promise<void>
+  /** Extra context forwarded to `onSubmit`. */
+  context?: FeedbackInlineContext
+  /** Ack text shown after positive rating. Default: 'Merci !' */
+  positiveAck?: string
+  /** Ack text shown after negative rating. Default: "Noté, on s'améliore" */
+  negativeAck?: string
+  /** Extra Tailwind classes on the container. */
+  class?: string
+}
+
+/**
+ * @experimental
+ * Per-message inline feedback (thumbs up/down). Non-blocking.
+ */
+export const FeedbackInline: Component<FeedbackInlineProps> = (props) => {
+  const [rating, setRating] = createSignal<'positive' | 'negative' | null>(null)
+
+  const handle = (value: 'positive' | 'negative') => {
+    if (rating() !== null) return // already submitted, final state
+    setRating(value)
+    try {
+      // Fire-and-forget. If the consumer returns a Promise that rejects,
+      // swallow it — feedback is best-effort by design.
+      const result = props.onSubmit(value, props.context)
+      if (result && typeof (result as Promise<void>).catch === 'function') {
+        ;(result as Promise<void>).catch(() => {
+          /* non-blocking */
+        })
+      }
+    } catch {
+      /* non-blocking */
+    }
+  }
+
+  return (
+    <div class={`flex items-center gap-1 ${props.class ?? ''}`.trim()}>
+      <Show
+        when={rating() === null}
+        fallback={
+          <span class="text-[11px] text-deposium-slate-500">
+            {rating() === 'positive'
+              ? (props.positiveAck ?? 'Merci !')
+              : (props.negativeAck ?? "Noté, on s'améliore")}
+          </span>
+        }
+      >
+        <button
+          type="button"
+          onClick={() => handle('positive')}
+          class="p-1 rounded hover:bg-green-500/10 text-deposium-slate-500 hover:text-green-500 transition-colors"
+          title="Utile"
+          aria-label="Mark response as useful"
+          data-feedback-inline-rating="positive"
+        >
+          <svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path
+              stroke-linecap="round"
+              stroke-linejoin="round"
+              stroke-width="2"
+              d="M14 9V5a3 3 0 00-3-3l-4 9v11h11.28a2 2 0 002-1.7l1.38-9a2 2 0 00-2-2.3H14z M3 15v7"
+            />
+          </svg>
+        </button>
+        <button
+          type="button"
+          onClick={() => handle('negative')}
+          class="p-1 rounded hover:bg-red-500/10 text-deposium-slate-500 hover:text-red-500 transition-colors"
+          title="Pas utile"
+          aria-label="Mark response as not useful"
+          data-feedback-inline-rating="negative"
+        >
+          <svg class="w-3.5 h-3.5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+            <path
+              stroke-linecap="round"
+              stroke-linejoin="round"
+              stroke-width="2"
+              d="M10 15v4a3 3 0 003 3l4-9V2H5.72a2 2 0 00-2 1.7l-1.38 9a2 2 0 002 2.3H10z M21 4v7"
+            />
+          </svg>
+        </button>
+      </Show>
+    </div>
+  )
+}

package/src/components/index.ts

@@ -88,5 +88,9 @@ export type { DataPreviewSectionProps } from './DataPreviewSection'
 export { RenderContext, RenderProvider, useRenderContext } from './RenderContext'
 export type { RenderContextValue, RenderComponentFn } from './RenderContext'
 
+// MCP elicitation (v5.3.0)
+export { ElicitationForm } from './ElicitationForm'
+export type { ElicitationFormProps } from './ElicitationForm'
+
 // Default exports for lazy loading compatibility
 export { UIResourceRenderer as default } from './UIResourceRenderer'

package/src/index.ts

@@ -37,12 +37,36 @@ export { ResizeHandle } from './components/ResizeHandle'
 export { EditableUIResourceRenderer } from './components/EditableUIResourceRenderer'
 export { ExpandableWrapper, useExpanded } from './components/ExpandableWrapper'
 export { ComponentToolbar } from './components/ComponentToolbar'
+export { FeedbackInline } from './components/FeedbackInline'
+export type { FeedbackInlineProps, FeedbackInlineContext } from './components/FeedbackInline'
 
 // Chat Bus (v2.4.0 — @experimental)
 export { ChatBusProvider, useChatBus } from './hooks/useChatBus'
 export { ChatPrompt } from './components/ChatPrompt'
+export { ElicitationForm } from './components/ElicitationForm'
 export { ScratchpadPanel } from './components/ScratchpadPanel'
-export { dispatchScratchpad, useScratchpadState } from './stores/scratchpad-store'
+export {
+  dispatchScratchpad,
+  useScratchpadState,
+  createScratchpadStore,
+  ScratchpadStoreContext,
+  ScratchpadStoreProvider,
+} from './stores/scratchpad-store'
+export type { ScratchpadStoreHandle } from './stores/scratchpad-store'
+
+// Server Capabilities (v5.3.0)
+export {
+  setServerCapabilities,
+  useServerCapabilities,
+  createServerCapabilitiesStore,
+  ServerCapabilitiesContext,
+  ServerCapabilitiesProvider,
+} from './stores/server-capabilities-store'
+export type {
+  ServerCapabilities,
+  ServerInitializeInfo,
+  ServerCapabilitiesStoreHandle,
+} from './stores/server-capabilities-store'
 
 // Data Verification Components (v3.1.0)
 export { VerifiedText } from './components/VerifiedText'
@@ -71,6 +95,7 @@ export type { EditableUIResourceRendererProps } from './components/EditableUIRes
 export type { ExpandableWrapperProps } from './components/ExpandableWrapper'
 export type { ComponentToolbarProps, ToolbarAction, ToolbarIcon } from './components/ComponentToolbar'
 export type { ChatPromptProps } from './components/ChatPrompt'
+export type { ElicitationFormProps } from './components/ElicitationForm'
 export type { ScratchpadPanelProps } from './components/ScratchpadPanel'
 export type { VerifiedTextProps } from './components/VerifiedText'
 export type { DataPreviewSectionProps } from './components/DataPreviewSection'
@@ -248,6 +273,16 @@ export {
 // Clarification → Prompt helper (v4.3.9)
 export { clarificationToPromptConfig } from './services/chat-bus'
 
+// Elicitation → Prompt helper (v5.2.0)
+export { elicitationToPromptConfig } from './services/chat-bus'
+
+// Chat prompt controller (v5.2.0)
+export {
+  createChatPromptController,
+  PromptReplacedError,
+} from './services/chat-prompt-controller'
+export type { ChatPromptController } from './services/chat-prompt-controller'
+
 // Testing utilities (v4.3.9)
 export { createMockChatBus } from './testing'
 export type { MockChatBusOptions } from './testing'
@@ -279,6 +314,9 @@ export type {
   Citation,
   ToolCallEvent,
   ClarificationEvent,
+  ElicitationEvent,
+  ElicitationRequestedSchema,
+  ElicitationPropertySchema,
   // Data Validation types (v3.1.0)
   DataValidation,
   LLMNumber,

package/src/services/chat-bus.test.ts

@@ -3,8 +3,8 @@
  */
 
 import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest'
-import { createEventEmitter, createCommandHandler, createChatBus, clarificationToPromptConfig } from './chat-bus'
-import type { ChatEvents, ChatCommands, ClarificationEvent } from '../types/chat-bus'
+import { createEventEmitter, createCommandHandler, createChatBus, clarificationToPromptConfig, elicitationToPromptConfig } from './chat-bus'
+import type { ChatEvents, ChatCommands, ClarificationEvent, ElicitationEvent } from '../types/chat-bus'
 
 describe('createEventEmitter', () => {
   it('emits events to subscribed listeners', () => {
@@ -384,3 +384,155 @@ describe('clarificationToPromptConfig', () => {
     expect(opts[0]).not.toHaveProperty('metadata')
   })
 })
+
+describe('elicitationToPromptConfig — v5.2.0', () => {
+  it('single boolean property maps to confirm prompt', () => {
+    const event: ElicitationEvent = {
+      message: 'Proceed with the deployment?',
+      requestedSchema: {
+        type: 'object',
+        properties: { confirmed: { type: 'boolean', description: 'Ship it?' } },
+        required: ['confirmed'],
+      },
+    }
+    const config = elicitationToPromptConfig(event)
+    expect(config.type).toBe('confirm')
+    expect(config.title).toBe('Proceed with the deployment?')
+    expect((config.config as any).message).toBe('Ship it?')
+  })
+
+  it('single enum string property (≤4 values) maps to choice prompt', () => {
+    const event: ElicitationEvent = {
+      message: 'Select severity',
+      requestedSchema: {
+        type: 'object',
+        properties: {
+          level: {
+            type: 'string',
+            enum: ['low', 'medium', 'high'],
+            enumNames: ['Low', 'Medium', 'High'],
+          },
+        },
+      },
+    }
+    const config = elicitationToPromptConfig(event)
+    expect(config.type).toBe('choice')
+    const opts = (config.config as any).options
+    expect(opts).toEqual([
+      { value: 'low', label: 'Low' },
+      { value: 'medium', label: 'Medium' },
+      { value: 'high', label: 'High' },
+    ])
+  })
+
+  it('enum with >4 values maps to form with select field (not choice)', () => {
+    const event: ElicitationEvent = {
+      message: 'Pick a country',
+      requestedSchema: {
+        type: 'object',
+        properties: {
+          country: {
+            type: 'string',
+            enum: ['FR', 'DE', 'IT', 'ES', 'PT'],
+          },
+        },
+      },
+    }
+    const config = elicitationToPromptConfig(event)
+    expect(config.type).toBe('form')
+    const fields = (config.config as any).fields
+    expect(fields[0].type).toBe('select')
+    expect(fields[0].options).toHaveLength(5)
+  })
+
+  it('multi-property object maps to form with one field per property', () => {
+    const event: ElicitationEvent = {
+      message: 'Fill in contact info',
+      requestedSchema: {
+        type: 'object',
+        properties: {
+          name: { type: 'string', title: 'Full name' },
+          age: { type: 'integer' },
+          newsletter: { type: 'boolean', description: 'Opt-in' },
+        },
+        required: ['name'],
+      },
+    }
+    const config = elicitationToPromptConfig(event)
+    expect(config.type).toBe('form')
+    const fields = (config.config as any).fields
+    expect(fields).toHaveLength(3)
+    expect(fields.map((f: any) => f.name)).toEqual(['name', 'age', 'newsletter'])
+    expect(fields[0]).toMatchObject({ type: 'text', label: 'Full name', required: true })
+    expect(fields[1]).toMatchObject({ type: 'number', required: false })
+    expect(fields[2]).toMatchObject({ type: 'checkbox', helpText: 'Opt-in' })
+  })
+
+  it('string format email maps to email field', () => {
+    const event: ElicitationEvent = {
+      message: 'Contact',
+      requestedSchema: {
+        type: 'object',
+        properties: {
+          email: { type: 'string', format: 'email' },
+          reply: { type: 'string' }, // force form (not single-property shortcut)
+        },
+      },
+    }
+    const config = elicitationToPromptConfig(event)
+    const fields = (config.config as any).fields
+    expect(fields[0]).toMatchObject({ name: 'email', type: 'email' })
+  })
+
+  it('string format date / date-time maps to date field', () => {
+    const event: ElicitationEvent = {
+      message: 'Schedule',
+      requestedSchema: {
+        type: 'object',
+        properties: {
+          start: { type: 'string', format: 'date' },
+          end: { type: 'string', format: 'date-time' },
+        },
+      },
+    }
+    const config = elicitationToPromptConfig(event)
+    const fields = (config.config as any).fields
+    expect(fields[0].type).toBe('date')
+    expect(fields[1].type).toBe('date')
+  })
+
+  it('default value maps to placeholder', () => {
+    const event: ElicitationEvent = {
+      message: 'Settings',
+      requestedSchema: {
+        type: 'object',
+        properties: {
+          retries: { type: 'integer', default: 3 },
+          timeout: { type: 'integer' }, // second property to force form
+        },
+      },
+    }
+    const config = elicitationToPromptConfig(event)
+    const fields = (config.config as any).fields
+    expect(fields[0]).toMatchObject({ placeholder: '3' })
+  })
+
+  it('unknown schema type falls through to text with console.warn', () => {
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {})
+    const event = {
+      message: 'Edge case',
+      requestedSchema: {
+        type: 'object',
+        properties: {
+          weird: { type: 'array' }, // not a primitive
+          other: { type: 'string' },
+        },
+      },
+    } as unknown as ElicitationEvent
+    const config = elicitationToPromptConfig(event)
+    const fields = (config.config as any).fields
+    expect(fields[0].type).toBe('text')
+    expect(warnSpy).toHaveBeenCalled()
+    warnSpy.mockRestore()
+  })
+})

package/src/services/chat-bus.ts

@@ -14,7 +14,10 @@ import type {
   EventSubscribeOptions,
   ScratchpadSection,
   ClarificationEvent,
+  ElicitationEvent,
+  ElicitationPropertySchema,
   ChatPromptConfig,
+  FormPromptConfig,
 } from '../types/chat-bus'
 
 // ─── Event Emitter ───────────────────────────────────────────
@@ -245,6 +248,118 @@ export function mergeScratchpadSections(
  *   bus.commands.exec('showChatPrompt', clarificationToPromptConfig(clarification))
  * })
  */
+// ─── Elicitation → Prompt Helper (v5.2.0) ───────────────────
+
+/**
+ * Convert an MCP `elicitation/create` payload into a `ChatPromptConfig`.
+ *
+ * Mapping rules :
+ * - Single `boolean` property → `type: 'confirm'`
+ * - Single property with `enum` of ≤4 values → `type: 'choice'` (one option per enum value)
+ * - Anything else → `type: 'form'` with one field per schema property
+ *
+ * JSON Schema primitive types map to mcp-ui form field types :
+ *
+ * | JSON Schema | mcp-ui FormFieldType |
+ * |---|---|
+ * | `type: 'string'` | `'text'` |
+ * | `type: 'string', format: 'email'` | `'email'` |
+ * | `type: 'string', format: 'date'` or `'date-time'` | `'date'` |
+ * | `type: 'string', enum: [...]` | `'select'` |
+ * | `type: 'number' \| 'integer'` | `'number'` |
+ * | `type: 'boolean'` | `'checkbox'` |
+ *
+ * Unknown shapes fall through to plain text with a `helpText` warning.
+ *
+ * @experimental
+ * @since v5.2.0
+ *
+ * @example
+ * bus.events.on('onElicitation', ({ elicitation }) => {
+ *   bus.commands.exec('showChatPrompt', elicitationToPromptConfig(elicitation))
+ * })
+ */
+export function elicitationToPromptConfig(event: ElicitationEvent): ChatPromptConfig {
+  const propEntries = Object.entries(event.requestedSchema.properties)
+
+  // Shortcut 1 : single boolean → confirm
+  if (propEntries.length === 1 && propEntries[0][1].type === 'boolean') {
+    return {
+      type: 'confirm',
+      title: event.message,
+      config: {
+        message: propEntries[0][1].description,
+      },
+    }
+  }
+
+  // Shortcut 2 : single enum property with ≤4 values → choice
+  if (propEntries.length === 1) {
+    const [, schema] = propEntries[0]
+    if (schema.enum && schema.enum.length > 0 && schema.enum.length <= 4) {
+      return {
+        type: 'choice',
+        title: event.message,
+        config: {
+          options: schema.enum.map((val, idx) => ({
+            value: String(val),
+            label: schema.enumNames?.[idx] ?? String(val),
+          })),
+          layout: 'vertical',
+        },
+      }
+    }
+  }
+
+  // Default : full form
+  const required = new Set(event.requestedSchema.required ?? [])
+  const fields: FormPromptConfig['fields'] = propEntries.map(([name, schema]) => ({
+    name,
+    label: schema.title ?? name,
+    ...schemaToFieldType(schema),
+    required: required.has(name),
+    helpText: schema.description,
+    ...(schema.default !== undefined ? { placeholder: String(schema.default) } : {}),
+  }))
+
+  return {
+    type: 'form',
+    title: event.message,
+    config: { fields },
+  }
+}
+
+function schemaToFieldType(
+  schema: ElicitationPropertySchema
+):
+  | { type: FormPromptConfig['fields'][number]['type']; options?: Array<{ label: string; value: string }> }
+  | { type: FormPromptConfig['fields'][number]['type']; helpText?: string } {
+  // Enum → select
+  if (schema.enum && schema.enum.length > 0) {
+    return {
+      type: 'select',
+      options: schema.enum.map((val, idx) => ({
+        label: schema.enumNames?.[idx] ?? String(val),
+        value: String(val),
+      })),
+    }
+  }
+
+  if (schema.type === 'boolean') return { type: 'checkbox' }
+  if (schema.type === 'number' || schema.type === 'integer') return { type: 'number' }
+  if (schema.type === 'string') {
+    if (schema.format === 'email') return { type: 'email' }
+    if (schema.format === 'date' || schema.format === 'date-time') return { type: 'date' }
+    return { type: 'text' }
+  }
+
+  // Unknown primitive — fall back to text with a warning
+  console.warn(
+    `[MCP-UI] elicitationToPromptConfig: unsupported schema type "${(schema as { type?: string }).type}", falling back to text.`
+  )
+  return { type: 'text' }
+}
+
 export function clarificationToPromptConfig(
   event: ClarificationEvent
 ): ChatPromptConfig {

package/src/services/chat-prompt-controller.test.ts

@@ -0,0 +1,144 @@
+/**
+ * Tests for createChatPromptController — v5.2.0
+ */
+
+import { describe, it, expect } from 'vitest'
+import { createRoot } from 'solid-js'
+import {
+  createChatPromptController,
+  PromptReplacedError,
+} from './chat-prompt-controller'
+import type { ChatPromptConfig, ChatPromptResponse } from '../types/chat-bus'
+
+const choiceConfig = (title = 'Pick one'): ChatPromptConfig => ({
+  type: 'choice',
+  title,
+  config: { options: [{ value: 'a', label: 'A' }, { value: 'b', label: 'B' }] },
+})
+
+const confirmConfig = (title = 'Confirm?'): ChatPromptConfig => ({
+  type: 'confirm',
+  title,
+  config: { message: 'Sure?' },
+})
+
+const choiceResponse = (value: string): ChatPromptResponse => ({
+  type: 'choice',
+  value,
+  label: value,
+})
+
+describe('createChatPromptController — v5.2.0', () => {
+  it('sequential prompts both resolve', async () => {
+    await createRoot(async (dispose) => {
+      const ctrl = createChatPromptController()
+
+      const p1 = ctrl.handle(choiceConfig('First'))
+      expect(ctrl.activePrompt()?.title).toBe('First')
+      ctrl.resolveActive(choiceResponse('a'))
+      expect(ctrl.activePrompt()).toBeNull()
+      const r1 = await p1
+      expect(r1.value).toBe('a')
+
+      const p2 = ctrl.handle(choiceConfig('Second'))
+      expect(ctrl.activePrompt()?.title).toBe('Second')
+      ctrl.resolveActive(choiceResponse('b'))
+      const r2 = await p2
+      expect(r2.value).toBe('b')
+
+      dispose()
+    })
+  })
+
+  it('re-entrant call rejects previous Promise with PromptReplacedError', async () => {
+    await createRoot(async (dispose) => {
+      const ctrl = createChatPromptController()
+
+      const p1 = ctrl.handle(choiceConfig('First'))
+      // Don't resolve — fire a second one
+      const p2 = ctrl.handle(choiceConfig('Second'))
+
+      await expect(p1).rejects.toBeInstanceOf(PromptReplacedError)
+
+      // The second prompt is now active and can still resolve
+      expect(ctrl.activePrompt()?.title).toBe('Second')
+      ctrl.resolveActive(choiceResponse('b'))
+      await expect(p2).resolves.toMatchObject({ value: 'b' })
+
+      dispose()
+    })
+  })
+
+  it('AbortSignal already aborted on entry rejects with DOMException AbortError', async () => {
+    await createRoot(async (dispose) => {
+      const ctrl = createChatPromptController()
+      const ac = new AbortController()
+      ac.abort()
+
+      const p = ctrl.handle(choiceConfig('Never shown'), ac.signal)
+      expect(ctrl.activePrompt()).toBeNull() // UI never installed
+
+      await expect(p).rejects.toMatchObject({ name: 'AbortError' })
+      dispose()
+    })
+  })
+
+  it('AbortSignal aborted during prompt rejects + clears activePrompt', async () => {
+    await createRoot(async (dispose) => {
+      const ctrl = createChatPromptController()
+      const ac = new AbortController()
+
+      const p = ctrl.handle(choiceConfig('Pending'), ac.signal)
+      expect(ctrl.activePrompt()?.title).toBe('Pending')
+
+      ac.abort()
+      await expect(p).rejects.toMatchObject({ name: 'AbortError' })
+      expect(ctrl.activePrompt()).toBeNull()
+
+      dispose()
+    })
+  })
+
+  it('abort() method rejects pending Promise with AbortError', async () => {
+    await createRoot(async (dispose) => {
+      const ctrl = createChatPromptController()
+
+      const p = ctrl.handle(choiceConfig('Will abort'))
+      ctrl.abort('Navigated away')
+
+      await expect(p).rejects.toMatchObject({ name: 'AbortError' })
+      expect(ctrl.activePrompt()).toBeNull()
+
+      dispose()
+    })
+  })
+
+  it('dismissActive resolves with dismissed: true and preserves the prompt type', async () => {
+    await createRoot(async (dispose) => {
+      const ctrl = createChatPromptController()
+      const p = ctrl.handle(confirmConfig('Really?'))
+
+      ctrl.dismissActive()
+      const r = await p
+      expect(r).toMatchObject({ type: 'confirm', dismissed: true })
+      expect(ctrl.activePrompt()).toBeNull()
+
+      dispose()
+    })
+  })
+
+  it('resolve/dismiss after abort is a no-op (double-settle protection)', async () => {
+    await createRoot(async (dispose) => {
+      const ctrl = createChatPromptController()
+      const p = ctrl.handle(choiceConfig('x'))
+
+      ctrl.abort()
+      // These should not throw or re-settle
+      ctrl.resolveActive(choiceResponse('ignored'))
+      ctrl.dismissActive()
+
+      await expect(p).rejects.toMatchObject({ name: 'AbortError' })
+      dispose()
+    })
+  })
+})