@vintasoftware/pr-review-canvas 0.1.0

package/src/store/canvas-store.ts

@@ -0,0 +1,120 @@
+import path from 'node:path'
+import type { CanvasRelation } from '../contract/api.js'
+import {
+  type CanvasIndex,
+  CanvasIndexSchema,
+  type CanvasManifest,
+  CanvasManifestSchema,
+} from '../contract/canvas-manifest.js'
+import { type ReviewArtifact, ReviewArtifactSchema } from '../contract/review-artifact.js'
+import type { Git } from '../git/git.js'
+import { readJson, readText, writeJsonAtomic } from './atomic-json.js'
+
+export type CanvasLookup =
+  | { status: 'ready'; headSha: string }
+  | { status: 'stale'; headSha: string; relation: CanvasRelation; commitsBehind?: number }
+  | { status: 'missing' }
+
+export interface CanvasStore {
+  readonly root: string
+  canvasDir(headSha: string): string
+  readIndex(): Promise<CanvasIndex>
+  /** True when a review.json exists for the sha, whatever its format. */
+  exists(headSha: string): Promise<boolean>
+  readArtifact(headSha: string): Promise<ReviewArtifact | null>
+  readManifest(headSha: string): Promise<CanvasManifest | null>
+  /** Writes review.json + manifest.json atomically and records the canvas in index.json. */
+  write(headSha: string, artifact: ReviewArtifact, manifest: CanvasManifest, prNumber?: number): Promise<void>
+  /**
+   * The best canvas for this PR: the one written for its current head, else the newest one the
+   * head was built on top of, else one from a branch the head no longer contains.
+   */
+  findForPr(prNumber: number, currentHeadSha: string): Promise<CanvasLookup>
+  /** Records the PR number on a canvas that was exported before the pull request existed. */
+  attachPrNumber(headSha: string, prNumber: number): Promise<void>
+}
+
+const SHA_RE = /^[0-9a-f]{40}$/
+
+export function createCanvasStore(repoRoot: string, git: Git): CanvasStore {
+  const indexFile = path.join(repoRoot, 'index.json')
+  const canvasDir = (headSha: string): string => {
+    if (!SHA_RE.test(headSha)) {
+      throw new Error(`not a commit sha: ${headSha}`)
+    }
+    return path.join(repoRoot, 'canvases', headSha)
+  }
+  const readIndex = async (): Promise<CanvasIndex> => (await readJson(indexFile, CanvasIndexSchema)) ?? { canvases: {} }
+
+  return {
+    root: repoRoot,
+    canvasDir,
+    readIndex,
+    exists: async headSha => (await readText(path.join(canvasDir(headSha), 'review.json'))) !== null,
+    readArtifact: headSha => readJson(path.join(canvasDir(headSha), 'review.json'), ReviewArtifactSchema),
+    readManifest: headSha => readJson(path.join(canvasDir(headSha), 'manifest.json'), CanvasManifestSchema),
+    write: async (headSha, artifact, manifest, prNumber) => {
+      const dir = canvasDir(headSha)
+      await writeJsonAtomic(path.join(dir, 'review.json'), artifact)
+      await writeJsonAtomic(path.join(dir, 'manifest.json'), manifest)
+      const index = await readIndex()
+      const entry: CanvasIndex['canvases'][string] = { generatedAt: artifact.generatedAt, source: artifact.source }
+      const number = prNumber ?? manifest.prNumber
+      if (number !== undefined) {
+        entry.prNumber = number
+      }
+      if (artifact.importedAt !== undefined) {
+        entry.importedAt = artifact.importedAt
+      }
+      index.canvases[headSha] = entry
+      await writeJsonAtomic(indexFile, index)
+    },
+    findForPr: async (prNumber, currentHeadSha) => {
+      const index = await readIndex()
+      if (index.canvases[currentHeadSha] !== undefined) {
+        return { status: 'ready', headSha: currentHeadSha }
+      }
+      // A canvas belongs to this PR when it was exported for it, or before the PR existed.
+      const candidates = Object.entries(index.canvases).filter(
+        ([sha, entry]) => sha !== currentHeadSha && (entry.prNumber === undefined || entry.prNumber === prNumber)
+      )
+      const ranked: Array<{ headSha: string; generatedAt: string; relation: CanvasRelation; commitsBehind?: number }> =
+        []
+      for (const [sha, entry] of candidates) {
+        if (await git.isAncestor(sha, currentHeadSha)) {
+          ranked.push({
+            headSha: sha,
+            generatedAt: entry.generatedAt,
+            relation: 'ancestor',
+            commitsBehind: await git.countCommitsBetween(sha, currentHeadSha),
+          })
+        } else {
+          ranked.push({ headSha: sha, generatedAt: entry.generatedAt, relation: 'unrelated' })
+        }
+      }
+      // Commits the head was built on come first; a force-pushed-away canvas is the last resort.
+      ranked.sort((a, b) => {
+        if (a.relation !== b.relation) {
+          return a.relation === 'ancestor' ? -1 : 1
+        }
+        return a.generatedAt < b.generatedAt ? 1 : a.generatedAt > b.generatedAt ? -1 : 0
+      })
+      const best = ranked[0]
+      if (best === undefined) {
+        return { status: 'missing' }
+      }
+      return best.commitsBehind === undefined
+        ? { status: 'stale', headSha: best.headSha, relation: best.relation }
+        : { status: 'stale', headSha: best.headSha, relation: best.relation, commitsBehind: best.commitsBehind }
+    },
+    attachPrNumber: async (headSha, prNumber) => {
+      const index = await readIndex()
+      const entry = index.canvases[headSha]
+      if (entry === undefined || entry.prNumber === prNumber) {
+        return
+      }
+      index.canvases[headSha] = { ...entry, prNumber }
+      await writeJsonAtomic(indexFile, index)
+    },
+  }
+}

