@lvce-editor/shared-process 0.13.0 → 0.14.0

package/src/parts/ExtensionManagement/ExtensionManagementColorTheme.js

@@ -1,4 +1,4 @@
-import VError from 'verror'
+import * as Assert from '../Assert/Assert.js'
 import * as Error from '../Error/Error.js'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as FileSystemWatch from '../FileSystemWatch/FileSystemWatch.js'
@@ -6,6 +6,7 @@ import * as ReadJson from '../JsonFile/JsonFile.js'
 import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
 import * as Path from '../Path/Path.js'
 import * as Process from '../Process/Process.js'
+import { VError } from '../VError/VError.js'
 import * as ExtensionManagement from './ExtensionManagement.js'
 
 // TODO test this function
@@ -28,6 +29,7 @@ const getColorThemePath = async (extensions, colorThemeId) => {
 }
 
 export const getColorThemeJson = async (colorThemeId) => {
+  Assert.string(colorThemeId)
   const extensions = await ExtensionManagement.getExtensions()
   const colorThemePath = await getColorThemePath(extensions, colorThemeId)
   if (!colorThemePath) {

package/src/parts/ExtensionManagement/ExtensionManagementIconTheme.js

@@ -1,8 +1,8 @@
-import VError from 'verror'
 import * as Error from '../Error/Error.js'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as ReadJson from '../JsonFile/JsonFile.js'
 import * as Path from '../Path/Path.js'
+import { VError } from '../VError/VError.js'
 import * as ExtensionManagement from './ExtensionManagement.js'
 
 export const getIconTheme = async (iconThemeId) => {

package/src/parts/ExtensionManagement/ExtensionManagementLanguages.js

@@ -1,7 +1,8 @@
+// TODO rename file to languageConfiguration.js
 import { join } from 'node:path'
 import { pathToFileURL } from 'node:url'
-import VError from 'verror'
-import * as ReadJson from '../JsonFile/JsonFile.js'
+import * as JsonFile from '../JsonFile/JsonFile.js'
+import { VError } from '../VError/VError.js'
 import * as ExtensionManagement from './ExtensionManagement.js'
 
 const getExtensionLanguages = (extension) => {
@@ -70,7 +71,10 @@ export const getLanguageConfiguration = async (languageId) => {
   try {
     const extensions = await ExtensionManagement.getExtensions()
     const languageConfigurationPath = getLanguageConfigurationPathFromExtensions(extensions, languageId)
-    return await ReadJson.readJson(languageConfigurationPath)
+    if (!languageConfigurationPath) {
+      return undefined
+    }
+    return await JsonFile.readJson(languageConfigurationPath)
   } catch (error) {
     throw new VError(error, `Failed to load language configuration for ${languageId}`)
   }

package/src/parts/ExtensionManifestInputType/ExtensionManifestInputType.js

@@ -1,3 +1,5 @@
 export const Folder = 1
 
 export const OnlyExtension = 2
+
+export const LinkedExtensionsFolder = 3

package/src/parts/ExtensionManifests/ExtensionManifests.js

@@ -1,5 +1,6 @@
 import * as ExtensionManifestInputType from '../ExtensionManifestInputType/ExtensionManifestInputType.js'
 import * as ExtensionManifestsGetFromFolder from './ExtensionManifestsFromFolder.js'
+import * as ExtensionManifestsGetFromLinkedExtensionsFolder from './ExtensionManifestsFromLinkedExtensionsFolder.js'
 import * as ExtensionManifestsGetFromOnlyExtension from './ExtensionManifestsFromOnlyExtension.js'
 
 const getModule = (type) => {
@@ -8,6 +9,8 @@ const getModule = (type) => {
       return ExtensionManifestsGetFromFolder
     case ExtensionManifestInputType.OnlyExtension:
       return ExtensionManifestsGetFromOnlyExtension
+    case ExtensionManifestInputType.LinkedExtensionsFolder:
+      return ExtensionManifestsGetFromLinkedExtensionsFolder
     default:
       throw new Error('unsupported input type')
   }

package/src/parts/ExtensionManifests/ExtensionManifestsFromFolder.js

@@ -1,16 +1,8 @@
-import VError from 'verror'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as Path from '../Path/Path.js'
-import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
-
-const toAbsolutePaths = (path, dirents) => {
-  const absolutePaths = []
-  for (const dirent of dirents) {
-    absolutePaths.push(Path.join(path, dirent))
-  }
-  return absolutePaths
-}
+import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js'
+import { VError } from '../VError/VError.js'
 
 export const getExtensionManifests = async (path) => {
   try {
@@ -18,10 +10,8 @@ export const getExtensionManifests = async (path) => {
       return []
     }
     const dirents = await FileSystem.readDir(path)
-    const absolutePaths = toAbsolutePaths(path, dirents)
-    const manifests = await Promise.all(
-      absolutePaths.map(ExtensionManifest.get)
-    )
+    const absolutePaths = ToAbsolutePaths.toAbsolutePaths(path, dirents)
+    const manifests = await Promise.all(absolutePaths.map(ExtensionManifest.get))
     return manifests
   } catch (error) {
     // TODO how to make typescript happy?

package/src/parts/ExtensionManifests/ExtensionManifestsFromLinkedExtensionsFolder.js

@@ -0,0 +1,56 @@
+import { readlink } from 'fs/promises'
+import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
+import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as ToAbsolutePaths from '../ToAbsolutePaths/ToAbsolutePaths.js'
+import { VError } from '../VError/VError.js'
+
+const readSymlink = async (absolutePath) => {
+  try {
+    const info = await readlink(absolutePath)
+    return info
+  } catch {
+    return ''
+  }
+}
+
+const readSymlinks = (absolutePaths) => {
+  return Promise.all(absolutePaths.map(readSymlink))
+}
+
+const mergeWithSymLinks = (manifests, symlinks) => {
+  const length = manifests.length
+  const merged = []
+  for (let i = 0; i < length; i++) {
+    const manifest = manifests[i]
+    const symlink = symlinks[i]
+    if (manifest.status === ExtensionManifestStatus.Rejected) {
+      merged.push(manifest)
+    } else {
+      merged.push({ ...manifest, symlink })
+    }
+  }
+  return merged
+}
+
+export const getExtensionManifests = async (path) => {
+  try {
+    if (!path) {
+      return []
+    }
+    const dirents = await FileSystem.readDir(path)
+    const absolutePaths = ToAbsolutePaths.toAbsolutePaths(path, dirents)
+    const manifests = await Promise.all(absolutePaths.map(ExtensionManifest.get))
+    const symlinks = await readSymlinks(absolutePaths)
+    const merged = mergeWithSymLinks(manifests, symlinks)
+    return merged
+  } catch (error) {
+    // TODO how to make typescript happy?
+    // @ts-ignore
+    if (error.code === ErrorCodes.ENOENT) {
+      return []
+    }
+    throw new VError(error, 'Failed to get extension manifests')
+  }
+}

package/src/parts/ExtensionUninstall/ExtensionUninstall.js

@@ -0,0 +1,18 @@
+import { rm } from 'node:fs/promises'
+import * as Debug from '../Debug/Debug.js'
+import * as Path from '../Path/Path.js'
+import * as Platform from '../Platform/Platform.js'
+import { VError } from '../VError/VError.js'
+
+export const uninstall = async (id) => {
+  try {
+    Debug.debug(`ExtensionManagement#uninstall ${id}`)
+    const extensionsPath = Platform.getExtensionsPath()
+    await rm(Path.join(extensionsPath, id), { recursive: true })
+  } catch (error) {
+    // if (error.code === 'ENOENT') {
+    //   return
+    // }
+    throw new VError(error, `Failed to uninstall extension "${id}"`)
+  }
+}

package/src/parts/ExtensionUnlink/ExtensionUnlink.js

@@ -1,9 +1,9 @@
-import VError from 'verror'
 import * as ExtensionManifest from '../ExtensionManifest/ExtensionManifest.js'
 import * as ExtensionManifestStatus from '../ExtensionManifestStatus/ExtensionManifestStatus.js'
 import * as FileSystem from '../FileSystem/FileSystem.js'
 import * as Path from '../Path/Path.js'
 import * as Platform from '../Platform/Platform.js'
+import { VError } from '../VError/VError.js'
 
 export const unlink = async (path) => {
   try {

package/src/parts/Extract/Extract.js

@@ -3,16 +3,12 @@ import { mkdir } from 'node:fs/promises'
 import { pipeline } from 'node:stream/promises'
 import { createBrotliDecompress, createGunzip } from 'node:zlib'
 import tar from 'tar-fs'
-import VError from 'verror'
+import { VError } from '../VError/VError.js'
 
 export const extractTarBr = async (inFile, outDir) => {
   try {
     await mkdir(outDir, { recursive: true })
-    await pipeline(
-      createReadStream(inFile),
-      createBrotliDecompress(),
-      tar.extract(outDir)
-    )
+    await pipeline(createReadStream(inFile), createBrotliDecompress(), tar.extract(outDir))
   } catch (error) {
     throw new VError(error, `Failed to extract ${inFile}`)
   }

package/src/parts/ExtractZip/ExtractZip.js

@@ -1,6 +1,6 @@
 import { mkdir } from 'node:fs/promises'
 import extract from 'extract-zip'
-import VError from 'verror'
+import { VError } from '../VError/VError.js'
 
 export const extractZip = async ({ inFile, outDir }) => {
   try {

package/src/parts/{Error → FileNotFoundError}/FileNotFoundError.js

@@ -1,9 +1,16 @@
-import VError from 'verror'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import { VError } from '../VError/VError.js'
+
+const getDisplayPath = (path) => {
+  if (path === '') {
+    return '<empty string>'
+  }
+  return path
+}
 
 export class FileNotFoundError extends VError {
   constructor(path) {
-    super(`File not found '${path}'`)
+    super(`File not found: '${getDisplayPath(path)}'`)
     this.name = 'FileNotFoundError'
     this.code = ErrorCodes.ENOENT
   }

package/src/parts/FileSystem/FileSystem.js

@@ -1,14 +1,14 @@
 // TODO lazyload chokidar and trash (but doesn't work currently because of bug with jest)
 import * as fs from 'node:fs/promises'
 import * as os from 'node:os'
-import VError from 'verror'
-import * as DirentType from '../DirentType/DirentType.js'
-import { FileNotFoundError } from '../Error/FileNotFoundError.js'
+import * as EncodingType from '../EncodingType/EncodingType.js'
+import { FileNotFoundError } from '../FileNotFoundError/FileNotFoundError.js'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
+import * as GetDirentType from '../GetDirentType/GetDirentType.js'
 import * as Path from '../Path/Path.js'
 import * as Platform from '../Platform/Platform.js'
 import * as Trash from '../Trash/Trash.js'
-import * as EncodingType from '../EncodingType/EncodingType.js'
+import { VError } from '../VError/VError.js'
 
 export const state = {
   watcherMap: Object.create(null),
@@ -132,39 +132,13 @@ export const exists = async (path) => {
   }
 }
 
-/**
- * @param {import('fs').Dirent|import('fs').StatsBase} dirent
- */
-const getType = (dirent) => {
-  if (dirent.isFile()) {
-    return DirentType.File
-  }
-  if (dirent.isDirectory()) {
-    return DirentType.Directory
-  }
-  if (dirent.isSymbolicLink()) {
-    return DirentType.Symlink
-  }
-  if (dirent.isSocket()) {
-    return DirentType.Socket
-  }
-  if (dirent.isBlockDevice()) {
-    return DirentType.BlockDevice
-  }
-  if (dirent.isCharacterDevice()) {
-    return DirentType.CharacterDevice
-  }
-  console.log({ dirent })
-  return DirentType.Unknown
-}
-
 /**
  * @param {import('fs').Dirent} dirent
  */
 const toPrettyDirent = (dirent) => {
   return {
     name: dirent.name,
-    type: getType(dirent),
+    type: GetDirentType.getDirentType(dirent),
   }
 }
 
@@ -264,7 +238,7 @@ export const getRealPath = async (path) => {
 // TODO handle error
 export const stat = async (path) => {
   const stats = await fs.stat(path)
-  const type = getType(stats)
+  const type = GetDirentType.getDirentType(stats)
   return type
 }
 

package/src/parts/FirstNodeWorkerEventType/FirstNodeWorkerEventType.js

@@ -0,0 +1,5 @@
+export const Exit = 'exit'
+
+export const Error = 'error'
+
+export const Message = 'message'

package/src/parts/GetDirentType/GetDirentType.js

@@ -0,0 +1,27 @@
+import * as DirentType from '../DirentType/DirentType.js'
+
+/**
+ * @param {import('fs').Dirent|import('fs').StatsBase} dirent
+ */
+export const getDirentType = (dirent) => {
+  if (dirent.isFile()) {
+    return DirentType.File
+  }
+  if (dirent.isDirectory()) {
+    return DirentType.Directory
+  }
+  if (dirent.isSymbolicLink()) {
+    return DirentType.Symlink
+  }
+  if (dirent.isSocket()) {
+    return DirentType.Socket
+  }
+  if (dirent.isBlockDevice()) {
+    return DirentType.BlockDevice
+  }
+  if (dirent.isCharacterDevice()) {
+    return DirentType.CharacterDevice
+  }
+  console.log({ dirent })
+  return DirentType.Unknown
+}

package/src/parts/GetFirstNodeChildProcessEvent/GetFirstNodeChildProcessEvent.js

@@ -0,0 +1,39 @@
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+
+export const getFirstNodeChildProcessEvent = async (childProcess) => {
+  const { type, event, stdout, stderr } = await new Promise((resolve, reject) => {
+    let stderr = ''
+    let stdout = ''
+    const cleanup = () => {
+      childProcess.stderr.off('data', handleStdErrData)
+      childProcess.stdout.off('data', handleStdoutData)
+      childProcess.off('message', handleMessage)
+      childProcess.off('exit', handleExit)
+      childProcess.off('error', handleError)
+    }
+    const handleStdErrData = (data) => {
+      stderr += data
+    }
+    const handleStdoutData = (data) => {
+      stdout += data
+    }
+    const handleMessage = (event) => {
+      cleanup()
+      resolve({ type: FirstNodeWorkerEventType.Message, event, stdout, stderr })
+    }
+    const handleExit = (event) => {
+      cleanup()
+      resolve({ type: FirstNodeWorkerEventType.Exit, event, stdout, stderr })
+    }
+    const handleError = (event) => {
+      cleanup()
+      resolve({ type: FirstNodeWorkerEventType.Error, event, stdout, stderr })
+    }
+    childProcess.stderr.on('data', handleStdErrData)
+    childProcess.stdout.on('data', handleStdoutData)
+    childProcess.on('message', handleMessage)
+    childProcess.on('exit', handleExit)
+    childProcess.on('error', handleError)
+  })
+  return { type, event, stdout, stderr }
+}

package/src/parts/GetFirstNodeWorkerEvent/GetFirstNodeWorkerEvent.js

@@ -0,0 +1,21 @@
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+
+export const getFirstNodeWorkerEvent = async (worker) => {
+  const { type, event } = await new Promise((resolve, reject) => {
+    const cleanup = () => {
+      worker.off('exit', handleExit)
+      worker.off('error', handleError)
+    }
+    const handleExit = (event) => {
+      cleanup()
+      resolve({ type: FirstNodeWorkerEventType.Exit, event })
+    }
+    const handleError = (event) => {
+      cleanup()
+      resolve({ type: FirstNodeWorkerEventType.Error, event })
+    }
+    worker.on('exit', handleExit)
+    worker.on('error', handleError)
+  })
+  return { type, event }
+}

package/src/parts/GetNewLineIndex/GetNewLineIndex.js

@@ -0,0 +1,9 @@
+/**
+ *
+ * @param {string} string
+ * @param {number|undefined} startIndex
+ * @returns
+ */
+export const getNewLineIndex = (string, startIndex = undefined) => {
+  return string.indexOf('\n', startIndex)
+}

package/src/parts/GetResponse/GetResponse.js

@@ -1,24 +1,31 @@
 import * as Command from '../Command/Command.js'
+import { CommandNotFoundError } from '../CommandNotFoundError/CommandNotFoundError.js'
 import * as ErrorCodes from '../ErrorCodes/ErrorCodes.js'
 import * as JsonRpcErrorCode from '../JsonRpcErrorCode/JsonRpcErrorCode.js'
 import * as JsonRpcVersion from '../JsonRpcVersion/JsonRpcVersion.js'
 import * as PrettyError from '../PrettyError/PrettyError.js'
 import * as PrintPrettyError from '../PrintPrettyError/PrintPrettyError.js'
-import { requiresSocket } from '../RequiresSocket/RequiresSocket.js'
+import * as RequiresSocket from '../RequiresSocket/RequiresSocket.js'
+
+const shouldLogError = (error) => {
+  if (error && error.code === ErrorCodes.ENOENT) {
+    return false
+  }
+  return true
+}
 
 export const getResponse = async (message, handle) => {
   try {
-    const result = requiresSocket(message.method)
+    const result = RequiresSocket.requiresSocket(message.method)
       ? await Command.execute(message.method, handle, ...message.params)
       : await Command.execute(message.method, ...message.params)
-
     return {
       jsonrpc: JsonRpcVersion.Two,
       id: message.id,
       result: result ?? null,
     }
   } catch (error) {
-    if (error && error instanceof Error && error.message && error.message.startsWith('method not found')) {
+    if (error && error instanceof CommandNotFoundError) {
       return {
         jsonrpc: JsonRpcVersion.Two,
         id: message.id,
@@ -29,14 +36,16 @@ export const getResponse = async (message, handle) => {
         },
       }
     }
-    // @ts-ignore
-    if (error && error instanceof Error && error.code === ErrorCodes.ENOENT) {
+    if (!shouldLogError(error)) {
       return {
         jsonrpc: JsonRpcVersion.Two,
         id: message.id,
         error: {
           code: JsonRpcErrorCode.Custom,
           message: `${error}`,
+          data: {
+            code: error.code,
+          },
         },
       }
     }
@@ -51,6 +60,7 @@ export const getResponse = async (message, handle) => {
         data: {
           stack: prettyError.stack,
           codeFrame: prettyError.codeFrame,
+          type: prettyError.type,
         },
       },
     }

package/src/parts/GetTextSearchRipGrepArgs/GetTextSearchRipGrepArgs.js

@@ -0,0 +1,14 @@
+export const getRipGrepArgs = ({ threads, isCaseSensitive, searchString }) => {
+  const ripGrepArgs = ['--smart-case', '--stats', '--json']
+  ripGrepArgs.push('--threads', `${threads}`)
+  if (isCaseSensitive) {
+    ripGrepArgs.push('--case-sensitive')
+  } else {
+    ripGrepArgs.push('--ignore-case')
+  }
+  ripGrepArgs.push('--fixed-strings')
+  ripGrepArgs.push('--')
+  ripGrepArgs.push(searchString)
+  ripGrepArgs.push('.')
+  return ripGrepArgs
+}

package/src/parts/InstallExtension/InstallExtension.ipc.js

@@ -0,0 +1,6 @@
+import * as InstallExtension from './InstallExtension.js'
+
+// prettier-ignore
+export const Commands = {
+  'InstallExtension.installExtension': InstallExtension.installExtension,
+}

package/src/parts/InstallExtension/InstallExtension.js

@@ -0,0 +1,33 @@
+import * as Debug from '../Debug/Debug.js'
+import * as Download from '../Download/Download.js'
+import * as Extract from '../Extract/Extract.js'
+import * as Path from '../Path/Path.js'
+import * as Platform from '../Platform/Platform.js'
+import * as Queue from '../Queue/Queue.js'
+import { VError } from '../VError/VError.js'
+
+export const installExtension = async (id) => {
+  // TODO this should be a stateless function, renderer-worker should have info on marketplace url
+  // TODO use command.execute
+  try {
+    const marketplaceUrl = Platform.getMarketplaceUrl()
+    Debug.debug(`ExtensionManagement#install ${id}`)
+    const cachedExtensionsPath = Platform.getCachedExtensionsPath()
+    const extensionsPath = Platform.getExtensionsPath()
+    // TODO maybe a queue is over engineering here
+    await Queue.add('download', async () => {
+      Debug.debug(`ExtensionManagement#download ${id}`)
+      // TODO use command.execute
+      await Download.download(`${marketplaceUrl}/download/${id}`, Path.join(cachedExtensionsPath, `${id}.tar.br`))
+      Debug.debug(`ExtensionManagement#extract ${id}`)
+      await Extract.extractTarBr(Path.join(cachedExtensionsPath, `${id}.tar.br`), Path.join(extensionsPath, id))
+    })
+    // TODO should this be here? (probably not)
+    // await ExtensionHost.enableExtension({
+    //   id,
+    //   type: 'marketplace',
+    // })
+  } catch (error) {
+    throw new VError(error, `Failed to install extension "${id}"`)
+  }
+}

package/src/parts/IpcParent/IpcParent.js

@@ -0,0 +1,9 @@
+import * as IpcParentModule from '../IpcParentModule/IpcParentModule.js'
+
+export const create = async ({ method, ...options }) => {
+  const module = await IpcParentModule.getModule(method)
+  // @ts-ignore
+  const rawIpc = await module.create(options)
+  const ipc = module.wrap(rawIpc)
+  return ipc
+}

package/src/parts/IpcParentModule/IpcParentModule.js

@@ -0,0 +1,12 @@
+import * as IpcParentType from '../IpcParentType/IpcParentType.js'
+
+export const getModule = (method) => {
+  switch (method) {
+    case IpcParentType.NodeWorker:
+      return import('../IpcParentWithNodeWorker/IpcParentWithNodeWorker.js')
+    case IpcParentType.NodeForkedProcess:
+      return import('../IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js')
+    default:
+      throw new Error('unexpected ipc type')
+  }
+}

package/src/parts/IpcParentType/IpcParentType.js

@@ -0,0 +1,2 @@
+export const NodeWorker = 1
+export const NodeForkedProcess = 2

package/src/parts/IpcParentWithNodeForkedProcess/IpcParentWithNodeForkedProcess.js

@@ -0,0 +1,49 @@
+import * as Assert from '../Assert/Assert.js'
+import { fork } from 'node:child_process'
+import * as GetFirstNodeChildProcessEvent from '../GetFirstNodeChildProcessEvent/GetFirstNodeChildProcessEvent.js'
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+import { ChildProcessError } from '../ChildProcessError/ChildProcessError.js'
+import { VError } from '../VError/VError.js'
+
+export const create = async ({ path, argv = [], env, execArgv = [], stdio = 'inherit', name = 'child process' }) => {
+  try {
+    Assert.string(path)
+    const childProcess = fork(path, argv, {
+      env,
+      execArgv,
+      stdio: 'pipe',
+    })
+    const { type, event, stdout, stderr } = await GetFirstNodeChildProcessEvent.getFirstNodeChildProcessEvent(childProcess)
+    if (type === FirstNodeWorkerEventType.Exit) {
+      throw new ChildProcessError(stderr)
+    }
+    if (type === FirstNodeWorkerEventType.Error) {
+      throw new Error(`child process had an error ${event}`)
+    }
+    if (stdio === 'inherit' && childProcess.stdout && childProcess.stderr) {
+      childProcess.stdout.pipe(process.stdout)
+      childProcess.stderr.pipe(process.stderr)
+    }
+    return childProcess
+  } catch (error) {
+    throw new VError(error, `Failed to launch ${name}`)
+  }
+}
+
+export const wrap = (childProcess) => {
+  return {
+    childProcess,
+    on(event, listener) {
+      this.childProcess.on(event, listener)
+    },
+    send(message) {
+      this.childProcess.send(message)
+    },
+    sendAndTransfer(message, transfer) {
+      throw new Error('transfer is not supported')
+    },
+    dispose() {
+      this.childProcess.kill()
+    },
+  }
+}

package/src/parts/IpcParentWithNodeWorker/IpcParentWithNodeWorker.js

@@ -0,0 +1,36 @@
+import { Worker } from 'node:worker_threads'
+import * as Assert from '../Assert/Assert.js'
+import * as FirstNodeWorkerEventType from '../FirstNodeWorkerEventType/FirstNodeWorkerEventType.js'
+import * as GetFirstNodeWorkerEvent from '../GetFirstNodeWorkerEvent/GetFirstNodeWorkerEvent.js'
+
+export const create = async ({ path, argv, env, execArgv }) => {
+  Assert.string(path)
+  const worker = new Worker(path, {
+    argv,
+    env,
+    execArgv,
+  })
+  const { type, event } = await GetFirstNodeWorkerEvent.getFirstNodeWorkerEvent(worker)
+  if (type === FirstNodeWorkerEventType.Error) {
+    throw event
+  }
+  return worker
+}
+
+export const wrap = (worker) => {
+  return {
+    worker,
+    on(event, listener) {
+      this.worker.on(event, listener)
+    },
+    send(message) {
+      this.worker.postMessage(message)
+    },
+    sendAndTransfer(message, transfer) {
+      this.worker.postMessage(message, transfer)
+    },
+    dispose() {
+      this.worker.terminate()
+    },
+  }
+}