const normalizeLine = line => {
  if (line.startsWith('Error: ')) {
    return line.slice('Error: '.length);
  }
  if (line.startsWith('VError: ')) {
    return line.slice('VError: '.length);
  }
  return line;
};
const getCombinedMessage = (error, message) => {
  const stringifiedError = normalizeLine(`${error}`);
  if (message) {
    return `${message}: ${stringifiedError}`;
  }
  return stringifiedError;
};
const NewLine$2 = '\n';
const getNewLineIndex$1 = (string, startIndex = undefined) => {
  return string.indexOf(NewLine$2, startIndex);
};
const mergeStacks = (parent, child) => {
  if (!child) {
    return parent;
  }
  const parentNewLineIndex = getNewLineIndex$1(parent);
  const childNewLineIndex = getNewLineIndex$1(child);
  if (childNewLineIndex === -1) {
    return parent;
  }
  const parentFirstLine = parent.slice(0, parentNewLineIndex);
  const childRest = child.slice(childNewLineIndex);
  const childFirstLine = normalizeLine(child.slice(0, childNewLineIndex));
  if (parentFirstLine.includes(childFirstLine)) {
    return parentFirstLine + childRest;
  }
  return child;
};
class VError extends Error {
  constructor(error, message) {
    const combinedMessage = getCombinedMessage(error, message);
    super(combinedMessage);
    this.name = 'VError';
    if (error instanceof Error) {
      this.stack = mergeStacks(this.stack, error.stack);
    }
    if (error.codeFrame) {
      // @ts-ignore
      this.codeFrame = error.codeFrame;
    }
    if (error.code) {
      // @ts-ignore
      this.code = error.code;
    }
  }
}