package/src/store/data-dir.ts

@@ -0,0 +1,29 @@
+import { mkdir, writeFile } from 'node:fs/promises'
+import path from 'node:path'
+import type { Repo } from '../contract/review-artifact.js'
+import { readText } from './atomic-json.js'
+
+/**
+ * `.pr-review/` next to the git common dir, so every worktree of one clone shares canvases, PR
+ * state, and settings. The common dir of a worktree is `<main checkout>/.git`, and its parent
+ * is the main checkout root. An explicit override wins.
+ */
+export function resolveDataDir(opts: { override?: string | undefined; commonDir: string }): string {
+  if (opts.override !== undefined && opts.override !== '') {
+    return path.resolve(opts.override)
+  }
+  return path.join(path.dirname(path.resolve(opts.commonDir)), '.pr-review')
+}
+
+/** Creates the directory and the `.gitignore` with `*` so it never gets committed. */
+export async function ensureDataDir(dataDir: string): Promise<void> {
+  await mkdir(dataDir, { recursive: true })
+  const ignore = path.join(dataDir, '.gitignore')
+  if ((await readText(ignore)) === null) {
+    await writeFile(ignore, '*\n', 'utf8')
+  }
+}
+
+export function repoDir(dataDir: string, repo: Repo): string {
+  return path.join(dataDir, 'repos', `${repo.owner}__${repo.name}`)
+}

package/src/store/derived-store.ts

