@decohere/scribe 0.0.1-dev.20 → 0.0.1-dev.20261105.103

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025-2026 Typesmiths
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

package/es6/src/console.adapter.js

@@ -1,28 +1,33 @@
 import { formatError, LogAdapter } from "./logger.adapter.js";
+import { redact } from "./redact.js";
 import { DefaultLogLevel, LogLevels } from "./types.js";
 export class ConsoleAdapter extends LogAdapter {
     configuredLevels;
     configuredLogLevel = DefaultLogLevel;
     configuredLogLevelValue = LogLevels.info;
+    redactionKeys = redact.fromOptions();
     constructor(_options = {}){
         super();
     }
     configure(scribeOptions) {
-        // Get merged log levels (default + custom) using parent class method
         this.configuredLevels = this.getLogLevels(scribeOptions);
         const logLevelStr = scribeOptions.logLevel ?? DefaultLogLevel;
         this.configuredLogLevel = logLevelStr;
         this.configuredLogLevelValue = this.configuredLevels[logLevelStr] ?? LogLevels.info;
+        this.redactionKeys = redact.fromOptions(scribeOptions.redactions);
     }
     getLogger(name) {
         const loggerName = name || "default";
-        return this.createConsoleLogger(loggerName);
+        return this.createConsoleLogger(loggerName, {});
     }
-    createConsoleLogger(name) {
-        // Use the levels configured during the configure() call
+    createConsoleLogger(name, bindings) {
         const allLevels = this.configuredLevels;
         const currentLevel = this.configuredLogLevel;
         const threshold = this.configuredLogLevelValue;
+        const redactionKeys = this.redactionKeys;
+        const bound = Object.keys(bindings).length > 0 ? [
+            redact.object(bindings, redactionKeys)
+        ] : [];
         const baseLogger = {
             get currentLevel () {
                 return currentLevel;
@@ -35,30 +40,32 @@ export class ConsoleAdapter extends LogAdapter {
                 const timestamp = new Date().toISOString();
                 let message;
                 if (typeof msg === "object") {
-                    message = msg instanceof Error ? formatError(msg) : JSON.stringify(msg);
+                    message = msg instanceof Error ? formatError(msg) : JSON.stringify(redact.object(msg, redactionKeys));
                 } else {
                     message = String(msg);
                 }
                 const logLine = `[${timestamp}] ${level.toUpperCase()} [${name}]: ${message}`;
-                if (args.length > 0) {
-                    console.log(logLine, ...args);
+                const payload = [
+                    ...args.map((arg)=>redact.object(arg, redactionKeys)),
+                    ...bound
+                ];
+                if (payload.length > 0) {
+                    console.log(logLine, ...payload);
                 } else {
                     console.log(logLine);
                 }
             };
         const noop = ()=>{};
-        // Start with base logger and isLevelEnabled method
         const logger = Object.assign(baseLogger, {
-            isLevelEnabled: (level)=>(allLevels[level] ?? 0) >= threshold
+            isLevelEnabled: (level)=>(allLevels[level] ?? 0) >= threshold,
+            child: (fields)=>this.createConsoleLogger(name, {
+                    ...bindings,
+                    ...fields
+                })
         });
-        // Dynamically add all log level methods (default + custom)
-        // Levels below the configured threshold are patched to noop
         for (const [levelName, levelValue] of Object.entries(allLevels)){
-            // biome-ignore lint/suspicious/noExplicitAny: Dynamic logger level creation requires any
             logger[levelName] = levelValue >= threshold ? logFunction(levelName) : noop;
         }
         return logger;
     }
 }
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUvc3JjL2NvbnNvbGUuYWRhcHRlci50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBmb3JtYXRFcnJvciwgTG9nQWRhcHRlciB9IGZyb20gXCIuL2xvZ2dlci5hZGFwdGVyLmpzXCI7XG5pbXBvcnQgdHlwZSB7IEJhc2VMb2dnZXIsIExvZ2dlciB9IGZyb20gXCIuL2xvZ2dlci50eXBlLmpzXCI7XG5pbXBvcnQge1xuXHREZWZhdWx0TG9nTGV2ZWwsXG5cdHR5cGUgTG9nQWRhcHRlck9wdGlvbnMsXG5cdExvZ0xldmVscyxcblx0dHlwZSBTY3JpYmVPcHRpb25zLFxufSBmcm9tIFwiLi90eXBlcy5qc1wiO1xuXG5leHBvcnQgdHlwZSBDb25zb2xlQWRhcHRlck9wdGlvbnMgPSB7fSAmIExvZ0FkYXB0ZXJPcHRpb25zO1xuXG5leHBvcnQgY2xhc3MgQ29uc29sZUFkYXB0ZXIgZXh0ZW5kcyBMb2dBZGFwdGVyIHtcblx0cHJpdmF0ZSBjb25maWd1cmVkTGV2ZWxzOiBSZWNvcmQ8c3RyaW5nLCBudW1iZXI+O1xuXHRwcml2YXRlIGNvbmZpZ3VyZWRMb2dMZXZlbDogc3RyaW5nID0gRGVmYXVsdExvZ0xldmVsO1xuXHRwcml2YXRlIGNvbmZpZ3VyZWRMb2dMZXZlbFZhbHVlOiBudW1iZXIgPSBMb2dMZXZlbHMuaW5mbztcblxuXHRwdWJsaWMgY29uc3RydWN0b3IoX29wdGlvbnM6IENvbnNvbGVBZGFwdGVyT3B0aW9ucyA9IHt9KSB7XG5cdFx0c3VwZXIoKTtcblx0fVxuXG5cdHB1YmxpYyBjb25maWd1cmU8VCBleHRlbmRzIHN0cmluZyA9IG5ldmVyLCBDdXN0b21Pbmx5IGV4dGVuZHMgdHJ1ZSB8IGZhbHNlID0gZmFsc2U+KFxuXHRcdHNjcmliZU9wdGlvbnM6IFNjcmliZU9wdGlvbnM8VCwgQ3VzdG9tT25seT4sXG5cdCkge1xuXHRcdC8vIEdldCBtZXJnZWQgbG9nIGxldmVscyAoZGVmYXVsdCArIGN1c3RvbSkgdXNpbmcgcGFyZW50IGNsYXNzIG1ldGhvZFxuXHRcdHRoaXMuY29uZmlndXJlZExldmVscyA9IHRoaXMuZ2V0TG9nTGV2ZWxzKHNjcmliZU9wdGlvbnMpO1xuXHRcdGNvbnN0IGxvZ0xldmVsU3RyID0gc2NyaWJlT3B0aW9ucy5sb2dMZXZlbCA/PyBEZWZhdWx0TG9nTGV2ZWw7XG5cdFx0dGhpcy5jb25maWd1cmVkTG9nTGV2ZWwgPSBsb2dMZXZlbFN0cjtcblx0XHR0aGlzLmNvbmZpZ3VyZWRMb2dMZXZlbFZhbHVlID0gdGhpcy5jb25maWd1cmVkTGV2ZWxzW2xvZ0xldmVsU3RyXSA/PyBMb2dMZXZlbHMuaW5mbztcblx0fVxuXG5cdHB1YmxpYyBnZXRMb2dnZXI8VCBleHRlbmRzIHN0cmluZyA9IG5ldmVyLCBDdXN0b21Pbmx5IGV4dGVuZHMgdHJ1ZSB8IGZhbHNlID0gZmFsc2U+KFxuXHRcdG5hbWU/OiBzdHJpbmcsXG5cdCk6IExvZ2dlcjxULCBDdXN0b21Pbmx5PiB7XG5cdFx0Y29uc3QgbG9nZ2VyTmFtZSA9IG5hbWUgfHwgXCJkZWZhdWx0XCI7XG5cdFx0cmV0dXJuIHRoaXMuY3JlYXRlQ29uc29sZUxvZ2dlcjxULCBDdXN0b21Pbmx5Pihsb2dnZXJOYW1lKTtcblx0fVxuXG5cdHByaXZhdGUgY3JlYXRlQ29uc29sZUxvZ2dlcjxcblx0XHRUIGV4dGVuZHMgc3RyaW5nID0gbmV2ZXIsXG5cdFx0Q3VzdG9tT25seSBleHRlbmRzIHRydWUgfCBmYWxzZSA9IGZhbHNlLFxuXHQ+KG5hbWU6IHN0cmluZyk6IExvZ2dlcjxULCBDdXN0b21Pbmx5PiB7XG5cdFx0Ly8gVXNlIHRoZSBsZXZlbHMgY29uZmlndXJlZCBkdXJpbmcgdGhlIGNvbmZpZ3VyZSgpIGNhbGxcblx0XHRjb25zdCBhbGxMZXZlbHMgPSB0aGlzLmNvbmZpZ3VyZWRMZXZlbHM7XG5cdFx0Y29uc3QgY3VycmVudExldmVsID0gdGhpcy5jb25maWd1cmVkTG9nTGV2ZWw7XG5cdFx0Y29uc3QgdGhyZXNob2xkID0gdGhpcy5jb25maWd1cmVkTG9nTGV2ZWxWYWx1ZTtcblxuXHRcdGNvbnN0IGJhc2VMb2dnZXI6IEJhc2VMb2dnZXIgPSB7XG5cdFx0XHRnZXQgY3VycmVudExldmVsKCkge1xuXHRcdFx0XHRyZXR1cm4gY3VycmVudExldmVsO1xuXHRcdFx0fSxcblx0XHRcdGdldCBsb2dMZXZlbHMoKSB7XG5cdFx0XHRcdHJldHVybiBhbGxMZXZlbHM7XG5cdFx0XHR9LFxuXHRcdH07XG5cblx0XHRjb25zdCBsb2dGdW5jdGlvbiA9XG5cdFx0XHQobGV2ZWw6IHN0cmluZykgPT5cblx0XHRcdChtc2c6IHN0cmluZyB8IG51bWJlciB8IG9iamVjdCwgLi4uYXJnczogdW5rbm93bltdKSA9PiB7XG5cdFx0XHRcdGNvbnN0IHRpbWVzdGFtcCA9IG5ldyBEYXRlKCkudG9JU09TdHJpbmcoKTtcblx0XHRcdFx0bGV0IG1lc3NhZ2U6IHN0cmluZztcblxuXHRcdFx0XHRpZiAodHlwZW9mIG1zZyA9PT0gXCJvYmplY3RcIikge1xuXHRcdFx0XHRcdG1lc3NhZ2UgPSBtc2cgaW5zdGFuY2VvZiBFcnJvciA/IGZvcm1hdEVycm9yKG1zZykgOiBKU09OLnN0cmluZ2lmeShtc2cpO1xuXHRcdFx0XHR9IGVsc2Uge1xuXHRcdFx0XHRcdG1lc3NhZ2UgPSBTdHJpbmcobXNnKTtcblx0XHRcdFx0fVxuXG5cdFx0XHRcdGNvbnN0IGxvZ0xpbmUgPSBgWyR7dGltZXN0YW1wfV0gJHtsZXZlbC50b1VwcGVyQ2FzZSgpfSBbJHtuYW1lfV06ICR7bWVzc2FnZX1gO1xuXG5cdFx0XHRcdGlmIChhcmdzLmxlbmd0aCA+IDApIHtcblx0XHRcdFx0XHRjb25zb2xlLmxvZyhsb2dMaW5lLCAuLi5hcmdzKTtcblx0XHRcdFx0fSBlbHNlIHtcblx0XHRcdFx0XHRjb25zb2xlLmxvZyhsb2dMaW5lKTtcblx0XHRcdFx0fVxuXHRcdFx0fTtcblxuXHRcdGNvbnN0IG5vb3AgPSAoKSA9PiB7fTtcblxuXHRcdC8vIFN0YXJ0IHdpdGggYmFzZSBsb2dnZXIgYW5kIGlzTGV2ZWxFbmFibGVkIG1ldGhvZFxuXHRcdGNvbnN0IGxvZ2dlciA9IE9iamVjdC5hc3NpZ24oYmFzZUxvZ2dlciwge1xuXHRcdFx0aXNMZXZlbEVuYWJsZWQ6IChsZXZlbDogc3RyaW5nKSA9PiAoYWxsTGV2ZWxzW2xldmVsXSA/PyAwKSA+PSB0aHJlc2hvbGQsXG5cdFx0fSk7XG5cblx0XHQvLyBEeW5hbWljYWxseSBhZGQgYWxsIGxvZyBsZXZlbCBtZXRob2RzIChkZWZhdWx0ICsgY3VzdG9tKVxuXHRcdC8vIExldmVscyBiZWxvdyB0aGUgY29uZmlndXJlZCB0aHJlc2hvbGQgYXJlIHBhdGNoZWQgdG8gbm9vcFxuXHRcdGZvciAoY29uc3QgW2xldmVsTmFtZSwgbGV2ZWxWYWx1ZV0gb2YgT2JqZWN0LmVudHJpZXMoYWxsTGV2ZWxzKSkge1xuXHRcdFx0Ly8gYmlvbWUtaWdub3JlIGxpbnQvc3VzcGljaW91cy9ub0V4cGxpY2l0QW55OiBEeW5hbWljIGxvZ2dlciBsZXZlbCBjcmVhdGlvbiByZXF1aXJlcyBhbnlcblx0XHRcdChsb2dnZXIgYXMgYW55KVtsZXZlbE5hbWVdID0gbGV2ZWxWYWx1ZSA+PSB0aHJlc2hvbGQgPyBsb2dGdW5jdGlvbihsZXZlbE5hbWUpIDogbm9vcDtcblx0XHR9XG5cblx0XHRyZXR1cm4gbG9nZ2VyIGFzIExvZ2dlcjxULCBDdXN0b21Pbmx5Pjtcblx0fVxufVxuIl0sIm5hbWVzIjpbImZvcm1hdEVycm9yIiwiTG9nQWRhcHRlciIsIkRlZmF1bHRMb2dMZXZlbCIsIkxvZ0xldmVscyIsIkNvbnNvbGVBZGFwdGVyIiwiY29uZmlndXJlZExldmVscyIsImNvbmZpZ3VyZWRMb2dMZXZlbCIsImNvbmZpZ3VyZWRMb2dMZXZlbFZhbHVlIiwiaW5mbyIsIl9vcHRpb25zIiwiY29uZmlndXJlIiwic2NyaWJlT3B0aW9ucyIsImdldExvZ0xldmVscyIsImxvZ0xldmVsU3RyIiwibG9nTGV2ZWwiLCJnZXRMb2dnZXIiLCJuYW1lIiwibG9nZ2VyTmFtZSIsImNyZWF0ZUNvbnNvbGVMb2dnZXIiLCJhbGxMZXZlbHMiLCJjdXJyZW50TGV2ZWwiLCJ0aHJlc2hvbGQiLCJiYXNlTG9nZ2VyIiwibG9nTGV2ZWxzIiwibG9nRnVuY3Rpb24iLCJsZXZlbCIsIm1zZyIsImFyZ3MiLCJ0aW1lc3RhbXAiLCJEYXRlIiwidG9JU09TdHJpbmciLCJtZXNzYWdlIiwiRXJyb3IiLCJKU09OIiwic3RyaW5naWZ5IiwiU3RyaW5nIiwibG9nTGluZSIsInRvVXBwZXJDYXNlIiwibGVuZ3RoIiwiY29uc29sZSIsImxvZyIsIm5vb3AiLCJsb2dnZXIiLCJPYmplY3QiLCJhc3NpZ24iLCJpc0xldmVsRW5hYmxlZCIsImxldmVsTmFtZSIsImxldmVsVmFsdWUiLCJlbnRyaWVzIl0sIm1hcHBpbmdzIjoiQUFBQSxTQUFTQSxXQUFXLEVBQUVDLFVBQVUsUUFBUSxzQkFBc0I7QUFFOUQsU0FDQ0MsZUFBZSxFQUVmQyxTQUFTLFFBRUgsYUFBYTtBQUlwQixPQUFPLE1BQU1DLHVCQUF1Qkg7SUFDM0JJLGlCQUF5QztJQUN6Q0MscUJBQTZCSixnQkFBZ0I7SUFDN0NLLDBCQUFrQ0osVUFBVUssSUFBSSxDQUFDO0lBRXpELFlBQW1CQyxXQUFrQyxDQUFDLENBQUMsQ0FBRTtRQUN4RCxLQUFLO0lBQ047SUFFT0MsVUFDTkMsYUFBMkMsRUFDMUM7UUFDRCxxRUFBcUU7UUFDckUsSUFBSSxDQUFDTixnQkFBZ0IsR0FBRyxJQUFJLENBQUNPLFlBQVksQ0FBQ0Q7UUFDMUMsTUFBTUUsY0FBY0YsY0FBY0csUUFBUSxJQUFJWjtRQUM5QyxJQUFJLENBQUNJLGtCQUFrQixHQUFHTztRQUMxQixJQUFJLENBQUNOLHVCQUF1QixHQUFHLElBQUksQ0FBQ0YsZ0JBQWdCLENBQUNRLFlBQVksSUFBSVYsVUFBVUssSUFBSTtJQUNwRjtJQUVPTyxVQUNOQyxJQUFhLEVBQ1c7UUFDeEIsTUFBTUMsYUFBYUQsUUFBUTtRQUMzQixPQUFPLElBQUksQ0FBQ0UsbUJBQW1CLENBQWdCRDtJQUNoRDtJQUVRQyxvQkFHTkYsSUFBWSxFQUF5QjtRQUN0Qyx3REFBd0Q7UUFDeEQsTUFBTUcsWUFBWSxJQUFJLENBQUNkLGdCQUFnQjtRQUN2QyxNQUFNZSxlQUFlLElBQUksQ0FBQ2Qsa0JBQWtCO1FBQzVDLE1BQU1lLFlBQVksSUFBSSxDQUFDZCx1QkFBdUI7UUFFOUMsTUFBTWUsYUFBeUI7WUFDOUIsSUFBSUYsZ0JBQWU7Z0JBQ2xCLE9BQU9BO1lBQ1I7WUFDQSxJQUFJRyxhQUFZO2dCQUNmLE9BQU9KO1lBQ1I7UUFDRDtRQUVBLE1BQU1LLGNBQ0wsQ0FBQ0MsUUFDRCxDQUFDQyxLQUErQixHQUFHQztnQkFDbEMsTUFBTUMsWUFBWSxJQUFJQyxPQUFPQyxXQUFXO2dCQUN4QyxJQUFJQztnQkFFSixJQUFJLE9BQU9MLFFBQVEsVUFBVTtvQkFDNUJLLFVBQVVMLGVBQWVNLFFBQVFoQyxZQUFZMEIsT0FBT08sS0FBS0MsU0FBUyxDQUFDUjtnQkFDcEUsT0FBTztvQkFDTkssVUFBVUksT0FBT1Q7Z0JBQ2xCO2dCQUVBLE1BQU1VLFVBQVUsQ0FBQyxDQUFDLEVBQUVSLFVBQVUsRUFBRSxFQUFFSCxNQUFNWSxXQUFXLEdBQUcsRUFBRSxFQUFFckIsS0FBSyxHQUFHLEVBQUVlLFNBQVM7Z0JBRTdFLElBQUlKLEtBQUtXLE1BQU0sR0FBRyxHQUFHO29CQUNwQkMsUUFBUUMsR0FBRyxDQUFDSixZQUFZVDtnQkFDekIsT0FBTztvQkFDTlksUUFBUUMsR0FBRyxDQUFDSjtnQkFDYjtZQUNEO1FBRUQsTUFBTUssT0FBTyxLQUFPO1FBRXBCLG1EQUFtRDtRQUNuRCxNQUFNQyxTQUFTQyxPQUFPQyxNQUFNLENBQUN0QixZQUFZO1lBQ3hDdUIsZ0JBQWdCLENBQUNwQixRQUFrQixBQUFDTixDQUFBQSxTQUFTLENBQUNNLE1BQU0sSUFBSSxDQUFBLEtBQU1KO1FBQy9EO1FBRUEsMkRBQTJEO1FBQzNELDREQUE0RDtRQUM1RCxLQUFLLE1BQU0sQ0FBQ3lCLFdBQVdDLFdBQVcsSUFBSUosT0FBT0ssT0FBTyxDQUFDN0IsV0FBWTtZQUNoRSx5RkFBeUY7WUFDeEZ1QixNQUFjLENBQUNJLFVBQVUsR0FBR0MsY0FBYzFCLFlBQVlHLFlBQVlzQixhQUFhTDtRQUNqRjtRQUVBLE9BQU9DO0lBQ1I7QUFDRCJ9

package/es6/src/env.js

@@ -17,10 +17,11 @@ const VALID_LEVELS = [
 /**
  * Reads the log level from environment variables.
  * Checks LOG_LEVEL, SCRIBE_LOG_LEVEL, and LOGGING_LEVEL in order.
- * Returns null if none are set.
+ * Returns null if none are set, or if the runtime has no `process` (browsers).
  */ export function getLogLevelFromEnv() {
+    const env = globalThis.process?.env;
     for (const name of ENV_VAR_NAMES){
-        const value = process.env[name]?.trim().toLowerCase();
+        const value = env?.[name]?.trim().toLowerCase();
         if (value) {
             return value;
         }
@@ -75,5 +76,3 @@ export function resolveLogLevel(arg) {
     }
     return defaultLogLevel;
 }
-
-//# sourceMappingURL=data:application/json;base64,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

package/es6/src/errors.js

@@ -1,4 +1,2 @@
 export class LoggingConfigurationError extends Error {
 }
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUvc3JjL2Vycm9ycy50cyJdLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgY2xhc3MgTG9nZ2luZ0NvbmZpZ3VyYXRpb25FcnJvciBleHRlbmRzIEVycm9yIHt9XG4iXSwibmFtZXMiOlsiTG9nZ2luZ0NvbmZpZ3VyYXRpb25FcnJvciIsIkVycm9yIl0sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLE1BQU1BLGtDQUFrQ0M7QUFBTyJ9

package/es6/src/index.js

@@ -1,9 +1,10 @@
 export * from "./console.adapter.js";
 export * from "./env.js";
 export * from "./errors.js";
+export * from "./log-entry.adapter.js";
+export * from "./log-entry.js";
 export * from "./logger.adapter.js";
 export * from "./logger.factory.js";
 export * from "./logger.type.js";
+export * from "./redact.js";
 export * from "./types.js";
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUvc3JjL2luZGV4LnRzIl0sInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gXCIuL2NvbnNvbGUuYWRhcHRlci5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vZW52LmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9lcnJvcnMuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL2xvZ2dlci5hZGFwdGVyLmpzXCI7XG5leHBvcnQgKiBmcm9tIFwiLi9sb2dnZXIuZmFjdG9yeS5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vbG9nZ2VyLnR5cGUuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3R5cGVzLmpzXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyx1QkFBdUI7QUFDckMsY0FBYyxXQUFXO0FBQ3pCLGNBQWMsY0FBYztBQUM1QixjQUFjLHNCQUFzQjtBQUNwQyxjQUFjLHNCQUFzQjtBQUNwQyxjQUFjLG1CQUFtQjtBQUNqQyxjQUFjLGFBQWEifQ==

package/es6/src/log-entry.adapter.js

@@ -0,0 +1,49 @@
+import { logEntry } from "./log-entry.js";
+import { LogAdapter } from "./logger.adapter.js";
+import { redact } from "./redact.js";
+import { DefaultLogLevel, LogLevels } from "./types.js";
+/**
+ * Base for adapters that write structured entries. It owns levels, the level
+ * threshold, `child`, and censoring the `redactions` keys; a subclass only
+ * writes each `LogEntry`.
+ */ export class LogEntryAdapter extends LogAdapter {
+    levels = LogLevels;
+    level = DefaultLogLevel;
+    threshold = LogLevels.info;
+    redactionKeys = redact.fromOptions();
+    configure(scribeOptions) {
+        this.levels = this.getLogLevels(scribeOptions);
+        this.level = scribeOptions.logLevel ?? DefaultLogLevel;
+        this.threshold = this.levels[this.level] ?? LogLevels.info;
+        this.redactionKeys = redact.fromOptions(scribeOptions.redactions);
+    }
+    getLogger(name) {
+        return this.createLogger(name || "default", {});
+    }
+    createLogger(name, bindings) {
+        const { levels, level: currentLevel, threshold, redactionKeys } = this;
+        const baseLogger = {
+            get currentLevel () {
+                return currentLevel;
+            },
+            get logLevels () {
+                return levels;
+            }
+        };
+        const noop = ()=>{};
+        const methods = {};
+        for (const [level, value] of Object.entries(levels)){
+            methods[level] = value >= threshold ? (...args)=>this.write(logEntry.from(level, name, args, {
+                    bindings,
+                    redactionKeys
+                })) : noop;
+        }
+        return Object.assign(baseLogger, methods, {
+            isLevelEnabled: (level)=>(levels[level] ?? 0) >= threshold,
+            child: (fields)=>this.createLogger(name, {
+                    ...bindings,
+                    ...fields
+                })
+        });
+    }
+}

package/es6/src/log-entry.js

@@ -0,0 +1,79 @@
+import { serializeError } from "./logger.adapter.js";
+import { redact } from "./redact.js";
+function isFields(value) {
+    return value != null && typeof value === "object" && !Array.isArray(value);
+}
+/** Serialize errors passed as fields (`{ error }`), so they keep their message and stack. */ function serializeErrors(fields) {
+    const out = {};
+    for (const [key, value] of Object.entries(fields)){
+        out[key] = value instanceof Error ? serializeError(value) : value;
+    }
+    return out;
+}
+/**
+ * Builds an entry from a log call's arguments:
+ *
+ * - `log.info("text")`, `log.info(42)` → `msg`
+ * - `log.error(err)` → `msg` is `err.message`, `err` the serialized error
+ * - `log.info({ fields })`, `log.info({ fields }, "text")` → `fields` (a string
+ *   `msg` field becomes the message)
+ * - `log.info("text", { fields })` → `msg` + `fields`
+ * - `log.error("text", err)` → `msg` + `err`
+ * - `log.info("text", value)` → `msg` + `fields.data`; any further arguments go
+ *   in `fields.args`
+ */ function from(level, name, [first, ...rest], { bindings, redactionKeys }) {
+    let msg;
+    let err;
+    let fields = {};
+    if (first instanceof Error) {
+        err = first;
+        msg = first.message;
+    } else if (isFields(first)) {
+        const { msg: fieldMsg, ...others } = first;
+        fields = others;
+        if (typeof fieldMsg === "string") {
+            msg = fieldMsg;
+        } else if (fieldMsg !== undefined) {
+            fields.msg = fieldMsg;
+        }
+        if (typeof rest[0] === "string") {
+            msg = rest.shift();
+        }
+    } else if (first !== undefined) {
+        msg = String(first);
+    }
+    const [second, ...extra] = rest;
+    if (second instanceof Error && err == null) {
+        err = second;
+    } else if (isFields(second)) {
+        fields = {
+            ...fields,
+            ...second
+        };
+    } else if (second !== undefined) {
+        fields.data = second;
+    }
+    if (extra.length > 0) {
+        fields.args = extra;
+    }
+    const allFields = serializeErrors({
+        ...bindings,
+        ...fields
+    });
+    const entry = {
+        level,
+        name,
+        fields: redactionKeys == null ? allFields : redact.object(allFields, redactionKeys)
+    };
+    if (msg !== undefined) {
+        entry.msg = msg;
+    }
+    if (err != null) {
+        const serialized = serializeError(err);
+        entry.err = redactionKeys == null ? serialized : redact.object(serialized, redactionKeys);
+    }
+    return entry;
+}
+export const logEntry = {
+    from
+};

package/es6/src/logger.adapter.js

@@ -2,11 +2,52 @@ import { LogLevels } from "./types.js";
 export function formatError(err) {
     return err.stack ?? err.message;
 }
+/** How many causes deep `serializeError` follows by default. */ export const DefaultErrorCauseDepth = 3;
+/**
+ * Plain-object form of an error for structured logs. An `Error` cause, or an
+ * `Error` in another own property, is serialized the same way, up to
+ * `causeDepth` levels; any other value is kept as it is.
+ */ export function serializeError(err, causeDepth = DefaultErrorCauseDepth) {
+    const out = {
+        name: err.name,
+        message: err.message
+    };
+    if (err.stack != null) {
+        out.stack = err.stack;
+    }
+    for (const [key, value] of Object.entries(err)){
+        if (key === "cause" || key in out) {
+            continue;
+        }
+        if (!(value instanceof Error)) {
+            out[key] = value;
+        } else if (causeDepth > 0) {
+            out[key] = serializeError(value, causeDepth - 1);
+        }
+    }
+    const { cause } = err;
+    if (cause instanceof Error) {
+        if (causeDepth > 0) {
+            out.cause = serializeError(cause, causeDepth - 1);
+        }
+    } else if (cause !== undefined) {
+        out.cause = cause;
+    }
+    return out;
+}
 export class LogAdapter {
     flush(cb) {
         cb?.();
     }
-    // biome-ignore lint/suspicious/noExplicitAny: Generic utility method needs flexible typing
+    retire() {
+    // Console / no-op adapters have nothing to release.
+    }
+    async stop() {
+        await this[Symbol.asyncDispose]();
+    }
+    async [Symbol.asyncDispose]() {
+    // Console / no-op adapters have nothing to release.
+    }
     getLogLevels(options) {
         const { customOnly, customLevels } = options;
         if (customOnly) {
@@ -23,5 +64,3 @@ export class LogAdapter {
         return unique;
     }
 }
-
-//# sourceMappingURL=data:application/json;base64,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

package/es6/src/logger.factory.js

@@ -1,23 +1,81 @@
 import { ConsoleAdapter } from "./console.adapter.js";
 import { resolveLogLevel } from "./env.js";
 import { LoggingConfigurationError } from "./errors.js";
+import { logEntry } from "./log-entry.js";
 import { DefaultLogLevel, DefaultRedactions } from "./types.js";
 export class scribe {
     loggerProvider;
+    /** True after `configure({ adapter })` — the constructor’s ConsoleAdapter is only a fallback. */ adapterConfigured = false;
+    defaultAdapterWarned = false;
+    tap;
     static instance = new scribe();
     static logger(name, customLevels) {
-        return scribe.instance.getLogger(name, customLevels);
+        // Apply custom levels once against the active adapter; the live handle
+        // re-resolves the underlying logger on each use.
+        if (customLevels) {
+            scribe.instance.getLogger(name, customLevels);
+        }
+        return scribe.createLiveLogger(name);
     }
     static configure(configOptions) {
+        const previous = scribe.instance;
+        // Sync: stop writes into the old ThreadStream before a new worker starts.
+        previous.retire();
         scribe.instance = new scribe();
-        return scribe.instance.configure(configOptions);
-    }
-    static get extend() {
-        return scribe.instance;
+        scribe.instance.configure(configOptions);
+        // Async drain of the retired adapter (flush / end). Flux/App.dispose may
+        // have already done this; reconfigure without stop still needs it.
+        void previous.stop();
+        return (name)=>scribe.logger(name);
     }
     static flush(cb) {
         scribe.instance.loggerProvider.flush(cb);
     }
+    /** Synchronously stop accepting writes on the active adapter. */ static retire() {
+        scribe.instance.retire();
+    }
+    /** Drain the active adapter and release workers / destinations. */ static async stop() {
+        await scribe.instance.stop();
+    }
+    /**
+	 * Module-level `const log = scribe.logger(...)` must follow a later
+	 * `scribe.configure()` (CLI / Flux / HotReloadServer). Forward every use to
+	 * the active adapter logger for `name`, and `child(fields)` to a live handle
+	 * that adds `bindings`, so children follow a reconfigure too.
+	 */ static createLiveLogger(name, bindings = {}) {
+        const bound = Object.keys(bindings).length > 0;
+        const resolve = ()=>{
+            const root = scribe.instance.getLogger(name);
+            return bound ? root.child(bindings) : root;
+        };
+        return new Proxy({}, {
+            get (_target, prop) {
+                if (prop === "child") {
+                    return (fields)=>scribe.createLiveLogger(name, {
+                            ...bindings,
+                            ...fields
+                        });
+                }
+                const underlying = resolve();
+                const value = Reflect.get(underlying, prop, underlying);
+                if (typeof value !== "function") {
+                    return value;
+                }
+                const method = value.bind(underlying);
+                const instance = scribe.instance;
+                if (instance.tap == null || typeof prop !== "string" || !Object.hasOwn(underlying.logLevels, prop) || !underlying.isLevelEnabled(prop)) {
+                    return method;
+                }
+                return (...args)=>{
+                    method(...args);
+                    instance.notifyTap(prop, name ?? "default", args, bindings);
+                };
+            },
+            has (_target, prop) {
+                return Reflect.has(resolve(), prop);
+            }
+        });
+    }
     constructor(){
         // Initialize with default console adapter
         this.loggerProvider = new ConsoleAdapter();
@@ -25,13 +83,32 @@ export class scribe {
         this.loggerProvider.configure(defaultOptions);
     }
     configure(configOptions) {
-        const { adapter, options } = configOptions;
+        const { adapter, options, tap } = configOptions;
+        const previous = this.loggerProvider;
+        if (previous !== adapter) {
+            previous.retire();
+        }
         this.loggerProvider = adapter;
+        this.adapterConfigured = true;
+        this.tap = tap;
         const defaultsAndOptions = this.mergeDefaults(options);
         adapter.configure(defaultsAndOptions);
-        return (name)=>adapter.getLogger(name);
+        if (previous !== adapter) {
+            void previous.stop();
+        }
+        return (name)=>scribe.logger(name);
+    }
+    retire() {
+        this.loggerProvider.retire();
+    }
+    async stop() {
+        await this.loggerProvider.stop();
+    }
+    async [Symbol.asyncDispose]() {
+        await this.stop();
     }
     getLogger(name, customLevels) {
+        this.warnIfDefaultAdapter();
         // If custom levels are provided, we need to reconfigure the adapter
         if (customLevels) {
             const currentOptions = this.mergeDefaults({
@@ -43,6 +120,30 @@ export class scribe {
         this.supportsLevels(customLevels, logger);
         return logger;
     }
+    notifyTap(level, name, args, bindings) {
+        const tap = this.tap;
+        if (tap == null) {
+            return;
+        }
+        try {
+            tap(logEntry.from(level, name, args, {
+                bindings
+            }));
+        } catch (err) {
+            // Not swallowed: the logging call returns, the runtime reports the tap's error.
+            queueMicrotask(()=>{
+                throw err;
+            });
+        }
+    }
+    warnIfDefaultAdapter() {
+        if (this.adapterConfigured || this.defaultAdapterWarned) {
+            return;
+        }
+        this.defaultAdapterWarned = true;
+        // console.warn, not the stderr stream: the facade runs in browsers and Workers too.
+        console.warn("[scribe] No logger adapter configured; using the default ConsoleAdapter. " + "Configure an adapter at your composition root (for production, prefer " + "@decohere/scribe-pino → JSON on stdout). See " + "https://github.com/typesmiths/decohere/blob/main/projects/scribe/README.md");
+    }
     supportsLevels(customLevels, logger) {
         if (!customLevels) {
             return;
@@ -57,12 +158,12 @@ export class scribe {
     }
     mergeDefaults(options) {
         const logLevel = resolveLogLevel(options?.logLevel) ?? DefaultLogLevel;
+        // Resolved logLevel must win over options spread (invalid explicit values
+        // would otherwise stick).
         return {
-            logLevel,
             redactions: DefaultRedactions,
-            ...options
+            ...options,
+            logLevel
         };
     }
 }
-
-//# sourceMappingURL=data:application/json;base64,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

package/es6/src/logger.type.js

@@ -1,3 +1 @@
 export { };
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUvc3JjL2xvZ2dlci50eXBlLnRzIl0sInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB0eXBlIHsgRGVmYXVsdExldmVscyB9IGZyb20gXCIuL3R5cGVzLmpzXCI7XG5cbmV4cG9ydCBpbnRlcmZhY2UgQmFzZUxvZ2dlciB7XG5cdGdldCBjdXJyZW50TGV2ZWwoKTogc3RyaW5nO1xuXHRnZXQgbG9nTGV2ZWxzKCk6IFJlY29yZDxzdHJpbmcsIG51bWJlcj47XG59XG5cbmV4cG9ydCB0eXBlIExvZ0ZuID0gKG1zZzogc3RyaW5nIHwgbnVtYmVyIHwgb2JqZWN0LCAuLi5hcmdzOiB1bmtub3duW10pID0+IHZvaWQ7XG5cbmV4cG9ydCB0eXBlIExvZ2dlcjxcblx0Q3VzdG9tTGV2ZWxzIGV4dGVuZHMgc3RyaW5nID0gbmV2ZXIsXG5cdEN1c3RvbU9ubHkgZXh0ZW5kcyB0cnVlIHwgZmFsc2UgPSB1bmRlZmluZWQsXG4+ID0ge1xuXHRbSyBpbiBEZWZhdWx0TGV2ZWxzIGFzIEN1c3RvbU9ubHkgZXh0ZW5kcyBmYWxzZSA/IEsgOiBuZXZlcl06IExvZ0ZuO1xufSAmIHtcblx0W1Byb3BlcnR5IGluIEN1c3RvbUxldmVsc106IExvZ0ZuO1xufSAmIHtcblx0aXNMZXZlbEVuYWJsZWQobGV2ZWw6IHN0cmluZyk6IGJvb2xlYW47XG59ICYgQmFzZUxvZ2dlcjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFTQSxXQVNlIn0=

package/es6/src/redact.js

@@ -0,0 +1,57 @@
+import { DefaultCensor, DefaultRedactions } from "./types.js";
+function keysFromPaths(paths) {
+    const keys = new Set();
+    for (const path of paths){
+        const segments = path.split(".").filter((segment)=>segment.length > 0 && segment !== "*");
+        const key = segments.at(-1);
+        if (key != null) {
+            keys.add(key);
+        }
+    }
+    return keys;
+}
+function isPlainObject(value) {
+    if (value == null || typeof value !== "object" || Array.isArray(value) || value instanceof Error) {
+        return false;
+    }
+    const proto = Object.getPrototypeOf(value);
+    return proto === Object.prototype || proto === null;
+}
+function object(value, keys, censor = DefaultCensor, copies = new WeakMap()) {
+    if (value == null || typeof value !== "object") {
+        return value;
+    }
+    if (value instanceof Error) {
+        return value;
+    }
+    // A cycle in the input stays a cycle in the copy.
+    const copied = copies.get(value);
+    if (copied !== undefined) {
+        return copied;
+    }
+    if (Array.isArray(value)) {
+        const out = [];
+        copies.set(value, out);
+        for (const item of value){
+            out.push(object(item, keys, censor, copies));
+        }
+        return out;
+    }
+    if (!isPlainObject(value)) {
+        return value;
+    }
+    const out = {};
+    copies.set(value, out);
+    for (const [key, nested] of Object.entries(value)){
+        out[key] = keys.has(key) ? censor : object(nested, keys, censor, copies);
+    }
+    return out;
+}
+function fromOptions(options) {
+    return keysFromPaths(options?.paths ?? DefaultRedactions.paths);
+}
+export const redact = {
+    object,
+    keysFromPaths,
+    fromOptions
+};

package/es6/src/testing/capture.adapter.js

@@ -0,0 +1,17 @@
+import { LogEntryAdapter } from "../log-entry.adapter.js";
+/**
+ * Test double: keeps every entry that passes the level threshold, prints
+ * nothing. `scribe.configure({ adapter: capture })`, run the code, then assert
+ * on `capture.entries`.
+ */ export class CaptureAdapter extends LogEntryAdapter {
+    entries = [];
+    /** Entries at `level`. */ at(level) {
+        return this.entries.filter((entry)=>entry.level === level);
+    }
+    clear() {
+        this.entries.length = 0;
+    }
+    write(entry) {
+        this.entries.push(entry);
+    }
+}

package/es6/src/testing/index.js

@@ -1,3 +1 @@
-export { };
-
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUvc3JjL3Rlc3RpbmcvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHt9O1xuIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLFdBQVUifQ==
+export * from "./capture.adapter.js";