@reventlessdev/reventless-core 3.0.0-alpha.166 → 3.0.0-alpha.168

package/src/components/Api/GraphQL_Stitcher.res.mjs

@@ -3,7 +3,6 @@
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
 import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
@@ -226,88 +225,6 @@ function stitchStandalone(fragment) {
   return assembleSdl([fragment], false);
 }
 
-function isIdentStart(line) {
-  let c = line.codePointAt(0);
-  if (c !== undefined) {
-    if (c >= 65 && c <= 90 || c >= 97 && c <= 122) {
-      return true;
-    } else {
-      return c === 95;
-    }
-  } else {
-    return false;
-  }
-}
-
-function rootTypeFieldNames(sdl, typeName) {
-  let marker = `type ` + typeName;
-  let typeStart = Stdlib_String.indexOfOpt(sdl, marker);
-  if (typeStart === undefined) {
-    return [];
-  }
-  let rest = sdl.slice(typeStart);
-  let match = Stdlib_String.indexOfOpt(rest, "{");
-  let match$1 = Stdlib_String.indexOfOpt(rest, "}");
-  if (match !== undefined) {
-    if (match$1 !== undefined) {
-      if (match$1 > match) {
-        return Stdlib_Array.filterMap(rest.slice(match + 1 | 0, match$1).split("\n"), line => {
-          let trimmed = line.trim();
-          if (!(trimmed.length > 0 && isIdentStart(trimmed))) {
-            return;
-          }
-          let name = extractLeadingName(trimmed);
-          let name$1 = name.endsWith(":") ? name.slice(0, name.length - 1 | 0) : name;
-          if (name$1.length > 0) {
-            return name$1;
-          }
-        });
-      } else {
-        return [];
-      }
-    } else {
-      return [];
-    }
-  } else {
-    return [];
-  }
-}
-
-function countRootTypeFields(sdl, typeName) {
-  return rootTypeFieldNames(sdl, typeName).length;
-}
-
-let rootTypeNames = [
-  "Mutation",
-  "Query",
-  "Subscription"
-];
-
-function allRootFieldNames(sdl) {
-  return rootTypeNames.flatMap(typeName => rootTypeFieldNames(sdl, typeName));
-}
-
-function missingRootFields(expectedSdl, liveSdl) {
-  let liveSet = new Set(allRootFieldNames(liveSdl));
-  return allRootFieldNames(expectedSdl).filter(name => !liveSet.has(name));
-}
-
-function isCatastrophicSchemaShrink(currentSdl, newSdl, threshold) {
-  let currentNames = allRootFieldNames(currentSdl);
-  let newSet = new Set(allRootFieldNames(newSdl));
-  let dropped = currentNames.filter(name => !newSet.has(name));
-  if (dropped.length === 0) {
-    return false;
-  }
-  let current = currentNames.length;
-  let next = allRootFieldNames(newSdl).length;
-  if (current > 0) {
-    return next < current * threshold;
-  } else {
-    return false;
-  }
-}
-
 export {
   log,
   encodeSubscriptionSource,
@@ -320,12 +237,5 @@ export {
   assembleSdl,
   stitch,
   stitchStandalone,
-  isIdentStart,
-  rootTypeFieldNames,
-  countRootTypeFields,
-  rootTypeNames,
-  allRootFieldNames,
-  missingRootFields,
-  isCatastrophicSchemaShrink,
 }
 /* log Not a pure module */

package/src/components/Dcb/Dcb_Builder.res

@@ -35,8 +35,15 @@ type dcbResult = {
   dcbPublishJsons: option<Pulumi.Output.t<CommandTopic.publishJsons>>,
   // SQS URL of the DCB command topic — shared by all StateChangeSlices in this
   // plugin. Surfaced so the bundled Plugin EventCollector Lambda can dispatch
-  // PublishStateChangeSliceCommand actions from user extensions to the right queue.
-  dcbCommandTopicQueueUrl: option<Pulumi.Output.t<string>>,
+  // PublishStateChangeSliceCommand actions from user extensions to the right
+  // queue. Resolves to "" when the plugin has no DCB slices — deliberately NOT
+  // option<Pulumi.Output.t<string>> (that combination is a repo-wide
+  // anti-pattern; it minted the nested-option sentinel that broke the
+  // collector's SendMessage grant). The Output is gated on the topic's
+  // `Component.operations`, so it resolves only after the topic finished
+  // constructing — see the construction site and
+  // docs/analysis/ec-publish-to-aggregates-grant-broken.md.
+  dcbCommandTopicQueueUrl: Pulumi.Output.t<string>,
   mutationEntries: array<ReventlessInfra.Api.mutationSchemaEntry>,
   queryEntries: array<ReventlessInfra.Api.querySchemaEntry>,
   eventLogEntries: array<ReventlessInfra.Api.eventLogSchemaEntry>,
@@ -51,7 +58,7 @@ let emptyResult: dcbResult = {
   inboundTranslationSlicesOutputs: Dict.make(),
   dcbRuntimeSetup: None,
   dcbPublishJsons: None,
-  dcbCommandTopicQueueUrl: None,
+  dcbCommandTopicQueueUrl: Pulumi.Output.make(""),
   mutationEntries: [],
   queryEntries: [],
   eventLogEntries: [],
@@ -956,24 +963,34 @@ module Make = (
             Sc.Spec.eventSchema->S.castToUnknown
           )
 
-        // NB: don't use `Option.map(r => r.id)` here — Stdlib_Option.map has a
-        // generic `'a => 'b` signature, so it wraps the lambda's return value
-        // via Caml_option.some(...). The static type of r.id is
-        // Pulumi.Output.t<string>, but a Pulumi Output is a JS object whose
-        // .id getter can resolve to undefined during early CustomResource
-        // construction; Caml_option.some(undefined) returns the nested-
-        // option sentinel `{BS_PRIVATE_NESTED_SOME_NONE: 0}`, which then
-        // flows through publishToAggregates into Lambda env vars and
-        // Pulumi's type checker rejects it (expected string, got object).
-        // The explicit switch keeps r.id's static type (non-option), so the
-        // `Some(r.id)` construction is identity-compiled — no wrapping.
-        let dcbCommandTopicQueueUrl = {
-          let outputs: CommandTopic.outputs = dcbCommandTopic->Component.outputs->Obj.magic
-          switch outputs.resources->Array.get(0) {
-          | Some(r) => Some(r.id)
-          | None => None
-          }
-        }
+        // Derive the DCB command topic's queue URL *after* the component's
+        // construct has stored its real resources. This reads `Component.outputs`
+        // as a synchronous side channel inside a callback gated on a DIFFERENT
+        // output (`Component.operations`, which resolves only post-construct) —
+        // reading `resources[0].id` at build time instead captured the SQS
+        // Queue's not-yet-resolved `.id`, which degenerated to the
+        // `{BS_PRIVATE_NESTED_SOME_NONE: 0}` nested-option sentinel and silently
+        // broke the Plugin EventCollector's sqs:SendMessage grant (cross-plugin
+        // extension → DCB-slice publishes → IAM AccessDenied).
+        //
+        // CONSUMER CONSTRAINT: because the value comes from that gated
+        // side-channel read (not from the `operations` payload itself), it must
+        // be resolved with a direct `.apply`, NOT batched through
+        // `Pulumi.Output.all`/`all2` — `all` invokes the callback at a different
+        // point in the graph where the side-channel read still yields the
+        // sentinel (verified on both preview and up). The EC grant builder
+        // therefore resolves it per-target. See
+        // docs/analysis/ec-publish-to-aggregates-grant-broken.md.
+        let dcbCommandTopicQueueUrl =
+          dcbCommandTopic
+          ->Component.operations
+          ->Pulumi.Output.flatMap(_ops => {
+            let outputs: CommandTopic.outputs = dcbCommandTopic->Component.outputs->Obj.magic
+            switch outputs.resources->Array.get(0) {
+            | Some(r) => r.id
+            | None => Pulumi.Output.make("")
+            }
+          })
         {
           dcbEventLogOutputs: Some(dcbEventLog->Component.outputs),
           stateChangeSlicesOutputs: Dict.fromArray(

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -4,6 +4,7 @@ import * as S from "sury/src/S.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+import * as Output$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/Output.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Effect from "effect/Effect";
 import * as Pulumi from "@pulumi/pulumi";
@@ -55,6 +56,8 @@ let emptyResult_outboundTranslationSlicesOutputs = {};
 
 let emptyResult_inboundTranslationSlicesOutputs = {};
 
+let emptyResult_dcbCommandTopicQueueUrl = Pulumi.output("");
+
 let emptyResult_mutationEntries = [];
 
 let emptyResult_queryEntries = [];
@@ -70,7 +73,7 @@ let emptyResult = {
   inboundTranslationSlicesOutputs: emptyResult_inboundTranslationSlicesOutputs,
   dcbRuntimeSetup: undefined,
   dcbPublishJsons: undefined,
-  dcbCommandTopicQueueUrl: undefined,
+  dcbCommandTopicQueueUrl: emptyResult_dcbCommandTopicQueueUrl,
   mutationEntries: emptyResult_mutationEntries,
   queryEntries: emptyResult_queryEntries,
   eventLogEntries: emptyResult_eventLogEntries
@@ -544,9 +547,15 @@ function Make(DcbEventLogStorage) {
         };
       });
       let allProducedSchemas = stateChangeSlices.map(Sc => Sc.Spec.eventSchema);
-      let outputs = Component$ReventlessCore.outputs(dcbCommandTopic);
-      let r = outputs.resources[0];
-      let dcbCommandTopicQueueUrl = r !== undefined ? r.id : undefined;
+      let dcbCommandTopicQueueUrl = Output$Pulumi.flatMap(Component$ReventlessCore.operations(dcbCommandTopic), _ops => {
+        let outputs = Component$ReventlessCore.outputs(dcbCommandTopic);
+        let r = outputs.resources[0];
+        if (r !== undefined) {
+          return r.id;
+        } else {
+          return Pulumi.output("");
+        }
+      });
       return {
         dcbEventLogOutputs: Component$ReventlessCore.outputs(dcbEventLog),
         stateChangeSlicesOutputs: Object.fromEntries(Object.entries(stateChangeSlicesOutputs).concat(Object.entries(asyncStateChangeSlicesOutputs))),

package/src/components/ReadModel/ReadModel_Callback.res

@@ -39,7 +39,7 @@ module Make = (
           _ => {
             let action = Projection.rewriteAction(action, ReadModelSpec.stateSchema)
             Effect.promise(
-              () => Projection.handleAction(action, Spec.operations, ReadModelSpec.subIdConfig),
+              () => Projection.handleAction(~comp, action, Spec.operations, ReadModelSpec.subIdConfig),
             )->Effect.map(_ => ())
           },
         )

package/src/components/ReadModel/ReadModel_Callback.res.mjs

@@ -31,7 +31,7 @@ function Make(ReadModelSpec) {
         return actions;
       }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => {
         let action$1 = Projection$ReventlessCore.rewriteAction(action, ReadModelSpec.stateSchema);
-        return Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(action$1, Spec.operations, ReadModelSpec.subIdConfig)), param => {});
+        return Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(comp, action$1, Spec.operations, ReadModelSpec.subIdConfig)), param => {});
       }));
     });
     return {

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -130,7 +130,7 @@ module Make = (
               ->Array.reduce(Effect.succeed(), (acc, action) =>
                 acc->Effect.flatMap(_ =>
                   Effect.promise(() =>
-                    FrameworkProjection.handleAction(action, projectionOps, Spec.subIdConfig)
+                    FrameworkProjection.handleAction(~comp, action, projectionOps, Spec.subIdConfig)
                   )->Effect.map(_ => ())
                 )
               )

package/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs

@@ -94,7 +94,7 @@ function Make(RuntimeEnvironment) {
               let fieldsStr = f === "" ? "" : `({` + f + `})`;
               Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, dataDict, `handling event ` + idxStr + `/` + total + `: ` + LogFormat$ReventlessCore.bold(eventType) + fieldsStr + ` ` + actionsStr));
               return actions;
-            }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(action, projectionOps, Spec.subIdConfig)), param => {})));
+            }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(comp, action, projectionOps, Spec.subIdConfig)), param => {})));
           });
           let handler = SpecificEventCollector.makeHandler(ec, jsonEventsHandler);
           let resources = Component$ReventlessCore.outputs(queryDb).resources;