@@ -0,0 +1,93 @@
+import path from 'node:path'
+import { z } from 'zod'
+import { type FileEntry, FileEntrySchema } from '../contract/review-artifact.js'
+import { collectDiffs, toFileEntry, toPatchMap } from '../git/diff-collector.js'
+import type { Git } from '../git/git.js'
+import { materialize } from '../git/materialize.js'
+import { labelPatch } from '../git/patch-lines.js'
+import { readJson, readText, writeJsonAtomic, writeTextAtomic } from './atomic-json.js'
+import type { CanvasStore } from './canvas-store.js'
+
+export interface Derived {
+  files: FileEntry[]
+  patches: Record<string, string>
+}
+
+const DerivedMetaSchema = z.object({ headSha: z.string(), mergeBaseSha: z.string(), builtAt: z.string() })
+const FilesSchema = z.array(FileEntrySchema)
+const PatchesSchema = z.record(z.string(), z.string())
+
+export interface DerivedStore {
+  derivedDir(headSha: string): string
+  /** Both commits are local, so `ensure` can rebuild. */
+  derivable(headSha: string, mergeBaseSha: string): Promise<boolean>
+  /** Reads `derived/` when it matches the commits, otherwise rebuilds it from local git. */
+  ensure(headSha: string, mergeBaseSha: string): Promise<Derived>
+  read(headSha: string): Promise<Derived | null>
+  /** Lines `from..to` (1-based, inclusive) of a materialized file, or null when not materialized. */
+  readLines(
+    headSha: string,
+    side: 'head' | 'base',
+    filePath: string,
+    from: number,
+    to: number
+  ): Promise<string[] | null>
+}
+
+export function createDerivedStore(canvases: CanvasStore, git: Git, now: () => Date): DerivedStore {
+  const derivedDir = (headSha: string): string => path.join(canvases.canvasDir(headSha), 'derived')
+
+  const read = async (headSha: string): Promise<Derived | null> => {
+    const dir = derivedDir(headSha)
+    const files = await readJson(path.join(dir, 'files.json'), FilesSchema)
+    const patches = await readJson(path.join(dir, 'patches.json'), PatchesSchema)
+    if (files === null || patches === null) {
+      return null
+    }
+    return { files, patches }
+  }
+
+  return {
+    derivedDir,
+    derivable: async (headSha, mergeBaseSha) =>
+      (await git.commitExists(headSha)) && (await git.commitExists(mergeBaseSha)),
+    ensure: async (headSha, mergeBaseSha) => {
+      const dir = derivedDir(headSha)
+      const meta = await readJson(path.join(dir, 'meta.json'), DerivedMetaSchema)
+      if (meta !== null && meta.mergeBaseSha === mergeBaseSha) {
+        const cached = await read(headSha)
+        if (cached !== null) {
+          return cached
+        }
+      }
+      const collected = await collectDiffs(git, mergeBaseSha, headSha)
+      const files = collected.map(toFileEntry)
+      const patches = toPatchMap(collected)
+      await writeJsonAtomic(path.join(dir, 'files.json'), files)
+      await writeJsonAtomic(path.join(dir, 'patches.json'), patches)
+      for (const f of collected) {
+        await writeTextAtomic(path.join(dir, 'patches', `${f.key}.diff`), `${labelPatch(f.key, f.patch)}\n`)
+      }
+      await materialize(git, { headSha, mergeBaseSha, files: collected, outDir: dir })
+      await writeJsonAtomic(path.join(dir, 'meta.json'), { headSha, mergeBaseSha, builtAt: now().toISOString() })
+      return { files, patches }
+    },
+    read,
+    readLines: async (headSha, side, filePath, from, to) => {
+      const root = path.join(derivedDir(headSha), side)
+      const full = path.resolve(root, filePath)
+      if (!full.startsWith(root + path.sep)) {
+        return null
+      }
+      const text = await readText(full)
+      if (text === null) {
+        return null
+      }
+      const lines = text.split('\n')
+      if (lines[lines.length - 1] === '') {
+        lines.pop()
+      }
+      return lines.slice(Math.max(from, 1) - 1, Math.max(to, 0))
+    },
+  }
+}

package/src/store/pr-store.ts

