@reventlessdev/reventless-core 3.0.0-alpha.134

package/src/util/LogFormat.res.mjs

@@ -0,0 +1,257 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as AnsiStyle$Reventless from "@reventlessdev/reventless-spec/src/AnsiStyle.res.mjs";
+import * as Message$ReventlessCore from "../Message.res.mjs";
+
+function cmdName(msg) {
+  return AnsiStyle$Reventless.bold(Message$ReventlessCore.variantNameOfJson(msg.commandJson));
+}
+
+function cmdNames(msgs) {
+  return `[` + msgs.map(cmdName).join(",") + `]`;
+}
+
+function cmdSummary(msg) {
+  return AnsiStyle$Reventless.bold(Message$ReventlessCore.variantNameOfJson(msg.commandJson)) + `(` + msg.id + `)`;
+}
+
+function cmdSummaries(msgs) {
+  return `[` + msgs.map(cmdSummary).join(",") + `]`;
+}
+
+function variantFields(json) {
+  if (typeof json !== "object" || json === null || Array.isArray(json)) {
+    return "";
+  }
+  let fields = Object.entries(json).filter(param => param[0] !== "TAG").map(param => param[0] + `:` + JSON.stringify(param[1])).join(",");
+  if (fields === "") {
+    return "";
+  } else {
+    return `, {` + fields + `}`;
+  }
+}
+
+function cmdDetail(msg) {
+  return AnsiStyle$Reventless.bold(Message$ReventlessCore.variantNameOfJson(msg.commandJson)) + `(` + msg.id + variantFields(msg.commandJson) + `)`;
+}
+
+function cmdDetails(msgs) {
+  return `[` + msgs.map(cmdDetail).join(", ") + `]`;
+}
+
+function cmdLabelOfJson(json) {
+  let fields = variantFields(json);
+  let body = fields.startsWith(", ") ? fields.slice(2, fields.length) : fields;
+  return AnsiStyle$Reventless.bold(Message$ReventlessCore.variantNameOfJson(json)) + `(` + body + `)`;
+}
+
+function cmdDetailNoId(msg) {
+  return cmdLabelOfJson(msg.commandJson);
+}
+
+function cmdFull(msg) {
+  let commandStr = JSON.stringify(msg.commandJson);
+  let metaStr = JSON.stringify(Message$ReventlessCore.encode(msg.meta, Message$ReventlessCore.metaSchema));
+  return `{"command":` + commandStr + `,"meta":` + metaStr + `,"id":"` + msg.id + `"}`;
+}
+
+function cmdFulls(msgs) {
+  return `[` + msgs.map(cmdFull).join(", ") + `]`;
+}
+
+function eventName(j) {
+  return AnsiStyle$Reventless.bold(Message$ReventlessCore.eventNameOfEvent$pJson(j));
+}
+
+function eventNames(events) {
+  return `[` + events.map(eventName).join(",") + `]`;
+}
+
+function eventSummary(j) {
+  let match = Message$ReventlessCore.idMetaEventOfEvent$pJson(j);
+  return AnsiStyle$Reventless.bold(Message$ReventlessCore.eventNameOfEvent$pJson(j)) + `(` + match[0] + `)`;
+}
+
+function eventSummaries(events) {
+  return `[` + events.map(eventSummary).join(",") + `]`;
+}
+
+function eventDetail(j) {
+  let match = Message$ReventlessCore.idMetaEventOfEvent$pJson(j);
+  let eventJson = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(j), d => d["event"]), null);
+  return AnsiStyle$Reventless.bold(Message$ReventlessCore.eventNameOfEvent$pJson(j)) + `(` + match[0] + variantFields(eventJson) + `)`;
+}
+
+function eventDetails(events) {
+  return `[` + events.map(eventDetail).join(", ") + `]`;
+}
+
+function eventFull(j) {
+  let match = Message$ReventlessCore.idMetaEventOfEvent$pJson(j);
+  return `{"event":` + match[2] + `,"meta":` + match[1] + `,"id":"` + match[0] + `"}`;
+}
+
+function eventFulls(events) {
+  return `[` + events.map(eventFull).join(", ") + `]`;
+}
+
+function actionName(action) {
+  if (typeof action !== "object") {
+    return "Ignore";
+  }
+  switch (action.TAG) {
+    case "Create" :
+      return "Create";
+    case "CreateMany" :
+      return "CreateMany";
+    case "Update" :
+      return "Update";
+    case "UpdateMany" :
+      return "UpdateMany";
+    case "UpdateWithDefault" :
+      return "UpdateWithDefault";
+    case "UpdateManyWithDefault" :
+      return "UpdateManyWithDefault";
+    case "Set" :
+      return "Set";
+    case "SetMany" :
+      return "SetMany";
+    case "Delete" :
+      return "Delete";
+    case "DeleteMany" :
+      return "DeleteMany";
+    case "DeleteIf" :
+      return "DeleteIf";
+    case "DeleteManyIf" :
+      return "DeleteManyIf";
+    case "CreateMultiState" :
+      return "CreateMultiState";
+    case "UpdateMultiState" :
+      return "UpdateMultiState";
+    case "UpdateManyMultiStates" :
+      return "UpdateManyMultiStates";
+  }
+}
+
+function actionNames(actions) {
+  return `[` + actions.map(actionName).join(",") + `]`;
+}
+
+function actionDetail(action) {
+  if (typeof action !== "object") {
+    return "Ignore";
+  }
+  switch (action.TAG) {
+    case "Create" :
+      return `Create(` + action._0 + `)`;
+    case "CreateMany" :
+      return `CreateMany(` + action._0.length.toString() + `)`;
+    case "Update" :
+      return `Update(` + action._0 + `)`;
+    case "UpdateMany" :
+      return `UpdateMany(` + action._0.length.toString() + `)`;
+    case "UpdateWithDefault" :
+      return `UpdateWithDefault(` + action._0 + `)`;
+    case "UpdateManyWithDefault" :
+      return `UpdateManyWithDefault(` + action._0.length.toString() + `)`;
+    case "Set" :
+      return `Set(` + action._0 + `)`;
+    case "SetMany" :
+      return `SetMany(` + action._0.length.toString() + `)`;
+    case "Delete" :
+      return `Delete(` + action._0 + `)`;
+    case "DeleteMany" :
+      return `DeleteMany(` + action._0.length.toString() + `)`;
+    case "DeleteIf" :
+      return `DeleteIf(` + action._0 + `)`;
+    case "DeleteManyIf" :
+      return `DeleteManyIf(` + action._0.length.toString() + `)`;
+    case "CreateMultiState" :
+      return `CreateMultiState(` + action._0 + `)`;
+    case "UpdateMultiState" :
+      return `UpdateMultiState(` + action._0 + `)`;
+    case "UpdateManyMultiStates" :
+      return `UpdateManyMultiStates(` + action._0.length.toString() + `)`;
+  }
+}
+
+function actionDetails(actions) {
+  return `[` + actions.map(actionDetail).join(",") + `]`;
+}
+
+function fmtState(name, id, seq) {
+  return `state=` + name + `(` + id + `) seq=` + seq.toString();
+}
+
+function fmtExn(e) {
+  return `err=` + Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(e), Stdlib_JsExn.message), "unknown");
+}
+
+function commandJsonsToLogMessages(cmdJsons) {
+  let count = cmdJsons.length.toString();
+  return cmdJsons.map((cmdJson, idx) => {
+    let idx$1 = (idx + 1 | 0).toString();
+    return idx$1 + `/` + count + `: ` + cmdSummary(cmdJson) + `: ` + cmdFull(cmdJson);
+  });
+}
+
+function event$pJsonToLogMessage(j) {
+  return eventSummary(j) + `: ` + eventFull(j);
+}
+
+function fmtCmds(msgs) {
+  return `cmds=` + msgs.length.toString() + ` [` + msgs.map(cmdName).join(",") + `]`;
+}
+
+let bold = AnsiStyle$Reventless.bold;
+
+let commandJsonToLogMessage = cmdFull;
+
+let fmtCmd = cmdSummary;
+
+let fmtEventJson = eventSummary;
+
+let fmtAction = actionName;
+
+let fmtActions = actionNames;
+
+export {
+  bold,
+  cmdName,
+  cmdNames,
+  cmdSummary,
+  cmdSummaries,
+  variantFields,
+  cmdDetail,
+  cmdDetails,
+  cmdLabelOfJson,
+  cmdDetailNoId,
+  cmdFull,
+  cmdFulls,
+  eventName,
+  eventNames,
+  eventSummary,
+  eventSummaries,
+  eventDetail,
+  eventDetails,
+  eventFull,
+  eventFulls,
+  actionName,
+  actionNames,
+  actionDetail,
+  actionDetails,
+  fmtState,
+  fmtExn,
+  commandJsonToLogMessage,
+  commandJsonsToLogMessages,
+  event$pJsonToLogMessage,
+  fmtCmd,
+  fmtCmds,
+  fmtEventJson,
+  fmtAction,
+  fmtActions,
+}
+/* Stdlib_JsExn Not a pure module */

