@lvce-editor/cache-worker 0.0.2

package/README.md

@@ -0,0 +1,48 @@
+# Cache Worker
+
+Browser storage APIs for LVCE workers. `@lvce-editor/cache-worker` provides Cache Storage, IndexedDB, and Origin Private File System (OPFS) operations through a worker RPC command map.
+
+## Commands
+
+| Command                               | Arguments                                           | Result                                                                                                               |
+| ------------------------------------- | --------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `Cache.getCacheStorageItem`           | `(request, cacheName = 'lvce-cache')`               | Structured-cloneable `{ body: ArrayBuffer, headers: [string, string][], status, statusText }` or `null` when missing |
+| `Cache.setCacheStorageItem`           | `(request, value, cacheName = 'lvce-cache')`        | `undefined`; stores a body accepted by the browser `Response` constructor                                            |
+| `Cache.removeCacheStorageItem`        | `(request, cacheName = 'lvce-cache')`               | `boolean` indicating whether an item was removed                                                                     |
+| `IndexedDb.addIndexedDbFileHandle`    | `(key, handle, databaseName = 'lvce-cache-worker')` | `undefined` after the write transaction commits                                                                      |
+| `IndexedDb.getIndexedDbFileHandle`    | `(key, databaseName = 'lvce-cache-worker')`         | Stored handle or `null` when missing through worker RPC                                                              |
+| `IndexedDb.removeIndexedDbFileHandle` | `(key, databaseName = 'lvce-cache-worker')`         | `undefined` after the delete transaction commits; deleting a missing key is a no-op                                  |
+| `Opfs.readFile`                       | `(name)`                                            | UTF-8 text; rejects when the file does not exist                                                                     |
+| `Opfs.writeFile`                      | `(name, content)`                                   | `undefined` after the writable is closed                                                                             |
+| `Opfs.removeFile`                     | `(name)`                                            | `undefined`; rejects when the file does not exist                                                                    |
+
+Missing browser APIs reject with an error that names the unavailable capability. Browser storage quota, security, invalid key, structured-clone, and transaction errors are propagated to the caller. File handles must be structured-cloneable by the browser and writable in the current origin. OPFS filenames are single path components; directory traversal is not supported.
+
+Resolve the worker entry URL with `getCacheWorkerUrl` and connect it using `@lvce-editor/rpc`'s `ModuleWorkerRpcParent`:
+
+```js
+import { ModuleWorkerRpcParent } from '@lvce-editor/rpc'
+import { getCacheWorkerUrl } from '@lvce-editor/cache-worker'
+
+const rpc = await ModuleWorkerRpcParent.create({
+  commandMap: {},
+  url: getCacheWorkerUrl().href,
+})
+```
+
+The worker registers the commands in `src/parts/CommandMap/CommandMap.js`. `Response` values are converted to structured-cloneable data before crossing RPC; callers can create a new `Response` from the returned body and metadata.
+
+## Development
+
+This repository uses npm workspaces and a root `package-lock.json`.
+
+The cross-browser suite checks Cache Storage and OPFS through worker RPC in Chromium and Firefox. IndexedDB file-handle restoration is covered in Firefox; Chromium checks general structured-clone persistence.
+
+```sh
+npm ci
+npm test
+npm run build
+npm run e2e
+```
+
+The browser suite runs against Chromium and Firefox. Install both with `npx playwright install --with-deps chromium firefox`.

package/cacheWorkerMain.js

