@jsenv/core 23.2.2 → 23.3.0

package/src/internal/compiling/startCompileServer.js

@@ -2,7 +2,7 @@ import { readFileSync } from "node:fs"
 import {
   jsenvAccessControlAllowedHeaders,
   startServer,
-  serveFile,
+  fetchFileSystem,
   createSSERoom,
   composeServicesWithTiming,
   urlToContentType,
@@ -23,13 +23,15 @@ import {
   urlIsInsideOf,
   urlToBasename,
 } from "@jsenv/filesystem"
+import {
+  createCallbackList,
+  createCallbackListNotifiedOnce,
+} from "@jsenv/abort"
 
-import { Abortable } from "@jsenv/core/src/abort/main.js"
 import { isBrowserPartOfSupportedRuntimes } from "@jsenv/core/src/internal/generateGroupMap/runtime_support.js"
 import { loadBabelPluginMapFromFile } from "./load_babel_plugin_map_from_file.js"
 import { extractSyntaxBabelPluginMap } from "./babel_plugins.js"
 import { generateGroupMap } from "../generateGroupMap/generateGroupMap.js"
-import { createCallbackList } from "../createCallbackList.js"
 import {
   jsenvCompileProxyFileInfo,
   sourcemapMainFileInfo,
@@ -46,6 +48,7 @@ import { createTransformHtmlSourceFileService } from "./html_source_file_service
 
 export const startCompileServer = async ({
   signal = new AbortController().signal,
+  handleSIGINT,
   compileServerLogLevel,
 
   projectDirectoryUrl,
@@ -215,12 +218,12 @@ export const startCompileServer = async ({
     ...babelPluginMap,
   }
 
-  const compileServerOperation = Abortable.fromSignal(signal)
+  const serverStopCallbackList = createCallbackListNotifiedOnce()
 
   let projectFileRequestedCallback = () => {}
   if (livereloadSSE) {
     const sseSetup = setupServerSentEventsForLivereload({
-      compileServerOperation,
+      serverStopCallbackList,
       projectDirectoryUrl,
       jsenvDirectoryRelativeUrl,
       outDirectoryRelativeUrl,
@@ -230,7 +233,7 @@ export const startCompileServer = async ({
 
     projectFileRequestedCallback = sseSetup.projectFileRequestedCallback
     const serveSSEForLivereload = createSSEForLivereloadService({
-      compileServerOperation,
+      serverStopCallbackList,
       outDirectoryRelativeUrl,
       trackMainAndDependencies: sseSetup.trackMainAndDependencies,
     })
@@ -296,7 +299,6 @@ export const startCompileServer = async ({
       projectDirectoryUrl,
     }),
     "service:compiled file": createCompiledFileService({
-      compileServerOperation,
       logger,
 
       projectDirectoryUrl,
@@ -345,9 +347,9 @@ export const startCompileServer = async ({
   }
 
   const compileServer = await startServer({
-    signal: compileServerOperation.signal,
+    signal,
     stopOnExit: false,
-    stopOnSIGINT: false,
+    stopOnSIGINT: handleSIGINT,
     stopOnInternalError: false,
     sendServerInternalErrorDetails: true,
     keepProcessAlive,
@@ -380,9 +382,9 @@ export const startCompileServer = async ({
       ...customServices,
       ...jsenvServices,
     }),
-    onStop: () => {
+    onStop: (reason) => {
       onStop()
-      compileServerOperation.cleaner.clean()
+      serverStopCallbackList.notify(reason)
     },
   })
 
@@ -559,7 +561,7 @@ const compareValueJson = (left, right) => {
  *
  */
 const setupServerSentEventsForLivereload = ({
-  compileServerOperation,
+  serverStopCallbackList,
   projectDirectoryUrl,
   jsenvDirectoryRelativeUrl,
   outDirectoryRelativeUrl,
@@ -582,7 +584,7 @@ const setupServerSentEventsForLivereload = ({
       return
     }
 
-    projectFileRequested.notify(relativeUrl, request)
+    projectFileRequested.notify({ relativeUrl, request })
   }
   const watchDescription = {
     ...livereloadWatchConfig,
@@ -605,7 +607,7 @@ const setupServerSentEventsForLivereload = ({
       recursive: true,
     },
   )
-  compileServerOperation.cleaner.addCallback(unregisterDirectoryLifecyle)
+  serverStopCallbackList.add(unregisterDirectoryLifecyle)
 
   const getDependencySet = (mainRelativeUrl) => {
     if (trackerMap.has(mainRelativeUrl)) {
@@ -618,7 +620,7 @@ const setupServerSentEventsForLivereload = ({
   }
 
   // each time a file is requested for the first time its dependencySet is computed
-  projectFileRequested.register((mainRelativeUrl) => {
+  projectFileRequested.add(({ relativeUrl: mainRelativeUrl }) => {
     // for now no use case of livereloading on node.js
     // and for browsers only html file can be main files
     // this avoid collecting dependencies of non html files that will never be used
@@ -632,8 +634,8 @@ const setupServerSentEventsForLivereload = ({
     dependencySet.add(mainRelativeUrl)
     trackerMap.set(mainRelativeUrl, dependencySet)
 
-    const unregisterDependencyRequested = projectFileRequested.register(
-      (relativeUrl, request) => {
+    const removeDependencyRequestedCallback = projectFileRequested.add(
+      ({ relativeUrl, request }) => {
         if (dependencySet.has(relativeUrl)) {
           return
         }
@@ -656,10 +658,10 @@ const setupServerSentEventsForLivereload = ({
         dependencySet.add(relativeUrl)
       },
     )
-    const unregisterMainRemoved = projectFileRemoved.register((relativeUrl) => {
+    const removeMainRemovedCallback = projectFileRemoved.add((relativeUrl) => {
       if (relativeUrl === mainRelativeUrl) {
-        unregisterDependencyRequested()
-        unregisterMainRemoved()
+        removeDependencyRequestedCallback()
+        removeMainRemovedCallback()
         trackerMap.delete(mainRelativeUrl)
       }
     })
@@ -671,19 +673,19 @@ const setupServerSentEventsForLivereload = ({
   ) => {
     livereloadLogger.debug(`track ${mainRelativeUrl} and its dependencies`)
 
-    const unregisterModified = projectFileModified.register((relativeUrl) => {
+    const removeModifiedCallback = projectFileModified.add((relativeUrl) => {
       const dependencySet = getDependencySet(mainRelativeUrl)
       if (dependencySet.has(relativeUrl)) {
         modified(relativeUrl)
       }
     })
-    const unregisterRemoved = projectFileRemoved.register((relativeUrl) => {
+    const removeRemovedCallback = projectFileRemoved.add((relativeUrl) => {
       const dependencySet = getDependencySet(mainRelativeUrl)
       if (dependencySet.has(relativeUrl)) {
         removed(relativeUrl)
       }
     })
-    const unregisterAdded = projectFileAdded.register((relativeUrl) => {
+    const removeAddedCallback = projectFileAdded.add((relativeUrl) => {
       const dependencySet = getDependencySet(mainRelativeUrl)
       if (dependencySet.has(relativeUrl)) {
         added(relativeUrl)
@@ -694,9 +696,9 @@ const setupServerSentEventsForLivereload = ({
       livereloadLogger.debug(
         `stop tracking ${mainRelativeUrl} and its dependencies.`,
       )
-      unregisterModified()
-      unregisterRemoved()
-      unregisterAdded()
+      removeModifiedCallback()
+      removeRemovedCallback()
+      removeAddedCallback()
     }
   }
 
@@ -768,7 +770,7 @@ const setupServerSentEventsForLivereload = ({
 }
 
 const createSSEForLivereloadService = ({
-  compileServerOperation,
+  serverStopCallbackList,
   outDirectoryRelativeUrl,
   trackMainAndDependencies,
 }) => {
@@ -802,13 +804,11 @@ const createSSEForLivereloadService = ({
       },
     })
 
-    const removeSSECleanupCallback = compileServerOperation.cleaner.addCallback(
-      () => {
-        removeSSECleanupCallback()
-        sseRoom.close()
-        stopTracking()
-      },
-    )
+    const removeSSECleanupCallback = serverStopCallbackList.add(() => {
+      removeSSECleanupCallback()
+      sseRoom.close()
+      stopTracking()
+    })
     cache.push({
       mainFileRelativeUrl,
       sseRoom,
@@ -857,10 +857,13 @@ const createCompilationAssetFileService = ({ projectDirectoryUrl }) => {
     const { origin, ressource } = request
     const requestUrl = `${origin}${ressource}`
     if (urlIsCompilationAsset(requestUrl)) {
-      return serveFile(request, {
-        rootDirectoryUrl: projectDirectoryUrl,
-        etagEnabled: true,
-      })
+      return fetchFileSystem(
+        new URL(request.ressource.slice(1), projectDirectoryUrl),
+        {
+          headers: request.headers,
+          etagEnabled: true,
+        },
+      )
     }
     return null
   }
@@ -916,10 +919,13 @@ const createSourceFileService = ({
     const relativeUrl = ressource.slice(1)
     projectFileRequestedCallback(relativeUrl, request)
 
-    const responsePromise = serveFile(request, {
-      rootDirectoryUrl: projectDirectoryUrl,
-      etagEnabled: projectFileEtagEnabled,
-    })
+    const responsePromise = fetchFileSystem(
+      new URL(request.ressource.slice(1), projectDirectoryUrl),
+      {
+        headers: request.headers,
+        etagEnabled: projectFileEtagEnabled,
+      },
+    )
 
     return responsePromise
   }
@@ -1051,10 +1057,13 @@ const createOutFilesService = async ({
       if (!isOutRootFile(requestUrl)) {
         return null
       }
-      return serveFile(request, {
-        rootDirectoryUrl: projectDirectoryUrl,
-        etagEnabled: true,
-      })
+      return fetchFileSystem(
+        new URL(request.ressource.slice(1), projectDirectoryUrl),
+        {
+          headers: request.headers,
+          etagEnabled: true,
+        },
+      )
     }
   }
   // serve from memory

package/src/internal/executing/coverage/relativeUrlToEmptyCoverage.js

@@ -1,6 +1,5 @@
 import { resolveUrl, urlToFileSystemPath, readFile } from "@jsenv/filesystem"
 
-import { Abortable } from "@jsenv/core/src/abort/main.js"
 import {
   babelPluginsFromBabelPluginMap,
   getMinimalBabelPluginMap,
@@ -15,7 +14,7 @@ export const relativeUrlToEmptyCoverage = async (
   const { transformAsync } = await import("@babel/core")
 
   const fileUrl = resolveUrl(relativeUrl, projectDirectoryUrl)
-  Abortable.throwIfAborted(multipleExecutionsOperation)
+  multipleExecutionsOperation.throwIfAborted()
   const source = await readFile(fileUrl)
 
   try {
@@ -25,7 +24,7 @@ export const relativeUrlToEmptyCoverage = async (
       "transform-instrument": [babelPluginInstrument, { projectDirectoryUrl }],
     }
 
-    Abortable.throwIfAborted(multipleExecutionsOperation)
+    multipleExecutionsOperation.throwIfAborted()
     const { metadata } = await transformAsync(source, {
       filename: urlToFileSystemPath(fileUrl),
       filenameRelative: relativeUrl,

package/src/internal/executing/createSummaryLog.js

@@ -1,4 +1,5 @@
-import { setANSIColor } from "../logs/log_style.js"
+import { ANSI } from "@jsenv/log"
+
 import { msAsDuration } from "../logs/msAsDuration.js"
 import { EXECUTION_COLORS } from "./execution_colors.js"
 
@@ -39,19 +40,19 @@ export const createSummaryDetails = ({
   cancelledCount,
 }) => {
   if (abortedCount === executionCount) {
-    return `all ${setANSIColor(`aborted`, EXECUTION_COLORS.aborted)}`
+    return `all ${ANSI.color(`aborted`, EXECUTION_COLORS.aborted)}`
   }
   if (timedoutCount === executionCount) {
-    return `all ${setANSIColor(`timed out`, EXECUTION_COLORS.timedout)}`
+    return `all ${ANSI.color(`timed out`, EXECUTION_COLORS.timedout)}`
   }
   if (erroredCount === executionCount) {
-    return `all ${setANSIColor(`errored`, EXECUTION_COLORS.errored)}`
+    return `all ${ANSI.color(`errored`, EXECUTION_COLORS.errored)}`
   }
   if (completedCount === executionCount) {
-    return `all ${setANSIColor(`completed`, EXECUTION_COLORS.completed)}`
+    return `all ${ANSI.color(`completed`, EXECUTION_COLORS.completed)}`
   }
   if (cancelledCount === executionCount) {
-    return `all ${setANSIColor(`cancelled`, EXECUTION_COLORS.cancelled)}`
+    return `all ${ANSI.color(`cancelled`, EXECUTION_COLORS.cancelled)}`
   }
 
   return createMixedDetails({
@@ -75,22 +76,19 @@ const createMixedDetails = ({
 
   if (timedoutCount) {
     parts.push(
-      `${timedoutCount} ${setANSIColor(
-        `timed out`,
-        EXECUTION_COLORS.timedout,
-      )}`,
+      `${timedoutCount} ${ANSI.color(`timed out`, EXECUTION_COLORS.timedout)}`,
     )
   }
 
   if (erroredCount) {
     parts.push(
-      `${erroredCount} ${setANSIColor(`errored`, EXECUTION_COLORS.errored)}`,
+      `${erroredCount} ${ANSI.color(`errored`, EXECUTION_COLORS.errored)}`,
     )
   }
 
   if (completedCount) {
     parts.push(
-      `${completedCount} ${setANSIColor(
+      `${completedCount} ${ANSI.color(
         `completed`,
         EXECUTION_COLORS.completed,
       )}`,
@@ -99,13 +97,13 @@ const createMixedDetails = ({
 
   if (abortedCount) {
     parts.push(
-      `${abortedCount} ${setANSIColor(`aborted`, EXECUTION_COLORS.aborted)}`,
+      `${abortedCount} ${ANSI.color(`aborted`, EXECUTION_COLORS.aborted)}`,
     )
   }
 
   if (cancelledCount) {
     parts.push(
-      `${cancelledCount} ${setANSIColor(
+      `${cancelledCount} ${ANSI.color(
         `cancelled`,
         EXECUTION_COLORS.cancelled,
       )}`,

package/src/internal/executing/executeConcurrently.js

@@ -2,10 +2,10 @@ import { stat } from "node:fs"
 import wrapAnsi from "wrap-ansi"
 import { loggerToLevels, createDetailedMessage } from "@jsenv/logger"
 import { urlToFileSystemPath } from "@jsenv/filesystem"
+import { createLog } from "@jsenv/log"
 
 import { launchAndExecute } from "../executing/launchAndExecute.js"
 import { reportToCoverage } from "./coverage/reportToCoverage.js"
-import { writeLog } from "./writeLog.js"
 import { createExecutionResultLog } from "./executionLogs.js"
 import { createSummaryLog } from "./createSummaryLog.js"
 
@@ -173,11 +173,13 @@ export const executeConcurrently = async (
             : true) &&
           executionResult.status === "completed"
         ) {
-          previousExecutionLog = previousExecutionLog.update(log)
+          previousExecutionLog.write(log)
         } else {
-          previousExecutionLog = writeLog(log, {
-            mightUpdate: completedExecutionLogMerging,
-          })
+          if (previousExecutionLog) {
+            previousExecutionLog.destroy()
+          }
+          previousExecutionLog = createLog()
+          previousExecutionLog.write(log)
         }
       }
 

package/src/internal/executing/executePlan.js

@@ -1,7 +1,5 @@
-import {
-  Abortable,
-  raceProcessTeardownEvents,
-} from "@jsenv/core/src/abort/main.js"
+import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
+
 import { mergeRuntimeSupport } from "@jsenv/core/src/internal/generateGroupMap/runtime_support.js"
 import { startCompileServer } from "../compiling/startCompileServer.js"
 import { babelPluginInstrument } from "./coverage/babel_plugin_instrument.js"
@@ -74,97 +72,99 @@ export const executePlan = async (
     })
   })
 
-  const multipleExecutionsOperation = Abortable.fromSignal(signal)
+  const multipleExecutionsOperation = Abort.startOperation()
+  multipleExecutionsOperation.addAbortSignal(signal)
   if (handleSIGINT) {
-    Abortable.effect(multipleExecutionsOperation, (cb) =>
-      raceProcessTeardownEvents(
+    multipleExecutionsOperation.addAbortSource((abort) => {
+      return raceProcessTeardownEvents(
         {
           SIGINT: true,
         },
         () => {
           logger.info("Aborting execution (SIGINT)")
-          cb()
+          abort()
         },
-      ),
-    )
+      )
+    })
   }
 
-  const compileServer = await startCompileServer({
-    signal: multipleExecutionsOperation.signal,
-    compileServerLogLevel,
-
-    projectDirectoryUrl,
-    jsenvDirectoryRelativeUrl,
-    jsenvDirectoryClean,
-    outDirectoryName: "out-dev",
-
-    importResolutionMethod,
-    importDefaultExtension,
-
-    compileServerProtocol,
-    compileServerPrivateKey,
-    compileServerCertificate,
-    compileServerIp,
-    compileServerPort,
-    compileServerCanReadFromFilesystem,
-    compileServerCanWriteOnFilesystem,
-    keepProcessAlive: true, // to be sure it stays alive
-    babelPluginMap,
-    babelConfigFileUrl,
-    customCompilers,
-    runtimeSupport,
-  })
-
-  multipleExecutionsOperation.cleaner.addCallback(async () => {
-    await compileServer.stop()
-  })
-
-  const executionSteps = await generateExecutionSteps(
-    {
-      ...plan,
-      [compileServer.outDirectoryRelativeUrl]: null,
-    },
-    {
+  try {
+    const compileServer = await startCompileServer({
       signal: multipleExecutionsOperation.signal,
-      projectDirectoryUrl,
-    },
-  )
+      compileServerLogLevel,
 
-  const result = await executeConcurrently(executionSteps, {
-    multipleExecutionsOperation,
-    logger,
-    launchAndExecuteLogLevel,
-
-    projectDirectoryUrl,
-    compileServerOrigin: compileServer.origin,
-    outDirectoryRelativeUrl: compileServer.outDirectoryRelativeUrl,
-
-    // not sure we actually have to pass import params to executeConcurrently
-    importResolutionMethod,
-    importDefaultExtension,
+      projectDirectoryUrl,
+      jsenvDirectoryRelativeUrl,
+      jsenvDirectoryClean,
+      outDirectoryName: "out-dev",
+
+      importResolutionMethod,
+      importDefaultExtension,
+
+      compileServerProtocol,
+      compileServerPrivateKey,
+      compileServerCertificate,
+      compileServerIp,
+      compileServerPort,
+      compileServerCanReadFromFilesystem,
+      compileServerCanWriteOnFilesystem,
+      keepProcessAlive: true, // to be sure it stays alive
+      babelPluginMap,
+      babelConfigFileUrl,
+      customCompilers,
+      runtimeSupport,
+    })
 
-    babelPluginMap: compileServer.babelPluginMap,
+    multipleExecutionsOperation.addEndCallback(async () => {
+      await compileServer.stop()
+    })
 
-    defaultMsAllocatedPerExecution,
-    maxExecutionsInParallel,
-    completedExecutionLogMerging,
-    completedExecutionLogAbbreviation,
-    logSummary,
-    measureGlobalDuration,
+    const executionSteps = await generateExecutionSteps(
+      {
+        ...plan,
+        [compileServer.outDirectoryRelativeUrl]: null,
+      },
+      {
+        signal: multipleExecutionsOperation.signal,
+        projectDirectoryUrl,
+      },
+    )
 
-    coverage,
-    coverageConfig,
-    coverageIncludeMissing,
-    coverageForceIstanbul,
-    coverageV8MergeConflictIsExpected,
-  })
+    const result = await executeConcurrently(executionSteps, {
+      multipleExecutionsOperation,
+      logger,
+      launchAndExecuteLogLevel,
 
-  // (used to stop potential chrome browser still opened to be reused)
-  multipleExecutionsOperation.cleaner.clean("all execution done")
+      projectDirectoryUrl,
+      compileServerOrigin: compileServer.origin,
+      outDirectoryRelativeUrl: compileServer.outDirectoryRelativeUrl,
+
+      // not sure we actually have to pass import params to executeConcurrently
+      importResolutionMethod,
+      importDefaultExtension,
+
+      babelPluginMap: compileServer.babelPluginMap,
+
+      defaultMsAllocatedPerExecution,
+      maxExecutionsInParallel,
+      completedExecutionLogMerging,
+      completedExecutionLogAbbreviation,
+      logSummary,
+      measureGlobalDuration,
+
+      coverage,
+      coverageConfig,
+      coverageIncludeMissing,
+      coverageForceIstanbul,
+      coverageV8MergeConflictIsExpected,
+    })
 
-  return {
-    planSummary: result.summary,
-    planReport: result.report,
-    planCoverage: result.coverage,
+    return {
+      planSummary: result.summary,
+      planReport: result.report,
+      planCoverage: result.coverage,
+    }
+  } finally {
+    await multipleExecutionsOperation.end()
   }
 }

package/src/internal/executing/executionLogs.js

@@ -1,9 +1,5 @@
-import {
-  failureSignColorLess,
-  okSignColorLess,
-  setANSIColor,
-  ANSI_GREY,
-} from "../logs/log_style.js"
+import { ANSI, UNICODE } from "@jsenv/log"
+
 import { msAsDuration } from "../logs/msAsDuration.js"
 import { EXECUTION_COLORS } from "./execution_colors.js"
 import { createSummaryDetails } from "./createSummaryLog.js"
@@ -56,32 +52,32 @@ runtime: ${runtime}${appendDuration({
 
 const descriptionFormatters = {
   aborted: ({ executionNumber, executionCount }) => {
-    return setANSIColor(
-      `${failureSignColorLess} execution ${executionNumber} of ${executionCount} aborted`,
+    return ANSI.color(
+      `${UNICODE.FAILURE_RAW} execution ${executionNumber} of ${executionCount} aborted`,
       EXECUTION_COLORS.aborted,
     )
   },
   timedout: ({ executionNumber, allocatedMs, executionCount }) => {
-    return setANSIColor(
-      `${failureSignColorLess} execution ${executionNumber} of ${executionCount} timeout after ${allocatedMs}ms`,
+    return ANSI.color(
+      `${UNICODE.FAILURE_RAW} execution ${executionNumber} of ${executionCount} timeout after ${allocatedMs}ms`,
       EXECUTION_COLORS.timedout,
     )
   },
   errored: ({ executionNumber, executionCount }) => {
-    return setANSIColor(
-      `${failureSignColorLess} execution ${executionNumber} of ${executionCount} error`,
+    return ANSI.color(
+      `${UNICODE.FAILURE_RAW} execution ${executionNumber} of ${executionCount} error`,
       EXECUTION_COLORS.errored,
     )
   },
   completed: ({ executionNumber, executionCount }) => {
-    return setANSIColor(
-      `${okSignColorLess} execution ${executionNumber} of ${executionCount} completed`,
+    return ANSI.color(
+      `${UNICODE.OK_RAW} execution ${executionNumber} of ${executionCount} completed`,
       EXECUTION_COLORS.completed,
     )
   },
   cancelled: ({ executionNumber, executionCount }) => {
-    return setANSIColor(
-      `${failureSignColorLess} execution ${executionNumber} of ${executionCount} cancelled`,
+    return ANSI.color(
+      `${UNICODE.FAILURE_RAW} execution ${executionNumber} of ${executionCount} cancelled`,
       EXECUTION_COLORS.cancelled,
     )
   },
@@ -105,9 +101,9 @@ const appendConsole = (consoleCalls) => {
   if (consoleOutputTrimmed === "") return ""
 
   return `
-${setANSIColor(`-------- console --------`, ANSI_GREY)}
+${ANSI.color(`-------- console --------`, ANSI.GREY)}
 ${consoleOutputTrimmed}
-${setANSIColor(`-------------------------`, ANSI_GREY)}`
+${ANSI.color(`-------------------------`, ANSI.GREY)}`
 }
 
 const appendError = (error) => {

package/src/internal/executing/execution_colors.js

@@ -1,15 +1,9 @@
-import {
-  ANSI_GREY,
-  ANSI_YELLOW,
-  ANSI_RED,
-  ANSI_GREEN,
-  ANSI_MAGENTA,
-} from "../logs/log_style.js"
+import { ANSI } from "@jsenv/log"
 
 export const EXECUTION_COLORS = {
-  aborted: ANSI_MAGENTA,
-  timedout: ANSI_YELLOW,
-  errored: ANSI_RED,
-  completed: ANSI_GREEN,
-  cancelled: ANSI_GREY,
+  aborted: ANSI.MAGENTA,
+  timedout: ANSI.YELLOW,
+  errored: ANSI.RED,
+  completed: ANSI.GREEN,
+  cancelled: ANSI.GREY,
 }