package/src/util/Logger.res

@@ -0,0 +1,196 @@
+// Unified logger for deploy-time (Pulumi Output.apply) and non-Effect runtime code.
+// EffectLogger delegates to `emit` so the format is defined once here.
+//
+// Usage:
+//   let log = Logger.fromEnv()         // reads LOG_LEVEL from process.env once
+//   log.info(~comp="MyModule", "done")
+//   log.debug(~comp="MyModule", ~data=json, "detail")
+//
+// LOG_LEVEL env var: "silent" | "debug" | "warn" | "error" | (anything else = "info")
+
+@val external _logLevel: option<string> = "process.env.LOG_LEVEL"
+
+// service field (3.3): explicit REVENTLESS_SERVICE override wins, else the
+// Lambda function name. Read per-emit (cheap) so a platform/test can set it
+// after module init. None ⇒ field omitted.
+@val external _serviceOverride: option<string> = "process.env.REVENTLESS_SERVICE"
+@val external _lambdaName: option<string> = "process.env.AWS_LAMBDA_FUNCTION_NAME"
+let serviceName = (): option<string> =>
+  switch _serviceOverride {
+  | Some(s) => Some(s)
+  | None => _lambdaName
+  }
+
+// detail truncation cap (3.1) — configurable; default 32 KB. CloudWatch caps a
+// single record at 256 KB, so an oversized ~detail is replaced with a preview
+// stub rather than risking a silent drop.
+@val external _maxDetailBytes: option<string> = "process.env.REVENTLESS_LOG_MAX_DETAIL_BYTES"
+let maxDetailBytes = switch _maxDetailBytes {
+| Some(s) => s->Int.fromString->Option.getOr(32 * 1024)
+| None => 32 * 1024
+}
+
+type logFn = (~comp: string=?, ~data: JSON.t=?, string) => unit
+
+type t = {
+  debug: logFn,
+  info: logFn,
+  warn: logFn,
+  error: logFn,
+}
+
+type level = Debug | Info | Warn | Error
+
+let levelToInt = l =>
+  switch l {
+  | Debug => 0
+  | Info => 1
+  | Warn => 2
+  | Error => 3
+  }
+
+let levelLabel = l =>
+  switch l {
+  | Debug => "DEBUG"
+  | Info => "INFO"
+  | Warn => "WARN"
+  | Error => "ERROR"
+  }
+
+// ─── Shared format + output ──────────────────────────────────────────────────
+// Single definition used by Logger.t AND EffectLogger.
+
+// ANSI codes
+let red = "\x1b[31m"
+let yellow = "\x1b[33m"
+let cyan = "\x1b[36m"
+let dim = "\x1b[90m"
+let reset = "\x1b[0m"
+
+let hms = () => {
+  let d = Date.make()
+  let h = d->Date.getHours->Int.toString->String.padStart(2, "0")
+  let m = d->Date.getMinutes->Int.toString->String.padStart(2, "0")
+  let s = d->Date.getSeconds->Int.toString->String.padStart(2, "0")
+  `${h}:${m}:${s}`
+}
+
+// RFC 3339 / ISO-8601 timestamp for the JSON `time` field (3.2).
+let iso = () => Date.make()->Date.toISOString
+
+// Replace an oversized detail payload with a bounded preview stub (3.1).
+let truncateDetail = (d: JSON.t): JSON.t => {
+  let s = d->JSON.stringify
+  if s->String.length > maxDetailBytes {
+    Dict.fromArray([
+      ("truncated", JSON.Encode.bool(true)),
+      ("bytes", JSON.Encode.int(s->String.length)),
+      ("preview", s->String.slice(~start=0, ~end=512)->JSON.Encode.string),
+    ])->JSON.Encode.object
+  } else {
+    d
+  }
+}
+
+// Plugin-name resolution + prefix formatting live in `Reventless.LogPrefix`
+// so that infra-layer log helpers (ExtensionPointMapping, ExtensionMapping)
+// can share the same logic without depending on this package.
+let currentPluginName = Reventless.LogPrefix.currentPluginName
+let registerComponentPlugin = Reventless.LogPrefix.registerComponentPlugin
+let fmtComp = Reventless.LogPrefix.fmtComp
+let fmtPlainPrefix = Reventless.LogPrefix.fmtPlainPrefix
+let resolvePlugin = Reventless.LogPrefix.resolvePlugin
+
+// Central emit — all log output flows through here.
+// ~detail: structured data shown only in CloudWatch (expandable on click).
+//   Terminal (in-memory): shows only the message line.
+//   JSON sink (CloudWatch/…): structured object with plugin/comp/detail fields.
+// ~plugin: explicit plugin override (e.g. from Effect annotations set at the
+//   Lambda boundary). Falls back to LogPrefix.resolvePlugin lookup if absent.
+// ~annotations: extra structured key/value pairs (e.g. correlationId, requestId)
+//   carried via Effect log annotations. JSON sink only; ignored in the TTY view.
+let emit = (
+  ~level: level,
+  ~comp=?,
+  ~plugin: option<string>=?,
+  ~detail: option<JSON.t>=?,
+  ~annotations: option<dict<string>>=?,
+  msg: string,
+) => {
+  // Sink decision lives in Reventless.AnsiStyle (single source of truth, shared
+  // with fmtComp / AnsiStyle.bold). Non-TTY collectors (Lambda, Fargate, ECS,
+  // Azure, GCP, Docker, CI, piped stdout) all get JSON; a TTY stays text.
+  if Reventless.AnsiStyle.isJsonSink() {
+    // Structured JSON for any log collector. Plugin/comp/annotations are promoted
+    // to top-level queryable keys instead of being baked into `message`; `message`
+    // stays clean human text. `detail` is the expandable structured payload.
+    // Explicit ~plugin wins; otherwise fall back to the LogPrefix registry.
+    let pluginField = switch plugin {
+    | Some(_) as p => p
+    | None => resolvePlugin(~comp?, ())
+    }
+    let annotationFields =
+      annotations->Option.mapOr([], a =>
+        a->Dict.toArray->Array.map(((k, v)) => (k, JSON.Encode.string(v)))
+      )
+    let fields =
+      [
+        ("time", iso()->JSON.Encode.string),
+        ("level", levelLabel(level)->JSON.Encode.string),
+        ("message", msg->JSON.Encode.string),
+      ]
+      ->Array.concat(serviceName()->Option.mapOr([], s => [("service", JSON.Encode.string(s))]))
+      ->Array.concat(pluginField->Option.mapOr([], p => [("plugin", JSON.Encode.string(p))]))
+      ->Array.concat(comp->Option.mapOr([], c => [("comp", JSON.Encode.string(c))]))
+      ->Array.concat(annotationFields)
+      ->Array.concat(detail->Option.mapOr([], d => [("detail", truncateDetail(d))]))
+    Console.log(fields->Dict.fromArray->JSON.Encode.object->JSON.stringify)
+  } else {
+    // Terminal — colored, human-readable, no detail
+    let t = hms()
+    let c = fmtComp(~comp?, ())
+    switch level {
+    | Error => Console.error(`${t} ${red}E${reset} ${c}${msg}`)
+    | Warn => Console.warn(`${t} ${yellow}W${reset} ${c}${msg}`)
+    | Info => Console.log(`${t} ${cyan}I${reset} ${c}${msg}`)
+    | Debug => Console.log(`${t} ${dim}D${reset} ${c}${msg}`)
+    }
+  }
+}
+
+// ─── Logger.t (record-based API) ─────────────────────────────────────────────
+
+let makeLogger = (~minLevel=Info): t => {
+  let shouldLog = l => levelToInt(l) >= levelToInt(minLevel)
+  let log = (level, ~comp=?, ~data=?, msg) =>
+    if shouldLog(level) {
+      let dataStr = data->Option.map(d => ` ${d->JSON.stringify}`)->Option.getOr("")
+      emit(~level, ~comp?, `${msg}${dataStr}`)
+    }
+  {
+    debug: (~comp=?, ~data=?, msg) => log(Debug, ~comp?, ~data?, msg),
+    info: (~comp=?, ~data=?, msg) => log(Info, ~comp?, ~data?, msg),
+    warn: (~comp=?, ~data=?, msg) => log(Warn, ~comp?, ~data?, msg),
+    error: (~comp=?, ~data=?, msg) => log(Error, ~comp?, ~data?, msg),
+  }
+}
+
+let silent: t = {
+  debug: (~comp as _=?, ~data as _=?, _) => (),
+  info: (~comp as _=?, ~data as _=?, _) => (),
+  warn: (~comp as _=?, ~data as _=?, _) => (),
+  error: (~comp as _=?, ~data as _=?, _) => (),
+}
+
+// Reads LOG_LEVEL from process.env and returns a configured logger.
+// Call once at module top-level or startup — not inside hot loops.
+// LOG_LEVEL=silent disables all output (used by the reventless-gwt CLI so
+// framework diagnostics don't interleave with NDJSON / TAP / JUnit streams).
+let fromEnv = (): t =>
+  switch _logLevel {
+  | Some("silent") => silent
+  | Some("debug") => makeLogger(~minLevel=Debug)
+  | Some("warn") => makeLogger(~minLevel=Warn)
+  | Some("error") => makeLogger(~minLevel=Error)
+  | _ => makeLogger(~minLevel=Info)
+  }