@@ -0,0 +1,809 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/@lvce-editor/ipc/dist/index.js
+var isMessagePort = (value) => {
+  return value && value instanceof MessagePort;
+};
+var isMessagePortMain = (value) => {
+  return value && value.constructor && value.constructor.name === "MessagePortMain";
+};
+var isOffscreenCanvas = (value) => {
+  return typeof OffscreenCanvas !== "undefined" && value instanceof OffscreenCanvas;
+};
+var isInstanceOf = (value, constructorName) => {
+  return value?.constructor?.name === constructorName;
+};
+var isSocket = (value) => {
+  return isInstanceOf(value, "Socket");
+};
+var transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
+var isTransferrable = (value) => {
+  for (const fn of transferrables) {
+    if (fn(value)) {
+      return true;
+    }
+  }
+  return false;
+};
+var walkValue = (value, transferrables2, isTransferrable2) => {
+  if (!value) {
+    return;
+  }
+  if (isTransferrable2(value)) {
+    transferrables2.push(value);
+    return;
+  }
+  if (Array.isArray(value)) {
+    for (const item of value) {
+      walkValue(item, transferrables2, isTransferrable2);
+    }
+    return;
+  }
+  if (typeof value === "object") {
+    for (const property of Object.values(value)) {
+      walkValue(property, transferrables2, isTransferrable2);
+    }
+  }
+};
+var getTransferrables = (value) => {
+  const transferrables2 = [];
+  walkValue(value, transferrables2, isTransferrable);
+  return transferrables2;
+};
+var attachEvents = (that) => {
+  const handleMessage2 = (...args) => {
+    const data = that.getData(...args);
+    that.dispatchEvent(new MessageEvent("message", {
+      data
+    }));
+  };
+  that.onMessage(handleMessage2);
+  const handleClose = (event) => {
+    that.dispatchEvent(new Event("close"));
+  };
+  that.onClose(handleClose);
+};
+var Ipc = class extends EventTarget {
+  constructor(rawIpc) {
+    super();
+    this._rawIpc = rawIpc;
+    attachEvents(this);
+  }
+};
+var readyMessage = "ready";
+var getData$2 = (event) => {
+  return event.data;
+};
+var listen$7 = () => {
+  if (typeof WorkerGlobalScope === "undefined") {
+    throw new TypeError("module is not in web worker scope");
+  }
+  return globalThis;
+};
+var signal$8 = (global) => {
+  global.postMessage(readyMessage);
+};
+var IpcChildWithModuleWorker = class 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() {
+  }
+  onClose(callback) {
+  }
+  onMessage(callback) {
+    this._rawIpc.addEventListener("message", callback);
+  }
+};
+var wrap$f = (global) => {
+  return new IpcChildWithModuleWorker(global);
+};
+var IpcChildWithModuleWorker$1 = {
+  __proto__: null,
+  listen: listen$7,
+  signal: signal$8,
+  wrap: wrap$f
+};
+
+// node_modules/@lvce-editor/command/dist/index.js
+var CommandNotFoundError = class extends Error {
+  constructor(command) {
+    super(`Command not found ${command}`);
+    this.name = "CommandNotFoundError";
+  }
+};
+var commands = /* @__PURE__ */ Object.create(null);
+var register = (commandMap2) => {
+  Object.assign(commands, commandMap2);
+};
+var getCommand = (key) => {
+  return commands[key];
+};
+var execute = (command, ...args) => {
+  const fn = getCommand(command);
+  if (!fn) {
+    throw new CommandNotFoundError(command);
+  }
+  return fn(...args);
+};
+
+// node_modules/@lvce-editor/json-rpc/dist/index.js
+var Two = "2.0";
+var callbacks = /* @__PURE__ */ Object.create(null);
+var get = (id2) => {
+  return callbacks[id2];
+};
+var remove = (id2) => {
+  delete callbacks[id2];
+};
+var JsonRpcError = class extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "JsonRpcError";
+  }
+};
+var NewLine = "\n";
+var DomException = "DOMException";
+var ReferenceError$1 = "ReferenceError";
+var SyntaxError$1 = "SyntaxError";
+var TypeError$1 = "TypeError";
+var getErrorConstructor = (message, type) => {
+  if (type) {
+    switch (type) {
+      case DomException:
+        return DOMException;
+      case ReferenceError$1:
+        return ReferenceError;
+      case SyntaxError$1:
+        return SyntaxError;
+      case TypeError$1:
+        return TypeError;
+      default:
+        return Error;
+    }
+  }
+  if (message.startsWith("TypeError: ")) {
+    return TypeError;
+  }
+  if (message.startsWith("SyntaxError: ")) {
+    return SyntaxError;
+  }
+  if (message.startsWith("ReferenceError: ")) {
+    return ReferenceError;
+  }
+  return Error;
+};
+var constructError = (message, type, name) => {
+  const ErrorConstructor = getErrorConstructor(message, type);
+  if (ErrorConstructor === DOMException && name) {
+    return new ErrorConstructor(message, name);
+  }
+  if (ErrorConstructor === Error) {
+    const error = new Error(message);
+    if (name && name !== "VError") {
+      Object.defineProperty(error, "name", {
+        configurable: true,
+        value: name
+      });
+    }
+    return error;
+  }
+  return new ErrorConstructor(message);
+};
+var joinLines = (lines) => {
+  return lines.join(NewLine);
+};
+var splitLines = (lines) => {
+  return lines.split(NewLine);
+};
+var getCurrentStack = () => {
+  const stackLinesToSkip = 3;
+  const currentStack = joinLines(splitLines(new Error().stack || "").slice(stackLinesToSkip));
+  return currentStack;
+};
+var getNewLineIndex = (string2, startIndex) => {
+  {
+    return string2.indexOf(NewLine);
+  }
+};
+var getParentStack = (error) => {
+  let parentStack = error.stack || error.data || error.message || "";
+  if (parentStack.startsWith("    at")) {
+    parentStack = error.message + NewLine + parentStack;
+  }
+  return parentStack;
+};
+var MethodNotFound = -32601;
+var Custom = -32001;
+var setStack = (error, stack) => {
+  const descriptor = Object.getOwnPropertyDescriptor(error, "stack");
+  if (descriptor) {
+    if (!descriptor.configurable && !descriptor.writable) {
+      return;
+    }
+    if (!descriptor.configurable && descriptor.writable) {
+      error.stack = stack;
+      return;
+    }
+  }
+  Object.defineProperty(error, "stack", {
+    configurable: true,
+    value: stack,
+    writable: true
+  });
+};
+var restoreExistingError = (error, currentStack) => {
+  if (typeof error.stack === "string") {
+    setStack(error, `${error.stack}${NewLine}${currentStack}`);
+  }
+  return error;
+};
+var restoreMethodNotFoundError = (error, currentStack) => {
+  const restoredError = new JsonRpcError(error.message);
+  Object.assign(restoredError, {
+    code: error.code
+  });
+  const parentStack = getParentStack(error);
+  setStack(restoredError, `${parentStack}${NewLine}${currentStack}`);
+  return restoredError;
+};
+var restoreStackFromData = (restoredError, error, currentStack) => {
+  if (error.data.stack && error.data.type && error.message) {
+    setStack(restoredError, `${error.data.type}: ${error.message}${NewLine}${error.data.stack}${NewLine}${currentStack}`);
+    return;
+  }
+  if (error.data.stack) {
+    setStack(restoredError, error.data.stack);
+  }
+};
+var applyDataProperties = (restoredError, error) => {
+  restoreStackFromData(restoredError, error, getCurrentStack());
+  if (error.data.codeFrame) {
+    restoredError.codeFrame = error.data.codeFrame;
+  }
+  if (typeof error.data.code === "string" || typeof error.data.code === "number") {
+    Object.defineProperty(restoredError, "code", {
+      configurable: true,
+      value: error.data.code,
+      writable: true
+    });
+  }
+  if (error.data.type) {
+    restoredError.name = error.data.type;
+  }
+};
+var applyDirectProperties = (restoredError, error) => {
+  if (error.stack) {
+    const lowerStack = restoredError.stack || "";
+    const indexNewLine = getNewLineIndex(lowerStack);
+    const parentStack = getParentStack(error);
+    setStack(restoredError, `${parentStack}${lowerStack.slice(indexNewLine)}`);
+  }
+  if (error.codeFrame) {
+    restoredError.codeFrame = error.codeFrame;
+  }
+};
+var restoreMessageError = (error, _currentStack) => {
+  const restoredError = constructError(error.message, error.type || error.data?.type, error.name);
+  if (typeof error.code === "string" || typeof error.code === "number") {
+    Object.defineProperty(restoredError, "code", {
+      configurable: true,
+      value: error.code,
+      writable: true
+    });
+  }
+  if (error.data) {
+    applyDataProperties(restoredError, error);
+  } else {
+    applyDirectProperties(restoredError, error);
+  }
+  return restoredError;
+};
+var getFallbackMessage = (error) => {
+  if (error && typeof error.message === "string" && error.message) {
+    return error.message;
+  }
+  if (error && error.data) {
+    return getFallbackMessage(error.data);
+  }
+  const stringified = String(error);
+  if (stringified !== "[object Object]") {
+    return stringified;
+  }
+  try {
+    return JSON.stringify(error);
+  } catch {
+    return stringified;
+  }
+};
+var restoreJsonRpcError = (error) => {
+  const currentStack = getCurrentStack();
+  if (error && error instanceof Error) {
+    return restoreExistingError(error, currentStack);
+  }
+  if (error && error.code && error.code === MethodNotFound) {
+    return restoreMethodNotFoundError(error, currentStack);
+  }
+  if (error && error.error) {
+    return restoreJsonRpcError(error.error);
+  }
+  if (error && error.message) {
+    return restoreMessageError(error);
+  }
+  return new Error(`JsonRpc Error: ${getFallbackMessage(error)}`);
+};
+var unwrapJsonRpcResult = (responseMessage) => {
+  if ("error" in responseMessage) {
+    const restoredError = restoreJsonRpcError(responseMessage.error);
+    throw restoredError;
+  }
+  if ("result" in responseMessage) {
+    return responseMessage.result;
+  }
+  throw new JsonRpcError("unexpected response message");
+};
+var warn = (...args) => {
+  console.warn(...args);
+};
+var resolve = (id2, response) => {
+  const fn = get(id2);
+  if (!fn) {
+    console.log(response);
+    warn(`callback ${id2} may already be disposed`);
+    return;
+  }
+  fn(response);
+  remove(id2);
+};
+var E_COMMAND_NOT_FOUND = "E_COMMAND_NOT_FOUND";
+var getErrorType = (prettyError) => {
+  if (prettyError && prettyError.type) {
+    return prettyError.type;
+  }
+  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
+    return prettyError.constructor.name;
+  }
+  return void 0;
+};
+var isAlreadyStack = (line) => {
+  return line.trim().startsWith("at ");
+};
+var getStack = (prettyError) => {
+  const stackString = prettyError.stack || "";
+  const newLineIndex = stackString.indexOf("\n");
+  if (newLineIndex !== -1 && !isAlreadyStack(stackString.slice(0, newLineIndex))) {
+    return stackString.slice(newLineIndex + 1);
+  }
+  return stackString;
+};
+var getErrorProperty = (error, prettyError) => {
+  if (error && error.code === E_COMMAND_NOT_FOUND) {
+    return {
+      code: MethodNotFound,
+      data: error.stack,
+      message: error.message
+    };
+  }
+  return {
+    code: Custom,
+    data: {
+      code: prettyError.code ?? error?.code,
+      codeFrame: prettyError.codeFrame,
+      name: prettyError.name ?? error?.name,
+      stack: getStack(prettyError),
+      type: getErrorType(prettyError)
+    },
+    message: prettyError.message
+  };
+};
+var create$1 = (id2, error) => {
+  return {
+    error,
+    id: id2,
+    jsonrpc: Two
+  };
+};
+var getErrorResponse = (id2, error, preparePrettyError2, logError2) => {
+  const prettyError = preparePrettyError2(error);
+  logError2(error, prettyError);
+  const errorProperty = getErrorProperty(error, prettyError);
+  return create$1(id2, errorProperty);
+};
+var create = (message, result) => {
+  return {
+    id: message.id,
+    jsonrpc: Two,
+    result: result ?? null
+  };
+};
+var getSuccessResponse = (message, result) => {
+  const resultProperty = result ?? null;
+  return create(message, resultProperty);
+};
+var getErrorResponseSimple = (id2, error) => {
+  return {
+    error: {
+      code: Custom,
+      data: error instanceof Error ? {
+        ...error,
+        code: "code" in error ? error.code : void 0,
+        stack: error.stack,
+        type: error.name
+      } : error,
+      // @ts-ignore
+      message: error.message
+    },
+    id: id2,
+    jsonrpc: Two
+  };
+};
+var getResponse = async (message, ipc, execute2, preparePrettyError2, logError2, requiresSocket2) => {
+  try {
+    const result = requiresSocket2(message.method) ? await execute2(message.method, ipc, ...message.params) : await execute2(message.method, ...message.params);
+    return getSuccessResponse(message, result);
+  } catch (error) {
+    if (ipc.canUseSimpleErrorResponse) {
+      return getErrorResponseSimple(message.id, error);
+    }
+    return getErrorResponse(message.id, error, preparePrettyError2, logError2);
+  }
+};
+var defaultPreparePrettyError = (error) => {
+  return error;
+};
+var defaultLogError = () => {
+};
+var defaultRequiresSocket = () => {
+  return false;
+};
+var defaultResolve = resolve;
+var normalizeParams = (args) => {
+  if (args.length === 1) {
+    const options = args[0];
+    return {
+      execute: options.execute,
+      ipc: options.ipc,
+      logError: options.logError || defaultLogError,
+      message: options.message,
+      preparePrettyError: options.preparePrettyError || defaultPreparePrettyError,
+      requiresSocket: options.requiresSocket || defaultRequiresSocket,
+      resolve: options.resolve || defaultResolve
+    };
+  }
+  return {
+    execute: args[2],
+    ipc: args[0],
+    logError: args[5],
+    message: args[1],
+    preparePrettyError: args[4],
+    requiresSocket: args[6],
+    resolve: args[3]
+  };
+};
+var handleJsonRpcMessage = async (...args) => {
+  const options = normalizeParams(args);
+  const {
+    execute: execute2,
+    ipc,
+    logError: logError2,
+    message,
+    preparePrettyError: preparePrettyError2,
+    requiresSocket: requiresSocket2,
+    resolve: resolve2
+  } = options;
+  if ("id" in message) {
+    if ("method" in message) {
+      const response = await getResponse(message, ipc, execute2, preparePrettyError2, logError2, requiresSocket2);
+      try {
+        ipc.send(response);
+      } catch (error) {
+        const errorResponse = getErrorResponse(message.id, error, preparePrettyError2, logError2);
+        ipc.send(errorResponse);
+      }
+      return;
+    }
+    resolve2(message.id, message);
+    return;
+  }
+  if ("method" in message) {
+    await getResponse(message, ipc, execute2, preparePrettyError2, logError2, requiresSocket2);
+    return;
+  }
+  throw new JsonRpcError("unexpected message");
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/JsonRpcVersion/JsonRpcVersion.js
+var Two2 = "2.0";
+
+// node_modules/@lvce-editor/rpc/dist/parts/JsonRpcEvent/JsonRpcEvent.js
+var create2 = (method, params) => {
+  return {
+    jsonrpc: Two2,
+    method,
+    params
+  };
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/JsonRpcRequest/JsonRpcRequest.js
+var create3 = (id2, method, params) => {
+  const message = {
+    id: id2,
+    jsonrpc: Two2,
+    method,
+    params
+  };
+  return message;
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/Id/Id.js
+var id = 0;
+var create4 = () => {
+  return ++id;
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/RegisterPromise/RegisterPromise.js
+var registerPromise = (map) => {
+  const id2 = create4();
+  const { promise, resolve: resolve2 } = Promise.withResolvers();
+  map[id2] = resolve2;
+  return { id: id2, promise };
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/CreateRpc/CreateRpc.js
+var invokeHelper = async (callbacks2, ipc, method, params, useSendAndTransfer) => {
+  const { id: id2, promise } = registerPromise(callbacks2);
+  const message = create3(id2, method, params);
+  if (useSendAndTransfer && ipc.sendAndTransfer) {
+    ipc.sendAndTransfer(message);
+  } else {
+    ipc.send(message);
+  }
+  const responseMessage = await promise;
+  return unwrapJsonRpcResult(responseMessage);
+};
+var createRpc = (ipc) => {
+  const callbacks2 = /* @__PURE__ */ Object.create(null);
+  ipc._resolve = (id2, response) => {
+    const fn = callbacks2[id2];
+    if (!fn) {
+      console.warn(`callback ${id2} may already be disposed`);
+      return;
+    }
+    fn(response);
+    delete callbacks2[id2];
+  };
+  const rpc = {
+    async dispose() {
+      await ipc?.dispose();
+    },
+    invoke(method, ...params) {
+      return invokeHelper(callbacks2, ipc, method, params, false);
+    },
+    invokeAndTransfer(method, ...params) {
+      return invokeHelper(callbacks2, ipc, method, params, true);
+    },
+    // @ts-ignore
+    ipc,
+    /**
+     * @deprecated
+     */
+    send(method, ...params) {
+      const message = create2(method, params);
+      ipc.send(message);
+    }
+  };
+  return rpc;
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/HandleMessage/HandleMessage.js
+var requiresSocket = () => {
+  return false;
+};
+var preparePrettyError = (error) => {
+  return error;
+};
+var logError = () => {
+};
+var handleMessage = (event) => {
+  if (event.data === "ready") {
+    return Promise.resolve();
+  }
+  const actualRequiresSocket = event?.target?.requiresSocket || requiresSocket;
+  const actualExecute = event?.target?.execute || execute;
+  return handleJsonRpcMessage(event.target, event.data, actualExecute, event.target._resolve, preparePrettyError, logError, actualRequiresSocket);
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/HandleIpc/HandleIpc.js
+var handleIpc = (ipc) => {
+  if ("addEventListener" in ipc) {
+    ipc.addEventListener("message", handleMessage);
+  } else if ("on" in ipc) {
+    ipc.on("message", handleMessage);
+  }
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/IpcChildNode/IpcChildNode.js
+var listen = async (module, options) => {
+  const rawIpc = await module.listen(options);
+  if (module.signal) {
+    module.signal(rawIpc);
+  }
+  const ipc = module.wrap(rawIpc);
+  return ipc;
+};
+
+// node_modules/@lvce-editor/rpc/dist/parts/WebWorkerRpcClient2/WebWorkerRpcClient2.js
+var WebWorkerRpcClient2_exports = {};
+__export(WebWorkerRpcClient2_exports, {
+  create: () => create5
+});
+var create5 = async ({ commandMap: commandMap2 }) => {
+  register(commandMap2);
+  const ipc = await listen(IpcChildWithModuleWorker$1);
+  handleIpc(ipc);
+  const rpc = createRpc(ipc);
+  return rpc;
+};
+
+// packages/cache-worker/src/parts/Cache/Cache.js
+var getCacheStorage = () => {
+  if (typeof caches === "undefined") {
+    throw new Error("Cache Storage is not available in this context");
+  }
+  return caches;
+};
+var getCacheStorageItem = async (request, cacheName = "lvce-cache") => {
+  const cache = await getCacheStorage().open(cacheName);
+  const response = await cache.match(request);
+  if (!response) {
+    return null;
+  }
+  return {
+    body: await response.arrayBuffer(),
+    headers: [...response.headers.entries()],
+    status: response.status,
+    statusText: response.statusText
+  };
+};
+var setCacheStorageItem = async (request, value, cacheName = "lvce-cache") => {
+  const cache = await getCacheStorage().open(cacheName);
+  const response = new Response(value);
+  await cache.put(request, response);
+};
+var removeCacheStorageItem = async (request, cacheName = "lvce-cache") => {
+  const cache = await getCacheStorage().open(cacheName);
+  return cache.delete(request);
+};
+
+// packages/cache-worker/src/parts/IndexedDb/IndexedDb.js
+var requestResult = (request) => new Promise((resolve2, reject) => {
+  request.onsuccess = () => resolve2(request.result);
+  request.onerror = () => reject(request.error ?? new Error("IndexedDB request failed"));
+});
+var transactionDone = (transaction) => new Promise((resolve2, reject) => {
+  transaction.oncomplete = () => resolve2();
+  transaction.onabort = () => reject(transaction.error ?? new Error("IndexedDB transaction aborted"));
+  transaction.onerror = () => reject(transaction.error ?? new Error("IndexedDB transaction failed"));
+});
+var openDatabase = (name) => {
+  if (typeof indexedDB === "undefined") {
+    throw new Error("IndexedDB is not available in this context");
+  }
+  return new Promise((resolve2, reject) => {
+    const request = indexedDB.open(name, 1);
+    request.onupgradeneeded = () => {
+      if (!request.result.objectStoreNames.contains("file-handles")) {
+        request.result.createObjectStore("file-handles");
+      }
+    };
+    request.onsuccess = () => {
+      request.result.onversionchange = () => request.result.close();
+      resolve2(request.result);
+    };
+    request.onerror = () => reject(request.error ?? new Error("Failed to open IndexedDB database"));
+    request.onblocked = () => reject(new Error(`Opening IndexedDB database "${name}" was blocked`));
+  });
+};
+var addIndexedDbFileHandle = async (key, handle, databaseName = "lvce-cache-worker") => {
+  const database = await openDatabase(databaseName);
+  const transaction = database.transaction("file-handles", "readwrite");
+  const done = transactionDone(transaction);
+  const request = transaction.objectStore("file-handles").put(handle, key);
+  try {
+    await Promise.all([requestResult(request), done]);
+  } finally {
+    database.close();
+  }
+};
+var getIndexedDbFileHandle = async (key, databaseName = "lvce-cache-worker") => {
+  const database = await openDatabase(databaseName);
+  const transaction = database.transaction("file-handles", "readonly");
+  const done = transactionDone(transaction);
+  try {
+    const value = await requestResult(transaction.objectStore("file-handles").get(key));
+    await done;
+    return value;
+  } finally {
+    database.close();
+  }
+};
+var removeIndexedDbFileHandle = async (key, databaseName = "lvce-cache-worker") => {
+  const database = await openDatabase(databaseName);
+  const transaction = database.transaction("file-handles", "readwrite");
+  const done = transactionDone(transaction);
+  const request = transaction.objectStore("file-handles").delete(key);
+  try {
+    await Promise.all([requestResult(request), done]);
+  } finally {
+    database.close();
+  }
+};
+
+// packages/cache-worker/src/parts/Opfs/Opfs.js
+var getRoot = async () => {
+  if (typeof navigator === "undefined" || typeof navigator.storage?.getDirectory !== "function") {
+    throw new Error("Origin Private File System is not available in this context");
+  }
+  return navigator.storage.getDirectory();
+};
+var validateName = (name) => {
+  if (typeof name !== "string" || name.length === 0 || name === "." || name === ".." || /[/\\]/.test(name)) {
+    throw new TypeError("OPFS filename must be a non-empty single path component");
+  }
+};
+var readFile = async (name) => {
+  validateName(name);
+  const root = await getRoot();
+  const handle = await root.getFileHandle(name);
+  return (await handle.getFile()).text();
+};
+var writeFile = async (name, content) => {
+  validateName(name);
+  const root = await getRoot();
+  const handle = await root.getFileHandle(name, { create: true });
+  const writable = await handle.createWritable();
+  try {
+    await writable.write(content);
+  } catch (error) {
+    await writable.abort();
+    throw error;
+  }
+  await writable.close();
+};
+var removeFile = async (name) => {
+  validateName(name);
+  const root = await getRoot();
+  await root.removeEntry(name);
+};
+
+// packages/cache-worker/src/parts/CommandMap/CommandMap.js
+var commandMap = {
+  "Cache.getCacheStorageItem": getCacheStorageItem,
+  "Cache.setCacheStorageItem": setCacheStorageItem,
+  "Cache.removeCacheStorageItem": removeCacheStorageItem,
+  "IndexedDb.addIndexedDbFileHandle": addIndexedDbFileHandle,
+  "IndexedDb.getIndexedDbFileHandle": getIndexedDbFileHandle,
+  "IndexedDb.removeIndexedDbFileHandle": removeIndexedDbFileHandle,
+  "Opfs.readFile": readFile,
+  "Opfs.writeFile": writeFile,
+  "Opfs.removeFile": removeFile
+};
+
+// packages/cache-worker/src/parts/Listen/Listen.js
+var listen2 = async () => {
+  await WebWorkerRpcClient2_exports.create({ commandMap });
+};
+
+// packages/cache-worker/src/cacheWorkerMain.js
+await listen2();

package/index.js

@@ -0,0 +1 @@
+export const getCacheWorkerUrl = () => new URL('./cacheWorkerMain.js', import.meta.url)

package/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@lvce-editor/cache-worker",
+  "version": "0.0.2",
+  "description": "Worker APIs for Cache Storage, IndexedDB, and OPFS",
+  "license": "MIT",
+  "author": "Lvce Editor",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/lvce-editor/cache-worker.git"
+  },
+  "type": "module",
+  "main": "index.js",
+  "exports": {
+    ".": "./index.js",
+    "./cacheWorkerMain.js": "./cacheWorkerMain.js"
+  }
+}