const isMessagePort = value => {
  return value && value instanceof MessagePort;
};
const isMessagePortMain = value => {
  return value && value.constructor && value.constructor.name === 'MessagePortMain';
};
const isOffscreenCanvas = value => {
  return typeof OffscreenCanvas !== 'undefined' && value instanceof OffscreenCanvas;
};
const isInstanceOf = (value, constructorName) => {
  return value?.constructor?.name === constructorName;
};
const isSocket = value => {
  return isInstanceOf(value, 'Socket');
};
const transferrables = [isMessagePort, isMessagePortMain, isOffscreenCanvas, isSocket];
const isTransferrable = value => {
  for (const fn of transferrables) {
    if (fn(value)) {
      return true;
    }
  }
  return false;
};
const walkValue = (value, transferrables, isTransferrable) => {
  if (!value) {
    return;
  }
  if (isTransferrable(value)) {
    transferrables.push(value);
    return;
  }
  if (Array.isArray(value)) {
    for (const item of value) {
      walkValue(item, transferrables, isTransferrable);
    }
    return;
  }
  if (typeof value === 'object') {
    for (const property of Object.values(value)) {
      walkValue(property, transferrables, isTransferrable);
    }
    return;
  }
};
const getTransferrables = value => {
  const transferrables = [];
  walkValue(value, transferrables, isTransferrable);
  return transferrables;
};
const attachEvents = that => {
  const handleMessage = (...args) => {
    const data = that.getData(...args);
    that.dispatchEvent(new MessageEvent('message', {
      data
    }));
  };
  that.onMessage(handleMessage);
  const handleClose = event => {
    that.dispatchEvent(new Event('close'));
  };
  that.onClose(handleClose);
};
class Ipc extends EventTarget {
  constructor(rawIpc) {
    super();
    this._rawIpc = rawIpc;
    attachEvents(this);
  }
}
const E_INCOMPATIBLE_NATIVE_MODULE = 'E_INCOMPATIBLE_NATIVE_MODULE';
const E_MODULES_NOT_SUPPORTED_IN_ELECTRON = 'E_MODULES_NOT_SUPPORTED_IN_ELECTRON';
const ERR_MODULE_NOT_FOUND = 'ERR_MODULE_NOT_FOUND';
const NewLine$1 = '\n';
const joinLines$1 = lines => {
  return lines.join(NewLine$1);
};
const RE_AT = /^\s+at/;
const RE_AT_PROMISE_INDEX = /^\s*at async Promise.all \(index \d+\)$/;
const isNormalStackLine = line => {
  return RE_AT.test(line) && !RE_AT_PROMISE_INDEX.test(line);
};
const getDetails = lines => {
  const index = lines.findIndex(isNormalStackLine);
  if (index === -1) {
    return {
      actualMessage: joinLines$1(lines),
      rest: []
    };
  }
  let lastIndex = index - 1;
  while (++lastIndex < lines.length) {
    if (!isNormalStackLine(lines[lastIndex])) {
      break;
    }
  }
  return {
    actualMessage: lines[index - 1],
    rest: lines.slice(index, lastIndex)
  };
};
const splitLines$1 = lines => {
  return lines.split(NewLine$1);
};
const RE_MESSAGE_CODE_BLOCK_START = /^Error: The module '.*'$/;
const RE_MESSAGE_CODE_BLOCK_END = /^\s* at/;
const isMessageCodeBlockStartIndex = line => {
  return RE_MESSAGE_CODE_BLOCK_START.test(line);
};
const isMessageCodeBlockEndIndex = line => {
  return RE_MESSAGE_CODE_BLOCK_END.test(line);
};
const getMessageCodeBlock = stderr => {
  const lines = splitLines$1(stderr);
  const startIndex = lines.findIndex(isMessageCodeBlockStartIndex);
  const endIndex = startIndex + lines.slice(startIndex).findIndex(isMessageCodeBlockEndIndex, startIndex);
  const relevantLines = lines.slice(startIndex, endIndex);
  const relevantMessage = relevantLines.join(' ').slice('Error: '.length);
  return relevantMessage;
};
const isModuleNotFoundMessage = line => {
  return line.includes('[ERR_MODULE_NOT_FOUND]');
};
const getModuleNotFoundError = stderr => {
  const lines = splitLines$1(stderr);
  const messageIndex = lines.findIndex(isModuleNotFoundMessage);
  const message = lines[messageIndex];
  return {
    code: ERR_MODULE_NOT_FOUND,
    message
  };
};
const isModuleNotFoundError = stderr => {
  if (!stderr) {
    return false;
  }
  return stderr.includes('ERR_MODULE_NOT_FOUND');
};
const isModulesSyntaxError = stderr => {
  if (!stderr) {
    return false;
  }
  return stderr.includes('SyntaxError: Cannot use import statement outside a module');
};
const RE_NATIVE_MODULE_ERROR = /^innerError Error: Cannot find module '.*.node'/;
const RE_NATIVE_MODULE_ERROR_2 = /was compiled against a different Node.js version/;
const isUnhelpfulNativeModuleError = stderr => {
  return RE_NATIVE_MODULE_ERROR.test(stderr) && RE_NATIVE_MODULE_ERROR_2.test(stderr);
};
const getNativeModuleErrorMessage = stderr => {
  const message = getMessageCodeBlock(stderr);
  return {
    code: E_INCOMPATIBLE_NATIVE_MODULE,
    message: `Incompatible native node module: ${message}`
  };
};
const getModuleSyntaxError = () => {
  return {
    code: E_MODULES_NOT_SUPPORTED_IN_ELECTRON,
    message: `ES Modules are not supported in electron`
  };
};
const getHelpfulChildProcessError = (stdout, stderr) => {
  if (isUnhelpfulNativeModuleError(stderr)) {
    return getNativeModuleErrorMessage(stderr);
  }
  if (isModulesSyntaxError(stderr)) {
    return getModuleSyntaxError();
  }
  if (isModuleNotFoundError(stderr)) {
    return getModuleNotFoundError(stderr);
  }
  const lines = splitLines$1(stderr);
  const {
    actualMessage,
    rest
  } = getDetails(lines);
  return {
    code: '',
    message: actualMessage,
    stack: rest
  };
};
class IpcError extends VError {
  // @ts-ignore
  constructor(betterMessage, stdout = '', stderr = '') {
    if (stdout || stderr) {
      // @ts-ignore
      const {
        code,
        message,
        stack
      } = getHelpfulChildProcessError(stdout, stderr);
      const cause = new Error(message);
      // @ts-ignore
      cause.code = code;
      cause.stack = stack;
      super(cause, betterMessage);
    } else {
      super(betterMessage);
    }
    // @ts-ignore
    this.name = 'IpcError';
    // @ts-ignore
    this.stdout = stdout;
    // @ts-ignore
    this.stderr = stderr;
  }
}
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') {
    throw new TypeError('module is not in web worker scope');
  }
  return globalThis;
};
const signal$8 = global => {
  global.postMessage(readyMessage);
};
class IpcChildWithModuleWorker extends Ipc {
  getData(event) {
    return getData$2(event);
  }
  send(message) {
    // @ts-ignore
    this._rawIpc.postMessage(message);
  }
  sendAndTransfer(message) {
    const transfer = getTransferrables(message);
    // @ts-ignore
    this._rawIpc.postMessage(message, transfer);
  }
  dispose() {
    // ignore
  }
  onClose(callback) {
    // ignore
  }
  onMessage(callback) {
    this._rawIpc.addEventListener('message', callback);
  }
}
const wrap$f = global => {
  return new IpcChildWithModuleWorker(global);
};
const waitForFirstMessage = async port => {
  const {
    promise,
    resolve
  } = Promise.withResolvers();
  port.addEventListener('message', resolve, {
    once: true
  });
  const event = await promise;
  // @ts-ignore
  return event.data;
};
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 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;
  }
  return globalThis;
};
class IpcChildWithModuleWorkerAndMessagePort 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() {
    if (this._rawIpc.close) {
      this._rawIpc.close();
    }
  }
  onClose(callback) {
    // ignore
  }
  onMessage(callback) {
    this._rawIpc.addEventListener('message', callback);
    this._rawIpc.start();
  }
}
const wrap$e = port => {
  return new IpcChildWithModuleWorkerAndMessagePort(port);
};
const IpcChildWithModuleWorkerAndMessagePort$1 = {
  __proto__: null,
  listen: listen$6,
  wrap: wrap$e
};

class CommandNotFoundError extends Error {
  constructor(command) {
    super(`Command not found ${command}`);
    this.name = 'CommandNotFoundError';
  }
}
const commands = Object.create(null);
const register = commandMap => {
  Object.assign(commands, commandMap);
};
const getCommand = key => {
  return commands[key];
};
const execute = (command, ...args) => {
  const fn = getCommand(command);
  if (!fn) {
    throw new CommandNotFoundError(command);
  }
  return fn(...args);
};

