@lvce-editor/shared-process 0.125.14 → 0.125.16

package/index.js

@@ -22,10 +22,10 @@ const toAbsoluteExtensionPath = (root, extensionPath) => {
 }
 
 /**
- * @param {{extensionPath?: string, extensionPaths?: string[] | string, onLoadCommands?: readonly unknown[], cspOptions?: {allowExternalConnections?: boolean}, testPath?: string, root?: string}} [options]
+ * @param {{bundleMode?: boolean, extensionPath?: string, extensionPaths?: string[] | string, onLoadCommands?: readonly unknown[], cspOptions?: {allowExternalConnections?: boolean}, testPath?: string, root?: string}} [options]
  */
 export const exportStatic = async (options      = {}) => {
-  const { cspOptions, extensionPath, extensionPaths = [], onLoadCommands = [], root = '', testPath = '' } = options
+  const { bundleMode = false, cspOptions, extensionPath, extensionPaths = [], onLoadCommands = [], root = '', testPath = '' } = options
   if (!root) {
     throw new Error(`root argument is required`)
   }
@@ -36,6 +36,7 @@ export const exportStatic = async (options      = {}) => {
   const absoluteExtensionPaths = extensionPathList.map((extensionPath) => toAbsoluteExtensionPath(root, extensionPath))
   const pathPrefix = process.env.PATH_PREFIX || ''
   return fn.exportStatic({
+    bundleMode,
     cspOptions,
     extensionPath: absoluteExtensionPath,
     extensionPaths: absoluteExtensionPaths,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.125.14",
+  "version": "0.125.16",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -27,6 +27,7 @@
     "@lvce-editor/rpc-registry": "9.66.2",
     "@lvce-editor/verror": "1.7.0",
     "is-object": "^1.0.2",
+    "rollup": "^4.63.6",
     "xdg-basedir": "^5.1.0"
   },
   "optionalDependencies": {

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', '3f6689e', 'extensions')
+  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', 'b9e03b1', 'extensions')
   return builtinExtensionsPath
 }

package/src/parts/BundleStaticWorkers/BundleStaticWorkers.js

@@ -0,0 +1,88 @@
+import { readFile, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { rollup } from 'rollup'
+import { createBundledWorkerConstructor } from '../BundledWorkerRuntime/BundledWorkerRuntime.js'
+
+const mainCall = /^(?:await\s+)?main\(\);?$/m
+const awaitedListen = /^await listen\(\);?$/m
+
+const workerIds = ['editor', 'extensionManagementWorker', 'iconThemeWorker', 'cacheWorker', 'explorer']
+const bindings = [
+  'globalThis',
+  'self',
+  'Worker',
+  'WorkerGlobalScope',
+  'MessageChannel',
+  'location',
+  'name',
+  'postMessage',
+  'addEventListener',
+  'removeEventListener',
+  'close',
+  'setTimeout',
+  'clearTimeout',
+  'setInterval',
+  'clearInterval',
+  'requestAnimationFrame',
+  'cancelAnimationFrame',
+  'fetch',
+  'window',
+  'document',
+]
+
+export const createWorkerFactory = async (input, publicPath) => {
+  const bundle = await rollup({
+    input,
+    plugins: [
+      {
+        name: 'bundled-worker-scope',
+        resolveImportMeta(property)         {
+          if (property === 'url') return 'globalThis.location.href'
+          throw new Error(`Unsupported worker import.meta property: ${property}`)
+        },
+        transform(code, id)                {
+          if (id.replaceAll('\\', '/') === input.replaceAll('\\', '/')) {
+            // Capture rejected startup rather than leaving the parent's ready wait hanging.
+            if (awaitedListen.test(code)) return null
+            if (!mainCall.test(code)) throw new Error(`Missing worker startup call: ${input}`)
+            return code.replace(mainCall, 'const bundledStartupPromise = main();') + '\nawait bundledStartupPromise;\n'
+          }
+          return null
+        },
+      },
+    ],
+    preserveEntrySignatures: false,
+  })
+  try {
+    const { output } = await bundle.generate({ format: 'es', inlineDynamicImports: true })
+    const chunk = output[0]
+    if (chunk.type !== 'chunk' || chunk.imports.length || chunk.exports.length) throw new Error(`Worker must be self-contained: ${input}`)
+    return `[new URL(${JSON.stringify(publicPath)}, location.origin).href]: async (scope) => {\nconst { ${bindings.join(', ')} } = scope;\nawait (async () => {\n${chunk.code}\n})();\n}`
+  } finally {
+    await bundle.close()
+  }
+}
+
+export const bundleStaticWorkers = async ({ commitHash, pathPrefix, root, workers }     ) => {
+  const paths = [
+    '/packages/renderer-worker/dist/rendererWorkerMain.js',
+    ...workerIds.map((id) => {
+      const worker = workers.find((item) => item.id === id)
+      if (!worker) throw new Error(`Missing bundled worker: ${id}`)
+      return worker.productionPath
+    }),
+  ]
+  const factories           = []
+  for (const path of paths) {
+    const publicPath = `${pathPrefix}/${commitHash}${path}`
+    factories.push(await createWorkerFactory(join(root, 'dist', commitHash, path), publicPath))
+  }
+  const rendererDirectory = join(root, 'dist', commitHash, 'packages/renderer-process/dist')
+  const renderer = await readFile(join(rendererDirectory, 'rendererProcessMain.js'), 'utf8')
+  const runtime = `const Worker = (${createBundledWorkerConstructor.toString()})({${factories.join(',\n')}}, globalThis);\n`
+  await writeFile(join(rendererDirectory, 'renderer-process.bundled.js'), runtime + renderer)
+  const htmlPath = join(root, 'dist', 'index.html')
+  const html = await readFile(htmlPath, 'utf8')
+  if (!html.includes('/rendererProcessMain.js')) throw new Error('Missing renderer script in static export')
+  await writeFile(htmlPath, html.replaceAll('/rendererProcessMain.js', '/renderer-process.bundled.js'))
+}

package/src/parts/BundledWorkerRuntime/BundledWorkerRuntime.js

@@ -0,0 +1,183 @@
+// This function is serialized into the static export. Keep it self-contained.
+export const createBundledWorkerConstructor = (factories, host) => {
+  const NativeWorker = host.Worker
+  class BundledWorker extends host.EventTarget {
+    static [Symbol.hasInstance](value)          {
+      return value instanceof NativeWorker || Object.prototype.isPrototypeOf.call(this.prototype, value)
+    }
+    onmessage      = null
+    onmessageerror      = null
+    onerror      = null
+    stopped = false
+    ports = new Set     ()
+    timers = new Map          ()
+    frames = new Map          ()
+    children = new Set     ()
+    abortController = new host.AbortController()
+    endpoint     
+
+    constructor(url, options      = {}) {
+      super()
+      const resolved = new URL(url, host.location.href)
+      const factoryUrl = new URL(resolved)
+      factoryUrl.search = ''
+      factoryUrl.hash = ''
+      const factory = factories[resolved.href] || factories[factoryUrl.href]
+      if (!factory || options.type !== 'module') {
+        return new NativeWorker(url, options)
+      }
+      const channel = new host.MessageChannel()
+      this.endpoint = channel.port1
+      this.ports.add(channel.port1)
+      this.ports.add(channel.port2)
+      const dispatch = (event) => {
+        if (this.stopped) return
+        const copy = new host.MessageEvent(event.type, { data: event.data, ports: event.ports })
+        this.dispatchEvent(copy)
+        const listener = event.type === 'message' ? this.onmessage : this.onmessageerror
+        listener?.call(this, copy)
+      }
+      channel.port1.addEventListener('message', dispatch)
+      channel.port1.addEventListener('messageerror', dispatch)
+      channel.port1.start()
+      // The nested Worker/MessageChannel constructors have their own this.
+      // eslint-disable-next-line @typescript-eslint/no-this-alias
+      const owner = this
+      const schedule =
+        (start, stop, repeat, registry = owner.timers) =>
+        (callback, delay, ...args) => {
+          if (owner.stopped) return 0
+          const id = start((...callbackArgs) => {
+            if (!repeat) registry.delete(id)
+            if (!owner.stopped) callback(...callbackArgs, ...args)
+          }, delay)
+          registry.set(id, stop)
+          return id
+        }
+      const clear = (id) => {
+        owner.timers.get(id)?.(id)
+        owner.timers.delete(id)
+      }
+      const trackedPorts = new WeakSet     ()
+      const trackPort = (port) => {
+        if (owner.stopped) {
+          port.close()
+          return
+        }
+        if (trackedPorts.has(port)) return
+        trackedPorts.add(port)
+        owner.ports.add(port)
+        const close = port.close.bind(port)
+        const postMessage = port.postMessage.bind(port)
+        port.close = () => {
+          owner.ports.delete(port)
+          close()
+        }
+        port.postMessage = (message, options) => {
+          postMessage(message, options)
+          const transfer = Array.isArray(options) ? options : options?.transfer || []
+          for (const item of transfer) owner.ports.delete(item)
+        }
+        port.addEventListener('message', (event) => {
+          for (const transferred of event.ports) trackPort(transferred)
+        })
+      }
+      trackPort(channel.port2)
+      const scope      = {
+        addEventListener: channel.port2.addEventListener.bind(channel.port2),
+        cancelAnimationFrame: (id) => {
+          owner.frames.get(id)?.(id)
+          owner.frames.delete(id)
+        },
+        clearInterval: clear,
+        clearTimeout: clear,
+        close: () => owner.terminate(),
+        document: undefined,
+        fetch: (input, init) => {
+          const signal = init?.signal || input?.signal
+          return host.fetch(typeof input === 'string' ? new URL(input, resolved) : input, {
+            ...init,
+            signal: signal ? host.AbortSignal.any([signal, owner.abortController.signal]) : owner.abortController.signal,
+          })
+        },
+        location: resolved,
+        MessageChannel: class extends host.MessageChannel {
+          constructor() {
+            super()
+            trackPort(this.port1)
+            trackPort(this.port2)
+          }
+        },
+        name: options.name || '',
+        postMessage: channel.port2.postMessage.bind(channel.port2),
+        removeEventListener: channel.port2.removeEventListener.bind(channel.port2),
+        requestAnimationFrame: schedule(host.requestAnimationFrame.bind(host), host.cancelAnimationFrame.bind(host), false, owner.frames),
+        setInterval: schedule(host.setInterval.bind(host), host.clearInterval.bind(host), true),
+        setTimeout: schedule(host.setTimeout.bind(host), host.clearTimeout.bind(host), false),
+        window: undefined,
+        Worker: class extends BundledWorker {
+          constructor(childUrl, childOptions) {
+            super(new URL(childUrl, resolved), childOptions)
+            if (owner.stopped) this.terminate()
+            else owner.children.add(this)
+          }
+        },
+        WorkerGlobalScope: class WorkerGlobalScope {},
+      }
+      Object.defineProperty(scope, 'onmessage', {
+        get: () => channel.port2.onmessage,
+        set: (listener) => {
+          channel.port2.onmessage = listener
+        },
+      })
+      const global = new Proxy(scope, {
+        get(target, key)      {
+          if (key in target) return target[key]
+          return host[key]
+        },
+        has: (target, key) => key in target || key in host,
+      })
+      scope.globalThis = global
+      scope.self = global
+      channel.port2.start()
+      // Start after callers have installed readiness/error listeners.
+      queueMicrotask(() => {
+        if (owner.stopped) return
+        Promise.resolve()
+          .then(() => factory(global))
+          .catch((error) => {
+            if (owner.stopped) return
+            const event = new host.ErrorEvent('error', { error, filename: resolved.href, message: String(error) })
+            try {
+              owner.dispatchEvent(event)
+              owner.onerror?.call(owner, event)
+            } finally {
+              owner.terminate()
+            }
+          })
+      })
+    }
+
+    postMessage(message, transfer)       {
+      if (!this.stopped) this.endpoint.postMessage(message, transfer)
+    }
+
+    terminate()       {
+      if (this.stopped) return
+      this.stopped = true
+      this.abortController.abort()
+      for (const child of this.children) child.terminate()
+      for (const [id, cancel] of this.timers) cancel(id)
+      for (const [id, cancel] of this.frames) cancel(id)
+      for (const port of this.ports) port.close()
+      this.children.clear()
+      this.timers.clear()
+      this.frames.clear()
+      this.ports.clear()
+      this.onmessage = null
+      this.onmessageerror = null
+      this.onerror = null
+    }
+  }
+  return BundledWorker
+}

package/src/parts/ExportStatic/ExportStatic.js

@@ -756,9 +756,10 @@ const getExtensionPaths = (extensionPath, extensionPaths) => {
 
 /**
  *
- * @param {{root:string, pathPrefix:string, extensionPath:string, extensionPaths?:string[], onLoadCommands?:readonly unknown[], cspOptions?: {allowExternalConnections?: boolean}, testPath:string, useSimpleWebExtensionFile?:boolean, serverStaticPath?:string }} param0
+ * @param {{root:string, pathPrefix:string, extensionPath:string, extensionPaths?:string[], onLoadCommands?:readonly unknown[], cspOptions?: {allowExternalConnections?: boolean}, testPath:string, useSimpleWebExtensionFile?:boolean, serverStaticPath?:string, bundleMode?:boolean }} param0
  */
 export const exportStatic = async ({
+  bundleMode = false,
   cspOptions = {},
   extensionPath,
   extensionPaths,
@@ -814,6 +815,11 @@ export const exportStatic = async ({
   console.timeEnd('applyOverrides')
 
   await copyBuiltinWebExtensions({ commitHash, pathPrefix, root })
+
+  if (bundleMode) {
+    const BundleStaticWorkers = await import('../BundleStaticWorkers/BundleStaticWorkers.js')
+    await BundleStaticWorkers.bundleStaticWorkers({ commitHash, pathPrefix, root, workers })
+  }
   await updateExtensionsJson({ commitHash, extraExtensions: [], pathPrefix, root })
   await JsonFile.writeJson(Path.join(root, 'dist', commitHash, 'config', 'onLoadCommands.json'), onLoadCommands)
 

package/src/parts/Platform/Platform.js

@@ -56,11 +56,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.125.14'
+export const version = '0.125.16'
 
-export const commit = '3f6689e'
+export const commit = 'b9e03b1'
 
-export const date = '2026-10-23T21:25:45.000Z'
+export const date = '2026-10-24T21:14:34.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', '3f6689e', 'packages', 'preload', 'dist', 'index.js')
+  return join(Root.root, 'static', 'b9e03b1', 'packages', 'preload', 'dist', 'index.js')
 }