dsh-mosaic 0.2.1

package/lib/prompt-store.js

@@ -0,0 +1,354 @@
+/**
+ * The model prompt the plugin contributes, and the routes the settings page uses to
+ * read and change it.
+ *
+ * Precedence: the user's saved override, then the row's `config.prompt`, then the text
+ * built into this package. The override lives in the Host's own data directory as one
+ * small JSON file, so it survives restarts without touching the profile's composition.
+ *
+ * The routes are plugin-owned, and `/api` does not cover them, so this module enforces
+ * its own policy: a state-changing request must be same-origin, JSON, and confirmable
+ * by the browser's `Sec-Fetch-Site` header.
+ */
+import { randomBytes } from 'node:crypto'
+import { mkdir, open as openFile, readFile, rename, unlink } from 'node:fs/promises'
+import { homedir } from 'node:os'
+import { basename, dirname, join } from 'node:path'
+
+export const PROMPT_ROUTE = '/dsh-mosaic/prompt'
+export const PROMPT_LIMIT_BYTES = 128 * 1024
+
+/** Where the override lives: the Host data directory this process already owns. */
+export function promptStorePath(env = process.env) {
+  const home = typeof env.DSH_HOME === 'string' && env.DSH_HOME !== '' ? env.DSH_HOME : join(homedir(), '.dsh')
+  return join(home, 'mosaic', 'prompt.json')
+}
+
+/**
+ * Read the saved override and say why it was unusable, if it was.
+ *
+ * @param {string} path - absolute file path.
+ * @returns {Promise<{ prompt?: string, error?: 'corrupt' | 'unreadable' }>} the saved
+ *   prompt, or the reason there is none. A missing file is not an error.
+ */
+export async function readPromptFile(path) {
+  let raw
+  try {
+    raw = await readFile(path, 'utf8')
+  } catch (error) {
+    return error && error.code === 'ENOENT' ? {} : { error: 'unreadable' }
+  }
+  let parsed
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return { error: 'corrupt' }
+  }
+  const prompt = parsed !== null && typeof parsed === 'object' && typeof parsed.prompt === 'string'
+    ? parsed.prompt.trim()
+    : ''
+  // An empty override is how a reset is stored, so it is not an error.
+  return prompt === '' ? {} : { prompt }
+}
+
+/**
+ * Persist one override, or clear it when `prompt` is `undefined`.
+ *
+ * @param {string} path - absolute file path.
+ * @param {string | undefined} prompt - the text to store, or `undefined` to clear.
+ * @returns {Promise<{ persisted: boolean, reason?: string }>} whether it reached disk.
+ */
+export async function writeStoredPrompt(path, prompt) {
+  const body = `${JSON.stringify({
+    prompt: prompt === undefined ? '' : prompt,
+    updatedAt: new Date().toISOString(),
+  }, null, 2)}\n`
+  const directory = dirname(path)
+  const temp = join(directory, `.${basename(path)}.${randomBytes(6).toString('hex')}.tmp`)
+  let handle
+  try {
+    await mkdir(directory, { recursive: true, mode: 0o700 })
+    // Same-directory exclusive temp file, fsync, then rename: a crash leaves either the
+    // old file or the new one, never a half-written prompt.
+    handle = await openFile(temp, 'wx', 0o600)
+    await handle.writeFile(body, 'utf8')
+    await handle.sync()
+    await handle.close()
+    handle = undefined
+    await rename(temp, path)
+    await syncDirectory(directory)
+    return { persisted: true }
+  } catch (error) {
+    if (handle !== undefined) {
+      try {
+        await handle.close()
+      } catch {}
+    }
+    try {
+      await unlink(temp)
+    } catch {}
+    return { persisted: false, reason: error instanceof Error ? error.message : String(error) }
+  }
+}
+
+/** Make a renamed entry crash-durable where the platform supports it. */
+async function syncDirectory(directory) {
+  if (process.platform === 'win32') return
+  let handle
+  try {
+    handle = await openFile(directory, 'r')
+    await handle.sync()
+  } catch {
+    // Directory fsync is best effort; the rename itself already succeeded.
+  } finally {
+    if (handle !== undefined) {
+      try {
+        await handle.close()
+      } catch {}
+    }
+  }
+}
+
+/** Accept only a plausible prompt body; anything else is a client bug. */
+export function parsePromptBody(body) {
+  if (body === null || typeof body !== 'object' || Array.isArray(body)) return { ok: false, error: 'invalid_body' }
+  if (body.reset === true) return { ok: true, reset: true }
+  if (typeof body.prompt !== 'string') return { ok: false, error: 'prompt_required' }
+  const prompt = body.prompt.trim()
+  if (prompt === '') return { ok: false, error: 'prompt_required' }
+  if (Buffer.byteLength(prompt, 'utf8') > PROMPT_LIMIT_BYTES) return { ok: false, error: 'prompt_too_large' }
+  return { ok: true, prompt }
+}
+
+/**
+ * Reject a state-changing request that a foreign page could have triggered.
+ *
+ * `Sec-Fetch-Site` is sent by the browser and cannot be forged by page script; a
+ * foreign origin also fails the `Origin` comparison, and a JSON content type forces a
+ * preflight that this route never approves.
+ *
+ * @param {import('node:http').IncomingMessage} req - the request under test.
+ * @returns {string | undefined} a rejection reason, or `undefined` when allowed.
+ */
+export function crossSiteError(req) {
+  const site = req.headers['sec-fetch-site']
+  if (typeof site === 'string' && site !== 'same-origin' && site !== 'none') return 'cross_site'
+  const origin = req.headers.origin
+  if (typeof origin === 'string' && origin !== '') {
+    let host
+    try {
+      host = new URL(origin).host
+    } catch {
+      return 'invalid_origin'
+    }
+    if (host !== req.headers.host) return 'cross_site'
+  }
+  return undefined
+}
+
+/** Policy for a state-changing request: same-origin plus a JSON body. */
+export function requestPolicyError(req) {
+  const crossSite = crossSiteError(req)
+  if (crossSite !== undefined) return crossSite
+  const type = req.headers['content-type']
+  if (typeof type !== 'string' || !type.toLowerCase().startsWith('application/json')) return 'json_required'
+  return undefined
+}
+
+/** Read a small JSON request body. */
+export async function readJsonBody(req, limit = PROMPT_LIMIT_BYTES + 1024) {
+  const chunks = []
+  let total = 0
+  for await (const chunk of req) {
+    total += chunk.length
+    if (total > limit) throw new Error('body_too_large')
+    chunks.push(chunk)
+  }
+  const text = Buffer.concat(chunks).toString('utf8')
+  if (text.trim() === '') return {}
+  return JSON.parse(text)
+}
+
+function sendJson(res, status, body) {
+  if (typeof res.setHeader === 'function') {
+    res.setHeader('content-type', 'application/json; charset=utf-8')
+    res.setHeader('cache-control', 'no-store')
+  }
+  res.statusCode = status
+  res.end(JSON.stringify(body))
+}
+
+/**
+ * Own the effective prompt: resolve its source, re-register the prompt section on every
+ * change, and answer the two routes the settings page calls.
+ *
+ * @param {object} options - wiring.
+ * @param {object} options.ctx - the plugin context (provides `systemPrompt`).
+ * @param {unknown} options.config - the Loader row's config.
+ * @param {(config: unknown) => string} options.resolveConfigPrompt - config precedence.
+ * @param {string} options.builtin - the text shipped in this package.
+ * @param {(ctx: object, text: string) => () => void} options.registerSection - registers
+ *   the prompt section and returns its disposer.
+ * @param {string} [options.path] - override file path; defaults to the Host data dir.
+ */
+export function createPromptController(options) {
+  const { ctx, config, resolveConfigPrompt, builtin, registerSection } = options
+  // A logger is optional so the controller stays testable without one.
+  const log = options.log ?? { info() {}, warn() {}, error() {} }
+  const path = options.path ?? promptStorePath()
+  // The Host owns its route layout; publishing the asset URL here keeps an older
+  // browser half working after a route change.
+  const assets = options.assets ?? {}
+
+  const state = {
+    /** Saved by the user in this profile, or `undefined`. */
+    user: undefined,
+    /** From the row's `config.prompt`, or `undefined`. */
+    configured: resolveConfigPrompt(config) === builtin ? undefined : resolveConfigPrompt(config),
+    /** Whether the last write reached disk. */
+    persisted: false,
+    /** Why the last write failed, when it did. */
+    persistenceError: undefined,
+    /** Why the saved override could not be used, when it could not. */
+    readError: undefined,
+    path,
+    /** Disposer of the currently registered section. */
+    dispose: undefined,
+    /** False after the owning plugin is disposed; no registration may happen then. */
+    active: false,
+  }
+
+  // Prompt writes are serialized so the file always ends with the last accepted value.
+  let writes = Promise.resolve()
+
+  const effective = () => state.user ?? state.configured ?? builtin
+  const source = () => (state.user !== undefined ? 'user' : state.configured !== undefined ? 'config' : 'builtin')
+
+  function snapshot() {
+    return {
+      prompt: effective(),
+      defaultPrompt: builtin,
+      configuredPrompt: state.configured,
+      customized: source() !== 'builtin',
+      source: source(),
+      persisted: state.persisted,
+      ...state.persistenceError === undefined ? {} : { persistenceError: state.persistenceError },
+      ...state.readError === undefined ? {} : { readError: state.readError },
+      assets,
+    }
+  }
+
+  function applySection() {
+    if (!state.active) return
+    if (typeof state.dispose === 'function') {
+      try {
+        state.dispose()
+      } catch {}
+    }
+    state.dispose = registerSection(ctx, effective())
+  }
+
+  return {
+    path,
+    snapshot,
+    /** Register the initial section; the returned disposer revokes whatever is live. */
+    start() {
+      state.active = true
+      applySection()
+      return () => {
+        if (!state.active) return
+        state.active = false
+        const dispose = state.dispose
+        state.dispose = undefined
+        if (typeof dispose === 'function') {
+          try {
+            dispose()
+          } catch {}
+        }
+      }
+    },
+    /** Pick up a saved override on activation. */
+    async hydrate() {
+      const stored = await readPromptFile(state.path)
+      // A `start()` may have been revoked, or a save may have landed first.
+      if (!state.active || state.user !== undefined) return snapshot()
+      if (stored.error !== undefined) {
+        // Keep the file: the user may want to recover it, and a later save overwrites it.
+        state.readError = stored.error
+        log.warn('prompt.read-failed', { reason: stored.error })
+        return snapshot()
+      }
+      if (stored.prompt === undefined) {
+        log.info('prompt.hydrate', { source: source(), stored: false })
+        return snapshot()
+      }
+      state.user = stored.prompt
+      state.persisted = true
+      applySection()
+      log.info('prompt.hydrate', { source: source(), stored: true, chars: stored.prompt.length })
+      return snapshot()
+    },
+    /** Apply one accepted body and persist it. */
+    async update(body) {
+      if (!state.active) {
+        log.warn('prompt.update-rejected', { reason: 'inactive' })
+        return { status: 503, body: { error: 'inactive' } }
+      }
+      const parsed = parsePromptBody(body)
+      if (!parsed.ok) {
+        log.warn('prompt.update-rejected', { reason: parsed.error })
+        return { status: 400, body: { error: parsed.error } }
+      }
+      const next = parsed.reset ? undefined : parsed.prompt
+      state.user = next
+      const write = await (writes = writes.then(() => writeStoredPrompt(state.path, next)))
+      if (!state.active) return { status: 503, body: { error: 'inactive' } }
+      state.persisted = write.persisted
+      state.persistenceError = write.reason
+      state.readError = undefined
+      applySection()
+      if (write.persisted) {
+        log.info('prompt.update', { reset: next === undefined, source: source(), chars: next === undefined ? 0 : next.length })
+      } else {
+        log.warn('prompt.persist-failed', { reason: write.reason })
+      }
+      return { status: 200, body: snapshot() }
+    },
+    /**
+     * One HTTP handler for both methods.
+     *
+     * @param {import('node:http').IncomingMessage} req - request.
+     * @param {import('node:http').ServerResponse} res - response.
+     */
+    async handle(req, res) {
+      if (req.method === 'GET' || req.method === 'HEAD') {
+        const readPolicy = crossSiteError(req)
+        if (readPolicy !== undefined) {
+          sendJson(res, 403, { error: readPolicy })
+          return
+        }
+        sendJson(res, 200, snapshot())
+        return
+      }
+      if (req.method !== 'POST') {
+        sendJson(res, 405, { error: 'method_not_allowed' })
+        return
+      }
+      const policy = requestPolicyError(req)
+      if (policy !== undefined) {
+        sendJson(res, 403, { error: policy })
+        return
+      }
+      let body
+      try {
+        body = await readJsonBody(req)
+      } catch (error) {
+        const tooLarge = error instanceof Error && error.message === 'body_too_large'
+        sendJson(res, tooLarge ? 413 : 400, { error: tooLarge ? 'body_too_large' : 'invalid_json' })
+        return
+      }
+      const result = await this.update(body)
+      sendJson(res, result.status, result.body)
+    },
+  }
+}

