stub frontend state machine

deno.lock

···
     "npm:@tauri-apps/plugin-positioner@2.3": "2.3.0",
     "npm:@tauri-apps/plugin-store@2.4": "2.4.0",
     "npm:@tauri-apps/plugin-window-state@2.4": "2.4.0",
+    "npm:@xstate/svelte@5": "5.0.0_svelte@5.38.3__acorn@8.15.0_xstate@5.21.0",
     "npm:svelte-check@4": "4.3.1_svelte@5.38.3__acorn@8.15.0_typescript@5.6.3",
     "npm:svelte@5": "5.38.3_acorn@8.15.0",
     "npm:tailwindcss@^4.1.12": "4.1.12",
     "npm:typescript@~5.6.2": "5.6.3",
-    "npm:vite@^6.0.3": "6.3.5_picomatch@4.0.3"
+    "npm:vite@^6.0.3": "6.3.5_picomatch@4.0.3",
+    "npm:xstate@^5.21.0": "5.21.0"
   },
   "jsr": {
     "@std/async@1.0.14": {
···
     "@types/estree@1.0.8": {
       "integrity": "sha512-dWHzHa2WqEXI/O1E9OjrocMTKJl2mSrEolh1Iomrv6U+JuNwaHXsXx9bLu5gG7BUWFIN0skIQJQ/L1rIex4X6w=="
     },
+    "@xstate/svelte@5.0.0_svelte@5.38.3__acorn@8.15.0_xstate@5.21.0": {
+      "integrity": "sha512-VZABqXXwKIpnEDIoz5Vb7P1C+4rIivxG8u3eNqCKW048cVg7eHBXc4lr+icwXQitSJG/fJSmfgvSGYjn9ouuRQ==",
+      "dependencies": [
+        "svelte",
+        "xstate"
+      ],
+      "optionalPeers": [
+        "xstate"
+      ]
+    },
     "acorn@8.15.0": {
       "integrity": "sha512-NZyJarBfL7nWwIq+FDL6Zp/yHEhePMNnnJ0y3qfieCrmNvYct8uvtiV41UvlSe6apAfk0fY1FbWx+NwfmpvtTg==",
       "bin": true
···
         "vite"
       ]
     },
+    "xstate@5.21.0": {
+      "integrity": "sha512-y4wmqxjyAa0tgz4k3m/MgTF1kDOahE5+xLfWt5eh1sk+43DatLhKlI8lQDJZpvihZavjbD3TUgy2PRMphhhqgQ=="
+    },
     "yallist@5.0.0": {
       "integrity": "sha512-YgvUTfwqyc7UXVMrB+SImsVYSmTS8X/tSrtdNZMImM+n7+QTriRXyXim0mBrTXNeqzVF0KWGgHPeiyViFFrNDw=="
     },
···
         "npm:@tauri-apps/plugin-positioner@2.3",
         "npm:@tauri-apps/plugin-store@2.4",
         "npm:@tauri-apps/plugin-window-state@2.4",
+        "npm:@xstate/svelte@5",
         "npm:svelte-check@4",
         "npm:svelte@5",
         "npm:tailwindcss@^4.1.12",
         "npm:typescript@~5.6.2",
-        "npm:vite@^6.0.3"
+        "npm:vite@^6.0.3",
+        "npm:xstate@^5.21.0"
       ]
     }
   }

package.json

···
     "@tauri-apps/plugin-positioner": "~2.3.0",
     "@tauri-apps/plugin-store": "~2.4.0",
     "@tauri-apps/plugin-window-state": "~2.4.0",