const Two$1 = '2.0';
const callbacks = Object.create(null);
const get$1 = id => {
  return callbacks[id];
};
const remove$1 = id => {
  delete callbacks[id];
};
class JsonRpcError extends Error {
  constructor(message) {
    super(message);
    this.name = 'JsonRpcError';
  }
}
const NewLine = '\n';
const DomException = 'DOMException';
const ReferenceError$1 = 'ReferenceError';
const SyntaxError$1 = 'SyntaxError';
const TypeError$1 = 'TypeError';
const 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;
};
const 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') {
      error.name = name;
    }
    return error;
  }
  return new ErrorConstructor(message);
};
const joinLines = lines => {
  return lines.join(NewLine);
};
const splitLines = lines => {
  return lines.split(NewLine);
};
const getCurrentStack = () => {
  const stackLinesToSkip = 3;
  const currentStack = joinLines(splitLines(new Error().stack || '').slice(stackLinesToSkip));
  return currentStack;
};
const getNewLineIndex = (string, startIndex = undefined) => {
  return string.indexOf(NewLine, startIndex);
};
const getParentStack = error => {
  let parentStack = error.stack || error.data || error.message || '';
  if (parentStack.startsWith('    at')) {
    parentStack = error.message + NewLine + parentStack;
  }
  return parentStack;
};
const MethodNotFound = -32601;
const Custom = -32001;
const restoreJsonRpcError = error => {
  const currentStack = getCurrentStack();
  if (error && error instanceof Error) {
    if (typeof error.stack === 'string') {
      error.stack = error.stack + NewLine + currentStack;
    }
    return error;
  }
  if (error && error.code && error.code === MethodNotFound) {
    const restoredError = new JsonRpcError(error.message);
    const parentStack = getParentStack(error);
    restoredError.stack = parentStack + NewLine + currentStack;
    return restoredError;
  }
  if (error && error.message) {
    const restoredError = constructError(error.message, error.type, error.name);
    if (error.data) {
      if (error.data.stack && error.data.type && error.message) {
        restoredError.stack = error.data.type + ': ' + error.message + NewLine + error.data.stack + NewLine + currentStack;
      } else if (error.data.stack) {
        restoredError.stack = error.data.stack;
      }
      if (error.data.codeFrame) {
        // @ts-ignore
        restoredError.codeFrame = error.data.codeFrame;
      }
      if (error.data.code) {
        // @ts-ignore
        restoredError.code = error.data.code;
      }
      if (error.data.type) {
        // @ts-ignore
        restoredError.name = error.data.type;
      }
    } else {
      if (error.stack) {
        const lowerStack = restoredError.stack || '';
        // @ts-ignore
        const indexNewLine = getNewLineIndex(lowerStack);
        const parentStack = getParentStack(error);
        // @ts-ignore
        restoredError.stack = parentStack + lowerStack.slice(indexNewLine);
      }
      if (error.codeFrame) {
        // @ts-ignore
        restoredError.codeFrame = error.codeFrame;
      }
    }
    return restoredError;
  }
  if (typeof error === 'string') {
    return new Error(`JsonRpc Error: ${error}`);
  }
  return new Error(`JsonRpc Error: ${error}`);
};
const 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');
};
const warn = (...args) => {
  console.warn(...args);
};
const resolve = (id, response) => {
  const fn = get$1(id);
  if (!fn) {
    console.log(response);
    warn(`callback ${id} may already be disposed`);
    return;
  }
  fn(response);
  remove$1(id);
};
const E_COMMAND_NOT_FOUND = 'E_COMMAND_NOT_FOUND';
const getErrorType = prettyError => {
  if (prettyError && prettyError.type) {
    return prettyError.type;
  }
  if (prettyError && prettyError.constructor && prettyError.constructor.name) {
    return prettyError.constructor.name;
  }
  return undefined;
};
const isAlreadyStack = line => {
  return line.trim().startsWith('at ');
};
const 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;
};
const 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,
      codeFrame: prettyError.codeFrame,
      name: prettyError.name,
      stack: getStack(prettyError),
      type: getErrorType(prettyError)
    },
    message: prettyError.message
  };
};
const create$1$1 = (id, error) => {
  return {
    error,
    id,
    jsonrpc: Two$1
  };
};
const getErrorResponse = (id, error, preparePrettyError, logError) => {
  const prettyError = preparePrettyError(error);
  logError(error, prettyError);
  const errorProperty = getErrorProperty(error, prettyError);
  return create$1$1(id, errorProperty);
};
const create$6 = (message, result) => {
  return {
    id: message.id,
    jsonrpc: Two$1,
    result: result ?? null
  };
};
const getSuccessResponse = (message, result) => {
  const resultProperty = result ?? null;
  return create$6(message, resultProperty);
};
const getErrorResponseSimple = (id, error) => {
  return {
    error: {
      code: Custom,
      data: error,
      // @ts-ignore
      message: error.message
    },
    id,
    jsonrpc: Two$1
  };
};
const getResponse = async (message, ipc, execute, preparePrettyError, logError, requiresSocket) => {
  try {
    const result = requiresSocket(message.method) ? await execute(message.method, ipc, ...message.params) : await execute(message.method, ...message.params);
    return getSuccessResponse(message, result);
  } catch (error) {
    if (ipc.canUseSimpleErrorResponse) {
      return getErrorResponseSimple(message.id, error);
    }
    return getErrorResponse(message.id, error, preparePrettyError, logError);
  }
};
const defaultPreparePrettyError = error => {
  return error;
};
const defaultLogError = () => {
  // ignore
};
const defaultRequiresSocket = () => {
  return false;
};
const defaultResolve = resolve;

// TODO maybe remove this in v6 or v7, only accept options object to simplify the code
const 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]
  };
};
const handleJsonRpcMessage = async (...args) => {
  const options = normalizeParams(args);
  const {
    execute,
    ipc,
    logError,
    message,
    preparePrettyError,
    requiresSocket,
    resolve
  } = options;
  if ('id' in message) {
    if ('method' in message) {
      const response = await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
      try {
        ipc.send(response);
      } catch (error) {
        const errorResponse = getErrorResponse(message.id, error, preparePrettyError, logError);
        ipc.send(errorResponse);
      }
      return;
    }
    resolve(message.id, message);
    return;
  }
  if ('method' in message) {
    await getResponse(message, ipc, execute, preparePrettyError, logError, requiresSocket);
    return;
  }
  throw new JsonRpcError('unexpected message');
};

const Two = '2.0';