package/src/components/StateViewSlice/StateViewSlice_Callback.res

@@ -59,6 +59,6 @@ module Make = (
         `skipped=${skipped->Int.toString} events (decode mismatch)`,
       )->Effect.runSync
     }
-    await FrameworkProjection.handleActions(allActions, queryDbOps, Spec.subIdConfig)
+    await FrameworkProjection.handleActions(~comp, allActions, queryDbOps, Spec.subIdConfig)
   }
 }

package/src/components/StateViewSlice/StateViewSlice_Callback.res.mjs

@@ -38,7 +38,7 @@ function Make(Spec) {
       if (skipped > 0) {
         Effect.runSync(EffectLogger$ReventlessCore.logWarn(comp, undefined, `skipped=` + skipped.toString() + ` events (decode mismatch)`));
       }
-      return await Projection$ReventlessCore.handleActions(allActions, queryDbOps, Spec.subIdConfig);
+      return await Projection$ReventlessCore.handleActions(comp, allActions, queryDbOps, Spec.subIdConfig);
     };
     return {
       Spec: Spec,

package/src/plugin/component/Plugin_Builder.res

@@ -776,13 +776,11 @@ module Make = (
         // All DCB StateChangeSlices share the same dcb command topic — map
         // every slice name to that single URL so PublishStateChangeSliceCommand
         // routes correctly regardless of which slice the extension targets.
-        switch dcbResult.dcbCommandTopicQueueUrl {
-        | Some(url) =>
-          stateChangeSlices->Array.forEach((module(Sc: StateChangeSlice.T)) =>
-            aggregateQueueUrls->Dict.set(Sc.Spec.name, url)
-          )
-        | None => ()
-        }
+        // (No-op when the plugin has no DCB slices: the list is empty and the
+        // URL Output resolves to "".)
+        stateChangeSlices->Array.forEach((module(Sc: StateChangeSlice.T)) =>
+          aggregateQueueUrls->Dict.set(Sc.Spec.name, dcbResult.dcbCommandTopicQueueUrl)
+        )
 
         // Per-RM EventCollector SQS URL — populated only for plugins that
         // expose RMs the bundled handler may enqueue events into directly.

package/src/plugin/component/Plugin_Builder.res.mjs

@@ -510,12 +510,9 @@ function Make(Spec) {
               return;
             }
           });
