@lvce-editor/static-server 0.77.3 → 0.77.5

package/static/{01dd1a1 → e30ed59}/packages/chat-storage-worker/dist/chatStorageWorkerMain.js

@@ -267,45 +267,6 @@ const readyMessage = 'ready';
 const getData$2 = event => {
   return event.data;
 };
-const listen$8 = ({
-  port
-}) => {
-  return port;
-};
-const signal$9 = port => {
-  port.postMessage(readyMessage);
-};
-class IpcChildWithMessagePort extends Ipc {
-  getData(event) {
-    return getData$2(event);
-  }
-  send(message) {
-    this._rawIpc.postMessage(message);
-  }
-  sendAndTransfer(message) {
-    const transfer = getTransferrables(message);
-    this._rawIpc.postMessage(message, transfer);
-  }
-  dispose() {
-    // ignore
-  }
-  onClose(callback) {
-    // ignore
-  }
-  onMessage(callback) {
-    this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
-  }
-}
-const wrap$g = port => {
-  return new IpcChildWithMessagePort(port);
-};
-const IpcChildWithMessagePort$1 = {
-  __proto__: null,
-  listen: listen$8,
-  signal: signal$9,
-  wrap: wrap$g
-};
 const listen$7 = () => {
   // @ts-ignore
   if (typeof WorkerGlobalScope === 'undefined') {
@@ -342,43 +303,82 @@ class IpcChildWithModuleWorker extends Ipc {
 const wrap$f = global => {
   return new IpcChildWithModuleWorker(global);
 };
-const waitForFirstMessage = async port => {
+const IpcChildWithModuleWorker$1 = {
+  __proto__: null,
+  listen: listen$7,
+  signal: signal$8,
+  wrap: wrap$f
+};
+const addListener = (emitter, type, callback) => {
+  if ('addEventListener' in emitter) {
+    emitter.addEventListener(type, callback);
+  } else {
+    emitter.on(type, callback);
+  }
+};
+const removeListener = (emitter, type, callback) => {
+  if ('removeEventListener' in emitter) {
+    emitter.removeEventListener(type, callback);
+  } else {
+    emitter.off(type, callback);
+  }
+};
+const getFirstEvent = (eventEmitter, eventMap) => {
   const {
     promise,
     resolve
   } = Promise.withResolvers();
-  port.addEventListener('message', resolve, {
-    once: true
-  });
-  const event = await promise;
-  // @ts-ignore
-  return event.data;
+  const listenerMap = Object.create(null);
+  const cleanup = value => {
+    for (const event of Object.keys(eventMap)) {
+      removeListener(eventEmitter, event, listenerMap[event]);
+    }
+    resolve(value);
+  };
+  for (const [event, type] of Object.entries(eventMap)) {
+    const listener = event => {
+      cleanup({
+        event,
+        type
+      });
+    };
+    addListener(eventEmitter, event, listener);
+    listenerMap[event] = listener;
+  }
+  return promise;
 };
-const listen$6 = async () => {
-  const parentIpcRaw = listen$7();
-  signal$8(parentIpcRaw);
-  const parentIpc = wrap$f(parentIpcRaw);
-  const firstMessage = await waitForFirstMessage(parentIpc);
-  if (firstMessage.method !== 'initialize') {
-    throw new IpcError('unexpected first message');
+const Message$1 = 3;
+const create$5$1 = async ({
+  isMessagePortOpen,
+  messagePort
+}) => {
+  if (!isMessagePort(messagePort)) {
+    throw new IpcError('port must be of type MessagePort');
   }
-  const type = firstMessage.params[0];
-  if (type === 'message-port') {
-    parentIpc.send({
-      id: firstMessage.id,
-      jsonrpc: '2.0',
-      result: null
-    });
-    parentIpc.dispose();
-    const port = firstMessage.params[1];
-    return port;
+  if (isMessagePortOpen) {
+    return messagePort;
   }
-  return globalThis;
-};
-class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
-  getData(event) {
-    return getData$2(event);
+  const eventPromise = getFirstEvent(messagePort, {
+    message: Message$1
+  });
+  messagePort.start();
+  const {
+    event,
+    type
+  } = await eventPromise;
+  if (type !== Message$1) {
+    throw new IpcError('Failed to wait for ipc message');
+  }
+  if (event.data !== readyMessage) {
+    throw new IpcError('unexpected first message');
   }
+  return messagePort;
+};
+const signal$1 = messagePort => {
+  messagePort.start();
+};
+class IpcParentWithMessagePort extends Ipc {
+  getData = getData$2;
   send(message) {
     this._rawIpc.postMessage(message);
   }
@@ -387,25 +387,21 @@ class IpcChildWithModuleWorkerAndMessagePort extends Ipc {
     this._rawIpc.postMessage(message, transfer);
   }
   dispose() {
-    if (this._rawIpc.close) {
-      this._rawIpc.close();
-    }
-  }
-  onClose(callback) {
-    // ignore
+    this._rawIpc.close();
   }
   onMessage(callback) {
     this._rawIpc.addEventListener('message', callback);
-    this._rawIpc.start();
   }
+  onClose(callback) {}
 }
-const wrap$e = port => {
-  return new IpcChildWithModuleWorkerAndMessagePort(port);
+const wrap$5 = messagePort => {
+  return new IpcParentWithMessagePort(messagePort);
 };
-const IpcChildWithModuleWorkerAndMessagePort$1 = {
+const IpcParentWithMessagePort$1 = {
   __proto__: null,
-  listen: listen$6,
-  wrap: wrap$e
+  create: create$5$1,
+  signal: signal$1,
+  wrap: wrap$5
 };
 
 class CommandNotFoundError extends Error {
@@ -865,15 +861,19 @@ const listen$1 = async (module, options) => {
 
 const create$1 = async ({
   commandMap,
+  isMessagePortOpen = true,
   messagePort
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$1(IpcChildWithMessagePort$1, {
-    port: messagePort
+  const rawIpc = await IpcParentWithMessagePort$1.create({
+    isMessagePortOpen,
+    messagePort
   });
+  const ipc = IpcParentWithMessagePort$1.wrap(rawIpc);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
+  messagePort.start();
   return rpc;
 };
 
@@ -882,53 +882,267 @@ const create = async ({
 }) => {
   // TODO create a commandMap per rpc instance
   register(commandMap);
-  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
+  const ipc = await listen$1(IpcChildWithModuleWorker$1);
   handleIpc(ipc);
   const rpc = createRpc(ipc);
   return rpc;
 };
 
-const toError = error => {
-  if (error instanceof Error) {
-    return error;
-  }
-  return new Error('IndexedDB request failed');
-};
-
-const requestToPromise = async createRequest => {
-  const request = createRequest();
-  const {
-    promise,
-    reject,
-    resolve
-  } = Promise.withResolvers();
-  request.addEventListener('success', () => {
-    resolve(request.result);
-  });
-  request.addEventListener('error', () => {
-    reject(toError(request.error));
+const instanceOfAny = (object, constructors) => constructors.some(c => object instanceof c);
+let idbProxyableTypes;
+let cursorAdvanceMethods;
+// This is a function to prevent it throwing up in node environments.
+function getIdbProxyableTypes() {
+  return idbProxyableTypes || (idbProxyableTypes = [IDBDatabase, IDBObjectStore, IDBIndex, IDBCursor, IDBTransaction]);
+}
+// This is a function to prevent it throwing up in node environments.
+function getCursorAdvanceMethods() {
+  return cursorAdvanceMethods || (cursorAdvanceMethods = [IDBCursor.prototype.advance, IDBCursor.prototype.continue, IDBCursor.prototype.continuePrimaryKey]);
+}
+const transactionDoneMap = new WeakMap();
+const transformCache = new WeakMap();
+const reverseTransformCache = new WeakMap();
+function promisifyRequest(request) {
+  const promise = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      request.removeEventListener('success', success);
+      request.removeEventListener('error', error);
+    };
+    const success = () => {
+      resolve(wrap(request.result));
+      unlisten();
+    };
+    const error = () => {
+      reject(request.error);
+      unlisten();
+    };
+    request.addEventListener('success', success);
+    request.addEventListener('error', error);
   });
+  // This mapping exists in reverseTransformCache but doesn't exist in transformCache. This
+  // is because we create many promises from a single IDBRequest.
+  reverseTransformCache.set(promise, request);
   return promise;
-};
-
-const transactionToPromise = async createTransaction => {
-  const transaction = createTransaction();
-  const {
-    promise,
-    reject,
-    resolve
-  } = Promise.withResolvers();
-  transaction.addEventListener('complete', () => {
-    resolve();
-  });
-  transaction.addEventListener('error', () => {
-    reject(toError(transaction.error));
-  });
-  transaction.addEventListener('abort', () => {
-    reject(toError(transaction.error));
+}
+function cacheDonePromiseForTransaction(tx) {
+  // Early bail if we've already created a done promise for this transaction.
+  if (transactionDoneMap.has(tx)) return;
+  const done = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      tx.removeEventListener('complete', complete);
+      tx.removeEventListener('error', error);
+      tx.removeEventListener('abort', error);
+    };
+    const complete = () => {
+      resolve();
+      unlisten();
+    };
+    const error = () => {
+      reject(tx.error || new DOMException('AbortError', 'AbortError'));
+      unlisten();
+    };
+    tx.addEventListener('complete', complete);
+    tx.addEventListener('error', error);
+    tx.addEventListener('abort', error);
   });
-  return promise;
+  // Cache it for later retrieval.
+  transactionDoneMap.set(tx, done);
+}
+let idbProxyTraps = {
+  get(target, prop, receiver) {
+    if (target instanceof IDBTransaction) {
+      // Special handling for transaction.done.
+      if (prop === 'done') return transactionDoneMap.get(target);
+      // Make tx.store return the only store in the transaction, or undefined if there are many.
+      if (prop === 'store') {
+        return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]);
+      }
+    }
+    // Else transform whatever we get back.
+    return wrap(target[prop]);
+  },
+  set(target, prop, value) {
+    target[prop] = value;
+    return true;
+  },
+  has(target, prop) {
+    if (target instanceof IDBTransaction && (prop === 'done' || prop === 'store')) {
+      return true;
+    }
+    return prop in target;
+  }
 };
+function replaceTraps(callback) {
+  idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+  // Due to expected object equality (which is enforced by the caching in `wrap`), we
+  // only create one new func per func.
+  // Cursor methods are special, as the behaviour is a little more different to standard IDB. In
+  // IDB, you advance the cursor and wait for a new 'success' on the IDBRequest that gave you the
+  // cursor. It's kinda like a promise that can resolve with many values. That doesn't make sense
+  // with real promises, so each advance methods returns a new promise for the cursor object, or
+  // undefined if the end of the cursor has been reached.
+  if (getCursorAdvanceMethods().includes(func)) {
+    return function (...args) {
+      // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+      // the original object.
+      func.apply(unwrap(this), args);
+      return wrap(this.request);
+    };
+  }
+  return function (...args) {
+    // Calling the original function with the proxy as 'this' causes ILLEGAL INVOCATION, so we use
+    // the original object.
+    return wrap(func.apply(unwrap(this), args));
+  };
+}
+function transformCachableValue(value) {
+  if (typeof value === 'function') return wrapFunction(value);
+  // This doesn't return, it just creates a 'done' promise for the transaction,
+  // which is later returned for transaction.done (see idbObjectHandler).
+  if (value instanceof IDBTransaction) cacheDonePromiseForTransaction(value);
+  if (instanceOfAny(value, getIdbProxyableTypes())) return new Proxy(value, idbProxyTraps);
+  // Return the same value back if we're not going to transform it.
+  return value;
+}
+function wrap(value) {
+  // We sometimes generate multiple promises from a single IDBRequest (eg when cursoring), because
+  // IDB is weird and a single IDBRequest can yield many responses, so these can't be cached.
+  if (value instanceof IDBRequest) return promisifyRequest(value);
+  // If we've already transformed this value before, reuse the transformed value.
+  // This is faster, but it also provides object equality.
+  if (transformCache.has(value)) return transformCache.get(value);
+  const newValue = transformCachableValue(value);
+  // Not all types are transformed.
+  // These may be primitive types, so they can't be WeakMap keys.
+  if (newValue !== value) {
+    transformCache.set(value, newValue);
+    reverseTransformCache.set(newValue, value);
+  }
+  return newValue;
+}
+const unwrap = value => reverseTransformCache.get(value);
+
+/**
+ * Open a database.
+ *
+ * @param name Name of the database.
+ * @param version Schema version.
+ * @param callbacks Additional callbacks.
+ */
+function openDB(name, version, {
+  blocked,
+  upgrade,
+  blocking,
+  terminated
+} = {}) {
+  const request = indexedDB.open(name, version);
+  const openPromise = wrap(request);
+  if (upgrade) {
+    request.addEventListener('upgradeneeded', event => {
+      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+    });
+  }
+  if (blocked) {
+    request.addEventListener('blocked', event => blocked(
+    // Casting due to https://github.com/microsoft/TypeScript-DOM-lib-generator/pull/1405
+    event.oldVersion, event.newVersion, event));
+  }
+  openPromise.then(db => {
+    if (terminated) db.addEventListener('close', () => terminated());
+    if (blocking) {
+      db.addEventListener('versionchange', event => blocking(event.oldVersion, event.newVersion, event));
+    }
+  }).catch(() => {});
+  return openPromise;
+}
+const readMethods = ['get', 'getKey', 'getAll', 'getAllKeys', 'count'];
+const writeMethods = ['put', 'add', 'delete', 'clear'];
+const cachedMethods = new Map();
+function getMethod(target, prop) {
+  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === 'string')) {
+    return;
+  }
+  if (cachedMethods.get(prop)) return cachedMethods.get(prop);
+  const targetFuncName = prop.replace(/FromIndex$/, '');
+  const useIndex = prop !== targetFuncName;
+  const isWrite = writeMethods.includes(targetFuncName);
+  if (
+  // Bail if the target doesn't exist on the target. Eg, getAll isn't in Edge.
+  !(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
+    return;
+  }
+  const method = async function (storeName, ...args) {
+    // isWrite ? 'readwrite' : undefined gzipps better, but fails in Edge :(
+    const tx = this.transaction(storeName, isWrite ? 'readwrite' : 'readonly');
+    let target = tx.store;
+    if (useIndex) target = target.index(args.shift());
+    // Must reject if op rejects.
+    // If it's a write operation, must reject if tx.done rejects.
+    // Must reject with op rejection first.
+    // Must resolve with op value.
+    // Must handle both promises (no unhandled rejections)
+    return (await Promise.all([target[targetFuncName](...args), isWrite && tx.done]))[0];
+  };
+  cachedMethods.set(prop, method);
+  return method;
+}
+replaceTraps(oldTraps => ({
+  ...oldTraps,
+  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+const advanceMethodProps = ['continue', 'continuePrimaryKey', 'advance'];
+const methodMap = {};
+const advanceResults = new WeakMap();
+const ittrProxiedCursorToOriginalProxy = new WeakMap();
+const cursorIteratorTraps = {
+  get(target, prop) {
+    if (!advanceMethodProps.includes(prop)) return target[prop];
+    let cachedFunc = methodMap[prop];
+    if (!cachedFunc) {
+      cachedFunc = methodMap[prop] = function (...args) {
+        advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+      };
+    }
+    return cachedFunc;
+  }
+};
+async function* iterate(...args) {
+  // tslint:disable-next-line:no-this-assignment
+  let cursor = this;
+  if (!(cursor instanceof IDBCursor)) {
+    cursor = await cursor.openCursor(...args);
+  }
+  if (!cursor) return;
+  cursor = cursor;
+  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+  // Map this double-proxy back to the original, so other cursor methods work.
+  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+  while (cursor) {
+    yield proxiedCursor;
+    // If one of the advancing methods was not called, call continue().
+    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+    advanceResults.delete(proxiedCursor);
+  }
+}
+function isIteratorProp(target, prop) {
+  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === 'iterate' && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
+}
+replaceTraps(oldTraps => ({
+  ...oldTraps,
+  get(target, prop, receiver) {
+    if (isIteratorProp(target, prop)) return iterate;
+    return oldTraps.get(target, prop, receiver);
+  },
+  has(target, prop) {
+    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+  }
+}));
+
+/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
 
 const toChatViewEvent = event => {
   const {
@@ -1105,68 +1319,52 @@ class IndexedDbChatSessionStorage {
     if (this.state.databasePromise) {
       return this.state.databasePromise;
     }
-    const request = indexedDB.open(this.state.databaseName, this.state.databaseVersion);
-    request.addEventListener('upgradeneeded', () => {
-      const database = request.result;
-      if (!database.objectStoreNames.contains(this.state.storeName)) {
-        database.createObjectStore(this.state.storeName, {
-          keyPath: 'id'
-        });
-      }
-      if (database.objectStoreNames.contains(this.state.eventStoreName)) {
-        const {
-          transaction
-        } = request;
-        if (!transaction) {
-          return;
+    const databasePromise = openDB(this.state.databaseName, this.state.databaseVersion, {
+      upgrade: (database, _oldVersion, _newVersion, transaction) => {
+        if (!database.objectStoreNames.contains(this.state.storeName)) {
+          database.createObjectStore(this.state.storeName, {
+            keyPath: 'id'
+          });
         }
-        const eventStore = transaction.objectStore(this.state.eventStoreName);
-        if (!eventStore.indexNames.contains('sessionId')) {
+        if (database.objectStoreNames.contains(this.state.eventStoreName)) {
+          const eventStore = transaction.objectStore(this.state.eventStoreName);
+          if (!eventStore.indexNames.contains('sessionId')) {
+            eventStore.createIndex('sessionId', 'sessionId', {
+              unique: false
+            });
+          }
+        } else {
+          const eventStore = database.createObjectStore(this.state.eventStoreName, {
+            autoIncrement: true,
+            keyPath: 'eventId'
+          });
           eventStore.createIndex('sessionId', 'sessionId', {
             unique: false
           });
         }
-      } else {
-        const eventStore = database.createObjectStore(this.state.eventStoreName, {
-          autoIncrement: true,
-          keyPath: 'eventId'
-        });
-        eventStore.createIndex('sessionId', 'sessionId', {
-          unique: false
-        });
       }
     });
-    const databasePromise = requestToPromise(() => request);
     this.state.databasePromise = databasePromise;
     return databasePromise;
   };
   listSummaries = async () => {
     const database = await this.openDatabase();
-    const transaction = database.transaction(this.state.storeName, 'readonly');
-    const store = transaction.objectStore(this.state.storeName);
-    const summaries = await requestToPromise(() => store.getAll());
+    const summaries = await database.getAll(this.state.storeName);
     return summaries;
   };
   getSummary = async id => {
     const database = await this.openDatabase();
-    const transaction = database.transaction(this.state.storeName, 'readonly');
-    const store = transaction.objectStore(this.state.storeName);
-    const summary = await requestToPromise(() => store.get(id));
+    const summary = await database.get(this.state.storeName, id);
     return summary;
   };
   getEventsBySessionId = async sessionId => {
     const database = await this.openDatabase();
-    const transaction = database.transaction(this.state.eventStoreName, 'readonly');
-    const store = transaction.objectStore(this.state.eventStoreName);
-    const index = store.index('sessionId');
-    const events = await requestToPromise(() => index.getAll(IDBKeyRange.only(sessionId)));
+    const events = await database.getAllFromIndex(this.state.eventStoreName, 'sessionId', IDBKeyRange.only(sessionId));
     return events.map(toChatViewEvent);
   };
   listEventsInternal = async () => {
     const database = await this.openDatabase();
-    const transaction = database.transaction(this.state.eventStoreName, 'readonly');
-    const store = transaction.objectStore(this.state.eventStoreName);
-    const events = await requestToPromise(() => store.getAll());
+    const events = await database.getAll(this.state.eventStoreName);
     return events.map(toChatViewEvent);
   };
   appendEvents = async events => {
@@ -1178,18 +1376,18 @@ class IndexedDbChatSessionStorage {
     const summaryStore = transaction.objectStore(this.state.storeName);
     const eventStore = transaction.objectStore(this.state.eventStoreName);
     for (const event of events) {
-      eventStore.add(event);
+      await eventStore.add(event);
       if (event.type === 'chat-session-created' || event.type === 'chat-session-title-updated') {
-        summaryStore.put({
+        await summaryStore.put({
           id: event.sessionId,
           title: event.title
         });
       }
       if (event.type === 'chat-session-deleted') {
-        summaryStore.delete(event.sessionId);
+        await summaryStore.delete(event.sessionId);
       }
     }
-    await transactionToPromise(() => transaction);
+    await transaction.done;
   };
   async appendEvent(event) {
     await this.appendEvents([event]);
@@ -1197,9 +1395,8 @@ class IndexedDbChatSessionStorage {
   async clear() {
     const database = await this.openDatabase();
     const transaction = database.transaction([this.state.storeName, this.state.eventStoreName], 'readwrite');
-    transaction.objectStore(this.state.storeName).clear();
-    transaction.objectStore(this.state.eventStoreName).clear();
-    await transactionToPromise(() => transaction);
+    await Promise.all([transaction.objectStore(this.state.storeName).clear(), transaction.objectStore(this.state.eventStoreName).clear()]);
+    await transaction.done;
   }
   async deleteSession(id) {
     await this.appendEvent({
@@ -1239,11 +1436,11 @@ class IndexedDbChatSessionStorage {
       const database = await this.openDatabase();
       const transaction = database.transaction(this.state.storeName, 'readwrite');
       const summaryStore = transaction.objectStore(this.state.storeName);
-      summaryStore.put({
+      await summaryStore.put({
         id: session.id,
         title: session.title
       });
-      await transactionToPromise(() => transaction);
+      await transaction.done;
     }
   }
 }
@@ -1516,10 +1713,61 @@ const getChatViewEvents = async sessionId => {
 const handleMessagePort = async port => {
   await create$1({
     commandMap: commandMap,
+    isMessagePortOpen: true,
     messagePort: port
   });
 };
 
+const setTodosInIndexedDb = async todos => {
+  const todoDbName = 'chat-tool-worker';
+  const todoStoreName = 'state';
+  const todoKey = 'todoList';
+  const db = await new Promise((resolve, reject) => {
+    const openRequest = indexedDB.open(todoDbName, 1);
+    openRequest.onupgradeneeded = () => {
+      const nextDb = openRequest.result;
+      if (!nextDb.objectStoreNames.contains(todoStoreName)) {
+        nextDb.createObjectStore(todoStoreName);
+      }
+    };
+    openRequest.onsuccess = () => {
+      resolve(openRequest.result);
+    };
+    openRequest.onerror = () => {
+      reject(openRequest.error ?? new Error('Failed to open IndexedDB'));
+    };
+  });
+  await new Promise((resolve, reject) => {
+    const transaction = db.transaction(todoStoreName, 'readwrite');
+    transaction.objectStore(todoStoreName).put(todos, todoKey);
+    transaction.oncomplete = () => {
+      db.close();
+      resolve();
+    };
+    transaction.onerror = () => {
+      db.close();
+      reject(transaction.error ?? new Error('Failed to persist todo list'));
+    };
+    transaction.onabort = () => {
+      db.close();
+      reject(transaction.error ?? new Error('Failed to persist todo list'));
+    };
+  });
+};
+const setTodosInCacheStorage = async todos => {
+  const todoCacheName = 'chat-tool-worker-todo';
+  const todoCacheRequest = new Request('https://chat-tool-worker.local/todo-list');
+  const cache = await caches.open(todoCacheName);
+  const payload = JSON.stringify({
+    todos
+  });
+  await cache.put(todoCacheRequest, new Response(payload, {
+    headers: {
+      'content-type': 'application/json'
+    }
+  }));
+};
+
 const commandMap = {
   'ChatStorage.appendEvent': appendChatViewEvent,
   'ChatStorage.clear': clearChatSessions,
@@ -1528,7 +1776,10 @@ const commandMap = {
   'ChatStorage.getSession': getChatSession,
   'ChatStorage.listSessions': listChatSessions,
   'ChatStorage.setSession': setSession,
-  'HandleMessagePort.handleMessagePort': handleMessagePort
+  'ChatStorage.setTodosInCacheStorage': setTodosInCacheStorage,
+  'ChatStorage.setTodosInIndexedDb': setTodosInIndexedDb,
+  'HandleMessagePort.handleMessagePort': handleMessagePort,
+  initialize: (_, port) => handleMessagePort(port)
 };
 
 const listen = async () => {