@@ -0,0 +1,69 @@
+import { readdir, stat } from 'node:fs/promises'
+import path from 'node:path'
+import { type CommentsPayload, CommentsPayloadSchema } from '../contract/comments.js'
+import { type DiscoveryCache, DiscoveryCacheSchema } from '../contract/discovery.js'
+import { type Pr, PrSchema } from '../contract/review-artifact.js'
+import { readJson, readJsonOrDefault, writeJsonAtomic } from './atomic-json.js'
+
+/** PR-keyed files: the cached PR meta and the last comments payload. */
+export interface PrStore {
+  prDir(number: number): string
+  readPr(number: number): Promise<Pr | null>
+  writePr(pr: Pr): Promise<void>
+  readComments(number: number): Promise<CommentsPayload | null>
+  writeComments(number: number, comments: CommentsPayload): Promise<void>
+  /** The last attachment scan, so an unchanged PR is not scanned again. */
+  readDiscovery(number: number): Promise<DiscoveryCache | null>
+  writeDiscovery(number: number, discovery: DiscoveryCache): Promise<void>
+  /** PR numbers with a cached pr.json, newest first by file mtime. */
+  listRecent(limit: number): Promise<Array<{ number: number; title: string; updatedAt: string }>>
+}
+
+export function createPrStore(repoRoot: string): PrStore {
+  const prDir = (number: number): string => {
+    if (!Number.isInteger(number) || number <= 0) {
+      throw new Error(`not a pull request number: ${number}`)
+    }
+    return path.join(repoRoot, 'prs', String(number))
+  }
+  return {
+    prDir,
+    readPr: number => readJson(path.join(prDir(number), 'pr.json'), PrSchema),
+    writePr: async pr => {
+      if (pr.number === null) {
+        throw new Error('cannot cache a pre-PR change set under prs/')
+      }
+      await writeJsonAtomic(path.join(prDir(pr.number), 'pr.json'), pr)
+    },
+    readComments: number => readJson(path.join(prDir(number), 'comments.json'), CommentsPayloadSchema),
+    writeComments: (number, comments) => writeJsonAtomic(path.join(prDir(number), 'comments.json'), comments),
+    readDiscovery: number =>
+      readJsonOrDefault(path.join(prDir(number), 'discovery.json'), DiscoveryCacheSchema, () => null),
+    writeDiscovery: (number, discovery) => writeJsonAtomic(path.join(prDir(number), 'discovery.json'), discovery),
+    listRecent: async limit => {
+      let names: string[]
+      try {
+        names = await readdir(path.join(repoRoot, 'prs'))
+      } catch {
+        return []
+      }
+      const rows: Array<{ number: number; title: string; updatedAt: string; mtime: number }> = []
+      for (const name of names) {
+        const number = Number(name)
+        if (!Number.isInteger(number) || number <= 0) {
+          continue
+        }
+        const file = path.join(prDir(number), 'pr.json')
+        // A directory without pr.json, or one written by an older tool version, is skipped.
+        const pr = await readJsonOrDefault(file, PrSchema, () => null)
+        if (pr === null) {
+          continue
+        }
+        const s = await stat(file)
+        rows.push({ number, title: pr.title, updatedAt: s.mtime.toISOString(), mtime: s.mtimeMs })
+      }
+      rows.sort((a, b) => b.mtime - a.mtime)
+      return rows.slice(0, limit).map(({ number, title, updatedAt }) => ({ number, title, updatedAt }))
+    },
+  }
+}

package/src/store/settings-store.ts