-          let url = dcbResult.dcbCommandTopicQueueUrl;
-          if (url !== undefined) {
-            stateChangeSlices.forEach(Sc => {
-              aggregateQueueUrls[Sc.Spec.name] = url;
-            });
-          }
+          stateChangeSlices.forEach(Sc => {
+            aggregateQueueUrls[Sc.Spec.name] = dcbResult.dcbCommandTopicQueueUrl;
+          });
           let readModelQueueUrls = {};
           Object.entries(readModelsOutputs).forEach(param => {
             let urlOutput = Output$Pulumi.flatMap(param[1].eventCollector, ecOutputs => {

package/src/util/EffectLogger.res

@@ -68,8 +68,10 @@ external _withMinimumLogLevel: (Effect.t<'a, 'e, 'r>, effectLogLevel) => Effect.
 
 // Minimum level used when LOG_LEVEL is unset. Framework default is Info; a platform
 // may lower it (e.g. the in-memory dev platform sets Debug) via setDefaultMinLevel.
-let _defaultMin = ref(Logger.Info)
-let setDefaultMinLevel = (l: Logger.level) => _defaultMin := l
+// The ref lives in Logger (single source of truth) so both the record logger
+// (Logger.fromEnv) and this Effect logger share one platform default; re-exported
+// here so existing `EffectLogger.setDefaultMinLevel` callers keep working.
+let setDefaultMinLevel = Logger.setDefaultMinLevel
 
 // Resolve the active minimum: explicit LOG_LEVEL wins, else the platform default.
 let _effectMin = (): effectLogLevel =>
@@ -80,7 +82,7 @@ let _effectMin = (): effectLogLevel =>
   | Some("warn") => _llWarning
   | Some("error") => _llError
   | _ =>
-    switch _defaultMin.contents {
+    switch Logger.defaultMinLevel.contents {
     | Logger.Debug => _llDebug
     | Logger.Info => _llInfo
     | Logger.Warn => _llWarning

package/src/util/EffectLogger.res.mjs

@@ -26,14 +26,6 @@ function _messageToString(msg) {
   }
 }
 
-let _defaultMin = {
-  contents: "Info"
-};
-
-function setDefaultMinLevel(l) {
-  _defaultMin.contents = l;
-}
-
 function _effectMin() {
   let match = process.env.LOG_LEVEL;
   if (match !== undefined) {
@@ -50,7 +42,7 @@ function _effectMin() {
         return LogLevel.Warning;
     }
   }
-  let match$1 = _defaultMin.contents;
+  let match$1 = Logger$ReventlessCore.defaultMinLevel.contents;
   switch (match$1) {
     case "Debug" :
       return LogLevel.Debug;
@@ -155,9 +147,10 @@ function logDebug(comp, detail, msg) {
   return Logger.withMinimumLogLevel(_annotate(Effect.logDebug(msg), comp, detail), _effectMin());
 }
 
+let setDefaultMinLevel = Logger$ReventlessCore.setDefaultMinLevel;
+
 export {
   _messageToString,
-  _defaultMin,
   setDefaultMinLevel,
   _effectMin,
   ordinalToLevel,

package/src/util/Logger.res

@@ -165,8 +165,18 @@ let emit = (
 
 // ─── Logger.t (record-based API) ─────────────────────────────────────────────
 
-let makeLogger = (~minLevel=Info): t => {
-  let shouldLog = l => levelToInt(l) >= levelToInt(minLevel)
+// Platform-tunable default minimum level, used when LOG_LEVEL is unset. Lives
+// here (not in EffectLogger) so it is the single source of truth for BOTH logger
+// paths — the record logger below and EffectLogger, which re-exports
+// `setDefaultMinLevel`. A platform may lower it (e.g. reventless-local sets
+// Debug); the framework default is Info.
+let defaultMinLevel = ref(Info)
+let setDefaultMinLevel = (l: level) => defaultMinLevel := l
+
+// Build a logger from a per-call predicate. `shouldLog` is evaluated on every
+// emit, so a logger created at module-init time still reflects a platform
+// default set later (and a live LOG_LEVEL) instead of baking the level in once.
+let makeLoggerWith = (shouldLog: level => bool): t => {
   let log = (level, ~comp=?, ~data=?, msg) =>
     if shouldLog(level) {
       let dataStr = data->Option.map(d => ` ${d->JSON.stringify}`)->Option.getOr("")
@@ -184,6 +194,11 @@ let makeLogger = (~minLevel=Info): t => {
   }
 }
 
+// Fixed-level logger — the level is baked at creation. Used by tests that assert
+// a specific minimum regardless of env/platform default.
+let makeLogger = (~minLevel=Info): t =>
+  makeLoggerWith(l => levelToInt(l) >= levelToInt(minLevel))
+
 let silent: t = {
   debug: (~comp as _=?, ~data as _=?, _) => (),
   info: (~comp as _=?, ~data as _=?, _) => (),
@@ -192,15 +207,30 @@ let silent: t = {
   debugLazy: (~comp as _=?, _) => (),
 }
 
-// Reads LOG_LEVEL from process.env and returns a configured logger.
-// Call once at module top-level or startup — not inside hot loops.
+// Active minimum level: explicit LOG_LEVEL wins, else the platform default.
+// None ⇒ silent (suppress everything). Re-read per call — LOG_LEVEL via the
+// process.env external, the platform default via `defaultMinLevel`.
+let effectiveMin = (): option<level> =>
+  switch _logLevel {
+  | Some("silent") => None
+  | Some("debug") => Some(Debug)
+  | Some("info") => Some(Info)
+  | Some("warn") => Some(Warn)
+  | Some("error") => Some(Error)
+  | Some(_) => Some(Info) // unrecognized value ⇒ Info (unchanged behavior)
+  | None => Some(defaultMinLevel.contents)
+  }
+
+// Reads LOG_LEVEL from process.env on every call and honors the platform default
+// when unset. Safe to call at module top-level: the returned logger evaluates the
+// level lazily, so a platform lowering the default afterwards (e.g.
+// reventless-local → Debug) takes effect for loggers already constructed.
 // 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)
-  }
+  makeLoggerWith(l =>
+    switch effectiveMin() {
+    | None => false
+    | Some(min) => levelToInt(l) >= levelToInt(min)
+    }
+  )

package/src/util/Logger.res.mjs

@@ -142,9 +142,15 @@ function emit(level, comp, plugin, detail, annotations, msg) {
   }
 }
 
-function makeLogger(minLevelOpt) {
-  let minLevel = minLevelOpt !== undefined ? minLevelOpt : "Info";
-  let shouldLog = l => levelToInt(l) >= levelToInt(minLevel);
+let defaultMinLevel = {
+  contents: "Info"
+};
+
+function setDefaultMinLevel(l) {
+  defaultMinLevel.contents = l;
+}
+
+function makeLoggerWith(shouldLog) {
   let log = (level, comp, data, msg) => {
     if (!shouldLog(level)) {
       return;
@@ -165,6 +171,11 @@ function makeLogger(minLevelOpt) {
   };
 }
 
+function makeLogger(minLevelOpt) {
+  let minLevel = minLevelOpt !== undefined ? minLevelOpt : "Info";
+  return makeLoggerWith(l => levelToInt(l) >= levelToInt(minLevel));
+}
+
 function silent_debug(param, param$1, param$2) {
   
 }
@@ -193,25 +204,36 @@ let silent = {
   debugLazy: silent_debugLazy
 };
 
-function fromEnv() {
+function effectiveMin() {
   let match = process.env.LOG_LEVEL;
   if (match === undefined) {
-    return makeLogger("Info");
+    return defaultMinLevel.contents;
   }
   switch (match) {
     case "debug" :
-      return makeLogger("Debug");
+      return "Debug";
     case "error" :
-      return makeLogger("Error");
+      return "Error";
     case "silent" :
-      return silent;
+      return;
     case "warn" :
-      return makeLogger("Warn");
+      return "Warn";
     default:
-      return makeLogger("Info");
+      return "Info";
   }
 }
 
+function fromEnv() {
+  return makeLoggerWith(l => {
+    let min = effectiveMin();
+    if (min !== undefined) {
+      return levelToInt(l) >= levelToInt(min);
+    } else {
+      return false;
+    }
+  });
+}
+
 let currentPluginName = LogPrefix$Reventless.currentPluginName;
 
 let registerComponentPlugin = LogPrefix$Reventless.registerComponentPlugin;
@@ -241,8 +263,12 @@ export {
   fmtPlainPrefix,
   resolvePlugin,
   emit,
+  defaultMinLevel,
+  setDefaultMinLevel,
+  makeLoggerWith,
   makeLogger,
   silent,
+  effectiveMin,
   fromEnv,
 }
 /* s Not a pure module */