@lvce-editor/shared-process 0.108.12 → 0.108.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.108.12",
+  "version": "0.108.14",
   "main": "index.js",
   "type": "module",
   "keywords": [

package/src/parts/BuiltinExtensionsPath/BuiltinExtensionsPath.js

@@ -3,6 +3,6 @@ import { fileURLToPath } from 'url'
 
 export const getBuiltinExtensionsPath = () => {
   const staticServerPath = fileURLToPath(import.meta.resolve('@lvce-editor/static-server'))
-  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', 'bf15721', 'extensions')
+  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', '0efdeb9', 'extensions')
   return builtinExtensionsPath
 }

package/src/parts/ExtensionManifests/ExtensionManifestsFromLinkedExtension.js

@@ -12,6 +12,7 @@ export const getExtensionManifests = async (path) => {
   return [
     {
       ...manifest,
+      linked: true,
       symlink: path,
     },
   ]

package/src/parts/HandleElectronReady/HandleElectronReady.js

@@ -12,6 +12,12 @@ export const handleElectronReady = async (parsedArgs, workingDirectory) => {
   Assert.string(workingDirectory)
   try {
     await TransientLinkedExtensions.validate()
+  } catch (error) {
+    Logger.error(error)
+    Process.exit(ExitCode.Error)
+    return
+  }
+  try {
     const preferences = await Preferences.getAllSafe()
     const preloadUrl = PreloadUrl.getPreloadUrl()
     await AppWindow.createAppWindow({ parsedArgs, preferences, preloadUrl, workingDirectory })

package/src/parts/HandleRequest/HandleRequest.ipc.js

@@ -1,7 +1,7 @@
-import * as HandleRequestTest from './HandleRequest.js'
+import * as HandleRequest from './HandleRequest.js'
 
 export const name = 'HandleRequest'
 
 export const Commands = {
-  handleRequest: HandleRequestTest.handleRequest,
+  handleRequest: HandleRequest.handleRequest,
 }

package/src/parts/HandleRequest/HandleRequest.js

@@ -1,22 +1,28 @@
 import { join } from 'path'
 import * as Assert from '../Assert/Assert.js'
 import * as GetElectronFileResponse from '../GetElectronFileResponse/GetElectronFileResponse.js'
-import * as HandleRequestTest from '../HandleRequestTest/HandleRequestTest.js'
-import * as HttpServerResponse from '../HttpServerResponse/HttpServerResponse.js'
+import * as GetTestRequestResponse from '../GetTestRequestResponse/GetTestRequestResponse.js'
+import * as HttpStatusCode from '../HttpStatusCode/HttpStatusCode.js'
 import * as StaticPath from '../StaticPath/StaticPath.js'
 
-export const handleRequest = async (socket, request) => {
-  if (!request) {
-    // socket might have been closed during transfer
-    return
+const toHttpResponse = (request, response) => {
+  const { body, init } = response
+  return {
+    body,
+    hasBody: request.method !== 'HEAD' && init.status !== HttpStatusCode.NotModifed,
+    headers: init.headers || {},
+    status: init.status,
   }
-  Assert.object(socket)
+}
+
+export const handleRequest = async (request) => {
   Assert.object(request)
   if (request.url.startsWith('/tests')) {
     const staticPath = StaticPath.getStaticPath()
     const indexHtmlPath = join(staticPath, 'index.html')
-    return HandleRequestTest.handleRequestTest(socket, request, indexHtmlPath)
+    const response = await GetTestRequestResponse.getTestRequestResponse(request, indexHtmlPath)
+    return toHttpResponse(request, response)
   }
-  const fileResponse = await GetElectronFileResponse.getElectronFileResponse(request.url, request)
-  HttpServerResponse.send(request, socket, fileResponse)
+  const response = await GetElectronFileResponse.getElectronFileResponse(request.url, request)
+  return toHttpResponse(request, response)
 }

package/src/parts/LinkedWorkerManifest/LinkedWorkerManifest.js

@@ -0,0 +1,42 @@
+import workers from '../Workers/Workers.json' with { type: 'json' }
+import * as FileSystem from '../FileSystem/FileSystem.js'
+import * as Path from '../Path/Path.js'
+
+                  
+                              
+                              
+ 
+
+                                         
+                       
+                              
+ 
+
+const getPackageName = (worker) => {
+  const marker = '/node_modules/'
+  const index = worker.defaultPath.indexOf(marker)
+  if (index === -1) {
+    return ''
+  }
+  const packagePath = worker.defaultPath.slice(index + marker.length)
+  const parts = packagePath.split('/')
+  return packagePath.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]
+}
+
+const workersByPackageName = new Map((workers).map((worker) => [getPackageName(worker), worker]))
+
+export const getLinkedWorkerPreference = async (path) => {
+  try {
+    const packageJson = await FileSystem.readJson(Path.join(path, 'package.json'))
+    const worker = workersByPackageName.get(packageJson?.name)
+    if (!worker || typeof packageJson.main !== 'string') {
+      return undefined
+    }
+    return {
+      path: Path.join(path, packageJson.main),
+      settingName: worker.settingName,
+    }
+  } catch {
+    return undefined
+  }
+}

package/src/parts/LinkedWorkerPreferences/LinkedWorkerPreferences.js

@@ -1,43 +1,14 @@
-import workers from '../Workers/Workers.json' with { type: 'json' }
-import * as FileSystem from '../FileSystem/FileSystem.js'
-import * as Path from '../Path/Path.js'
+import * as LinkedWorkerManifest from '../LinkedWorkerManifest/LinkedWorkerManifest.js'
 import * as TransientLinkedExtensions from '../TransientLinkedExtensions/TransientLinkedExtensions.js'
 
-                  
-                              
-                              
- 
-
-const getPackageName = (worker) => {
-  const marker = '/node_modules/'
-  const index = worker.defaultPath.indexOf(marker)
-  if (index === -1) {
-    return ''
-  }
-  const packagePath = worker.defaultPath.slice(index + marker.length)
-  const parts = packagePath.split('/')
-  return packagePath.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0]
-}
-
-const workersByPackageName = new Map((workers).map((worker) => [getPackageName(worker), worker]))
-
-const getPackageJson = async (path) => {
-  try {
-    return await FileSystem.readJson(Path.join(path, 'package.json'))
-  } catch {
-    return undefined
-  }
-}
-
 export const getLinkedWorkerPreferences = async () => {
   const preferences                         = {}
   for (const link of TransientLinkedExtensions.getLinkedExtensions()) {
-    const packageJson = await getPackageJson(link.resolvedPath)
-    const worker = workersByPackageName.get(packageJson?.name)
-    if (!worker || typeof packageJson.main !== 'string') {
+    const preference = await LinkedWorkerManifest.getLinkedWorkerPreference(link.resolvedPath)
+    if (!preference) {
       continue
     }
-    preferences[worker.settingName] = Path.join(link.resolvedPath, packageJson.main)
+    preferences[preference.settingName] = preference.path
   }
   return preferences
 }

package/src/parts/Module/Module.js

@@ -98,12 +98,8 @@ export const load = (moduleId) => {
       return import('../HandleMessagePortForTerminalProcess/HandleMessagePortForTerminalProcess.ipc.js')
     case ModuleId.HandleNodeMessagePort:
       return import('../HandleNodeMessagePort/HandleNodeMessagePort.ipc.js')
-    case ModuleId.HandleRemoteRequest:
-      return import('../HandleRemoteRequest/HandleRemoteRequest.ipc.js')
     case ModuleId.HandleRequest:
       return import('../HandleRequest/HandleRequest.ipc.js')
-    case ModuleId.HandleRequestTest:
-      return import('../HandleRequestTest/HandleRequestTest.ipc.js')
     case ModuleId.HandleWebSocket:
       return import('../HandleWebSocket/HandleWebSocket.ipc.js')
     case ModuleId.HandleWindowAllClosed:

package/src/parts/ModuleId/ModuleId.js

@@ -59,8 +59,6 @@ export const HandleWindowAllClosed = 60
 export const HandleMessagePortForTerminalProcess = 61
 export const TemporaryMessagePort = 62
 export const GetElectronFileResponse = 63
-export const HandleRemoteRequest = 64
-export const HandleRequestTest = 69
 export const ContentSecurityPolicy = 70
 export const HandleMessagePortForEmbedsProcess = 72
 export const HandleMessagePortForProcessExplorer = 73

package/src/parts/ModuleMap/ModuleMap.js

@@ -193,12 +193,8 @@ export const getModuleId = (commandId) => {
       return ModuleId.HandleMessagePortForTerminalProcess
     case 'HandleNodeMessagePort.handleNodeMessagePort':
       return ModuleId.HandleNodeMessagePort
-    case 'HandleRemoteRequest.handleRemoteRequest':
-      return ModuleId.HandleRemoteRequest
     case 'HandleRequest.handleRequest':
       return ModuleId.HandleRequest
-    case 'HandleRequestTest.handleRequestTest':
-      return ModuleId.HandleRequestTest
     case 'HandleWebSocket.handleWebSocket':
       return ModuleId.HandleWebSocket
     case 'HandleWindowAllClosed.handleWindowAllClosed':

package/src/parts/Platform/Platform.js

@@ -61,11 +61,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.108.12'
+export const version = '0.108.14'
 
-export const commit = 'bf15721'
+export const commit = '0efdeb9'
 
-export const date = '2026-08-23T23:24:00.000Z'
+export const date = '2026-08-24T11:51:18.000Z'
 
 export const getVersion = () => {
   return version

package/src/parts/PreloadUrl/PreloadUrl.js

@@ -2,5 +2,5 @@ import { join } from 'node:path'
 import * as Root from '../Root/Root.js'
 
 export const getPreloadUrl = () => {
-  return join(Root.root, 'static', 'bf15721', 'packages', 'preload', 'dist', 'index.js')
+  return join(Root.root, 'static', '0efdeb9', 'packages', 'preload', 'dist', 'index.js')
 }

package/src/parts/TransientLinkedExtensions/TransientLinkedExtensions.js

@@ -1,5 +1,8 @@
 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 LinkedWorkerManifest from '../LinkedWorkerManifest/LinkedWorkerManifest.js'
 import * as Path from '../Path/Path.js'
 import * as Process from '../Process/Process.js'
 
@@ -58,6 +61,14 @@ const createPathNotFoundError = (link) => {
   return error
 }
 
+const createExtensionNotFoundError = (link) => {
+  const message = link.path === link.resolvedPath ? link.path : `${link.path} (resolved to ${link.resolvedPath})`
+  const error = new Error(`Failed to start: ${link.source} path does not contain an extension: ${message}`)
+  // @ts-ignore
+  error.code = ErrorCodes.E_MANIFEST_NOT_FOUND
+  return error
+}
+
 export const validate = async () => {
   const links = getLinkedExtensions()
   for (const link of links) {
@@ -67,6 +78,10 @@ export const validate = async () => {
     if (!(await FileSystem.exists(link.resolvedPath))) {
       throw createPathNotFoundError(link)
     }
+    const manifest = await ExtensionManifest.get(link.resolvedPath)
+    if (manifest.status !== ExtensionManifestStatus.Resolved && !(await LinkedWorkerManifest.getLinkedWorkerPreference(link.resolvedPath))) {
+      throw createExtensionNotFoundError(link)
+    }
   }
   return links
 }

package/src/parts/HandleRemoteRequest/HandleRemoteRequest.ipc.js

@@ -1,7 +0,0 @@
-import * as HandleRemoteRequest from './HandleRemoteRequest.js'
-
-export const name = 'HandleRemoteRequest'
-
-export const Commands = {
-  handleRemoteRequest: HandleRemoteRequest.handleRemoteRequest,
-}

package/src/parts/HandleRemoteRequest/HandleRemoteRequest.js

@@ -1,12 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as GetElectronFileResponse from '../GetElectronFileResponse/GetElectronFileResponse.js'
-import * as HandleSocketError from '../HandleSocketError/HandleSocketError.js'
-import * as HttpServerResponse from '../HttpServerResponse/HttpServerResponse.js'
-
-export const handleRemoteRequest = async (socket, request) => {
-  Assert.object(socket)
-  Assert.object(request)
-  socket.on('error', HandleSocketError.handleSocketError)
-  const result = await GetElectronFileResponse.getElectronFileResponse(request.url, request)
-  HttpServerResponse.send(request, socket, result)
-}

package/src/parts/HandleRequestTest/HandleRequestTest.ipc.js

@@ -1,7 +0,0 @@
-import * as HandleRequestTest from './HandleRequestTest.js'
-
-export const name = 'HandleRequestTest'
-
-export const Commands = {
-  handleRequestTest: HandleRequestTest.handleRequestTest,
-}

package/src/parts/HandleRequestTest/HandleRequestTest.js

@@ -1,11 +0,0 @@
-import * as Assert from '../Assert/Assert.js'
-import * as GetTestRequestResponse from '../GetTestRequestResponse/GetTestRequestResponse.js'
-import * as HttpServerResponse from '../HttpServerResponse/HttpServerResponse.js'
-
-export const handleRequestTest = async (socket, request, indexHtmlPath) => {
-  Assert.object(socket)
-  Assert.object(request)
-  Assert.string(indexHtmlPath)
-  const result = await GetTestRequestResponse.getTestRequestResponse(request, indexHtmlPath)
-  await HttpServerResponse.send(request, socket, result)
-}

package/src/parts/HttpServerResponse/HttpServerResponse.js

@@ -1,24 +0,0 @@
-import { ServerResponse } from 'node:http'
-import * as Assert from '../Assert/Assert.js'
-import * as SetHeaders from '../SetHeaders/SetHeaders.js'
-
-const handleResponseError = (error) => {
-  console.error(`[shared-process] Failed to send response ${error}`)
-}
-
-export const send = async (request, socket, result) => {
-  Assert.object(request)
-  Assert.object(socket)
-  Assert.object(result)
-  const response = new ServerResponse(request)
-  response.assignSocket(socket)
-  response.statusCode = result.init.status
-  SetHeaders.setHeaders(response, {
-    ...result.init.headers,
-    Connection: 'close',
-  })
-
-  // TODO use promises if possible
-  socket.on('error', handleResponseError)
-  response.end(result.body)
-}

package/src/parts/SetHeaders/SetHeaders.js

@@ -1,5 +0,0 @@
-export const setHeaders = (response, headers) => {
-  for (const [key, value] of Object.entries(headers)) {
-    response.setHeader(key, value)
-  }
-}