@jonsoc/app 1.1.34

package/src/utils/prompt.ts

@@ -0,0 +1,203 @@
+import type { AgentPart as MessageAgentPart, FilePart, Part, TextPart } from "@jonsoc/sdk/v2"
+import type { AgentPart, FileAttachmentPart, ImageAttachmentPart, Prompt } from "@/context/prompt"
+
+type Inline =
+  | {
+      type: "file"
+      start: number
+      end: number
+      value: string
+      path: string
+      selection?: {
+        startLine: number
+        endLine: number
+        startChar: number
+        endChar: number
+      }
+    }
+  | {
+      type: "agent"
+      start: number
+      end: number
+      value: string
+      name: string
+    }
+
+function selectionFromFileUrl(url: string): Extract<Inline, { type: "file" }>["selection"] {
+  const queryIndex = url.indexOf("?")
+  if (queryIndex === -1) return undefined
+  const params = new URLSearchParams(url.slice(queryIndex + 1))
+  const startLine = Number(params.get("start"))
+  const endLine = Number(params.get("end"))
+  if (!Number.isFinite(startLine) || !Number.isFinite(endLine)) return undefined
+  return {
+    startLine,
+    endLine,
+    startChar: 0,
+    endChar: 0,
+  }
+}
+
+function textPartValue(parts: Part[]) {
+  const candidates = parts
+    .filter((part): part is TextPart => part.type === "text")
+    .filter((part) => !part.synthetic && !part.ignored)
+  return candidates.reduce((best: TextPart | undefined, part) => {
+    if (!best) return part
+    if (part.text.length > best.text.length) return part
+    return best
+  }, undefined)
+}
+
+/**
+ * Extract prompt content from message parts for restoring into the prompt input.
+ * This is used by undo to restore the original user prompt.
+ */
+export function extractPromptFromParts(parts: Part[], opts?: { directory?: string; attachmentName?: string }): Prompt {
+  const textPart = textPartValue(parts)
+  const text = textPart?.text ?? ""
+  const directory = opts?.directory
+  const attachmentName = opts?.attachmentName ?? "attachment"
+
+  const toRelative = (path: string) => {
+    if (!directory) return path
+
+    const prefix = directory.endsWith("/") ? directory : directory + "/"
+    if (path.startsWith(prefix)) return path.slice(prefix.length)
+
+    if (path.startsWith(directory)) {
+      const next = path.slice(directory.length)
+      if (next.startsWith("/")) return next.slice(1)
+      return next
+    }
+
+    return path
+  }
+
+  const inline: Inline[] = []
+  const images: ImageAttachmentPart[] = []
+
+  for (const part of parts) {
+    if (part.type === "file") {
+      const filePart = part as FilePart
+      const sourceText = filePart.source?.text
+      if (sourceText) {
+        const value = sourceText.value
+        const start = sourceText.start
+        const end = sourceText.end
+        let path = value
+        if (value.startsWith("@")) path = value.slice(1)
+        if (!value.startsWith("@") && filePart.source && "path" in filePart.source) {
+          path = filePart.source.path
+        }
+        inline.push({
+          type: "file",
+          start,
+          end,
+          value,
+          path: toRelative(path),
+          selection: selectionFromFileUrl(filePart.url),
+        })
+        continue
+      }
+
+      if (filePart.url.startsWith("data:")) {
+        images.push({
+          type: "image",
+          id: filePart.id,
+          filename: filePart.filename ?? attachmentName,
+          mime: filePart.mime,
+          dataUrl: filePart.url,
+        })
+      }
+    }
+
+    if (part.type === "agent") {
+      const agentPart = part as MessageAgentPart
+      const source = agentPart.source
+      if (!source) continue
+      inline.push({
+        type: "agent",
+        start: source.start,
+        end: source.end,
+        value: source.value,
+        name: agentPart.name,
+      })
+    }
+  }
+
+  inline.sort((a, b) => {
+    if (a.start !== b.start) return a.start - b.start
+    return a.end - b.end
+  })
+
+  const result: Prompt = []
+  let position = 0
+  let cursor = 0
+
+  const pushText = (content: string) => {
+    if (!content) return
+    result.push({
+      type: "text",
+      content,
+      start: position,
+      end: position + content.length,
+    })
+    position += content.length
+  }
+
+  const pushFile = (item: Extract<Inline, { type: "file" }>) => {
+    const content = item.value
+    const attachment: FileAttachmentPart = {
+      type: "file",
+      path: item.path,
+      content,
+      start: position,
+      end: position + content.length,
+      selection: item.selection,
+    }
+    result.push(attachment)
+    position += content.length
+  }
+
+  const pushAgent = (item: Extract<Inline, { type: "agent" }>) => {
+    const content = item.value
+    const mention: AgentPart = {
+      type: "agent",
+      name: item.name,
+      content,
+      start: position,
+      end: position + content.length,
+    }
+    result.push(mention)
+    position += content.length
+  }
+
+  for (const item of inline) {
+    if (item.start < 0 || item.end < item.start) continue
+
+    const expected = item.value
+    if (!expected) continue
+
+    const mismatch = item.end > text.length || item.start < cursor || text.slice(item.start, item.end) !== expected
+    const start = mismatch ? text.indexOf(expected, cursor) : item.start
+    if (start === -1) continue
+    const end = mismatch ? start + expected.length : item.end
+
+    pushText(text.slice(cursor, start))
+
+    if (item.type === "file") pushFile(item)
+    if (item.type === "agent") pushAgent(item)
+
+    cursor = end
+  }
+
+  pushText(text.slice(cursor))
+
+  if (result.length === 0) {
+    result.push({ type: "text", content: "", start: 0, end: 0 })
+  }
+
+  if (images.length === 0) return result
+  return [...result, ...images]
+}