const create$5 = (method, params) => {
  return {
    jsonrpc: Two,
    method,
    params
  };
};

const create$4 = (id, method, params) => {
  const message = {
    id,
    jsonrpc: Two,
    method,
    params
  };
  return message;
};

let id = 0;
const create$3 = () => {
  return ++id;
};

const registerPromise = map => {
  const id = create$3();
  const {
    promise,
    resolve
  } = Promise.withResolvers();
  map[id] = resolve;
  return {
    id,
    promise
  };
};

const invokeHelper = async (callbacks, ipc, method, params, useSendAndTransfer) => {
  const {
    id,
    promise
  } = registerPromise(callbacks);
  const message = create$4(id, method, params);
  if (useSendAndTransfer && ipc.sendAndTransfer) {
    ipc.sendAndTransfer(message);
  } else {
    ipc.send(message);
  }
  const responseMessage = await promise;
  return unwrapJsonRpcResult(responseMessage);
};
const createRpc = ipc => {
  const callbacks = Object.create(null);
  ipc._resolve = (id, response) => {
    const fn = callbacks[id];
    if (!fn) {
      console.warn(`callback ${id} may already be disposed`);
      return;
    }
    fn(response);
    delete callbacks[id];
  };
  const rpc = {
    async dispose() {
      await ipc?.dispose();
    },
    invoke(method, ...params) {
      return invokeHelper(callbacks, ipc, method, params, false);
    },
    invokeAndTransfer(method, ...params) {
      return invokeHelper(callbacks, ipc, method, params, true);
    },
    // @ts-ignore
    ipc,
    /**
     * @deprecated
     */
    send(method, ...params) {
      const message = create$5(method, params);
      ipc.send(message);
    }
  };
  return rpc;
};

const requiresSocket = () => {
  return false;
};
const preparePrettyError = error => {
  return error;
};
const logError = () => {
  // handled by renderer worker
};
const handleMessage = event => {
  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);
};

const handleIpc = ipc => {
  if ('addEventListener' in ipc) {
    ipc.addEventListener('message', handleMessage);
  } else if ('on' in ipc) {
    // deprecated
    ipc.on('message', handleMessage);
  }
};

const listen$1 = async (module, options) => {
  const rawIpc = await module.listen(options);
  if (module.signal) {
    module.signal(rawIpc);
  }
  const ipc = module.wrap(rawIpc);
  return ipc;
};

const create$2 = async ({
  commandMap,
  messagePort
}) => {
  // TODO create a commandMap per rpc instance
  register(commandMap);
  const ipc = await listen$1(IpcChildWithMessagePort$1, {
    port: messagePort
  });
  handleIpc(ipc);
  const rpc = createRpc(ipc);
  return rpc;
};

const create$1 = async ({
  commandMap
}) => {
  // TODO create a commandMap per rpc instance
  register(commandMap);
  const ipc = await listen$1(IpcChildWithModuleWorkerAndMessagePort$1);
  handleIpc(ipc);
  const rpc = createRpc(ipc);
  return rpc;
};

const createMockRpc = ({
  commandMap
}) => {
  const invocations = [];
  const invoke = (method, ...params) => {
    invocations.push([method, ...params]);
    const command = commandMap[method];
    if (!command) {
      throw new Error(`command ${method} not found`);
    }
    return command(...params);
  };
  const mockRpc = {
    invocations,
    invoke,
    invokeAndTransfer: invoke
  };
  return mockRpc;
};

const rpcs = Object.create(null);
const set$1 = (id, rpc) => {
  rpcs[id] = rpc;
};
const get = id => {
  return rpcs[id];
};
const remove = id => {
  delete rpcs[id];
};

/* eslint-disable  @typescript-eslint/explicit-function-return-type */
const create = rpcId => {
  return {
    async dispose() {
      const rpc = get(rpcId);
      await rpc.dispose();
    },
    // @ts-ignore
    invoke(method, ...params) {
      const rpc = get(rpcId);
      // @ts-ignore
      return rpc.invoke(method, ...params);
    },
    // @ts-ignore
    invokeAndTransfer(method, ...params) {
      const rpc = get(rpcId);
      // @ts-ignore
      return rpc.invokeAndTransfer(method, ...params);
    },
    registerMockRpc(commandMap) {
      const mockRpc = createMockRpc({
        commandMap
      });
      set$1(rpcId, mockRpc);
      // @ts-ignore
      mockRpc[Symbol.dispose] = () => {
        remove(rpcId);
      };
      // @ts-ignore
      return mockRpc;
    },
    set(rpc) {
      set$1(rpcId, rpc);
    }
  };
};

const RendererWorker = 1;

const {
  invoke,
  set
} = create(RendererWorker);
const readFile = async uri => {
  return invoke('FileSystem.readFile', uri);
};
const writeFile = async (uri, text) => {
  await invoke('FileSystem.writeFile', uri, text);
};
const getWorkspacePath = () => {
  return invoke('Workspace.getPath');
};

const getToolErrorPayload = error => {
  const rawStack = error && typeof error === 'object' ? Reflect.get(error, 'stack') : undefined;
  return {
    error: String(error),
    ...(typeof rawStack === 'string' && rawStack.trim() ? {
      errorStack: rawStack,
      stack: rawStack
    } : {})
  };
};

const executeClosePreviewTool = async (_args, _options) => {
  try {
    await invoke('Preview.close');
    return {
      ok: true
    };
  } catch (error) {
    return getToolErrorPayload(error);
  }
};

const ABSOLUTE_URI_REGEX = /^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//;
const isAbsoluteUri = value => {
  return ABSOLUTE_URI_REGEX.test(value);
};