package/src/util/Logger.res.mjs

@@ -0,0 +1,238 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as AnsiStyle$Reventless from "@reventlessdev/reventless-spec/src/AnsiStyle.res.mjs";
+import * as LogPrefix$Reventless from "@reventlessdev/reventless-spec/src/LogPrefix.res.mjs";
+
+function serviceName() {
+  let s = process.env.REVENTLESS_SERVICE;
+  if (s !== undefined) {
+    return s;
+  } else {
+    return process.env.AWS_LAMBDA_FUNCTION_NAME;
+  }
+}
+
+let s = process.env.REVENTLESS_LOG_MAX_DETAIL_BYTES;
+
+let maxDetailBytes = s !== undefined ? Stdlib_Option.getOr(Stdlib_Int.fromString(s, undefined), 32768) : 32768;
+
+function levelToInt(l) {
+  switch (l) {
+    case "Debug" :
+      return 0;
+    case "Info" :
+      return 1;
+    case "Warn" :
+      return 2;
+    case "Error" :
+      return 3;
+  }
+}
+
+function levelLabel(l) {
+  switch (l) {
+    case "Debug" :
+      return "DEBUG";
+    case "Info" :
+      return "INFO";
+    case "Warn" :
+      return "WARN";
+    case "Error" :
+      return "ERROR";
+  }
+}
+
+let red = "\x1b[31m";
+
+let yellow = "\x1b[33m";
+
+let cyan = "\x1b[36m";
+
+let dim = "\x1b[90m";
+
+let reset = "\x1b[0m";
+
+function hms() {
+  let d = new Date();
+  let h = d.getHours().toString().padStart(2, "0");
+  let m = d.getMinutes().toString().padStart(2, "0");
+  let s = d.getSeconds().toString().padStart(2, "0");
+  return h + `:` + m + `:` + s;
+}
+
+function iso() {
+  return new Date().toISOString();
+}
+
+function truncateDetail(d) {
+  let s = JSON.stringify(d);
+  if (s.length > maxDetailBytes) {
+    return Object.fromEntries([
+      [
+        "truncated",
+        true
+      ],
+      [
+        "bytes",
+        s.length
+      ],
+      [
+        "preview",
+        s.slice(0, 512)
+      ]
+    ]);
+  } else {
+    return d;
+  }
+}
+
+function emit(level, comp, plugin, detail, annotations, msg) {
+  if (AnsiStyle$Reventless.isJsonSink()) {
+    let pluginField = plugin !== undefined ? plugin : LogPrefix$Reventless.resolvePlugin(comp, undefined);
+    let annotationFields = Stdlib_Option.mapOr(annotations, [], a => Object.entries(a).map(param => [
+      param[0],
+      param[1]
+    ]));
+    let fields = [
+      [
+        "time",
+        new Date().toISOString()
+      ],
+      [
+        "level",
+        levelLabel(level)
+      ],
+      [
+        "message",
+        msg
+      ]
+    ].concat(Stdlib_Option.mapOr(serviceName(), [], s => [[
+        "service",
+        s
+      ]])).concat(Stdlib_Option.mapOr(pluginField, [], p => [[
+        "plugin",
+        p
+      ]])).concat(Stdlib_Option.mapOr(comp, [], c => [[
+        "comp",
+        c
+      ]])).concat(annotationFields).concat(Stdlib_Option.mapOr(detail, [], d => [[
+        "detail",
+        truncateDetail(d)
+      ]]));
+    console.log(JSON.stringify(Object.fromEntries(fields)));
+    return;
+  }
+  let t = hms();
+  let c = LogPrefix$Reventless.fmtComp(comp, undefined);
+  switch (level) {
+    case "Debug" :
+      console.log(t + ` ` + dim + `D` + reset + ` ` + c + msg);
+      return;
+    case "Info" :
+      console.log(t + ` ` + cyan + `I` + reset + ` ` + c + msg);
+      return;
+    case "Warn" :
+      console.warn(t + ` ` + yellow + `W` + reset + ` ` + c + msg);
+      return;
+    case "Error" :
+      console.error(t + ` ` + red + `E` + reset + ` ` + c + msg);
+      return;
+  }
+}
+
+function makeLogger(minLevelOpt) {
+  let minLevel = minLevelOpt !== undefined ? minLevelOpt : "Info";
+  let shouldLog = l => levelToInt(l) >= levelToInt(minLevel);
+  let log = (level, comp, data, msg) => {
+    if (!shouldLog(level)) {
+      return;
+    }
+    let dataStr = Stdlib_Option.getOr(Stdlib_Option.map(data, d => ` ` + JSON.stringify(d)), "");
+    emit(level, comp, undefined, undefined, undefined, msg + dataStr);
+  };
+  return {
+    debug: (comp, data, msg) => log("Debug", comp, data, msg),
+    info: (comp, data, msg) => log("Info", comp, data, msg),
+    warn: (comp, data, msg) => log("Warn", comp, data, msg),
+    error: (comp, data, msg) => log("Error", comp, data, msg)
+  };
+}
+
+function silent_debug(param, param$1, param$2) {
+  
+}
+
+function silent_info(param, param$1, param$2) {
+  
+}
+
+function silent_warn(param, param$1, param$2) {
+  
+}
+
+function silent_error(param, param$1, param$2) {
+  
+}
+
+let silent = {
+  debug: silent_debug,
+  info: silent_info,
+  warn: silent_warn,
+  error: silent_error
+};
+
+function fromEnv() {
+  let match = process.env.LOG_LEVEL;
+  if (match === undefined) {
+    return makeLogger("Info");
+  }
+  switch (match) {
+    case "debug" :
+      return makeLogger("Debug");
+    case "error" :
+      return makeLogger("Error");
+    case "silent" :
+      return silent;
+    case "warn" :
+      return makeLogger("Warn");
+    default:
+      return makeLogger("Info");
+  }
+}
+
+let currentPluginName = LogPrefix$Reventless.currentPluginName;
+
+let registerComponentPlugin = LogPrefix$Reventless.registerComponentPlugin;
+
+let fmtComp = LogPrefix$Reventless.fmtComp;
+
+let fmtPlainPrefix = LogPrefix$Reventless.fmtPlainPrefix;
+
+let resolvePlugin = LogPrefix$Reventless.resolvePlugin;
+
+export {
+  serviceName,
+  maxDetailBytes,
+  levelToInt,
+  levelLabel,
+  red,
+  yellow,
+  cyan,
+  dim,
+  reset,
+  hms,
+  iso,
+  truncateDetail,
+  currentPluginName,
+  registerComponentPlugin,
+  fmtComp,
+  fmtPlainPrefix,
+  resolvePlugin,
+  emit,
+  makeLogger,
+  silent,
+  fromEnv,
+}
+/* s Not a pure module */