package/src/utils/same.ts

@@ -0,0 +1,6 @@
+export function same<T>(a: readonly T[] | undefined, b: readonly T[] | undefined) {
+  if (a === b) return true
+  if (!a || !b) return false
+  if (a.length !== b.length) return false
+  return a.every((x, i) => x === b[i])
+}

package/src/utils/solid-dnd.tsx

@@ -0,0 +1,55 @@
+import { useDragDropContext } from "@thisbeyond/solid-dnd"
+import { JSXElement } from "solid-js"
+import type { Transformer } from "@thisbeyond/solid-dnd"
+
+export const getDraggableId = (event: unknown): string | undefined => {
+  if (typeof event !== "object" || event === null) return undefined
+  if (!("draggable" in event)) return undefined
+  const draggable = (event as { draggable?: { id?: unknown } }).draggable
+  if (!draggable) return undefined
+  return typeof draggable.id === "string" ? draggable.id : undefined
+}
+
+export const ConstrainDragXAxis = (): JSXElement => {
+  const context = useDragDropContext()
+  if (!context) return <></>
+  const [, { onDragStart, onDragEnd, addTransformer, removeTransformer }] = context
+  const transformer: Transformer = {
+    id: "constrain-x-axis",
+    order: 100,
+    callback: (transform) => ({ ...transform, x: 0 }),
+  }
+  onDragStart((event) => {
+    const id = getDraggableId(event)
+    if (!id) return
+    addTransformer("draggables", id, transformer)
+  })
+  onDragEnd((event) => {
+    const id = getDraggableId(event)
+    if (!id) return
+    removeTransformer("draggables", id, transformer.id)
+  })
+  return <></>
+}
+
+export const ConstrainDragYAxis = (): JSXElement => {
+  const context = useDragDropContext()
+  if (!context) return <></>
+  const [, { onDragStart, onDragEnd, addTransformer, removeTransformer }] = context
+  const transformer: Transformer = {
+    id: "constrain-y-axis",
+    order: 100,
+    callback: (transform) => ({ ...transform, y: 0 }),
+  }
+  onDragStart((event) => {
+    const id = getDraggableId(event)
+    if (!id) return
+    addTransformer("draggables", id, transformer)
+  })
+  onDragEnd((event) => {
+    const id = getDraggableId(event)
+    if (!id) return
+    removeTransformer("draggables", id, transformer.id)
+  })
+  return <></>
+}

package/src/utils/sound.ts

