@lvce-editor/shared-process 0.99.15 → 0.99.18

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lvce-editor/shared-process",
-  "version": "0.99.15",
+  "version": "0.99.18",
   "main": "index.js",
   "type": "module",
   "keywords": [
@@ -18,13 +18,13 @@
   },
   "dependencies": {
     "@lvce-editor/assert": "1.9.0",
-    "@lvce-editor/extension-host-helper-process": "0.99.15",
+    "@lvce-editor/extension-host-helper-process": "0.99.18",
     "@lvce-editor/ipc": "16.10.0",
     "@lvce-editor/json-rpc": "8.6.0",
     "@lvce-editor/jsonc-parser": "1.5.0",
     "@lvce-editor/pretty-error": "2.0.0",
     "@lvce-editor/process-explorer": "3.14.0",
-    "@lvce-editor/rpc-registry": "9.47.0",
+    "@lvce-editor/rpc-registry": "9.48.0",
     "@lvce-editor/verror": "1.7.0",
     "is-object": "^1.0.2",
     "markdown-it": "^15.0.0",

package/src/parts/AddCustomPathsToIndexHtml/AddCustomPathsToIndexHtml.js

@@ -1,10 +1,3 @@
-export const addCustomPathsToIndexHtml = async (content, additionalConfig = {}) => {
-  if (Object.keys(additionalConfig).length === 0) {
+export const addCustomPathsToIndexHtml = async (content) => {
     return content
-  }
-  const stringifiedConfig = JSON.stringify(additionalConfig, null, 2)
-  return content.toString().replace(
-    '</title>',
-    '</title>\n    <script type="application/json" id="Config">' + stringifiedConfig + '</script>',
-  )
 }

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', '4af6ae6', 'extensions')
+  const builtinExtensionsPath = join(staticServerPath, '..', '..', 'static', '93dad47', 'extensions')
   return builtinExtensionsPath
 }

package/src/parts/GetElectronFileResponse/GetElectronFileResponse.js

@@ -10,7 +10,6 @@ import * as GetPathEtag from '../GetPathEtag/GetPathEtag.js'
 import * as GetServerErrorResponse from '../GetServerErrorResponse/GetServerErrorResponse.js'
 import * as GetTypeScriptSyntaxErrorResponse from '../GetTypeScriptSyntaxErrorResponse/GetTypeScriptSyntaxErrorResponse.js'
 import * as HttpHeader from '../HttpHeader/HttpHeader.js'
-import * as IsDocumentNavigation from '../IsDocumentNavigation/IsDocumentNavigation.js'
 import * as IsEnoentError from '../IsEnoentError/IsEnoentError.js'
 import * as IsTypeScriptSyntaxError from '../IsTypeScriptSyntaxError/IsTypeScriptSyntaxError.js'
 import * as Logger from '../Logger/Logger.js'
@@ -25,8 +24,6 @@ export const resolveElectronFileUri = (url) => {
 // maybe send webview requests directly to preview process
 export const getElectronFileResponse = async (url, request) => {
   try {
-    const isRootDocument = url === '/' || url.startsWith('/?')
-    const isSecretDocument = isRootDocument && IsDocumentNavigation.isDocumentNavigation(request)
     const pathName = GetElectronFileResponseRelativePath.getElectronFileResponseRelativePath(url)
     let absolutePath = GetElectronFileResponseAbsolutePath.getElectronFileResponseAbsolutePath(pathName)
     let etag
@@ -45,7 +42,7 @@ export const getElectronFileResponse = async (url, request) => {
         preparedContent = await GetElectronFileResponseContent.getElectronFileResponseContent(request, absolutePath, url)
         size = preparedContent.byteLength
       }
-      if (!isSecretDocument && request.headers[HttpHeader.IfNotMatch] === etag) {
+      if (request.headers[HttpHeader.IfNotMatch] === etag) {
         const headers = await GetHeaders.getHeaders(absolutePath, pathName, etag, url, size)
         return GetNotModifiedResponse.getNotModifiedResponse(headers)
       }
@@ -54,7 +51,7 @@ export const getElectronFileResponse = async (url, request) => {
     const size = content.byteLength
     const headers = await GetHeaders.getHeaders(absolutePath, pathName, etag, url, size)
 
-    headers[HttpHeader.CacheControl] = isSecretDocument ? 'no-store' : 'public, max-age=0, must-revalidate'
+    headers[HttpHeader.CacheControl] = 'public, max-age=0, must-revalidate'
     return GetContentResponse.getContentResponse(content, headers)
   } catch (error) {
     if (IsEnoentError.isEnoentError(error)) {

package/src/parts/GetElectronFileResponseContent/GetElectronFileResponseContent.js

@@ -1,10 +1,8 @@
 import { readFile } from 'node:fs/promises'
 import * as AddCustomPathsToIndexHtml from '../AddCustomPathsToIndexHtml/AddCustomPathsToIndexHtml.js'
-import * as IsDocumentNavigation from '../IsDocumentNavigation/IsDocumentNavigation.js'
 import * as Platform from '../Platform/Platform.js'
 import * as ShouldTranspileTypescript from '../ShouldTranspileTypescript/ShouldTranspileTypescript.js'
 import * as TranspileTypeScript from '../TranspileTypeScript/TranspileTypeScript.js'
-import * as WebSocketIssuerRegistry from '../WebSocketIssuerRegistry/WebSocketIssuerRegistry.js'
 
 const useCache = false // TODO enable this
 
@@ -25,9 +23,8 @@ export const getElectronFileResponseContent = async (request, absolutePath, url)
     content = content.toString().replace('    <link rel="manifest" href="/manifest.json" crossorigin="use-credentials" />\n', '')
     content = await AddCustomPathsToIndexHtml.addCustomPathsToIndexHtml(content)
   }
-  if (url === '/' || url.startsWith('/?')) {
-    const additionalConfig = IsDocumentNavigation.isDocumentNavigation(request) ? { webSocketIssuer: WebSocketIssuerRegistry.create() } : {}
-    content = await AddCustomPathsToIndexHtml.addCustomPathsToIndexHtml(content, additionalConfig)
+  if (url === '/') {
+    content = await AddCustomPathsToIndexHtml.addCustomPathsToIndexHtml(content)
   }
   if (typeof content === 'string') {
     content = Buffer.from(content)

package/src/parts/GetTestRequestResponse/GetTestRequestResponse.js

@@ -13,19 +13,13 @@ import * as GetTestPath from '../GetTestPath/GetTestPath.js'
 import * as HttpHeader from '../HttpHeader/HttpHeader.js'
 import * as HttpStatusCode from '../HttpStatusCode/HttpStatusCode.js'
 import * as Logger from '../Logger/Logger.js'
-import * as WebSocketIssuerRegistry from '../WebSocketIssuerRegistry/WebSocketIssuerRegistry.js'
-
-const getTestPageContent = async (indexHtmlPath) => {
-  const body = await readFile(indexHtmlPath, 'utf8')
-  const webSocketIssuer = WebSocketIssuerRegistry.create()
-  return AddCustomPathsToIndexHtml.addCustomPathsToIndexHtml(body, { webSocketIssuer })
-}
 
 export const getTestRequestResponse = async (request, indexHtmlPath) => {
   try {
     const pathName = GetPathName.getPathName(request)
     if (pathName === '/tests/_all.html') {
-      const content = await getTestPageContent(indexHtmlPath)
+      const body = await readFile(indexHtmlPath, 'utf8')
+      const content = await AddCustomPathsToIndexHtml.addCustomPathsToIndexHtml(body)
       const headers = {
         [HttpHeader.ContentSecurityPolicy]: ContentSecurityPolicyDocument.value,
         [HttpHeader.ContentType]: 'text/html',
@@ -36,7 +30,8 @@ export const getTestRequestResponse = async (request, indexHtmlPath) => {
       return GetContentResponse.getContentResponse(content, headers)
     }
     if (pathName.endsWith('.html')) {
-      const content = await getTestPageContent(indexHtmlPath)
+      const body = await readFile(indexHtmlPath, 'utf8')
+      const content = await AddCustomPathsToIndexHtml.addCustomPathsToIndexHtml(body)
       const headers = {
         [HttpHeader.ContentSecurityPolicy]: ContentSecurityPolicyDocument.value,
         [HttpHeader.ContentType]: 'text/html',

package/src/parts/HandleMessagePortForExtensionHostHelperProcess/HandleMessagePortForExtensionHostHelperProcess.ipc.js

@@ -4,6 +4,4 @@ export const name = 'HandleMessagePortForExtensionHostHelperProcess'
 
 export const Commands = {
   handleMessagePortForExtensionHostHelperProcess: HandleMessagePortForExtensionHostHelperProcess.handleMessagePortForExtensionHostHelperProcess,
-  handlePreloadedMessagePortForExtensionHostHelperProcess:
-    HandleMessagePortForExtensionHostHelperProcess.handlePreloadedMessagePortForExtensionHostHelperProcess,
 }

package/src/parts/HandleMessagePortForExtensionHostHelperProcess/HandleMessagePortForExtensionHostHelperProcess.js

@@ -23,22 +23,3 @@ export const handleMessagePortForExtensionHostHelperProcess = async (rendererWor
   // }
   // rendererWorkerIpc.on('close', cleanup)
 }
-
-export const handlePreloadedMessagePortForExtensionHostHelperProcess = async (
-  port,
-  modulePath,
-) => {
-  Assert.object(port)
-  Assert.string(modulePath)
-  const ipc = await ExtensionHostHelperProcessIpc.create({
-    method: IpcParentType.ElectronUtilityProcess,
-  })
-  HandleIpc.handleIpc(ipc)
-  try {
-    await JsonRpc.invoke(ipc, 'LoadFile.loadFile', modulePath)
-    await JsonRpc.invokeAndTransfer(ipc, 'HandleElectronMessagePort.handleElectronMessagePort', port, IpcId.ExtensionHostWorker)
-  } catch (error) {
-    ipc.dispose()
-    throw error
-  }
-}

package/src/parts/HandleRequest/HandleRequest.js

@@ -1,7 +1,6 @@
 import { join } from 'path'
 import * as Assert from '../Assert/Assert.js'
 import * as GetElectronFileResponse from '../GetElectronFileResponse/GetElectronFileResponse.js'
-import * as GetWebSocketCapabilityResponse from '../GetWebSocketCapabilityResponse/GetWebSocketCapabilityResponse.js'
 import * as HandleRequestTest from '../HandleRequestTest/HandleRequestTest.js'
 import * as HttpServerResponse from '../HttpServerResponse/HttpServerResponse.js'
 import * as StaticPath from '../StaticPath/StaticPath.js'
@@ -18,10 +17,6 @@ export const handleRequest = async (socket, request) => {
     const indexHtmlPath = join(staticPath, 'index.html')
     return HandleRequestTest.handleRequestTest(socket, request, indexHtmlPath)
   }
-  if (request.url.startsWith('/websocket-capabilities/')) {
-    const response = GetWebSocketCapabilityResponse.getWebSocketCapabilityResponse(request)
-    return HttpServerResponse.send(request, socket, response)
-  }
   const fileResponse = await GetElectronFileResponse.getElectronFileResponse(request.url, request)
   HttpServerResponse.send(request, socket, fileResponse)
 }

package/src/parts/HandleWebSocket/HandleWebSocket.js

@@ -5,29 +5,6 @@ import * as HandleWebSocketModule from '../HandleWebSocketModule/HandleWebSocket
 import * as IsAllowedWebSocketOrigin from '../IsAllowedWebSocketOrigin/IsAllowedWebSocketOrigin.js'
 import * as RejectWebSocket from '../RejectWebSocket/RejectWebSocket.js'
 import { VError } from '../VError/VError.js'
-import * as WebSocketCapabilityRegistry from '../WebSocketCapabilityRegistry/WebSocketCapabilityRegistry.js'
-
-const capabilityPath = '/websocket/capability'
-
-const getCapabilityToken = (message) => {
-  const header = message.headers?.['sec-websocket-protocol']
-  if (typeof header !== 'string') {
-    return ''
-  }
-  const protocols = header.split(',').map((protocol) => protocol.trim())
-  if (!protocols.includes(WebSocketCapabilityRegistry.capabilityProtocol)) {
-    return ''
-  }
-  const capabilityProtocol = protocols.find((protocol) => protocol.startsWith(WebSocketCapabilityRegistry.capabilityProtocolPrefix))
-  return capabilityProtocol?.slice(WebSocketCapabilityRegistry.capabilityProtocolPrefix.length) || ''
-}
-
-const sanitizeProtocols = (message) => {
-  message.headers = {
-    ...message.headers,
-    'sec-websocket-protocol': WebSocketCapabilityRegistry.capabilityProtocol,
-  }
-}
 
 export const handleWebSocket = async (handle, message) => {
   try {
@@ -38,21 +15,10 @@ export const handleWebSocket = async (handle, message) => {
       return
     }
     const { url } = message
-    if (url.split('?')[0] !== capabilityPath) {
-      RejectWebSocket.rejectWebSocket(handle)
-      return
-    }
-    const token = getCapabilityToken(message)
-    const capability = WebSocketCapabilityRegistry.consume(token)
-    if (!capability) {
-      RejectWebSocket.rejectWebSocket(handle)
-      return
-    }
-    sanitizeProtocols(message)
-    const type = capability.target
+    const type = GetTypeFromUrl.getTypeFromUrl(url)
     handle.pause()
     const module = HandleWebSocketModule.load(type)
-    await module.handleWebSocket(message, handle, type, capability)
+    module.handleWebSocket(message, handle, type)
   } catch (error) {
     DestroyWebSocket.destroySocket(handle)
     throw new VError(error, `Failed to connect to websocket`)

package/src/parts/HandleWebSocketForExtensionHostHelperProcess/HandleWebSocketForExtensionHostHelperProcess.js

@@ -1,22 +1,6 @@
-                                                                                                        
-import * as ExtensionHostHelperProcessIpc from '../ExtensionHostHelperProcessIpc/ExtensionHostHelperProcessIpc.js'
-import * as HandleIpc from '../HandleIpc/HandleIpc.js'
-import * as IpcParentType from '../IpcParentType/IpcParentType.js'
-import * as JsonRpc from '../JsonRpc/JsonRpc.js'
+import * as HandleIncomingIpc from '../HandleIncomingIpc/HandleIncomingIpc.js'
+import * as IpcId from '../IpcId/IpcId.js'
 
-export const handleWebSocket = async (message, handle, type, capability) => {
-  if (!capability.modulePath) {
-    throw new Error('extension helper capability is missing a module path')
-  }
-  const ipc = await ExtensionHostHelperProcessIpc.create({
-    method: IpcParentType.NodeForkedProcess,
-  })
-  HandleIpc.handleIpc(ipc)
-  try {
-    await JsonRpc.invoke(ipc, 'LoadFile.loadFile', capability.modulePath)
-    await JsonRpc.invokeAndTransfer(ipc, 'HandleWebSocket.handleWebSocket', handle, message)
-  } catch (error) {
-    ipc.dispose()
-    throw error
-  }
+export const handleWebSocket = (message, handle) => {
+  return HandleIncomingIpc.handleIncomingIpc(IpcId.ExtensionHostHelperProcess, handle, message)
 }

package/src/parts/Module/Module.js

@@ -154,8 +154,6 @@ export const load = (moduleId) => {
       return import('../Terminal/Terminal.ipc.js')
     case ModuleId.TextDocument:
       return import('../TextDocument/TextDocument.ipc.js')
-    case ModuleId.WebSocketCapability:
-      return import('../WebSocketCapability/WebSocketCapability.ipc.js')
     case ModuleId.WebViewServer:
       return import('../WebViewServer/WebViewServer.ipc.js')
     case ModuleId.Window:

package/src/parts/ModuleId/ModuleId.js

@@ -82,4 +82,3 @@ export const SendMessagePortToMainProcess = 88
 export const SecretStorage = 89
 export const ChromeCookieImport = 90
 export const FirefoxCookieImport = 91
-export const WebSocketCapability = 92

package/src/parts/ModuleMap/ModuleMap.js

@@ -302,10 +302,6 @@ export const getModuleId = (commandId) => {
       return ModuleId.Terminal
     case 'Transferrable.transfer':
       return ModuleId.Transferrable
-    case 'WebSocketCapability.create':
-    case 'WebSocketCapability.createExtensionNodeRpc':
-    case 'WebSocketCapability.createLegacyExtensionNodeRpc':
-      return ModuleId.WebSocketCapability
     case 'WebViewServer.create':
     case 'WebViewServer.registerProtocol':
     case 'WebViewServer.setHandler':

package/src/parts/Platform/Platform.js

@@ -61,11 +61,11 @@ export const getSetupName = () => {
   return 'Lvce-Setup'
 }
 
-export const version = '0.99.15'
+export const version = '0.99.18'
 
-export const commit = '4af6ae6'
+export const commit = '93dad47'
 
-export const date = '2026-08-06T01:16:58.000Z'
+export const date = '2026-08-08T05:53:58.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', '4af6ae6', 'packages', 'preload', 'dist', 'index.js')
+  return join(Root.root, 'static', '93dad47', 'packages', 'preload', 'dist', 'index.js')
 }

package/src/parts/Workers/Workers.json

@@ -652,6 +652,7 @@
           { "source": "state", "name": "platform" }, { "source": "state", "name": "assetDir" }, { "source": "state", "name": "parentUid" }
         ] },
         "loadContent": { "name": "SearchExtensions.loadContent", "parameters": [{ "source": "state", "name": "id" }, { "source": "argument", "name": "savedState" }] },
+        "handleExtensionsChanged": { "name": "SearchExtensions.handleExtensionsChanged", "parameters": [{ "source": "state", "name": "id" }] },
         "diff": { "name": "SearchExtensions.diff2", "parameters": [{ "source": "state", "name": "id" }] },
         "render": { "name": "SearchExtensions.render3", "parameters": [{ "source": "state", "name": "id" }, { "source": "result", "name": "diff" }] },
         "saveState": { "name": "SearchExtensions.saveState", "parameters": [{ "source": "state", "name": "id" }] },
@@ -662,6 +663,7 @@
         "getMenuEntries": { "name": "SearchExtensions.getMenuEntries2", "parameters": [{ "source": "argument", "name": "args", "spread": true }] },
         "renderEventListeners": { "name": "SearchExtensions.renderEventListeners", "parameters": [] }
       },
+      "extraCommands": [{ "name": "handleExtensionsChanged", "method": "handleExtensionsChanged" }],
       "title": "Extensions: Installed",
       "capabilities": { "events": true, "render": true, "resize": true, "rootRender": true }
     }

package/src/parts/GetWebSocketCapabilityResponse/GetWebSocketCapabilityResponse.js

@@ -1,43 +0,0 @@
-import * as HttpHeader from '../HttpHeader/HttpHeader.js'
-import * as HttpStatusCode from '../HttpStatusCode/HttpStatusCode.js'
-import * as WebSocketCapability from '../WebSocketCapability/WebSocketCapability.js'
-import * as WebSocketIssuerRegistry from '../WebSocketIssuerRegistry/WebSocketIssuerRegistry.js'
-
-const jsonHeaders = {
-  [HttpHeader.CacheControl]: 'no-store',
-  [HttpHeader.ContentType]: 'application/json; charset=utf-8',
-}
-
-const getResponse = (status, value) => {
-  return {
-    body: Buffer.from(JSON.stringify(value)),
-    init: {
-      headers: jsonHeaders,
-      status,
-    },
-  }
-}
-
-const getBearerToken = (authorization) => {
-  if (typeof authorization !== 'string' || !authorization.startsWith('Bearer ')) {
-    return ''
-  }
-  return authorization.slice('Bearer '.length)
-}
-
-export const getWebSocketCapabilityResponse = (request) => {
-  if (request.method !== 'GET') {
-    return getResponse(HttpStatusCode.Forbidden, { error: 'method not allowed' })
-  }
-  const issuer = getBearerToken(request.headers?.authorization)
-  if (!WebSocketIssuerRegistry.isValid(issuer)) {
-    return getResponse(HttpStatusCode.Forbidden, { error: 'invalid websocket issuer' })
-  }
-  const prefix = '/websocket-capabilities/'
-  try {
-    const target = decodeURIComponent(request.url.slice(prefix.length).split('?')[0])
-    return getResponse(HttpStatusCode.Ok, WebSocketCapability.create(target))
-  } catch {
-    return getResponse(HttpStatusCode.Forbidden, { error: 'websocket target not allowed' })
-  }
-}

package/src/parts/IsDocumentNavigation/IsDocumentNavigation.js

@@ -1,4 +0,0 @@
-export const isDocumentNavigation = (request) => {
-  const headers = request?.headers
-  return headers?.['sec-fetch-dest'] === 'document' || headers?.['sec-fetch-mode'] === 'navigate'
-}

package/src/parts/WebSocketCapability/WebSocketCapability.ipc.js

@@ -1,9 +0,0 @@
-import * as WebSocketCapability from './WebSocketCapability.js'
-
-export const name = 'WebSocketCapability'
-
-export const Commands = {
-  create: WebSocketCapability.create,
-  createExtensionNodeRpc: WebSocketCapability.createExtensionNodeRpc,
-  createLegacyExtensionNodeRpc: WebSocketCapability.createLegacyExtensionNodeRpc,
-}

package/src/parts/WebSocketCapability/WebSocketCapability.js

@@ -1,53 +0,0 @@
-import * as WebSocketCapabilityRegistry from '../WebSocketCapabilityRegistry/WebSocketCapabilityRegistry.js'
-
-const allowedTargets = new Set([
-  'clipboard-process',
-  'file-system-process',
-  'process-explorer',
-  'search-process',
-  'shared-process',
-  'terminal-process',
-])
-
-                                          
-                                       
-                      
- 
-
-const createConnectionInfo = (token) => {
-  return {
-    protocols: WebSocketCapabilityRegistry.getProtocols(token),
-    url: '/websocket/capability',
-  }
-}
-
-export const create = (target) => {
-  if (!allowedTargets.has(target)) {
-    throw new Error(`WebSocket target ${target} is not allowed`)
-  }
-  return createConnectionInfo(WebSocketCapabilityRegistry.create(target))
-}
-
-export const createExtensionNodeRpc = (extensionId, rpcId, modulePath) => {
-  if (!extensionId || !rpcId || !modulePath) {
-    throw new TypeError('extension node rpc capability requires extensionId, rpcId and modulePath')
-  }
-  return createConnectionInfo(
-    WebSocketCapabilityRegistry.create('extension-host-helper-process', {
-      extensionId,
-      modulePath,
-      rpcId,
-    }),
-  )
-}
-
-export const createLegacyExtensionNodeRpc = (modulePath) => {
-  if (!modulePath) {
-    throw new TypeError('legacy extension node rpc capability requires a modulePath')
-  }
-  return createConnectionInfo(
-    WebSocketCapabilityRegistry.create('extension-host-helper-process', {
-      modulePath,
-    }),
-  )
-}

package/src/parts/WebSocketCapabilityRegistry/WebSocketCapabilityRegistry.js

@@ -1,57 +0,0 @@
-import { randomBytes } from 'node:crypto'
-
-export const capabilityProtocol = 'lvce-rpc'
-export const capabilityProtocolPrefix = 'lvce-capability.'
-export const capabilityTtl = 60_000
-
-                                      
-                            
-                               
-                              
-                         
-                         
- 
-
-const capabilities = new Map                             ()
-
-const cleanup = (now) => {
-  for (const [token, capability] of capabilities) {
-    if (capability.expiresAt <= now) {
-      capabilities.delete(token)
-    }
-  }
-}
-
-export const create = (target, options                                                    = {}) => {
-  const now = Date.now()
-  cleanup(now)
-  const token = randomBytes(32).toString('base64url')
-  capabilities.set(token, {
-    ...options,
-    expiresAt: now + capabilityTtl,
-    target,
-  })
-  return token
-}
-
-export const consume = (token) => {
-  const now = Date.now()
-  cleanup(now)
-  const capability = capabilities.get(token)
-  if (!capability) {
-    return undefined
-  }
-  capabilities.delete(token)
-  if (capability.expiresAt <= now) {
-    return undefined
-  }
-  return capability
-}
-
-export const getProtocols = (token) => {
-  return [capabilityProtocol, `${capabilityProtocolPrefix}${token}`]
-}
-
-export const clear = () => {
-  capabilities.clear()
-}

package/src/parts/WebSocketIssuerRegistry/WebSocketIssuerRegistry.js

@@ -1,32 +0,0 @@
-import { randomBytes } from 'node:crypto'
-
-export const issuerTtl = 24 * 60 * 60 * 1000
-
-const issuers = new Map                ()
-
-const cleanup = (now) => {
-  for (const [issuer, expiresAt] of issuers) {
-    if (expiresAt <= now) {
-      issuers.delete(issuer)
-    }
-  }
-}
-
-export const create = () => {
-  const now = Date.now()
-  cleanup(now)
-  const issuer = randomBytes(32).toString('base64url')
-  issuers.set(issuer, now + issuerTtl)
-  return issuer
-}
-
-export const isValid = (issuer) => {
-  const now = Date.now()
-  cleanup(now)
-  const expiresAt = issuers.get(issuer)
-  return typeof expiresAt === 'number' && expiresAt > now
-}
-
-export const clear = () => {
-  issuers.clear()
-}