const executeCreateDirectoryTool = async (args, _options) => {
  const uri = typeof args.uri === 'string' ? args.uri : '';
  if (!uri || !isAbsoluteUri(uri)) {
    return {
      error: 'Invalid argument: uri must be an absolute URI.'
    };
  }
  try {
    new URL(uri);
  } catch {
    return {
      error: 'Invalid argument: invalid URL.'
    };
  }
  try {
    await invoke('FileSystem.mkdir', uri);
    return {
      ok: true,
      uri
    };
  } catch (error) {
    return {
      ...getToolErrorPayload(error),
      uri
    };
  }
};

const applyTextEdit = (content, start, end, text) => {
  if (start > content.length || end > content.length) {
    throw new Error('Invalid argument: edit range is out of bounds.');
  }
  return `${content.slice(0, start)}${text}${content.slice(end)}`;
};

const executeEditFileTool = async (args, _options) => {
  const uri = typeof args.uri === 'string' ? args.uri : '';
  const start = typeof args.start === 'number' ? args.start : -1;
  const end = typeof args.end === 'number' ? args.end : -1;
  const text = typeof args.text === 'string' ? args.text : '';
  if (!uri || !isAbsoluteUri(uri)) {
    return {
      error: 'Invalid argument: uri must be an absolute URI.'
    };
  }
  try {
    new URL(uri);
  } catch {
    return {
      error: 'Invalid argument: invalid URL.'
    };
  }
  if (!Number.isInteger(start) || start < 0) {
    return {
      error: 'Invalid argument: start must be a non-negative integer.'
    };
  }
  if (!Number.isInteger(end) || end < 0) {
    return {
      error: 'Invalid argument: end must be a non-negative integer.'
    };
  }
  if (start > end) {
    return {
      error: 'Invalid argument: start must be less than or equal to end.'
    };
  }
  try {
    const content = await readFile(uri);
    const nextContent = applyTextEdit(content, start, end, text);
    await writeFile(uri, nextContent);
    return {
      ok: true,
      uri
    };
  } catch (error) {
    return {
      ...getToolErrorPayload(error),
      uri
    };
  }
};

const executeGetWorkspaceUriTool = async (_args, _options) => {
  try {
    const workspaceUri = await getWorkspacePath();
    return {
      workspaceUri
    };
  } catch (error) {
    return getToolErrorPayload(error);
  }
};

const executeGlobTool = async (args, _options) => {
  const pattern = typeof args.pattern === 'string' ? args.pattern : '';
  if (!pattern) {
    return {
      error: 'Invalid argument: pattern must be a non-empty string.'
    };
  }
  const paths = ['./src/main.ts', './src/utils/search.ts', './test/Main.test.ts'];
  return {
    paths,
    pattern
  };
};

const executeListFilesTool = async (args, _options) => {
  const uri = typeof args.uri === 'string' ? args.uri : '';
  if (!uri || !isAbsoluteUri(uri)) {
    return {
      error: 'Invalid argument: uri must be an absolute URI.'
    };
  }
  if (uri === 'file:///workspace' || uri.startsWith('file:///workspace/')) {
    return {
      error: 'Invalid argument: uri must be a real workspace folder URI. Call getWorkspaceUri first and use the returned workspaceUri value.',
      uri
    };
  }
  try {
    const entries = await invoke('FileSystem.readDirWithFileTypes', uri);
    return {
      entries,
      uri
    };
  } catch (error) {
    return {
      ...getToolErrorPayload(error),
      uri
    };
  }
};

const executeOpenEditorTool = async (args, _options) => {
  const uri = typeof args.uri === 'string' ? args.uri : '';
  if (!uri || !isAbsoluteUri(uri)) {
    return {
      error: 'Invalid argument: uri must be an absolute URI.'
    };
  }
  try {
    await invoke('Main.openUri', uri);
    return {
      ok: true,
      uri
    };
  } catch (error) {
    return {
      ...getToolErrorPayload(error),
      uri
    };
  }
};

const executeOpenPreviewTool = async (args, _options) => {
  const uri = typeof args.uri === 'string' ? args.uri : '';
  if (!uri || !isAbsoluteUri(uri)) {
    return {
      error: 'Invalid argument: uri must be an absolute URI.'
    };
  }
  try {
    await invoke('Preview.open', uri);
    return {
      ok: true,
      uri
    };
  } catch (error) {
    return {
      ...getToolErrorPayload(error),
      uri
    };
  }
};

const executeReadFileTool = async (args, _options) => {
  const uri = typeof args.uri === 'string' ? args.uri : '';
  if (!uri || !isAbsoluteUri(uri)) {
    return {
      error: 'Invalid argument: uri must be an absolute URI.'
    };
  }
  try {
    const content = await readFile(uri);
    return {
      content,
      uri
    };
  } catch (error) {
    return {
      ...getToolErrorPayload(error),
      uri
    };
  }
};

/* eslint-disable @cspell/spellchecker */
/* eslint-disable e18e/prefer-url-canparse */
const executeRenameTool = async (args, _options) => {
  const oldUri = typeof args.oldUri === 'string' ? args.oldUri : '';
  const newUri = typeof args.newUri === 'string' ? args.newUri : '';
  if (!oldUri || !isAbsoluteUri(oldUri)) {
    return {
      error: 'Invalid argument: oldUri must be an absolute URI.'
    };
  }
  if (!newUri || !isAbsoluteUri(newUri)) {
    return {
      error: 'Invalid argument: newUri must be an absolute URI.'
    };
  }
  try {
    new URL(oldUri);
    new URL(newUri);
  } catch {
    return {
      error: 'Invalid argument: invalid URL.'
    };
  }
  try {
    await invoke('FileSystem.rename', oldUri, newUri);
    return {
      newUri,
      ok: true,
      oldUri
    };
  } catch (error) {
    return {
      ...getToolErrorPayload(error),
      newUri,
      oldUri
    };
  }
};