@@ -0,0 +1,110 @@
+import alert01 from "@jonsoc/ui/audio/alert-01.aac"
+import alert02 from "@jonsoc/ui/audio/alert-02.aac"
+import alert03 from "@jonsoc/ui/audio/alert-03.aac"
+import alert04 from "@jonsoc/ui/audio/alert-04.aac"
+import alert05 from "@jonsoc/ui/audio/alert-05.aac"
+import alert06 from "@jonsoc/ui/audio/alert-06.aac"
+import alert07 from "@jonsoc/ui/audio/alert-07.aac"
+import alert08 from "@jonsoc/ui/audio/alert-08.aac"
+import alert09 from "@jonsoc/ui/audio/alert-09.aac"
+import alert10 from "@jonsoc/ui/audio/alert-10.aac"
+import bipbop01 from "@jonsoc/ui/audio/bip-bop-01.aac"
+import bipbop02 from "@jonsoc/ui/audio/bip-bop-02.aac"
+import bipbop03 from "@jonsoc/ui/audio/bip-bop-03.aac"
+import bipbop04 from "@jonsoc/ui/audio/bip-bop-04.aac"
+import bipbop05 from "@jonsoc/ui/audio/bip-bop-05.aac"
+import bipbop06 from "@jonsoc/ui/audio/bip-bop-06.aac"
+import bipbop07 from "@jonsoc/ui/audio/bip-bop-07.aac"
+import bipbop08 from "@jonsoc/ui/audio/bip-bop-08.aac"
+import bipbop09 from "@jonsoc/ui/audio/bip-bop-09.aac"
+import bipbop10 from "@jonsoc/ui/audio/bip-bop-10.aac"
+import nope01 from "@jonsoc/ui/audio/nope-01.aac"
+import nope02 from "@jonsoc/ui/audio/nope-02.aac"
+import nope03 from "@jonsoc/ui/audio/nope-03.aac"
+import nope04 from "@jonsoc/ui/audio/nope-04.aac"
+import nope05 from "@jonsoc/ui/audio/nope-05.aac"
+import nope06 from "@jonsoc/ui/audio/nope-06.aac"
+import nope07 from "@jonsoc/ui/audio/nope-07.aac"
+import nope08 from "@jonsoc/ui/audio/nope-08.aac"
+import nope09 from "@jonsoc/ui/audio/nope-09.aac"
+import nope10 from "@jonsoc/ui/audio/nope-10.aac"
+import nope11 from "@jonsoc/ui/audio/nope-11.aac"
+import nope12 from "@jonsoc/ui/audio/nope-12.aac"
+import staplebops01 from "@jonsoc/ui/audio/staplebops-01.aac"
+import staplebops02 from "@jonsoc/ui/audio/staplebops-02.aac"
+import staplebops03 from "@jonsoc/ui/audio/staplebops-03.aac"
+import staplebops04 from "@jonsoc/ui/audio/staplebops-04.aac"
+import staplebops05 from "@jonsoc/ui/audio/staplebops-05.aac"
+import staplebops06 from "@jonsoc/ui/audio/staplebops-06.aac"
+import staplebops07 from "@jonsoc/ui/audio/staplebops-07.aac"
+import yup01 from "@jonsoc/ui/audio/yup-01.aac"
+import yup02 from "@jonsoc/ui/audio/yup-02.aac"
+import yup03 from "@jonsoc/ui/audio/yup-03.aac"
+import yup04 from "@jonsoc/ui/audio/yup-04.aac"
+import yup05 from "@jonsoc/ui/audio/yup-05.aac"
+import yup06 from "@jonsoc/ui/audio/yup-06.aac"
+
+export const SOUND_OPTIONS = [
+  { id: "alert-01", label: "sound.option.alert01", src: alert01 },
+  { id: "alert-02", label: "sound.option.alert02", src: alert02 },
+  { id: "alert-03", label: "sound.option.alert03", src: alert03 },
+  { id: "alert-04", label: "sound.option.alert04", src: alert04 },
+  { id: "alert-05", label: "sound.option.alert05", src: alert05 },
+  { id: "alert-06", label: "sound.option.alert06", src: alert06 },
+  { id: "alert-07", label: "sound.option.alert07", src: alert07 },
+  { id: "alert-08", label: "sound.option.alert08", src: alert08 },
+  { id: "alert-09", label: "sound.option.alert09", src: alert09 },
+  { id: "alert-10", label: "sound.option.alert10", src: alert10 },
+  { id: "bip-bop-01", label: "sound.option.bipbop01", src: bipbop01 },
+  { id: "bip-bop-02", label: "sound.option.bipbop02", src: bipbop02 },
+  { id: "bip-bop-03", label: "sound.option.bipbop03", src: bipbop03 },
+  { id: "bip-bop-04", label: "sound.option.bipbop04", src: bipbop04 },
+  { id: "bip-bop-05", label: "sound.option.bipbop05", src: bipbop05 },
+  { id: "bip-bop-06", label: "sound.option.bipbop06", src: bipbop06 },
+  { id: "bip-bop-07", label: "sound.option.bipbop07", src: bipbop07 },
+  { id: "bip-bop-08", label: "sound.option.bipbop08", src: bipbop08 },
+  { id: "bip-bop-09", label: "sound.option.bipbop09", src: bipbop09 },
+  { id: "bip-bop-10", label: "sound.option.bipbop10", src: bipbop10 },
+  { id: "staplebops-01", label: "sound.option.staplebops01", src: staplebops01 },
+  { id: "staplebops-02", label: "sound.option.staplebops02", src: staplebops02 },
+  { id: "staplebops-03", label: "sound.option.staplebops03", src: staplebops03 },
+  { id: "staplebops-04", label: "sound.option.staplebops04", src: staplebops04 },
+  { id: "staplebops-05", label: "sound.option.staplebops05", src: staplebops05 },
+  { id: "staplebops-06", label: "sound.option.staplebops06", src: staplebops06 },
+  { id: "staplebops-07", label: "sound.option.staplebops07", src: staplebops07 },
+  { id: "nope-01", label: "sound.option.nope01", src: nope01 },
+  { id: "nope-02", label: "sound.option.nope02", src: nope02 },
+  { id: "nope-03", label: "sound.option.nope03", src: nope03 },
+  { id: "nope-04", label: "sound.option.nope04", src: nope04 },
+  { id: "nope-05", label: "sound.option.nope05", src: nope05 },
+  { id: "nope-06", label: "sound.option.nope06", src: nope06 },
+  { id: "nope-07", label: "sound.option.nope07", src: nope07 },
+  { id: "nope-08", label: "sound.option.nope08", src: nope08 },
+  { id: "nope-09", label: "sound.option.nope09", src: nope09 },
+  { id: "nope-10", label: "sound.option.nope10", src: nope10 },
+  { id: "nope-11", label: "sound.option.nope11", src: nope11 },
+  { id: "nope-12", label: "sound.option.nope12", src: nope12 },
+  { id: "yup-01", label: "sound.option.yup01", src: yup01 },
+  { id: "yup-02", label: "sound.option.yup02", src: yup02 },
+  { id: "yup-03", label: "sound.option.yup03", src: yup03 },
+  { id: "yup-04", label: "sound.option.yup04", src: yup04 },
+  { id: "yup-05", label: "sound.option.yup05", src: yup05 },
+  { id: "yup-06", label: "sound.option.yup06", src: yup06 },
+] as const
+
+export type SoundOption = (typeof SOUND_OPTIONS)[number]
+export type SoundID = SoundOption["id"]
+
+const soundById = Object.fromEntries(SOUND_OPTIONS.map((s) => [s.id, s.src])) as Record<SoundID, string>
+
+export function soundSrc(id: string | undefined) {
+  if (!id) return
+  if (!(id in soundById)) return
+  return soundById[id as SoundID]
+}
+
+export function playSound(src: string | undefined) {
+  if (typeof Audio === "undefined") return
+  if (!src) return
+  void new Audio(src).play().catch(() => undefined)
+}