@@ -0,0 +1,152 @@
+import path from 'node:path'
+import { isMap, parseDocument } from 'yaml'
+import { DEFAULT_SETTINGS, type Settings, type SettingsInput, SettingsSchema } from '../contract/settings.js'
+import { readText, writeTextAtomic } from './atomic-json.js'
+
+export const SETTINGS_FILE = 'settings.yml'
+
+/** Written once, the first time the file is needed, so the user can edit it by hand too. */
+export const SETTINGS_TEMPLATE = `# Personal pr-review settings. Gitignored: this file is yours, not the project's.
+# Project-wide settings (layers, caps, chat.enabled) live in pr-review.config.yml at the repo root.
+version: 1
+
+# The look of the page: terminal or github.
+skin: terminal
+
+# Light or dark: auto follows the operating system, light and dark pin one.
+theme: auto
+
+# Which agent answers in the AI Chat pane: claude or codex.
+agent: claude
+
+# Model id for that agent, or null for the agent's own default.
+model: null
+
+# How long one chat turn may take, in seconds.
+chatTimeoutSec: 600
+
+# Cap on agent turns per message, or null for the agent's own default.
+maxTurns: null
+`
+
+export interface SettingsStore {
+  /** The file's path, shown in the settings dialog. */
+  file: string
+  /** The saved settings, or the defaults when the file is missing or unreadable. */
+  read(): Promise<Settings>
+  /**
+   * Writes the changed fields back. Comments and key order in the file survive, because the
+   * document is edited rather than re-serialized from a plain object.
+   */
+  write(input: SettingsInput): Promise<Settings>
+  /** Writes the commented template when the file does not exist yet. */
+  ensureFile(): Promise<boolean>
+}
+
+export function createSettingsStore(dataDir: string): SettingsStore {
+  const file = path.join(dataDir, SETTINGS_FILE)
+
+  const read = async (): Promise<Settings> => {
+    const text = await readText(file)
+    if (text === null) {
+      return DEFAULT_SETTINGS
+    }
+    return parseSettings(text)
+  }
+
+  /**
+   * Every write runs after the one before it, so two that arrive together both land and the
+   * first run's template never lands on top of a save.
+   */
+  let chain: Promise<unknown> = Promise.resolve()
+  const queued = <T>(task: () => Promise<T>): Promise<T> => {
+    const chained = chain.then(task, task)
+    chain = chained.catch(() => undefined)
+    return chained
+  }
+
+  const write = async (input: SettingsInput): Promise<Settings> => {
+    const current = (await readText(file)) ?? SETTINGS_TEMPLATE
+    const next = applySettings(current, input)
+    await writeTextAtomic(file, next.text)
+    return next.settings
+  }
+
+  const ensureFile = async (): Promise<boolean> => {
+    if ((await readText(file)) !== null) {
+      return false
+    }
+    await writeTextAtomic(file, SETTINGS_TEMPLATE)
+    return true
+  }
+
+  return {
+    file,
+    read,
+    ensureFile: () => queued(ensureFile),
+    write: input => queued(() => write(input)),
+  }
+}
+
+/**
+ * The settings a file holds. A file that is not YAML, or whose values do not fit, falls back to
+ * the defaults rather than failing the page: the dialog can then write a good file over it.
+ */
+export function parseSettings(text: string): Settings {
+  let raw: unknown
+  try {
+    raw = parseDocument(text).toJS() as unknown
+  } catch {
+    return DEFAULT_SETTINGS
+  }
+  if (typeof raw !== 'object' || raw === null) {
+    return DEFAULT_SETTINGS
+  }
+  const merged = { ...DEFAULT_SETTINGS, ...raw, version: 1 }
+  const parsed = SettingsSchema.safeParse(merged)
+  return parsed.success ? parsed.data : DEFAULT_SETTINGS
+}
+
+/** The new file text and the settings it holds, given the old text and the changed fields. */
+export function applySettings(text: string, input: SettingsInput): { text: string; settings: Settings } {
+  const wanted = { ...parseSettings(text), ...stripUndefined(input) }
+  const parsed = SettingsSchema.safeParse({ ...wanted, version: 1 })
+  const settings = parsed.success ? parsed.data : DEFAULT_SETTINGS
+  let doc = parseDocument(text)
+  // Only a mapping can hold these keys; a file that is a list or a scalar starts over from the
+  // template, which is also what a file that does not parse gets.
+  if (doc.errors.length > 0 || !isMap(doc.contents)) {
+    doc = parseDocument(SETTINGS_TEMPLATE)
+  }
+  doc.set('version', 1)
+  doc.set('skin', settings.skin)
+  doc.set('theme', settings.theme)
+  doc.set('agent', settings.agent)
+  doc.set('model', settings.model)
+  doc.set('chatTimeoutSec', settings.chatTimeoutSec)
+  doc.set('maxTurns', settings.maxTurns)
+  return { text: String(doc), settings }
+}
+
+function stripUndefined(input: SettingsInput): Partial<Settings> {
+  const out: Partial<Settings> = {}
+  if (input.skin !== undefined) {
+    out.skin = input.skin
+  }
+  if (input.theme !== undefined) {
+    out.theme = input.theme
+  }
+  if (input.agent !== undefined) {
+    out.agent = input.agent
+  }
+  if (input.model !== undefined) {
+    out.model = input.model === '' ? null : input.model
+  }
+  if (input.chatTimeoutSec !== undefined) {
+    out.chatTimeoutSec = input.chatTimeoutSec
+  }
+  if (input.maxTurns !== undefined) {
+    out.maxTurns = input.maxTurns
+  }
+  return out
+}

package/src/store/state-store.ts