const maxPayloadLength = 40_000;
const executeRenderHtmlTool = async (args, _options) => {
  const html = typeof args.html === 'string' ? args.html : '';
  const css = typeof args.css === 'string' ? args.css : '';
  const title = typeof args.title === 'string' ? args.title : '';
  if (!html) {
    return {
      error: 'Missing required argument: html'
    };
  }
  if (html.length > maxPayloadLength || css.length > maxPayloadLength) {
    return {
      error: 'Payload too large: keep html/css under 40,000 characters each.'
    };
  }
  return {
    css,
    html,
    ok: true,
    title
  };
};

const getRgArgs = args => {
  const {
    '-n': lineNumbers,
    output_mode,
    path,
    pattern
  } = args;
  if (typeof pattern !== 'string') {
    return undefined;
  }
  if (path !== undefined && typeof path !== 'string') {
    return undefined;
  }
  if (output_mode !== undefined && output_mode !== 'content' && output_mode !== 'files_with_matches' && output_mode !== 'count') {
    return undefined;
  }
  if (lineNumbers !== undefined && typeof lineNumbers !== 'boolean') {
    return undefined;
  }
  return {
    ...(lineNumbers === undefined ? {} : {
      '-n': lineNumbers
    }),
    ...(output_mode === undefined ? {} : {
      output_mode
    }),
    ...(path === undefined ? {} : {
      path
    }),
    pattern
  };
};
const executeRgTool = async (args, _options) => {
  const rgArgs = getRgArgs(args);
  if (!rgArgs) {
    return {
      error: 'Invalid argument: rg requires pattern (string), optional path (string), optional output_mode ("content" | "files_with_matches" | "count"), and optional -n (boolean).'
    };
  }
  return {
    arguments: rgArgs,
    result: 'No matches found.'
  };
};

const getRunInTerminalOptions = args => {
  const {
    options
  } = args;
  if (!options || typeof options !== 'object') {
    return undefined;
  }
  const candidate = options;
  const {
    command,
    shell
  } = candidate;
  if (typeof command !== 'string' || typeof shell !== 'string') {
    return undefined;
  }
  return {
    command,
    shell
  };
};
const executeRunInTerminalTool = async (args, _options) => {
  const runInTerminalOptions = getRunInTerminalOptions(args);
  if (!runInTerminalOptions) {
    return {
      error: 'Invalid argument: options must include shell (string) and command (string).'
    };
  }
  return {
    output: {
      exitCode: 0,
      stderr: '',
      stdout: `Mock output for "${runInTerminalOptions.command}" using shell "${runInTerminalOptions.shell}"`
    }
  };
};

const getSearchOptions = args => {
  const {
    options
  } = args;
  if (!options || typeof options !== 'object') {
    return undefined;
  }
  const candidate = options;
  const {
    exclude,
    isRegex,
    machWholeWord,
    matchCase,
    value
  } = candidate;
  if (typeof value !== 'string' || typeof isRegex !== 'boolean' || typeof matchCase !== 'boolean' || typeof machWholeWord !== 'boolean') {
    return undefined;
  }
  if (!Array.isArray(exclude) || exclude.some(item => typeof item !== 'string')) {
    return undefined;
  }
  return {
    exclude,
    isRegex,
    machWholeWord,
    matchCase,
    value
  };
};
const executeSearchTextTool = async (args, _options) => {
  const searchOptions = getSearchOptions(args);
  if (!searchOptions) {
    return {
      error: 'Invalid argument: options must include value (string), isRegex (boolean), matchCase (boolean), machWholeWord (boolean), and exclude (string[]).'
    };
  }
  const results = [{
    column: 12,
    line: 5,
    text: `Mock match for "${searchOptions.value}" in src/main.ts`,
    uri: 'file:///workspace/src/main.ts'
  }, {
    column: 3,
    line: 18,
    text: `Mock match for "${searchOptions.value}" in src/utils/search.ts`,
    uri: 'file:///workspace/src/utils/search.ts'
  }];
  return {
    options: searchOptions,
    results
  };
};

const todoDbName = 'chat-tool-worker';
const todoStoreName = 'state';
const todoKey = 'todoList';
const todoCacheName = 'chat-tool-worker-todo';
const todoCacheRequest = new Request('https://chat-tool-worker.local/todo-list');
let memoryTodoList = '';
const setTodosInIndexedDb = async todos => {
  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 cache = await caches.open(todoCacheName);
  const payload = JSON.stringify({
    todos
  });
  await cache.put(todoCacheRequest, new Response(payload, {
    headers: {
      'content-type': 'application/json'
    }
  }));
};
const executeUpdateTodoTool = async (args, _options) => {
  const todos = typeof args.todos === 'string' ? args.todos : '';
  if (!todos) {
    return {
      error: 'Missing required argument: todos'
    };
  }
  try {
    if (typeof indexedDB !== 'undefined') {
      await setTodosInIndexedDb(todos);
      return {
        message: 'TODO list updated',
        ok: true,
        storage: 'indexeddb',
        todos
      };
    }
    if (typeof caches !== 'undefined') {
      await setTodosInCacheStorage(todos);
      return {
        message: 'TODO list updated',
        ok: true,
        storage: 'cache',
        todos
      };
    }
    const previousTodos = memoryTodoList;
    memoryTodoList = todos;
    return {
      message: 'TODO list updated',
      ok: true,
      previousTodos,
      storage: 'memory',
      todos
    };
  } catch (error) {
    return getToolErrorPayload(error);
  }
};