package/src/utils/speech.ts

@@ -0,0 +1,302 @@
+import { createSignal, onCleanup } from "solid-js"
+
+// Minimal types to avoid relying on non-standard DOM typings
+type RecognitionResult = {
+  0: { transcript: string }
+  isFinal: boolean
+}
+
+type RecognitionEvent = {
+  results: RecognitionResult[]
+  resultIndex: number
+}
+
+interface Recognition {
+  continuous: boolean
+  interimResults: boolean
+  lang: string
+  start: () => void
+  stop: () => void
+  onresult: ((e: RecognitionEvent) => void) | null
+  onerror: ((e: { error: string }) => void) | null
+  onend: (() => void) | null
+  onstart: (() => void) | null
+}
+
+const COMMIT_DELAY = 250
+
+const appendSegment = (base: string, addition: string) => {
+  const trimmed = addition.trim()
+  if (!trimmed) return base
+  if (!base) return trimmed
+  const needsSpace = /\S$/.test(base) && !/^[,.;!?]/.test(trimmed)
+  return `${base}${needsSpace ? " " : ""}${trimmed}`
+}
+
+const extractSuffix = (committed: string, hypothesis: string) => {
+  const cleanHypothesis = hypothesis.trim()
+  if (!cleanHypothesis) return ""
+  const baseTokens = committed.trim() ? committed.trim().split(/\s+/) : []
+  const hypothesisTokens = cleanHypothesis.split(/\s+/)
+  let index = 0
+  while (
+    index < baseTokens.length &&
+    index < hypothesisTokens.length &&
+    baseTokens[index] === hypothesisTokens[index]
+  ) {
+    index += 1
+  }
+  if (index < baseTokens.length) return ""
+  return hypothesisTokens.slice(index).join(" ")
+}
+
+export function createSpeechRecognition(opts?: {
+  lang?: string
+  onFinal?: (text: string) => void
+  onInterim?: (text: string) => void
+}) {
+  const hasSupport =
+    typeof window !== "undefined" &&
+    Boolean((window as any).webkitSpeechRecognition || (window as any).SpeechRecognition)
+
+  const [isRecording, setIsRecording] = createSignal(false)
+  const [committed, setCommitted] = createSignal("")
+  const [interim, setInterim] = createSignal("")
+
+  let recognition: Recognition | undefined
+  let shouldContinue = false
+  let committedText = ""
+  let sessionCommitted = ""
+  let pendingHypothesis = ""
+  let lastInterimSuffix = ""
+  let shrinkCandidate: string | undefined
+  let commitTimer: number | undefined
+
+  const cancelPendingCommit = () => {
+    if (commitTimer === undefined) return
+    clearTimeout(commitTimer)
+    commitTimer = undefined
+  }
+
+  const commitSegment = (segment: string) => {
+    const nextCommitted = appendSegment(committedText, segment)
+    if (nextCommitted === committedText) return
+    committedText = nextCommitted
+    setCommitted(committedText)
+    if (opts?.onFinal) opts.onFinal(segment.trim())
+  }
+
+  const promotePending = () => {
+    if (!pendingHypothesis) return
+    const suffix = extractSuffix(sessionCommitted, pendingHypothesis)
+    if (!suffix) {
+      pendingHypothesis = ""
+      return
+    }
+    sessionCommitted = appendSegment(sessionCommitted, suffix)
+    commitSegment(suffix)
+    pendingHypothesis = ""
+    lastInterimSuffix = ""
+    shrinkCandidate = undefined
+    setInterim("")
+    if (opts?.onInterim) opts.onInterim("")
+  }
+
+  const applyInterim = (suffix: string, hypothesis: string) => {
+    cancelPendingCommit()
+    pendingHypothesis = hypothesis
+    lastInterimSuffix = suffix
+    shrinkCandidate = undefined
+    setInterim(suffix)
+    if (opts?.onInterim) {
+      opts.onInterim(suffix ? appendSegment(committedText, suffix) : "")
+    }
+    if (!suffix) return
+    const snapshot = hypothesis
+    commitTimer = window.setTimeout(() => {
+      if (pendingHypothesis !== snapshot) return
+      const currentSuffix = extractSuffix(sessionCommitted, pendingHypothesis)
+      if (!currentSuffix) return
+      sessionCommitted = appendSegment(sessionCommitted, currentSuffix)
+      commitSegment(currentSuffix)
+      pendingHypothesis = ""
+      lastInterimSuffix = ""
+      shrinkCandidate = undefined
+      setInterim("")
+      if (opts?.onInterim) opts.onInterim("")
+    }, COMMIT_DELAY)
+  }
+
+  if (hasSupport) {
+    const Ctor: new () => Recognition = (window as any).webkitSpeechRecognition || (window as any).SpeechRecognition
+
+    recognition = new Ctor()
+    recognition.continuous = false
+    recognition.interimResults = true
+    recognition.lang = opts?.lang || (typeof navigator !== "undefined" ? navigator.language : "en-US")
+
+    recognition.onresult = (event: RecognitionEvent) => {
+      if (!event.results.length) return
+
+      let aggregatedFinal = ""
+      let latestHypothesis = ""
+
+      for (let i = 0; i < event.results.length; i += 1) {
+        const result = event.results[i]
+        const transcript = (result[0]?.transcript || "").trim()
+        if (!transcript) continue
+        if (result.isFinal) {
+          aggregatedFinal = appendSegment(aggregatedFinal, transcript)
+        } else {
+          latestHypothesis = transcript
+        }
+      }
+
+      if (aggregatedFinal) {
+        cancelPendingCommit()
+        const finalSuffix = extractSuffix(sessionCommitted, aggregatedFinal)
+        if (finalSuffix) {
+          sessionCommitted = appendSegment(sessionCommitted, finalSuffix)
+          commitSegment(finalSuffix)
+        }
+        pendingHypothesis = ""
+        lastInterimSuffix = ""
+        shrinkCandidate = undefined
+        setInterim("")
+        if (opts?.onInterim) opts.onInterim("")
+        return
+      }
+
+      cancelPendingCommit()
+
+      if (!latestHypothesis) {
+        shrinkCandidate = undefined
+        applyInterim("", "")
+        return
+      }
+
+      const suffix = extractSuffix(sessionCommitted, latestHypothesis)
+
+      if (!suffix) {
+        if (!lastInterimSuffix) {
+          shrinkCandidate = undefined
+          applyInterim("", latestHypothesis)
+          return
+        }
+        if (shrinkCandidate === "") {
+          applyInterim("", latestHypothesis)
+          return
+        }
+        shrinkCandidate = ""
+        pendingHypothesis = latestHypothesis
+        return
+      }
+
+      if (lastInterimSuffix && suffix.length < lastInterimSuffix.length) {
+        if (shrinkCandidate === suffix) {
+          applyInterim(suffix, latestHypothesis)
+          return
+        }
+        shrinkCandidate = suffix
+        pendingHypothesis = latestHypothesis
+        return
+      }
+
+      shrinkCandidate = undefined
+      applyInterim(suffix, latestHypothesis)
+    }
+
+    recognition.onerror = (e: { error: string }) => {
+      cancelPendingCommit()
+      lastInterimSuffix = ""
+      shrinkCandidate = undefined
+      if (e.error === "no-speech" && shouldContinue) {
+        setInterim("")
+        if (opts?.onInterim) opts.onInterim("")
+        setTimeout(() => {
+          try {
+            recognition?.start()
+          } catch {}
+        }, 150)
+        return
+      }
+      shouldContinue = false
+      setIsRecording(false)
+    }
+
+    recognition.onstart = () => {
+      sessionCommitted = ""
+      pendingHypothesis = ""
+      cancelPendingCommit()
+      lastInterimSuffix = ""
+      shrinkCandidate = undefined
+      setInterim("")
+      if (opts?.onInterim) opts.onInterim("")
+      setIsRecording(true)
+    }
+
+    recognition.onend = () => {
+      cancelPendingCommit()
+      lastInterimSuffix = ""
+      shrinkCandidate = undefined
+      setIsRecording(false)
+      if (shouldContinue) {
+        setTimeout(() => {
+          try {
+            recognition?.start()
+          } catch {}
+        }, 150)
+      }
+    }
+  }
+
+  const start = () => {
+    if (!recognition) return
+    shouldContinue = true
+    sessionCommitted = ""
+    pendingHypothesis = ""
+    cancelPendingCommit()
+    lastInterimSuffix = ""
+    shrinkCandidate = undefined
+    setInterim("")
+    try {
+      recognition.start()
+    } catch {}
+  }
+
+  const stop = () => {
+    if (!recognition) return
+    shouldContinue = false
+    promotePending()
+    cancelPendingCommit()
+    lastInterimSuffix = ""
+    shrinkCandidate = undefined
+    setInterim("")
+    if (opts?.onInterim) opts.onInterim("")
+    try {
+      recognition.stop()
+    } catch {}
+  }
+
+  onCleanup(() => {
+    shouldContinue = false
+    promotePending()
+    cancelPendingCommit()
+    lastInterimSuffix = ""
+    shrinkCandidate = undefined
+    setInterim("")
+    if (opts?.onInterim) opts.onInterim("")
+    try {
+      recognition?.stop()
+    } catch {}
+  })
+
+  return {
+    isSupported: () => hasSupport,
+    isRecording,
+    committed,
+    interim,
+    start,
+    stop,
+  }
+}