-    "tailwindcss": "^4.1.12"
+    "@xstate/svelte": "^5.0.0",
+    "tailwindcss": "^4.1.12",
+    "xstate": "^5.21.0"
   },
   "devDependencies": {
     "@sveltejs/adapter-static": "^3.0.6",

src-tauri/src/cartesia/commands.rs

···
 use tauri::ipc::Channel;
 
-use crate::{cartesia::stt::TranscriptionWord, state::AppState};
+use crate::{cartesia::stt::SttTranscriptionWord, state::AppState};
 
 #[tauri::command]
 pub async fn start_stt(
     state: tauri::State<'_, AppState>,
-    on_event: Channel<TranscriptionWord>,
+    on_event: Channel<SttTranscriptionWord>,
 ) -> Result<(), ()> {
     let mut rec = state.stt_manager.transcribe().await;
 

src-tauri/src/cartesia/stt.rs

···
 use tauri::async_runtime::{channel, spawn, Mutex, Receiver, RwLock, Sender};
 use tokio::net::TcpStream;
 use tokio_tungstenite::{MaybeTlsStream, WebSocketStream};
+use ts_rs::TS;
 use tungstenite::{Bytes, Error, Message, Utf8Bytes};
 
 #[derive(Debug)]
···
     input: Arc<InputDeviceManager>,
 }
 
-#[derive(Deserialize, Debug, Serialize)]
-pub struct TranscriptionWord {
+#[derive(Deserialize, Debug, Serialize, TS)]
+#[ts(export)]
+pub struct SttTranscriptionWord {
     word: String,
     start: f32,
     end: f32,
···
         text: String,
         duration: Option<f32>,
         language: Option<String>,
-        words: Option<Vec<TranscriptionWord>>,
+        words: Option<Vec<SttTranscriptionWord>>,
     },
     Error {
         message: String,
···
     }
 
     /// Begins transcribing text via Cartesia. Blocks until `stop_transcription` is called
-    pub async fn transcribe(&self) -> Receiver<TranscriptionWord> {
+    pub async fn transcribe(&self) -> Receiver<SttTranscriptionWord> {
         {
             let mut status = self.status.write().await;
             *status = SttStatus::Opening;
···
         let input = self.input.start_listening().await;
         let stream = self.client.open_stt_connection().await;
         let (socket_in, socket_out) = stream.split();
-        let (fn_in, fn_out) = channel::<TranscriptionWord>(500);
+        let (fn_in, fn_out) = channel::<SttTranscriptionWord>(500);
         let writer = Arc::new(Mutex::new(socket_in));
 
         {
···
     input: Arc<InputDeviceManager>,
     mut socket_reader: SplitStream<WebSocketStream<MaybeTlsStream<TcpStream>>>,
     socket_writer: Arc<Mutex<SplitSink<WebSocketStream<MaybeTlsStream<TcpStream>>, Message>>>,
-    out_writer: Sender<TranscriptionWord>,
+    out_writer: Sender<SttTranscriptionWord>,
 ) {
     while let Some(message) = socket_reader.next().await {
         match message {

src/lib/actors/conversation.ts

···
+import { setup, fromPromise, assign, emit } from "xstate";
+import { invoke, Channel } from "@tauri-apps/api/core";
+import type { LettaCompletionMessage } from "../rust/LettaCompletionMessage.ts";
+import type { SttTranscriptionWord } from "../rust/SttTranscriptionWord.ts";
+
+interface Context {
+  draft: string;
+  history: Array<LettaCompletionMessage>;
+  responseInProgress?: LettaCompletionMessage;
+}
+
+type Event =
+  | {
+      type: "stt.start";
+    }
+  | {
+      type: "stt.transcribed";
+      word: SttTranscriptionWord;
+    }
+  | {
+      type: "stt.stop";
+    }
+  | {
+      type: "stt.error";
+    }
+  | {
+      type: "message.start";
+      msg: LettaCompletionMessage;
+    }
+  | {
+      type: "message.update";
+      msg: LettaCompletionMessage;
+    }
+  | {
+      type: "message.done";
+      msg: LettaCompletionMessage;
+    }
+  | {
+      type: "turn.unfinished";
+    }
+  | {
+      type: "turn.finished";
+    }
+  | {
+      type: "tts.speak";
+    }
+  | {
+      type: "tts.progress";
+    }
+  | {
+      type: "tts.stop";
+    }
+  | {
+      type: "tts.error";
+    }
+  | {
+      type: "interrupt";
+    }
+  | {
+      type: "draft.start";
+    }
+  | {
+      type: "draft.update";
+      draft: string;
+    }
+  | {
+      type: "draft.submit";
+      draft: string;
+    }
+  | {
+      type: "draft.abandon";
+    };
+
+export const conversation = setup({
+  types: {
+    context: {} as Context,
+    events: {} as Event,
+  },
+  actors: {
+    stt: fromPromise<void, undefined, Event>(async ({ emit }) => {
+      const onEvent = new Channel<SttTranscriptionWord>();
+
+      onEvent.onmessage = (word) => {
+        emit({ type: "stt.transcribed", word });
+      };
+
+      await invoke("start_stt", { onEvent });
+    }),
+    startCompletion: fromPromise<void, { prompt: string }, Event>(
+      async ({ input: { prompt }, emit }) => {
+        const onEvent = new Channel<LettaCompletionMessage>();
+
+        onEvent.onmessage = (msg) => {
+          // emit({ type: "message.start", msg })
+
+          emit({ type: "message.update", msg });
+
+          // emit({ type: "message.done", msg })
+        };
+
+        await invoke("start_llm_completion", { prompt, onEvent });
+      }
+    ),
+  },
+  actions: {
+    async stopStt() {
+      await invoke("stop_stt");
+    },
+    updateDraft: assign({
+      draft: ({ context, event }) => {
+        switch (event.type) {
+          case "draft.update":
+            return event.draft;
+          case "stt.transcribed":
+            return context.draft + event.word.word;
+          default:
+            return context.draft;
+        }
+      },
+    }),
+    resetDraft: assign({ draft: "" }),
+    commitDraft: assign({
+      history: ({ context }, params: { draft: string }) => {
+        const history = context.history;
+        const message: LettaCompletionMessage = {
+          id: crypto.randomUUID(),
+          date: new Date().toISOString(),
+          message_type: "user_message",
+          content: [{ type: "text", text: params.draft }],
+          is_err: false,
+          name: null,
+          otid: null,
+          run_id: null,
+          sender_id: null,
+          seq_id: null,
+          step_id: null,
+        };
+
+        history.push(message);
+
+        return new Array(...history);
+      },
+    }),
+  },
+  guards: {
+    hasDraft({ context }) {
+      return Boolean(context.draft.trim());
+    },
+  },
+}).createMachine({
+  /** @xstate-layout N4IgpgJg5mDOIC5QGMD2A7AbmATrAhgC4CWGAdMRADZgDEEO+AZoWbIfjoQNoAMAuolAAHVLGIkMQkAA9EAZgAsARjIA2AKxqATFrUBOAOyKjygDQgAnomVreZE-v3zeADiO95aw-IC+vizQsXAJJdApqOnZWdk4eAWlRcTDpOQQlVU0dPSMTQ3MrRG1FbTINXgqlQ29eHWVtf0CMbDwiUnCGZhJ0KHpGFjYAVwAjAFsJPkEkECSJdtTEDW0LawRlDQ1DMkMnNXXaww1FVw1GkCCW0PayTpZiHr6usnxh-HQIDEnEsTmpabT5PJMlpdGoDMZTCtEK5tK4yNonBpXHttOstK4zhcQm1yLdulAyIRGOhYMgcMRhvdeh90GAKFhUABrOlY1phG79fGE4mk8mUnoIe6YVDIHHoSZfaazFL-Gy8ZRw3iKAyo7TaeSbVyuKEIRQbMo+WrKJWGHa1U4Bc7NbHsvFU7lvXkUqm0XA4VA4MjCKhEJge0ZkVlXXGc+1Ex1k50CoUisUShJSn4y0BpY0KshKlX1dWa7WFBBqZFkdZqeSG-TaPYKzHWtnXO09B0kyP83rRNiEVDCSUiJPzWUF+SlTMnfLG-T1Qw6xSKeRkfQaFyaVzHdzymvBOshrphnktl3t8PNvmQHszPt-FOIUvD5VawyuU2uXj6HUItTzpz6GGuIdK-R6hulxihyO6NmgoyzA8eJkIMwgQEQYBntK-ZXgg2ieHOJT6GCj5KsU6w6kCcL1BUsKOGW8pqEBNr1qG4GoJBPwPO2sRcMhF7oAsayHFsrj1Ecyg7Js3hqERQkGkuyjyFqGq8KaNFbh09EEm6HqQI8AywCM4zxFMvbJKhsg2Eo9iKNU6L4d+r75ho+j2JsLglMo9k7NJinBspYGqTg7o4BpMFwQhhBIQmBm-FxA62EY2zlLwaqAmCLlifmYL2CuaizlqdgueZHkgRB3pgFyVDEOwYDoPalA0LQoxwAQMAdnEHGGZexk8boZBKF4exLDlXg6gqsIZvFY4IrwdmPvl7KFTQJVlSFlWNkFbQPHVsANXSK0hS1EXcaiShdXZCKotkaqDYY2hbC4V3OIumrHNN1yzcV9qleVS0EttLrrZtNwYKF+nnq1kVoUJnXdUlfXygN+a2JdI2VjotSlusT3kC980ffatIyIQtX1fgjVsXp3wg9xWqlBqFZarO34KgUqwuXZsWVi+K4Igqijo+EmNvQtFU42AeO0IQgw4OEgzoEw9xlQAFqeYXA3tA6U0dNMrvI9P8YN-FwrolZ62a3g84GjFFVji1CyLYsS2QMuVbACsQLtybtWr1Owpr2uMzYi76Ij1R2EcM4lP4lroKgEBwNIQZimTKtoQAtClqwI1+E5Xai6zGNzlpx+y1VgAnbtpCUF0fo437Pr+arGNR+e1p5oF3D0JdGWkSKKBmd6bMo46ToNmgjRUDOHI+zgNI3m7Nw2BJHk6rbt21aT5HCvH8XYdgzu4Op2Ro861FdLmAkCGym3PZtMeIbeJuTA4YWWxaKBNj71MqRjyNO5SSRNlbOMocyXgL4qTIGpfyEBl6g3atJWoGYgRXRftJQsWgdTeC2I5eKCJJ7EVNnzW+4VS4KBwp+JwKglTlH4ooQagD159TXiYeopY8HmzmvaGAtJGD4igdxZUpQM7kL1G4QBg1YT2EOP-Z8Ws3D6BYZBNhjZ3pWwIcrIhuoZykIAsaIRVDBpawDhIwsQljD5FnHIi2-NsaNiLjwqKlY5yewnPKZEE4pxwxhMOUa9RcpCUetPYCM1WGvUUQLT6sF4KrSgLYtCqI4GQ0yto+8GhdaAjIM+Y+FRnCGE8BifxtEMZBMtoLRsuNCDRPaiYfhX5BGUJEXDDYcJ7L-0zrCQBFomgzwKoUyxyiCQ0mLnfROMD7Hq05s4gwQlBqLlUBI7JOxMroPDr4IAA */
+  id: "conversation",
+  initial: "idle",
+  context: {
+    draft: "",
+    history: [],
+  },
+  states: {
+    idle: {
+      description: "Waiting for the user to compose a draft",
+      on: {
+        "draft.start": {
+          description: "User composing draft with text",
+          target: "drafting.composing",
+        },
+        "stt.start": {
+          description: "User composing draft with voice",
+          target: "drafting.transcribing",
+        },
+      },
+    },
+    drafting: {
+      description: "User is drafting a prompt for the agent",
+      states: {
+        transcribing: {
+          description: "User is actively using STT",
+          invoke: {
+            src: "stt",
+            onDone: {
+              description: "STT invocation finished without error",
+              target: "composing",
+            },
+            onError: {
+              target: "errored",
+            },
+          },
+          on: {
+            "stt.stop": {
+              description:
+                "User finished with STT; stop the backend transcription process",
+              actions: ["stopStt"],
+            },
+            "stt.transcribed": {
+              description:
+                "Backend emitted a transcription event; append to draft",
+              actions: ["updateDraft"],
+            },
+          },
+          exit: ["stopStt"],
+        },
+        composing: {
+          description: "User is editing the draft via textarea",
+          on: {
+            "draft.update": {
+              description: "onChange event fired, update draft",
+              actions: ["updateDraft"],
+            },
+            "stt.start": {
+              description: "User switching to voice; start STT",
+              target: "transcribing",
+            },
+          },
+        },
+        errored: {
+          description:
+            "Backend encountered an error, likely during transcription",
+          on: {
+            "draft.submit": {
+              description: "User submitted draft in error state; disallow",
+            },
+            "draft.update": {
+              description: "User is manually correcting prompt; recover",
+              actions: ["updateDraft"],
+              target: "composing",
+            },
+          },
+        },
+      },
+      on: {
+        "draft.submit": {
+          description:
+            "If we have a draft, submit it to history and start completion",
+          guard: "hasDraft",
+          target: "completing",
+          actions: [
+            {
+              type: "commitDraft",
+              params: ({ context }) => ({ draft: context.draft }),
+            },
+            "resetDraft",
+          ],
+        },
+        "draft.abandon": {
+          description: "User changed their mind about the current draft",
+          target: "idle",
+          actions: ["resetDraft"],
+        },
+      },
+    },
+    completing: {
+      description:
+        "Present the written prompt to Letta and Cartesia TTS for completion",
+      type: "parallel",
+      states: {
+        generating: {
+          description: "Start completion turn and emit events from the backend",
+          invoke: {
+            src: "startCompletion",
+            input: ({ context, event }) => ({
+              prompt:
+                event.type === "draft.submit" ? event.draft : context.draft,
+            }),
+          },
+        },
+        listening: {
+          description:
+            "Represent the state of the backend process from emitted events",
+          initial: "idle",
+          states: {
+            idle: {
+              description:
+                "Completion has started, but we haven't recieved initial metadata yet",
+              on: {
+                "message.start": {
+                  description: "Message metadata recieved",
+                  target: "updating",
+                },
+              },
+            },
+            updating: {
+              description:
+                "Backend is receiving streamed updates to the current message",
+              on: {
+                "message.update": {
+                  description:
+                    "New content chunk recieved; append to current message",
+                  actions: [],
+                },
+                "message.done": {
+                  description:
+                    "All updates for the current message have been transmitted",
+                  target: "next",
+                },
+              },
+            },
+            next: {
+              description: "Requesting the next message in the completion turn",
+              on: {
+                "message.start": {
+                  description:
+                    "The backend already has metadata for the next message; immediately start streaming updates",
+                  target: "updating",
+                },
+                "turn.unfinished": {
+                  description:
+                    "The current completion turn is not complete, but don't have the metadata for the next message yet",
+                  target: "idle",
+                },
+                "turn.finished": {
+                  description: "All messages have been streamed to the client",
+                  target: "done",
+                },
+              },
+            },
+            done: {
+              description:
+                "The current generated turn is complete; return to idle",
+              type: "final",
+              target: "#idle",
+            },
+          },
+        },
+      },
+    },
+  },
+});

src/lib/rust/LettaCompletionMessage.ts

···
 import type { LettaToolCall } from "./LettaToolCall";
 import type { LettaToolReturnStatus } from "./LettaToolReturnStatus";
 
-export type LettaCompletionMessage =
-  | {
-      message_type: "system_message";
-      id: string;
-      date: string;
-      content: string;
-      name: string | null;
-      otid: string | null;
-      sender_id: string | null;
-      step_id: string | null;
-      is_err: boolean | null;
-      seq_id: bigint | null;
-      run_id: string | null;
-    }
-  | {
-      message_type: "user_message";
-      id: string;
-      date: string;
-      content: Array<LettaMessageContent>;
-      name: string | null;
-      otid: string | null;
-      sender_id: string | null;
-      step_id: string | null;
-      is_err: boolean | null;
-      seq_id: bigint | null;
-      run_id: string | null;
-    }
-  | {
-      message_type: "reasoning_message";
-      id: string;
-      date: string;
-      reasoning: string;
-      name: string | null;
-      otid: string | null;
-      sender_id: string | null;
-      step_id: string | null;
-      is_err: boolean | null;
-      seq_id: bigint | null;
-      run_id: string | null;
-      source: LettaReasoningSource | null;
-      signature: string | null;
-    }
-  | {
-      message_type: "hidden_reasoning_message";
-      id: string;
-      date: string;
-      state: LettaHiddenReasoningState;
-      name: string | null;
-      otid: string | null;
-      sender_id: string | null;
-      step_id: string | null;
-      is_err: boolean | null;
-      seq_id: bigint | null;
-      run_id: string | null;
-      hidden_reasoning: string | null;
-    }
-  | {
-      message_type: "tool_call_message";
-      id: string;
-      date: string;
-      tool_call: LettaToolCall;
-      name: string | null;
-      otid: string | null;
-      sender_id: string | null;
-      step_id: string | null;
-      is_err: boolean | null;
-      seq_id: bigint | null;
-      run_id: string | null;
-    }
-  | {
-      message_type: "tool_return_message";
-      id: string;
-      date: string;
-      tool_return: string;
-      status: LettaToolReturnStatus;
-      tool_call_id: string;
-      name: string | null;
-      otid: string | null;
-      sender_id: string | null;
-      step_id: string | null;
-      is_err: boolean | null;
-      seq_id: bigint | null;
-      run_id: string | null;
-      stdout: Array<string> | null;
-      stderr: Array<string> | null;
-    }
-  | {
-      message_type: "assistant_message";
-      id: string;
-      date: string;
-      content: Array<LettaMessageContent>;
-      name: string | null;
-      otid: string | null;
-      sender_id: string | null;
-      step_id: string | null;
-      is_err: boolean | null;
-      seq_id: bigint | null;
-      run_id: string | null;
-    }
-  | {
-      message_type: "approval_request_message";
-      id: string;
-      date: string;
-      tool_call: LettaToolCall;
-      name: string | null;
-      otid: string | null;
-      sender_id: string | null;
-      step_id: string | null;
-      is_err: boolean | null;
-      seq_id: bigint | null;
-      run_id: string | null;
-    }
-  | {
-      message_type: "approval_response_message";
-      id: string;
-      date: string;
-      approve: boolean;
-      approval_request_id: string;
-      name: string | null;
-      otid: string | null;
-      sender_id: string | null;
-      step_id: string | null;
-      is_err: boolean | null;
-      seq_id: bigint | null;
-      run_id: string | null;
-      reason: string | null;
-    }
-  | { message_type: "stop_reason"; stop_reason: string }
-  | {
-      message_type: "usage_statistics";
-      completion_tokens: bigint;
-      prompt_tokens: bigint;
-      step_count: bigint;
-    };
+export type LettaCompletionMessage = { "message_type": "system_message", id: string, date: string, content: string, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, } | { "message_type": "user_message", id: string, date: string, content: Array<LettaMessageContent>, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, } | { "message_type": "reasoning_message", id: string, date: string, reasoning: string, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, source: LettaReasoningSource | null, signature: string | null, } | { "message_type": "hidden_reasoning_message", id: string, date: string, state: LettaHiddenReasoningState, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, hidden_reasoning: string | null, } | { "message_type": "tool_call_message", id: string, date: string, tool_call: LettaToolCall, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, } | { "message_type": "tool_return_message", id: string, date: string, tool_return: string, status: LettaToolReturnStatus, tool_call_id: string, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, stdout: Array<string> | null, stderr: Array<string> | null, } | { "message_type": "assistant_message", id: string, date: string, content: Array<LettaMessageContent>, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, } | { "message_type": "approval_request_message", id: string, date: string, tool_call: LettaToolCall, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, } | { "message_type": "approval_response_message", id: string, date: string, approve: boolean, approval_request_id: string, name: string | null, otid: string | null, sender_id: string | null, step_id: string | null, is_err: boolean | null, seq_id: bigint | null, run_id: string | null, reason: string | null, } | { "message_type": "stop_reason", stop_reason: string, } | { "message_type": "usage_statistics", completion_tokens: bigint, prompt_tokens: bigint, step_count: bigint, };

src/lib/rust/SttTranscriptionWord.ts

···
+// This file was generated by [ts-rs](https://github.com/Aleph-Alpha/ts-rs). Do not edit this file manually.
+
+export type SttTranscriptionWord = { word: string, start: number, end: number, };