@lvce-editor/shared-process 0.108.13 → 0.108.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.108.13",
+  "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', '241d72e', '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/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/Platform/Platform.js

@@ -61,11 +61,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.108.13'
+export const version = '0.108.14'
 
-export const commit = '241d72e'
+export const commit = '0efdeb9'
 
-export const date = '2026-08-24T08:36:37.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', '241d72e', '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
 }