package/lib/render-tool.js

@@ -0,0 +1,162 @@
+/**
+ * The `render_view` tool: a model-facing channel that renders a compact
+ * `dsh-view` spec as an interactive card in the conversation tool row.
+ *
+ * `execute` returns the canonical JSON value the Session persists; `output.render`
+ * turns that value into the protocol text the model reads, and
+ * `output.presentationMeta` projects the card data from the same value, so a replay
+ * renders identically without re-deriving anything from the arguments.
+ */
+import { isRenderable, jsonSafe, normalizeView } from './validate.js'
+
+/** One normalized view spec, as the browser renders it. */
+const SPEC_SCHEMA = {
+  type: 'object',
+  properties: {
+    title: { type: 'string', description: 'Short card title.' },
+    gap: { type: 'integer', description: 'Vertical gap between root items in px (0-48).' },
+    items: {
+      type: 'array',
+      items: { type: 'object', additionalProperties: true },
+      description: 'Root component list (see the mosaic skill for fields).',
+    },
+  },
+  required: ['items'],
+  additionalProperties: false,
+}
+
+const PARAMETERS = {
+  type: 'object',
+  properties: {
+    spec: {
+      ...SPEC_SCHEMA,
+      description: [
+        'Render a compact visual answer in the tool row. Use it when a structured view materially helps: a dashboard, a comparison table, a chart, a checklist, a quiz, or a sandboxed interactive widget.',
+        'The vocabulary is the same as the dsh-view fence. Prefer the fence when the UI belongs inline in the reply; use this tool when the deliverable is a self-contained card.',
+        'Pass spec as a JSON object, never as a serialized string.',
+      ].join(' '),
+    },
+  },
+  required: ['spec'],
+  additionalProperties: false,
+}
+
+const OUTPUT_SCHEMA = {
+  type: 'object',
+  properties: {
+    status: { type: 'string', enum: ['rendered', 'invalid'] },
+    title: { type: 'string' },
+    rendered: { type: 'integer' },
+    spec: SPEC_SCHEMA,
+    errors: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['status'],
+  additionalProperties: false,
+}
+
+/** Unwrap the shapes a model call or a session replay may hand to this tool. */
+function unwrap(value) {
+  if (!value || typeof value !== 'object' || Array.isArray(value)) return value
+  if ('spec' in value) return unwrap(value.spec)
+  if ('arguments' in value) return unwrap(value.arguments)
+  return value
+}
+
+function specOf(args) {
+  if (typeof args === 'string') {
+    try {
+      return unwrap(JSON.parse(args))
+    } catch {
+      return undefined
+    }
+  }
+  if (!args || typeof args !== 'object') return undefined
+  return unwrap(args)
+}
+
+/**
+ * A raw JSON-Schema tool owns its input validation: a call whose arguments are not the
+ * declared object fails the call instead of reporting a card that can never render.
+ */
+function assertArguments(args) {
+  const spec = specOf(args)
+  if (spec === undefined || spec === null || typeof spec !== 'object' || Array.isArray(spec)) {
+    throw new Error('invalid arguments: expected { spec: { items: [...] } } with spec as a JSON object')
+  }
+  if (!Array.isArray(spec.items) && typeof spec.type !== 'string') {
+    throw new Error('invalid arguments: spec must carry an `items` array (one component object is also accepted)')
+  }
+  return spec
+}
+
+/** The canonical value: declared JSON data, never prose a caller must parse. */
+function canonicalValue(args) {
+  const result = normalizeView(assertArguments(args))
+  if (!isRenderable(result)) return { status: 'invalid', errors: result.errors }
+  const spec = result.spec
+  return {
+    status: 'rendered',
+    ...typeof spec.title === 'string' ? { title: spec.title } : {},
+    rendered: spec.items.length,
+    spec: jsonSafe(spec),
+  }
+}
+
+/** Model-facing summary of one canonical value. */
+function protocolOf(value) {
+  if (value.status === 'invalid') {
+    return [
+      '[mosaic-render]',
+      'status=invalid',
+      'error=invalid_spec',
+      `detail=${JSON.stringify((value.errors ?? []).join('; '))}`,
+      'next=fix_and_retry',
+      'reply_language=conversation',
+    ].join('\n')
+  }
+  return [
+    '[mosaic-render]',
+    'status=rendered',
+    ...(typeof value.title === 'string' ? [`title=${JSON.stringify(value.title)}`] : []),
+    `rendered=${value.rendered}`,
+    'action_feedback=[mosaic-action]',
+    'reply_language=conversation',
+  ].join('\n')
+}
+
+function titleOf(value) {
+  return typeof value?.title === 'string' ? `Render view: ${value.title}` : 'Render view'
+}
+
+export function createRenderViewTool() {
+  return {
+    name: 'render_view',
+    description:
+      'Render a compact visual answer as an interactive card in the conversation tool row. '
+      + 'Use it when a structured view materially helps; plain prose is enough otherwise. '
+      + 'Use it for a dashboard, comparison table, chart, diagram, checklist, quiz, media card, or a sandboxed HTML/JS widget. '
+      + 'The vocabulary is the same as the dsh-view fence; use the fence for inline UI and this tool for a self-contained card. '
+      + 'Components with an action send [mosaic-action] back to you; components without one stay local.',
+    parameters: PARAMETERS,
+    output: {
+      schema: OUTPUT_SCHEMA,
+      render(_args, value) {
+        return [{ type: 'text', text: protocolOf(value) }]
+      },
+      presentationMeta(_args, value) {
+        return value.status === 'rendered' ? jsonSafe(value.spec) : undefined
+      },
+    },
+    async execute(args) {
+      return canonicalValue(args)
+    },
+    presentCall(args) {
+      const spec = specOf(args)
+      const title = spec && typeof spec === 'object' && typeof spec.title === 'string' ? spec.title : undefined
+      return { card: 'generic', title: title ? `Render view: ${title}` : 'Render view', kind: 'other' }
+    },
+    presentResult(_args, value) {
+      return { card: 'generic', title: titleOf(value) }
+    },
+  }
+}

package/lib/validate-tool.js

@@ -0,0 +1,160 @@
+/**
+ * The `validate_view` tool: a preflight check for the dsh-view fence.
+ * It parses the exact JSON body the model is about to emit and returns a
+ * stable protocol with path-level diagnostics.
+ */
+import { describeFailure, isRenderable, normalizeView } from './validate.js'
+
+const PARAMETERS = {
+  type: 'object',
+  properties: {
+    spec: {
+      oneOf: [
+        { type: 'string', description: 'The exact JSON text of the dsh-view fence body.' },
+        { type: 'object', description: 'The spec object (serialized before validation).' },
+      ],
+      description: 'Pass the exact fence body as a string for an exact check, or the spec object.',
+    },
+  },
+  required: ['spec'],
+  additionalProperties: false,
+}
+
+const OUTPUT_SCHEMA = {
+  type: 'object',
+  properties: {
+    status: { type: 'string', enum: ['valid', 'invalid'] },
+    error: { type: 'string' },
+    detail: { type: 'string' },
+    rendered: { type: 'integer' },
+    next: { type: 'string' },
+    braceDelta: { type: 'integer' },
+    bracketDelta: { type: 'integer' },
+    likelyCauses: { type: 'array', items: { type: 'string' } },
+  },
+  required: ['status', 'next'],
+  additionalProperties: false,
+}
+
+function rawOf(args) {
+  if (typeof args === 'string') return args
+  if (!args || typeof args !== 'object') return null
+  const value = 'spec' in args ? args.spec : 'arguments' in args ? args.arguments : undefined
+  if (typeof value === 'string') return value
+  if (value && typeof value === 'object') return JSON.stringify(value)
+  return null
+}
+
+function bracketDiagnostic(raw) {
+  let braces = 0
+  let brackets = 0
+  let inString = false
+  let escaped = false
+  for (const character of raw) {
+    if (escaped) {
+      escaped = false
+      continue
+    }
+    if (inString) {
+      if (character === '\\') escaped = true
+      else if (character === '"') inString = false
+      continue
+    }
+    if (character === '"') inString = true
+    else if (character === '{') braces += 1
+    else if (character === '}') braces -= 1
+    else if (character === '[') brackets += 1
+    else if (character === ']') brackets -= 1
+  }
+  return [
+    `brace_delta=${braces}`,
+    `bracket_delta=${brackets}`,
+    ...(braces === 0 && brackets === 0 ? [] : ['likely_causes=unbalanced_delimiters,trailing_comma,unescaped_quote']),
+  ]
+}
+
+/** The canonical value: declared JSON, so a caller never parses prose for a verdict. */
+function verdictOf(lines) {
+  const value = { status: 'invalid', next: 'fix_and_revalidate' }
+  for (const line of lines) {
+    const index = line.indexOf('=')
+    if (index < 0) continue
+    const key = line.slice(0, index)
+    const rest = line.slice(index + 1)
+    if (key === 'status') value.status = rest
+    else if (key === 'error') value.error = rest
+    else if (key === 'detail') value.detail = rest
+    else if (key === 'next') value.next = rest
+    else if (key === 'rendered') value.rendered = Number(rest)
+    else if (key === 'brace_delta') value.braceDelta = Number(rest)
+    else if (key === 'bracket_delta') value.bracketDelta = Number(rest)
+    else if (key === 'likely_causes') value.likelyCauses = rest.split(',')
+  }
+  return value
+}
+
+function protocolOf(value) {
+  const lines = ['[mosaic-validation]', `status=${value.status}`]
+  if (value.error) lines.push(`error=${value.error}`)
+  if (value.detail) lines.push(`detail=${JSON.stringify(value.detail)}`)
+  if (value.rendered !== undefined) lines.push(`rendered=${value.rendered}`)
+  if (value.braceDelta !== undefined) lines.push(`brace_delta=${value.braceDelta}`, `bracket_delta=${value.bracketDelta}`)
+  if (value.likelyCauses) lines.push(`likely_causes=${value.likelyCauses.join(',')}`)
+  lines.push(`next=${value.next}`, 'reply_language=conversation')
+  return lines.join('\n')
+}
+
+function isValid(value) {
+  return value.status === 'valid'
+}
+
+export function createValidateViewTool() {
+  return {
+    name: 'validate_view',
+    description:
+      'Validate a dsh-view fence body before emitting it. Useful for non-trivial specs (>=3 components or containing a table/widget/diagram). '
+      + 'Returns a [mosaic-validation] block with status, path-level diagnostics, and next action. '
+      + 'When invalid JSON is caused by a trailing comma or an unescaped quote, fix it and validate again.',
+    parameters: PARAMETERS,
+    output: {
+      schema: OUTPUT_SCHEMA,
+      render(_args, value) {
+        return [{ type: 'text', text: protocolOf(value) }]
+      },
+    },
+    async execute(args) {
+      const raw = rawOf(args)
+      if (raw === null || raw.trim() === '') return verdictOf(['status=invalid', 'error=missing_spec', 'next=provide_spec'])
+
+      let parsed
+      try {
+        parsed = JSON.parse(raw)
+      } catch (error) {
+        return verdictOf([
+          'status=invalid',
+          'error=invalid_json',
+          `detail=${error instanceof Error ? error.message : String(error)}`,
+          ...bracketDiagnostic(raw),
+          'next=fix_and_revalidate',
+        ])
+      }
+
+      const result = normalizeView(parsed)
+      if (!isRenderable(result)) {
+        return verdictOf([
+          'status=invalid',
+          'error=invalid_spec',
+          `detail=${describeFailure(result)}`,
+          'next=fix_and_revalidate',
+        ])
+      }
+      return verdictOf(['status=valid', `rendered=${result.spec.items.length}`, 'next=emit_fence'])
+    },
+    presentCall() {
+      return { card: 'generic', title: 'Validate dsh-view', kind: 'other' }
+    },
+    presentResult(_args, value) {
+      return { card: 'generic', title: isValid(value) ? 'Validate dsh-view: valid' : 'Validate dsh-view: invalid' }
+    },
+  }
+}