const executeWriteFileTool = async (args, _options) => {
  const uri = typeof args.uri === 'string' ? args.uri : '';
  const content = typeof args.content === 'string' ? args.content : '';
  if (!uri || !isAbsoluteUri(uri)) {
    return {
      error: 'Invalid argument: uri must be an absolute URI.'
    };
  }
  try {
    new URL(uri);
  } catch {
    return {
      error: 'Invalid argument: invalid URL.'
    };
  }
  try {
    await writeFile(uri, content);
    return {
      ok: true,
      uri
    };
  } catch (error) {
    return {
      ...getToolErrorPayload(error),
      uri
    };
  }
};

const parseToolArguments = rawArguments => {
  if (typeof rawArguments !== 'string') {
    return {};
  }
  try {
    const parsed = JSON.parse(rawArguments);
    if (!parsed || typeof parsed !== 'object') {
      return {};
    }
    return parsed;
  } catch {
    return {};
  }
};

const executeChatTool = async (name, rawArguments, options) => {
  const args = parseToolArguments(rawArguments);
  switch (name) {
    case 'close_preview':
      return executeClosePreviewTool();
    case 'create_directory':
      return executeCreateDirectoryTool(args);
    case 'edit_file':
      return executeEditFileTool(args);
    case 'getWorkspaceUri':
      return executeGetWorkspaceUriTool();
    case 'glob':
      return executeGlobTool(args);
    case 'list_files':
      return executeListFilesTool(args);
    case 'open_preview':
      return executeOpenPreviewTool(args);
    case 'openEditor':
      return executeOpenEditorTool(args);
    case 'read_file':
      return executeReadFileTool(args);
    case 'rename':
      return executeRenameTool(args);
    case 'render_html':
      return executeRenderHtmlTool(args);
    case 'rg':
      return executeRgTool(args);
    case 'run_in_terminal':
      return executeRunInTerminalTool(args);
    case 'search_text':
      return executeSearchTextTool(args);
    case 'update_todo':
      return executeUpdateTodoTool(args);
    case 'write_file':
      return executeWriteFileTool(args);
    default:
      return {
        error: `Unknown tool: ${name}`
      };
  }
};