@@ -0,0 +1,121 @@
+import path from 'node:path'
+import { emptyState, type PrState, PrStateSchema } from '../contract/state.js'
+import { readJsonOrDefault, writeJsonAtomic } from './atomic-json.js'
+import type { PrStore } from './pr-store.js'
+
+/** What the canvas posted to GitHub, so the sign-off body can list it. */
+export interface PostedEntry {
+  commentId: number
+  pointFingerprint?: string
+}
+
+/** Per-PR local state: reviewed cards, dismissed points, hidden threads, posted comments. */
+export interface StateStore {
+  /** Defaults when the file is missing or does not match the schema (an older tool version wrote it). */
+  read(number: number): Promise<PrState>
+  /**
+   * Read, change, write. Calls for the same PR run one after another, so two requests that
+   * arrive together both land instead of one overwriting the other.
+   */
+  update(number: number, mutate: (state: PrState) => PrState): Promise<PrState>
+  /**
+   * Marks one layer or file. `headSha` is the commit the page was showing: when it differs from
+   * the one the marks describe, the old marks are dropped, because they were about other code.
+   */
+  setReviewed(number: number, id: string, reviewed: boolean, headSha?: string): Promise<PrState>
+  setDismissed(number: number, fingerprint: string, dismissed: boolean, reason?: string): Promise<PrState>
+  setThreadHidden(number: number, rootCommentId: number, hidden: boolean): Promise<PrState>
+  addPosted(number: number, entry: PostedEntry): Promise<PrState>
+}
+
+/** `layer:<id>` or `layer:<id>/file:<key>`, with the ids and keys the artifact uses. */
+const REVIEWED_ID_RE = /^layer:[A-Za-z0-9_-]+(?:\/file:[A-Za-z0-9_]+)?$/
+
+export function isReviewedId(id: string): boolean {
+  return REVIEWED_ID_RE.test(id)
+}
+
+/** `layer:<id>` for both a layer id and one of its file ids. */
+function layerOf(id: string): string {
+  const at = id.indexOf('/file:')
+  return at === -1 ? id : id.slice(0, at)
+}
+
+export function createStateStore(prs: PrStore, now: () => Date): StateStore {
+  const file = (number: number): string => path.join(prs.prDir(number), 'state.json')
+  const read = (number: number): Promise<PrState> =>
+    readJsonOrDefault(file(number), PrStateSchema, () => emptyState(now().toISOString()))
+
+  /** One chain per PR number; each update waits for the one before it. */
+  const chains = new Map<number, Promise<unknown>>()
+
+  const update = (number: number, mutate: (state: PrState) => PrState): Promise<PrState> => {
+    const run = async (): Promise<PrState> => {
+      const current = await read(number)
+      // Every write counts up, so the page can tell which of two answers was written later.
+      const next = { ...mutate(current), rev: (current.rev ?? 0) + 1, updatedAt: now().toISOString() }
+      await writeJsonAtomic(file(number), next)
+      return next
+    }
+    const chained = (chains.get(number) ?? Promise.resolve()).then(run, run)
+    // The chain only orders the calls, so a failed update never blocks the next one.
+    chains.set(
+      number,
+      chained.catch(() => undefined)
+    )
+    return chained
+  }
+
+  return {
+    read,
+    update,
+    setReviewed: (number, id, reviewed, headSha) =>
+      update(number, state => {
+        const sameHead =
+          headSha === undefined || state.reviewedHeadSha === undefined || state.reviewedHeadSha === headSha
+        const next = sameHead ? { ...state.reviewed } : {}
+        if (reviewed) {
+          next[id] = true
+        } else {
+          for (const key of Object.keys(next)) {
+            // Reopening a layer reopens its files, and reopening a file reopens its layer:
+            // both readings of "reviewed" have to agree.
+            if (key === id || key.startsWith(`${id}/`) || key === layerOf(id)) {
+              delete next[key]
+            }
+          }
+        }
+        return headSha === undefined
+          ? { ...state, reviewed: next }
+          : { ...state, reviewed: next, reviewedHeadSha: headSha }
+      }),
+    setDismissed: (number, fingerprint, dismissed, reason) =>
+      update(number, state => {
+        const next = { ...state.dismissed }
+        if (dismissed) {
+          next[fingerprint] = reason === undefined ? { at: now().toISOString() } : { at: now().toISOString(), reason }
+        } else {
+          delete next[fingerprint]
+        }
+        return { ...state, dismissed: next }
+      }),
+    setThreadHidden: (number, rootCommentId, hidden) =>
+      update(number, state => {
+        const next = { ...state.hiddenThreads }
+        if (hidden) {
+          next[String(rootCommentId)] = { at: now().toISOString() }
+        } else {
+          delete next[String(rootCommentId)]
+        }
+        return { ...state, hiddenThreads: next }
+      }),
+    addPosted: (number, entry) =>
+      update(number, state => {
+        if (state.posted.some(p => p.commentId === entry.commentId)) {
+          return state
+        }
+        const posted = { ...entry, at: now().toISOString() }
+        return { ...state, posted: [...state.posted, posted] }
+      }),
+  }
+}