const getReadFileTool = () => {
  return {
    function: {
      description: 'Read UTF-8 text content from a file inside the currently open workspace folder. Only pass an absolute URI.',
      name: 'read_file',
      parameters: {
        additionalProperties: false,
        properties: {
          uri: {
            description: 'Absolute file URI for a real path inside the currently open workspace folder. Do not use placeholder URIs.',
            type: 'string'
          }
        },
        required: ['uri'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getWriteFileTool = () => {
  return {
    function: {
      description: 'Write UTF-8 text content to a file for an absolute URI (for example `file://...`, `memfs://...`, or extension-provided file system URIs). Do not pass a relative path and do not use a `path` argument.',
      name: 'write_file',
      parameters: {
        additionalProperties: false,
        properties: {
          content: {
            description: 'New UTF-8 text content to write to the file.',
            type: 'string'
          },
          uri: {
            description: 'Absolute URI for the target file (for example `file://...`, `memfs://...`, or extension-provided file system URIs). Relative paths are not allowed.',
            type: 'string'
          }
        },
        required: ['uri', 'content'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getRenameTool = () => {
  return {
    function: {
      description: 'Rename or move a file or folder from one absolute URI to another absolute URI (for example `file://...`, `memfs://...`, or extension-provided file system URIs).',
      name: 'rename',
      parameters: {
        additionalProperties: false,
        properties: {
          newUri: {
            description: 'Absolute target URI for the file or folder after renaming.',
            type: 'string'
          },
          oldUri: {
            description: 'Absolute source URI for the existing file or folder to rename.',
            type: 'string'
          }
        },
        required: ['oldUri', 'newUri'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getEditFileTool = () => {
  return {
    function: {
      description: 'Apply a targeted text edit to an existing file by character offsets. This reads the current file, applies the edit, and writes the updated result. Use this for small changes instead of rewriting the full file.',
      name: 'edit_file',
      parameters: {
        additionalProperties: false,
        properties: {
          end: {
            description: 'Zero-based end character offset (exclusive) in the current file content.',
            type: 'number'
          },
          start: {
            description: 'Zero-based start character offset (inclusive) in the current file content.',
            type: 'number'
          },
          text: {
            description: 'Replacement text inserted at the range [start, end).',
            type: 'string'
          },
          uri: {
            description: 'Absolute URI for the target file (for example `file://...`, `memfs://...`, or extension-provided file system URIs). Relative paths are not allowed.',
            type: 'string'
          }
        },
        required: ['uri', 'start', 'end', 'text'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getListFilesTool = () => {
  return {
    function: {
      description: 'List direct children (files and folders) for a folder URI inside the currently open workspace folder. If you do not already have a real workspace URI, call getWorkspaceUri first and then use that returned URI. Do not use placeholder URIs like file:///workspace.',
      name: 'list_files',
      parameters: {
        additionalProperties: false,
        properties: {
          uri: {
            description: 'Absolute folder URI for a real path inside the currently open workspace folder. If unknown, call getWorkspaceUri first and pass the returned workspaceUri value. Do not use placeholder URIs.',
            type: 'string'
          }
        },
        required: ['uri'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getGetWorkspaceUriTool = () => {
  return {
    function: {
      description: 'Get the URI of the currently open workspace folder. Call this first before using list_files, read_file, write_file, edit_file, open_preview, or openEditor when you do not already have a concrete workspace URI.',
      name: 'getWorkspaceUri',
      parameters: {
        additionalProperties: false,
        properties: {},
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getRenderHtmlTool = () => {
  return {
    function: {
      description: 'Render custom HTML and optional CSS directly in the chat tool call list using native chat UI rendering. Use this for structured cards, tables, and small dashboards. After calling this tool, do not repeat the same HTML, data table, or long content again as plain text unless the user explicitly asks for a text-only version.',
      name: 'render_html',
      parameters: {
        additionalProperties: false,
        properties: {
          css: {
            description: 'Optional CSS string applied inside the preview document.',
            type: 'string'
          },
          html: {
            description: 'HTML string to render in the preview document.',
            type: 'string'
          },
          title: {
            description: 'Optional short title for the preview.',
            type: 'string'
          }
        },
        required: ['html'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getOpenPreviewTool = () => {
  return {
    function: {
      description: 'Open the right-side preview for an HTML file URI inside the currently open workspace folder.',
      name: 'open_preview',
      parameters: {
        additionalProperties: false,
        properties: {
          uri: {
            description: 'Absolute HTML file URI for a real path inside the currently open workspace folder. Do not use placeholder URIs.',
            type: 'string'
          }
        },
        required: ['uri'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getOpenEditorTool = () => {
  return {
    function: {
      description: 'Open a file URI in the editor.',
      name: 'openEditor',
      parameters: {
        additionalProperties: false,
        properties: {
          uri: {
            description: 'Absolute file URI for a real path inside the currently open workspace folder. Do not use placeholder URIs.',
            type: 'string'
          }
        },
        required: ['uri'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getClosePreviewTool = () => {
  return {
    function: {
      description: 'Close the right-side preview if it is currently open.',
      name: 'close_preview',
      parameters: {
        additionalProperties: false,
        properties: {},
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getSearchTextTool = () => {
  return {
    function: {
      description: 'Search text in workspace files using query options and return matching results.',
      name: 'search_text',
      parameters: {
        additionalProperties: false,
        properties: {
          options: {
            additionalProperties: false,
            properties: {
              exclude: {
                items: {
                  type: 'string'
                },
                type: 'array'
              },
              isRegex: {
                type: 'boolean'
              },
              machWholeWord: {
                type: 'boolean'
              },
              matchCase: {
                type: 'boolean'
              },
              value: {
                type: 'string'
              }
            },
            required: ['value', 'isRegex', 'matchCase', 'machWholeWord', 'exclude'],
            type: 'object'
          }
        },
        required: ['options'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getRgTool = () => {
  return {
    function: {
      description: 'Search text or regex in workspace files using ripgrep-style arguments and return matching results.',
      name: 'rg',
      parameters: {
        additionalProperties: false,
        properties: {
          '-n': {
            description: 'When true, include line numbers in the output.',
            type: 'boolean'
          },
          output_mode: {
            description: 'Result format to return.',
            enum: ['content', 'files_with_matches', 'count'],
            type: 'string'
          },
          path: {
            description: 'Optional file or directory path inside the current workspace to scope the search.',
            type: 'string'
          },
          pattern: {
            description: 'Text or regular expression pattern to search for.',
            type: 'string'
          }
        },
        required: ['pattern'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getRunInTerminalTool = () => {
  return {
    function: {
      description: 'Run a shell command in a terminal using the provided shell and command options.',
      name: 'run_in_terminal',
      parameters: {
        additionalProperties: false,
        properties: {
          options: {
            additionalProperties: false,
            properties: {
              command: {
                type: 'string'
              },
              shell: {
                type: 'string'
              }
            },
            required: ['shell', 'command'],
            type: 'object'
          }
        },
        required: ['options'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getCreateDirectoryTool = () => {
  return {
    function: {
      description: 'Create a new directory at the given absolute URI (for example `file://...`, `memfs://...`, or extension-provided file system URIs). Do not pass a relative path.',
      name: 'create_directory',
      parameters: {
        additionalProperties: false,
        properties: {
          uri: {
            description: 'Absolute URI for the target directory (for example `file://...`, `memfs://...`, or extension-provided file system URIs). Relative paths are not allowed.',
            type: 'string'
          }
        },
        required: ['uri'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getGlobTool = () => {
  return {
    function: {
      description: 'Find files by glob pattern and return matching relative paths.',
      name: 'glob',
      parameters: {
        additionalProperties: false,
        properties: {
          pattern: {
            description: 'Glob pattern to match files, for example `packages/e2e/src/*.ts`.',
            type: 'string'
          }
        },
        required: ['pattern'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getUpdateTodoTool = () => {
  return {
    function: {
      description: 'Update the active TODO checklist for the current chat session. Pass the full markdown checklist text with one item per line (for example "- [ ] Step one").',
      name: 'update_todo',
      parameters: {
        additionalProperties: false,
        properties: {
          todos: {
            description: 'Complete markdown checklist content to store as the current TODO list state.',
            type: 'string'
          }
        },
        required: ['todos'],
        type: 'object'
      }
    },
    type: 'function'
  };
};
const getBasicChatTools = () => {
  return [getReadFileTool(), getWriteFileTool(), getRenameTool(), getEditFileTool(), getListFilesTool(), getGetWorkspaceUriTool(), getRenderHtmlTool(), getOpenPreviewTool(), getOpenEditorTool(), getClosePreviewTool(), getSearchTextTool(), getRgTool(), getRunInTerminalTool(), getCreateDirectoryTool(), getGlobTool(), getUpdateTodoTool()];
};

const handleMessagePort = async port => {
  await create$2({
    commandMap: commandMap,
    messagePort: port
  });
};

const commandMap = {
  'ChatTool.execute': executeChatTool,
  'ChatTool.getTools': getBasicChatTools,
  'HandleMessagePort.handleMessagePort': handleMessagePort
};

const initializeRendererWorker = async () => {
  const rpc = await create$1({
    commandMap: commandMap
  });
  set(rpc);
};

const listen = async () => {
  await initializeRendererWorker();
};

const main = async () => {
  await listen();
};

main();
