@decohere/scribe-pino 0.0.1-dev.7 → 0.0.1-dev.70

package/commonjs/src/index.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", {
     value: true
 });
 _export_star(require("./pino.adapater.js"), exports);
+_export_star(require("./pino.recipe.js"), exports);
 _export_star(require("./scribe-pino.js"), exports);
 function _export_star(from, to) {
     Object.keys(from).forEach(function(k) {
@@ -18,4 +19,4 @@ function _export_star(from, to) {
     return from;
 }
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUtcGluby9zcmMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vcGluby5hZGFwYXRlci5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2NyaWJlLXBpbm8uanNcIjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7O3FCQUFjO3FCQUNBIn0=
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUtcGluby9zcmMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vcGluby5hZGFwYXRlci5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcGluby5yZWNpcGUuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NjcmliZS1waW5vLmpzXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6Ijs7OztxQkFBYztxQkFDQTtxQkFDQSJ9

package/commonjs/src/pino.adapater.js

@@ -19,6 +19,8 @@ class PinoAdapter extends _scribe.LogAdapter {
     _pino;
     options;
     stream;
+    disposed = false;
+    retired = false;
     constructor(options, stream){
         super();
         this.options = options;
@@ -48,12 +50,80 @@ class PinoAdapter extends _scribe.LogAdapter {
         return logger;
     }
     flush(cb) {
+        if (this.retired || !this._pino) {
+            cb?.();
+            return;
+        }
         this._pino.flush(cb);
     }
+    /**
+	 * Immediately stop accepting writes into the destination (ThreadStream).
+	 * Does not wait for flush — use `stop()` for async drain after retire.
+	 */ retire() {
+        if (this.retired) {
+            return;
+        }
+        this.retired = true;
+        const guarded = this.stream;
+        if (typeof guarded?.retire === "function") {
+            guarded.retire("adapter retired");
+            return;
+        }
+        destroyDestination(this.stream);
+    }
+    async [Symbol.asyncDispose]() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        if (this._pino && !this.retired) {
+            await new Promise((resolve)=>{
+                try {
+                    this._pino.flush(()=>resolve());
+                } catch  {
+                    resolve();
+                }
+            });
+        }
+        if (!this.retired) {
+            await endDestination(this.stream);
+        }
+        // Mark dead after graceful end (or immediately if already force-retired).
+        this.retire();
+    }
+}
+function destroyDestination(stream) {
+    const destroyable = stream;
+    if (typeof destroyable?.destroy === "function") {
+        try {
+            destroyable.destroy();
+        } catch  {
+        // already dead
+        }
+    }
+}
+function endDestination(stream) {
+    const endable = stream;
+    if (typeof endable?.end !== "function") {
+        return Promise.resolve();
+    }
+    return new Promise((resolve)=>{
+        try {
+            endable.end(()=>resolve());
+        } catch  {
+            resolve();
+        }
+    });
 }
 function logMethod(args, method) {
     let message = args.at(0);
     const data = args.at(1);
+    if (message instanceof Error) {
+        method.call(this, {
+            err: message
+        }, (0, _scribe.formatError)(message));
+        return;
+    }
     if (data instanceof Error) {
         message = {
             msg: message,
@@ -85,4 +155,4 @@ function pinoMix(logger) {
     });
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe-pino/src/pino.adapater.ts"],"sourcesContent":["import {\n\ttype BaseLogger,\n\tformatError,\n\tLogAdapter,\n\ttype Logger,\n\ttype ScribeOptions,\n} from \"@decohere/scribe\";\nimport pino, { type LogFn } from \"pino\";\n\nimport type { GuardedTransport } from \"./pino.transport-guard.js\";\n\nexport type PinoAdapaterOptions = {\n\toptions?: pino.LoggerOptions;\n\tstream?: pino.DestinationStream;\n};\n\ntype EndableStream = {\n\tend?: (cb?: (err?: Error | null) => void) => void;\n\tdestroy?: (error?: Error) => void;\n};\n\nexport class PinoAdapter extends LogAdapter {\n\tprivate _pino: pino.Logger;\n\tprivate readonly options: pino.LoggerOptions;\n\tprivate readonly stream: pino.DestinationStream | undefined;\n\tprivate disposed = false;\n\tprivate retired = false;\n\n\tpublic constructor(options: pino.LoggerOptions, stream?: pino.DestinationStream) {\n\t\tsuper();\n\t\tthis.options = options;\n\t\tthis.stream = stream;\n\t}\n\n\tpublic configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tscribeOptions: ScribeOptions<T, CustomOnly>,\n\t) {\n\t\tconst { logLevel, redactions } = scribeOptions;\n\t\tconst customLevels = this.getLogLevels(scribeOptions);\n\n\t\tconst pinoOptions: pino.LoggerOptions = {\n\t\t\tcustomLevels,\n\t\t\tlevel: logLevel,\n\t\t\thooks: { logMethod },\n\t\t\tserializers: {\n\t\t\t\terror: pino.stdSerializers.err,\n\t\t\t},\n\t\t\tredact: redactions,\n\t\t\t...this.options,\n\t\t};\n\t\tthis._pino = pino(pinoOptions, this.stream);\n\t}\n\n\tpublic getLogger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname: string,\n\t): Logger<T, CustomOnly> {\n\t\tconst logger = pinoMix<T, CustomOnly>(this._pino.child({ name }));\n\t\treturn logger;\n\t}\n\n\tpublic flush(cb?: () => void): void {\n\t\tif (this.retired || !this._pino) {\n\t\t\tcb?.();\n\t\t\treturn;\n\t\t}\n\t\tthis._pino.flush(cb);\n\t}\n\n\t/**\n\t * Immediately stop accepting writes into the destination (ThreadStream).\n\t * Does not wait for flush — use `stop()` for async drain after retire.\n\t */\n\tpublic retire(): void {\n\t\tif (this.retired) {\n\t\t\treturn;\n\t\t}\n\t\tthis.retired = true;\n\t\tconst guarded = this.stream as GuardedTransport | undefined;\n\t\tif (typeof guarded?.retire === \"function\") {\n\t\t\tguarded.retire(\"adapter retired\");\n\t\t\treturn;\n\t\t}\n\t\tdestroyDestination(this.stream);\n\t}\n\n\tpublic async [Symbol.asyncDispose](): Promise<void> {\n\t\tif (this.disposed) {\n\t\t\treturn;\n\t\t}\n\t\tthis.disposed = true;\n\t\tif (this._pino && !this.retired) {\n\t\t\tawait new Promise<void>((resolve) => {\n\t\t\t\ttry {\n\t\t\t\t\tthis._pino.flush(() => resolve());\n\t\t\t\t} catch {\n\t\t\t\t\tresolve();\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\tif (!this.retired) {\n\t\t\tawait endDestination(this.stream);\n\t\t}\n\t\t// Mark dead after graceful end (or immediately if already force-retired).\n\t\tthis.retire();\n\t}\n}\n\nfunction destroyDestination(stream: pino.DestinationStream | undefined): void {\n\tconst destroyable = stream as EndableStream | undefined;\n\tif (typeof destroyable?.destroy === \"function\") {\n\t\ttry {\n\t\t\tdestroyable.destroy();\n\t\t} catch {\n\t\t\t// already dead\n\t\t}\n\t}\n}\n\nfunction endDestination(stream: pino.DestinationStream | undefined): Promise<void> {\n\tconst endable = stream as EndableStream | undefined;\n\tif (typeof endable?.end !== \"function\") {\n\t\treturn Promise.resolve();\n\t}\n\treturn new Promise<void>((resolve) => {\n\t\ttry {\n\t\t\tendable.end(() => resolve());\n\t\t} catch {\n\t\t\tresolve();\n\t\t}\n\t});\n}\n\nfunction logMethod(this: pino.Logger, args: Parameters<LogFn>, method: LogFn) {\n\tlet message = args.at(0);\n\tconst data = args.at(1);\n\n\tif (message instanceof Error) {\n\t\tmethod.call(this, { err: message }, formatError(message));\n\t\treturn;\n\t}\n\n\tif (data instanceof Error) {\n\t\tmessage = { msg: message, ...{ error: data } };\n\t} else if (typeof data === \"object\") {\n\t\tmessage = { msg: message, ...data };\n\t} else {\n\t\tmessage = { msg: message, data };\n\t}\n\n\tmethod.call(this, message);\n}\n\nfunction pinoMix<T extends string = never, CustomOnly extends true | false = false>(\n\tlogger: pino.Logger,\n): Logger<T, CustomOnly> {\n\treturn Object.assign<pino.Logger, BaseLogger>(logger, {\n\t\tget currentLevel() {\n\t\t\treturn logger.level;\n\t\t},\n\t\tget logLevels() {\n\t\t\treturn logger.levels.values;\n\t\t},\n\t}) as Logger<T, CustomOnly>;\n}\n"],"names":["PinoAdapter","LogAdapter","_pino","options","stream","disposed","retired","configure","scribeOptions","logLevel","redactions","customLevels","getLogLevels","pinoOptions","level","hooks","logMethod","serializers","error","pino","stdSerializers","err","redact","getLogger","name","logger","pinoMix","child","flush","cb","retire","guarded","destroyDestination","Symbol","asyncDispose","Promise","resolve","endDestination","destroyable","destroy","endable","end","args","method","message","at","data","Error","call","formatError","msg","Object","assign","currentLevel","logLevels","levels","values"],"mappings":"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"}

package/commonjs/src/pino.recipe.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "pinoRecipe", {
+    enumerable: true,
+    get: function() {
+        return pinoRecipe;
+    }
+});
+const _system = require("@decohere/nexus/system");
+const DEFAULT_ROLL_SIZE = "10m";
+const DEFAULT_ROLL_FREQUENCY = "daily";
+const DEFAULT_ROLL_KEEP = 14;
+function currentEnvironment() {
+    return process.env.NODE_ENV === _system.Environments.production ? _system.Environments.production : _system.Environments.development;
+}
+function isEnabled(when, environment) {
+    return (when ?? "development") === "always" || environment === _system.Environments.development;
+}
+function prettyTarget(options) {
+    return {
+        target: "pino-pretty",
+        options: {
+            colorize: options.colorize ?? true
+        }
+    };
+}
+function rollTarget(options) {
+    return {
+        target: "pino-roll",
+        options: {
+            file: options.file,
+            mkdir: options.mkdir ?? true,
+            size: options.size ?? DEFAULT_ROLL_SIZE,
+            frequency: options.frequency ?? DEFAULT_ROLL_FREQUENCY,
+            limit: {
+                count: options.keep ?? DEFAULT_ROLL_KEEP
+            },
+            symlink: options.symlink ?? false
+        }
+    };
+}
+function transport(plan, environment = currentEnvironment()) {
+    const targets = [];
+    if (plan.pretty && isEnabled(plan.pretty.when, environment)) {
+        targets.push(prettyTarget(plan.pretty));
+    }
+    if (plan.roll && isEnabled(plan.roll.when, environment)) {
+        targets.push(rollTarget(plan.roll));
+    }
+    if (targets.length === 0) {
+        return undefined;
+    }
+    if (targets.length === 1) {
+        return targets[0];
+    }
+    return {
+        targets
+    };
+}
+const pinoRecipe = {
+    transport,
+    currentEnvironment
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/pino.transport-guard.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "guardTransport", {
+    enumerable: true,
+    get: function() {
+        return guardTransport;
+    }
+});
+function guardTransport(transport) {
+    const stream = transport;
+    let retired = false;
+    let reported = false;
+    const retire = (reason = "retired")=>{
+        if (retired) {
+            return;
+        }
+        retired = true;
+        if (!reported) {
+            reported = true;
+            process.stderr.write(`[scribe-pino] transport retired: ${reason}\n`);
+        }
+        if (typeof stream.destroy === "function") {
+            try {
+                stream.destroy();
+            } catch  {
+            // already dead
+            }
+        }
+    };
+    if (typeof stream.on === "function") {
+        stream.on("error", (err)=>{
+            retire(err?.message ?? String(err));
+        });
+    }
+    if (typeof stream.write === "function") {
+        const originalWrite = stream.write.bind(stream);
+        stream.write = (chunk, encodingOrCb, cb)=>{
+            if (retired) {
+                completeWrite(encodingOrCb, cb);
+                return true;
+            }
+            try {
+                return originalWrite(chunk, encodingOrCb, cb);
+            } catch (err) {
+                retire(err instanceof Error ? err.message : String(err));
+                completeWrite(encodingOrCb, cb);
+                return true;
+            }
+        };
+    }
+    Object.defineProperty(stream, "retired", {
+        get: ()=>retired,
+        enumerable: true
+    });
+    Object.defineProperty(stream, "retire", {
+        value: retire,
+        enumerable: true
+    });
+    return stream;
+}
+function completeWrite(encodingOrCb, cb) {
+    const done = typeof encodingOrCb === "function" ? encodingOrCb : typeof cb === "function" ? cb : undefined;
+    if (typeof done === "function") {
+        done();
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/commonjs/src/scribe-pino.js

@@ -2,16 +2,35 @@
 Object.defineProperty(exports, "__esModule", {
     value: true
 });
-Object.defineProperty(exports, "PinoExtensions", {
-    enumerable: true,
-    get: function() {
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get PinoExtensions () {
         return PinoExtensions;
+    },
+    get guardTransport () {
+        return _pinotransportguard.guardTransport;
+    },
+    get pinoTransport () {
+        return pinoTransport;
     }
 });
 const _extensibility = require("@decohere/nexus/extensibility");
 const _system = require("@decohere/nexus/system");
 const _scribe = require("@decohere/scribe");
+const _pino = /*#__PURE__*/ _interop_require_default(require("pino"));
 const _pinoadapater = require("./pino.adapater.js");
+const _pinorecipe = require("./pino.recipe.js");
+const _pinotransportguard = require("./pino.transport-guard.js");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
 function _ts_decorate(decorators, target, key, desc) {
     var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
     if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
@@ -27,23 +46,28 @@ class PinoExtensions {
             logLevel
         }, config);
     }
-    static withPinoPretty(factory, logLevel) {
-        return PinoExtensions.withPino(factory, {
-            transports: {
-                target: "pino-pretty",
-                options: {
-                    colorize: true
-                }
-            }
-        }, logLevel);
+    static withPinoPretty(factory, logLevelOrOptions) {
+        const pretty = parsePrettyArg(logLevelOrOptions);
+        return attachRecipe(factory, {
+            pretty,
+            logLevel: pretty.logLevel
+        });
+    }
+    static withPinoRoll(factory, options) {
+        return attachRecipe(factory, {
+            roll: options,
+            logLevel: options.logLevel
+        });
     }
     static withPinoCustom(factory, options) {
-        const { scribe, transports } = options;
+        const { scribe, transports } = options ?? {};
         return configureScribe(factory, scribe, transports);
     }
 }
 _ts_decorate([
-    (0, _extensibility.extension)(_scribe.scribe),
+    (0, _extensibility.extension)(_scribe.scribe, {
+        static: true
+    }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _scribe.scribe === "undefined" ? Object : _scribe.scribe,
@@ -53,7 +77,9 @@ _ts_decorate([
     _ts_metadata("design:returntype", void 0)
 ], PinoExtensions, "withPino", null);
 _ts_decorate([
-    (0, _extensibility.extension)(_scribe.scribe),
+    (0, _extensibility.extension)(_scribe.scribe, {
+        static: true
+    }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _scribe.scribe === "undefined" ? Object : _scribe.scribe,
@@ -62,7 +88,20 @@ _ts_decorate([
     _ts_metadata("design:returntype", void 0)
 ], PinoExtensions, "withPinoPretty", null);
 _ts_decorate([
-    (0, _extensibility.extension)(_scribe.scribe),
+    (0, _extensibility.extension)(_scribe.scribe, {
+        static: true
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof _scribe.scribe === "undefined" ? Object : _scribe.scribe,
+        typeof PinoRollRecipeOptions === "undefined" ? Object : PinoRollRecipeOptions
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], PinoExtensions, "withPinoRoll", null);
+_ts_decorate([
+    (0, _extensibility.extension)(_scribe.scribe, {
+        static: true
+    }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof _scribe.scribe === "undefined" ? Object : _scribe.scribe,
@@ -70,23 +109,88 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", void 0)
 ], PinoExtensions, "withPinoCustom", null);
+function parsePrettyArg(logLevelOrOptions) {
+    if (logLevelOrOptions == null) {
+        return {};
+    }
+    if (typeof logLevelOrOptions === "string") {
+        return {
+            logLevel: logLevelOrOptions
+        };
+    }
+    return logLevelOrOptions;
+}
+function attachRecipe(factory, plan) {
+    const loggerFactory = applyRecipe(factory, plan);
+    const chain = {
+        withPinoPretty (logLevelOrOptions) {
+            const pretty = parsePrettyArg(logLevelOrOptions);
+            return attachRecipe(factory, {
+                ...plan,
+                pretty: {
+                    ...plan.pretty,
+                    ...pretty
+                },
+                logLevel: pretty.logLevel ?? plan.logLevel
+            });
+        },
+        withPinoRoll (options) {
+            return attachRecipe(factory, {
+                ...plan,
+                roll: options,
+                logLevel: options.logLevel ?? plan.logLevel
+            });
+        }
+    };
+    return Object.assign(loggerFactory, chain, {
+        and: chain
+    });
+}
+/**
+ * Guard a worker transport so failures (roll EEXIST, worker exit) neither
+ * crash the process nor spam stderr on every subsequent log write.
+ */ function createSafeTransport(options) {
+    return (0, _pinotransportguard.guardTransport)(_pino.default.transport(options));
+}
+function adapterForTransport(transport) {
+    if (transport == null) {
+        return new _pinoadapater.PinoAdapter({});
+    }
+    return new _pinoadapater.PinoAdapter({}, createSafeTransport(transport));
+}
+function applyRecipe(factory, plan) {
+    const adapter = adapterForTransport(_pinorecipe.pinoRecipe.transport(plan));
+    return factory.configure({
+        options: {
+            logLevel: plan.logLevel ?? _scribe.DefaultLogLevel
+        },
+        adapter
+    });
+}
 function configureScribe(factory, options, config) {
     const environment = process.env.NODE_ENV ?? _system.DefaultEnvironment;
-    const configs = Array.isArray(config) ? config : [
+    const configs = (Array.isArray(config) ? config : config != null ? [
         config
-    ];
-    const transports = configs.filter((config)=>config.environment && config.environment === environment || true);
-    if (transports.length > 1) {
+    ] : []).filter((item)=>item.environment == null || item.environment === environment);
+    if (configs.length > 1) {
         throw new _scribe.LoggingConfigurationError(`There should only be one configuration per environment for logging`);
     }
-    const transport = transports.at(0)?.transports;
-    const adapter = new _pinoadapater.PinoAdapter({
-        transport
-    });
+    const adapter = adapterForTransport(configs.at(0)?.transports);
     return factory.configure({
-        options,
+        options: {
+            ...options,
+            logLevel: options?.logLevel ?? _scribe.DefaultLogLevel
+        },
         adapter
     });
 }
+/** @deprecated Use {@link guardTransport} — kept for callers/tests from the silence-only era. */ function silenceErrors(transport) {
+    return (0, _pinotransportguard.guardTransport)(transport);
+}
+const pinoTransport = {
+    createSafeTransport,
+    guardTransport: _pinotransportguard.guardTransport,
+    silenceErrors
+};
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe-pino/src/scribe-pino.ts"],"sourcesContent":["import { extension } from \"@decohere/nexus/extensibility\";\nimport { DefaultEnvironment, type Environment } from \"@decohere/nexus/system\";\nimport {\n\ttype DefaultLevels,\n\tDefaultLogLevel,\n\ttype Logger,\n\tLoggingConfigurationError,\n\ttype ScribeOptions,\n\tscribe,\n} from \"@decohere/scribe\";\nimport pino, {\n\ttype DestinationStream,\n\ttype TransportMultiOptions,\n\ttype TransportPipelineOptions,\n\ttype TransportSingleOptions,\n} from \"pino\";\n\nimport { PinoAdapter } from \"./pino.adapater.js\";\nimport {\n\ttype PinoPrettyRecipeOptions,\n\ttype PinoRecipePlan,\n\ttype PinoRollRecipeOptions,\n\tpinoRecipe,\n} from \"./pino.recipe.js\";\nimport { type GuardedTransport, guardTransport } from \"./pino.transport-guard.js\";\n\nexport type { GuardedTransport } from \"./pino.transport-guard.js\";\nexport { guardTransport } from \"./pino.transport-guard.js\";\n\ntype TransportOptions =\n\t| TransportSingleOptions\n\t| TransportMultiOptions\n\t| TransportPipelineOptions;\n\ntype TransportConfig = {\n\tenvironment?: Environment;\n\ttransports: TransportOptions;\n};\n\ntype CustomLevelOptions<T extends string = never, CustomOnly extends true = undefined> = {\n\tscribe?: ScribeOptions<T, CustomOnly>;\n\ttransports?: TransportConfig | TransportConfig[];\n};\n\nexport type PinoLoggerFactory = (name?: string) => Logger;\n\nexport type PinoRecipeChain = {\n\twithPinoPretty(\n\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t): PinoRecipe;\n\twithPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;\n};\n\nexport type PinoRecipe = PinoLoggerFactory &\n\tPinoRecipeChain & {\n\t\treadonly and: PinoRecipeChain;\n\t};\n\ndeclare module \"@decohere/scribe\" {\n\tinterface scribe {\n\t\twithPino(\n\t\t\ttransports: TransportConfig | TransportConfig[],\n\t\t\tloglevel?: DefaultLevels | string,\n\t\t): PinoLoggerFactory;\n\t\t/**\n\t\t * Colorized pretty transport. Development only unless `{ when: \"always\" }`.\n\t\t * Chain with `.and.withPinoRoll({ file })`. Production writes JSON to stdout\n\t\t * so log shipping stays outside the process.\n\t\t */\n\t\twithPinoPretty(\n\t\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t\t): PinoRecipe;\n\t\t/**\n\t\t * Rolling log files. Development only unless `{ when: \"always\" }`.\n\t\t * Do not enable in production — ship stdout from a sidecar or platform agent.\n\t\t * `symlink` defaults off; enabling it can race under multi-worker / HMR.\n\t\t */\n\t\twithPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;\n\t\twithPinoCustom<T extends string = never, CustomOnly extends true = undefined>(\n\t\t\toptions?: CustomLevelOptions<T, CustomOnly>,\n\t\t): PinoLoggerFactory;\n\t}\n\tnamespace scribe {\n\t\tfunction withPino(\n\t\t\ttransports: TransportConfig | TransportConfig[],\n\t\t\tloglevel?: DefaultLevels | string,\n\t\t): PinoLoggerFactory;\n\t\tfunction withPinoPretty(\n\t\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t\t): PinoRecipe;\n\t\tfunction withPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;\n\t\tfunction withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(\n\t\t\toptions?: CustomLevelOptions<T, CustomOnly>,\n\t\t): PinoLoggerFactory;\n\t}\n}\n\nexport class PinoExtensions {\n\t@extension(scribe, { static: true })\n\tpublic static withPino(\n\t\tfactory: scribe,\n\t\tconfig: TransportConfig | TransportConfig[],\n\t\tlogLevel?: DefaultLevels | string,\n\t) {\n\t\treturn configureScribe(factory, { logLevel }, config);\n\t}\n\n\t@extension(scribe, { static: true })\n\tpublic static withPinoPretty(\n\t\tfactory: scribe,\n\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t) {\n\t\tconst pretty = parsePrettyArg(logLevelOrOptions);\n\t\treturn attachRecipe(factory, { pretty, logLevel: pretty.logLevel });\n\t}\n\n\t@extension(scribe, { static: true })\n\tpublic static withPinoRoll(factory: scribe, options: PinoRollRecipeOptions) {\n\t\treturn attachRecipe(factory, { roll: options, logLevel: options.logLevel });\n\t}\n\n\t@extension(scribe, { static: true })\n\tpublic static withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(\n\t\tfactory: scribe,\n\t\toptions?: CustomLevelOptions<T, CustomOnly>,\n\t) {\n\t\tconst { scribe, transports } = options ?? {};\n\t\treturn configureScribe(factory, scribe, transports);\n\t}\n}\n\nfunction parsePrettyArg(\n\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n): PinoPrettyRecipeOptions {\n\tif (logLevelOrOptions == null) {\n\t\treturn {};\n\t}\n\tif (typeof logLevelOrOptions === \"string\") {\n\t\treturn { logLevel: logLevelOrOptions };\n\t}\n\treturn logLevelOrOptions;\n}\n\nfunction attachRecipe(factory: scribe, plan: PinoRecipePlan): PinoRecipe {\n\tconst loggerFactory = applyRecipe(factory, plan);\n\tconst chain: PinoRecipeChain = {\n\t\twithPinoPretty(logLevelOrOptions) {\n\t\t\tconst pretty = parsePrettyArg(logLevelOrOptions);\n\t\t\treturn attachRecipe(factory, {\n\t\t\t\t...plan,\n\t\t\t\tpretty: { ...plan.pretty, ...pretty },\n\t\t\t\tlogLevel: pretty.logLevel ?? plan.logLevel,\n\t\t\t});\n\t\t},\n\t\twithPinoRoll(options) {\n\t\t\treturn attachRecipe(factory, {\n\t\t\t\t...plan,\n\t\t\t\troll: options,\n\t\t\t\tlogLevel: options.logLevel ?? plan.logLevel,\n\t\t\t});\n\t\t},\n\t};\n\treturn Object.assign(loggerFactory, chain, { and: chain });\n}\n\n/**\n * Guard a worker transport so failures (roll EEXIST, worker exit) neither\n * crash the process nor spam stderr on every subsequent log write.\n */\nfunction createSafeTransport(options: TransportOptions): DestinationStream {\n\treturn guardTransport(pino.transport(options));\n}\n\nfunction adapterForTransport(transport?: TransportOptions): PinoAdapter {\n\tif (transport == null) {\n\t\treturn new PinoAdapter({});\n\t}\n\treturn new PinoAdapter({}, createSafeTransport(transport));\n}\n\nfunction applyRecipe(factory: scribe, plan: PinoRecipePlan): PinoLoggerFactory {\n\tconst adapter = adapterForTransport(pinoRecipe.transport(plan));\n\treturn factory.configure({\n\t\toptions: { logLevel: plan.logLevel ?? DefaultLogLevel },\n\t\tadapter,\n\t});\n}\n\nfunction configureScribe<T extends string = never, CustomOnly extends true | false = false>(\n\tfactory: scribe,\n\toptions: ScribeOptions<T, CustomOnly>,\n\tconfig?: TransportConfig | TransportConfig[],\n) {\n\tconst environment = process.env.NODE_ENV ?? DefaultEnvironment;\n\tconst configs = (Array.isArray(config) ? config : config != null ? [config] : []).filter(\n\t\t(item) => item.environment == null || item.environment === environment,\n\t);\n\n\tif (configs.length > 1) {\n\t\tthrow new LoggingConfigurationError(\n\t\t\t`There should only be one configuration per environment for logging`,\n\t\t);\n\t}\n\n\tconst adapter = adapterForTransport(configs.at(0)?.transports);\n\treturn factory.configure({\n\t\toptions: { ...options, logLevel: options?.logLevel ?? DefaultLogLevel },\n\t\tadapter,\n\t});\n}\n\n/** @deprecated Use {@link guardTransport} — kept for callers/tests from the silence-only era. */\nfunction silenceErrors(transport: {\n\ton(event: \"error\", listener: (err: Error) => void): unknown;\n\twrite?: (...args: never[]) => unknown;\n}): GuardedTransport {\n\treturn guardTransport(transport as DestinationStream);\n}\n\nexport const pinoTransport = { createSafeTransport, guardTransport, silenceErrors };\n"],"names":["PinoExtensions","guardTransport","pinoTransport","withPino","factory","config","logLevel","configureScribe","withPinoPretty","logLevelOrOptions","pretty","parsePrettyArg","attachRecipe","withPinoRoll","options","roll","withPinoCustom","scribe","transports","static","plan","loggerFactory","applyRecipe","chain","Object","assign","and","createSafeTransport","pino","transport","adapterForTransport","PinoAdapter","adapter","pinoRecipe","configure","DefaultLogLevel","environment","process","env","NODE_ENV","DefaultEnvironment","configs","Array","isArray","filter","item","length","LoggingConfigurationError","at","silenceErrors"],"mappings":"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"}

package/es6/src/index.js

@@ -1,4 +1,5 @@
 export * from "./pino.adapater.js";
+export * from "./pino.recipe.js";
 export * from "./scribe-pino.js";
 
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUtcGluby9zcmMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vcGluby5hZGFwYXRlci5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vc2NyaWJlLXBpbm8uanNcIjtcbiJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLHFCQUFxQjtBQUNuQyxjQUFjLG1CQUFtQiJ9
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJzb3VyY2VzIjpbIi9ob21lL3J1bm5lci93b3JrL2RlY29oZXJlL2RlY29oZXJlL3Byb2plY3RzL3NjcmliZS9zY3JpYmUtcGluby9zcmMvaW5kZXgudHMiXSwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0ICogZnJvbSBcIi4vcGluby5hZGFwYXRlci5qc1wiO1xuZXhwb3J0ICogZnJvbSBcIi4vcGluby5yZWNpcGUuanNcIjtcbmV4cG9ydCAqIGZyb20gXCIuL3NjcmliZS1waW5vLmpzXCI7XG4iXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUEsY0FBYyxxQkFBcUI7QUFDbkMsY0FBYyxtQkFBbUI7QUFDakMsY0FBYyxtQkFBbUIifQ==

package/es6/src/pino.adapater.js

@@ -1,9 +1,11 @@
-import { LogAdapter } from "@decohere/scribe";
+import { formatError, LogAdapter } from "@decohere/scribe";
 import pino from "pino";
 export class PinoAdapter extends LogAdapter {
     _pino;
     options;
     stream;
+    disposed = false;
+    retired = false;
     constructor(options, stream){
         super();
         this.options = options;
@@ -33,12 +35,80 @@ export class PinoAdapter extends LogAdapter {
         return logger;
     }
     flush(cb) {
+        if (this.retired || !this._pino) {
+            cb?.();
+            return;
+        }
         this._pino.flush(cb);
     }
+    /**
+	 * Immediately stop accepting writes into the destination (ThreadStream).
+	 * Does not wait for flush — use `stop()` for async drain after retire.
+	 */ retire() {
+        if (this.retired) {
+            return;
+        }
+        this.retired = true;
+        const guarded = this.stream;
+        if (typeof guarded?.retire === "function") {
+            guarded.retire("adapter retired");
+            return;
+        }
+        destroyDestination(this.stream);
+    }
+    async [Symbol.asyncDispose]() {
+        if (this.disposed) {
+            return;
+        }
+        this.disposed = true;
+        if (this._pino && !this.retired) {
+            await new Promise((resolve)=>{
+                try {
+                    this._pino.flush(()=>resolve());
+                } catch  {
+                    resolve();
+                }
+            });
+        }
+        if (!this.retired) {
+            await endDestination(this.stream);
+        }
+        // Mark dead after graceful end (or immediately if already force-retired).
+        this.retire();
+    }
+}
+function destroyDestination(stream) {
+    const destroyable = stream;
+    if (typeof destroyable?.destroy === "function") {
+        try {
+            destroyable.destroy();
+        } catch  {
+        // already dead
+        }
+    }
+}
+function endDestination(stream) {
+    const endable = stream;
+    if (typeof endable?.end !== "function") {
+        return Promise.resolve();
+    }
+    return new Promise((resolve)=>{
+        try {
+            endable.end(()=>resolve());
+        } catch  {
+            resolve();
+        }
+    });
 }
 function logMethod(args, method) {
     let message = args.at(0);
     const data = args.at(1);
+    if (message instanceof Error) {
+        method.call(this, {
+            err: message
+        }, formatError(message));
+        return;
+    }
     if (data instanceof Error) {
         message = {
             msg: message,
@@ -70,4 +140,4 @@ function pinoMix(logger) {
     });
 }
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe-pino/src/pino.adapater.ts"],"sourcesContent":["import {\n\ttype BaseLogger,\n\tformatError,\n\tLogAdapter,\n\ttype Logger,\n\ttype ScribeOptions,\n} from \"@decohere/scribe\";\nimport pino, { type LogFn } from \"pino\";\n\nimport type { GuardedTransport } from \"./pino.transport-guard.js\";\n\nexport type PinoAdapaterOptions = {\n\toptions?: pino.LoggerOptions;\n\tstream?: pino.DestinationStream;\n};\n\ntype EndableStream = {\n\tend?: (cb?: (err?: Error | null) => void) => void;\n\tdestroy?: (error?: Error) => void;\n};\n\nexport class PinoAdapter extends LogAdapter {\n\tprivate _pino: pino.Logger;\n\tprivate readonly options: pino.LoggerOptions;\n\tprivate readonly stream: pino.DestinationStream | undefined;\n\tprivate disposed = false;\n\tprivate retired = false;\n\n\tpublic constructor(options: pino.LoggerOptions, stream?: pino.DestinationStream) {\n\t\tsuper();\n\t\tthis.options = options;\n\t\tthis.stream = stream;\n\t}\n\n\tpublic configure<T extends string = never, CustomOnly extends true | false = false>(\n\t\tscribeOptions: ScribeOptions<T, CustomOnly>,\n\t) {\n\t\tconst { logLevel, redactions } = scribeOptions;\n\t\tconst customLevels = this.getLogLevels(scribeOptions);\n\n\t\tconst pinoOptions: pino.LoggerOptions = {\n\t\t\tcustomLevels,\n\t\t\tlevel: logLevel,\n\t\t\thooks: { logMethod },\n\t\t\tserializers: {\n\t\t\t\terror: pino.stdSerializers.err,\n\t\t\t},\n\t\t\tredact: redactions,\n\t\t\t...this.options,\n\t\t};\n\t\tthis._pino = pino(pinoOptions, this.stream);\n\t}\n\n\tpublic getLogger<T extends string = never, CustomOnly extends true | false = false>(\n\t\tname: string,\n\t): Logger<T, CustomOnly> {\n\t\tconst logger = pinoMix<T, CustomOnly>(this._pino.child({ name }));\n\t\treturn logger;\n\t}\n\n\tpublic flush(cb?: () => void): void {\n\t\tif (this.retired || !this._pino) {\n\t\t\tcb?.();\n\t\t\treturn;\n\t\t}\n\t\tthis._pino.flush(cb);\n\t}\n\n\t/**\n\t * Immediately stop accepting writes into the destination (ThreadStream).\n\t * Does not wait for flush — use `stop()` for async drain after retire.\n\t */\n\tpublic retire(): void {\n\t\tif (this.retired) {\n\t\t\treturn;\n\t\t}\n\t\tthis.retired = true;\n\t\tconst guarded = this.stream as GuardedTransport | undefined;\n\t\tif (typeof guarded?.retire === \"function\") {\n\t\t\tguarded.retire(\"adapter retired\");\n\t\t\treturn;\n\t\t}\n\t\tdestroyDestination(this.stream);\n\t}\n\n\tpublic async [Symbol.asyncDispose](): Promise<void> {\n\t\tif (this.disposed) {\n\t\t\treturn;\n\t\t}\n\t\tthis.disposed = true;\n\t\tif (this._pino && !this.retired) {\n\t\t\tawait new Promise<void>((resolve) => {\n\t\t\t\ttry {\n\t\t\t\t\tthis._pino.flush(() => resolve());\n\t\t\t\t} catch {\n\t\t\t\t\tresolve();\n\t\t\t\t}\n\t\t\t});\n\t\t}\n\t\tif (!this.retired) {\n\t\t\tawait endDestination(this.stream);\n\t\t}\n\t\t// Mark dead after graceful end (or immediately if already force-retired).\n\t\tthis.retire();\n\t}\n}\n\nfunction destroyDestination(stream: pino.DestinationStream | undefined): void {\n\tconst destroyable = stream as EndableStream | undefined;\n\tif (typeof destroyable?.destroy === \"function\") {\n\t\ttry {\n\t\t\tdestroyable.destroy();\n\t\t} catch {\n\t\t\t// already dead\n\t\t}\n\t}\n}\n\nfunction endDestination(stream: pino.DestinationStream | undefined): Promise<void> {\n\tconst endable = stream as EndableStream | undefined;\n\tif (typeof endable?.end !== \"function\") {\n\t\treturn Promise.resolve();\n\t}\n\treturn new Promise<void>((resolve) => {\n\t\ttry {\n\t\t\tendable.end(() => resolve());\n\t\t} catch {\n\t\t\tresolve();\n\t\t}\n\t});\n}\n\nfunction logMethod(this: pino.Logger, args: Parameters<LogFn>, method: LogFn) {\n\tlet message = args.at(0);\n\tconst data = args.at(1);\n\n\tif (message instanceof Error) {\n\t\tmethod.call(this, { err: message }, formatError(message));\n\t\treturn;\n\t}\n\n\tif (data instanceof Error) {\n\t\tmessage = { msg: message, ...{ error: data } };\n\t} else if (typeof data === \"object\") {\n\t\tmessage = { msg: message, ...data };\n\t} else {\n\t\tmessage = { msg: message, data };\n\t}\n\n\tmethod.call(this, message);\n}\n\nfunction pinoMix<T extends string = never, CustomOnly extends true | false = false>(\n\tlogger: pino.Logger,\n): Logger<T, CustomOnly> {\n\treturn Object.assign<pino.Logger, BaseLogger>(logger, {\n\t\tget currentLevel() {\n\t\t\treturn logger.level;\n\t\t},\n\t\tget logLevels() {\n\t\t\treturn logger.levels.values;\n\t\t},\n\t}) as Logger<T, CustomOnly>;\n}\n"],"names":["formatError","LogAdapter","pino","PinoAdapter","_pino","options","stream","disposed","retired","configure","scribeOptions","logLevel","redactions","customLevels","getLogLevels","pinoOptions","level","hooks","logMethod","serializers","error","stdSerializers","err","redact","getLogger","name","logger","pinoMix","child","flush","cb","retire","guarded","destroyDestination","Symbol","asyncDispose","Promise","resolve","endDestination","destroyable","destroy","endable","end","args","method","message","at","data","Error","call","msg","Object","assign","currentLevel","logLevels","levels","values"],"mappings":"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"}

package/es6/src/pino.recipe.js

@@ -0,0 +1,57 @@
+import { Environments } from "@decohere/nexus/system";
+const DEFAULT_ROLL_SIZE = "10m";
+const DEFAULT_ROLL_FREQUENCY = "daily";
+const DEFAULT_ROLL_KEEP = 14;
+function currentEnvironment() {
+    return process.env.NODE_ENV === Environments.production ? Environments.production : Environments.development;
+}
+function isEnabled(when, environment) {
+    return (when ?? "development") === "always" || environment === Environments.development;
+}
+function prettyTarget(options) {
+    return {
+        target: "pino-pretty",
+        options: {
+            colorize: options.colorize ?? true
+        }
+    };
+}
+function rollTarget(options) {
+    return {
+        target: "pino-roll",
+        options: {
+            file: options.file,
+            mkdir: options.mkdir ?? true,
+            size: options.size ?? DEFAULT_ROLL_SIZE,
+            frequency: options.frequency ?? DEFAULT_ROLL_FREQUENCY,
+            limit: {
+                count: options.keep ?? DEFAULT_ROLL_KEEP
+            },
+            symlink: options.symlink ?? false
+        }
+    };
+}
+function transport(plan, environment = currentEnvironment()) {
+    const targets = [];
+    if (plan.pretty && isEnabled(plan.pretty.when, environment)) {
+        targets.push(prettyTarget(plan.pretty));
+    }
+    if (plan.roll && isEnabled(plan.roll.when, environment)) {
+        targets.push(rollTarget(plan.roll));
+    }
+    if (targets.length === 0) {
+        return undefined;
+    }
+    if (targets.length === 1) {
+        return targets[0];
+    }
+    return {
+        targets
+    };
+}
+export const pinoRecipe = {
+    transport,
+    currentEnvironment
+};
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/pino.transport-guard.js

@@ -0,0 +1,63 @@
+/**
+ * Wrap a pino worker transport so a dead ThreadStream cannot spam or crash.
+ * On first error / write throw: report once, destroy, no-op further writes.
+ */ export function guardTransport(transport) {
+    const stream = transport;
+    let retired = false;
+    let reported = false;
+    const retire = (reason = "retired")=>{
+        if (retired) {
+            return;
+        }
+        retired = true;
+        if (!reported) {
+            reported = true;
+            process.stderr.write(`[scribe-pino] transport retired: ${reason}\n`);
+        }
+        if (typeof stream.destroy === "function") {
+            try {
+                stream.destroy();
+            } catch  {
+            // already dead
+            }
+        }
+    };
+    if (typeof stream.on === "function") {
+        stream.on("error", (err)=>{
+            retire(err?.message ?? String(err));
+        });
+    }
+    if (typeof stream.write === "function") {
+        const originalWrite = stream.write.bind(stream);
+        stream.write = (chunk, encodingOrCb, cb)=>{
+            if (retired) {
+                completeWrite(encodingOrCb, cb);
+                return true;
+            }
+            try {
+                return originalWrite(chunk, encodingOrCb, cb);
+            } catch (err) {
+                retire(err instanceof Error ? err.message : String(err));
+                completeWrite(encodingOrCb, cb);
+                return true;
+            }
+        };
+    }
+    Object.defineProperty(stream, "retired", {
+        get: ()=>retired,
+        enumerable: true
+    });
+    Object.defineProperty(stream, "retire", {
+        value: retire,
+        enumerable: true
+    });
+    return stream;
+}
+function completeWrite(encodingOrCb, cb) {
+    const done = typeof encodingOrCb === "function" ? encodingOrCb : typeof cb === "function" ? cb : undefined;
+    if (typeof done === "function") {
+        done();
+    }
+}
+
+//# sourceMappingURL=data:application/json;base64,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

package/es6/src/scribe-pino.js

@@ -9,31 +9,40 @@ function _ts_metadata(k, v) {
 }
 import { extension } from "@decohere/nexus/extensibility";
 import { DefaultEnvironment } from "@decohere/nexus/system";
-import { LoggingConfigurationError, scribe } from "@decohere/scribe";
+import { DefaultLogLevel, LoggingConfigurationError, scribe } from "@decohere/scribe";
+import pino from "pino";
 import { PinoAdapter } from "./pino.adapater.js";
+import { pinoRecipe } from "./pino.recipe.js";
+import { guardTransport } from "./pino.transport-guard.js";
+export { guardTransport } from "./pino.transport-guard.js";
 export class PinoExtensions {
     static withPino(factory, config, logLevel) {
         return configureScribe(factory, {
             logLevel
         }, config);
     }
-    static withPinoPretty(factory, logLevel) {
-        return PinoExtensions.withPino(factory, {
-            transports: {
-                target: "pino-pretty",
-                options: {
-                    colorize: true
-                }
-            }
-        }, logLevel);
+    static withPinoPretty(factory, logLevelOrOptions) {
+        const pretty = parsePrettyArg(logLevelOrOptions);
+        return attachRecipe(factory, {
+            pretty,
+            logLevel: pretty.logLevel
+        });
+    }
+    static withPinoRoll(factory, options) {
+        return attachRecipe(factory, {
+            roll: options,
+            logLevel: options.logLevel
+        });
     }
     static withPinoCustom(factory, options) {
-        const { scribe, transports } = options;
+        const { scribe, transports } = options ?? {};
         return configureScribe(factory, scribe, transports);
     }
 }
 _ts_decorate([
-    extension(scribe),
+    extension(scribe, {
+        static: true
+    }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof scribe === "undefined" ? Object : scribe,
@@ -43,7 +52,9 @@ _ts_decorate([
     _ts_metadata("design:returntype", void 0)
 ], PinoExtensions, "withPino", null);
 _ts_decorate([
-    extension(scribe),
+    extension(scribe, {
+        static: true
+    }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof scribe === "undefined" ? Object : scribe,
@@ -52,7 +63,20 @@ _ts_decorate([
     _ts_metadata("design:returntype", void 0)
 ], PinoExtensions, "withPinoPretty", null);
 _ts_decorate([
-    extension(scribe),
+    extension(scribe, {
+        static: true
+    }),
+    _ts_metadata("design:type", Function),
+    _ts_metadata("design:paramtypes", [
+        typeof scribe === "undefined" ? Object : scribe,
+        typeof PinoRollRecipeOptions === "undefined" ? Object : PinoRollRecipeOptions
+    ]),
+    _ts_metadata("design:returntype", void 0)
+], PinoExtensions, "withPinoRoll", null);
+_ts_decorate([
+    extension(scribe, {
+        static: true
+    }),
     _ts_metadata("design:type", Function),
     _ts_metadata("design:paramtypes", [
         typeof scribe === "undefined" ? Object : scribe,
@@ -60,23 +84,88 @@ _ts_decorate([
     ]),
     _ts_metadata("design:returntype", void 0)
 ], PinoExtensions, "withPinoCustom", null);
+function parsePrettyArg(logLevelOrOptions) {
+    if (logLevelOrOptions == null) {
+        return {};
+    }
+    if (typeof logLevelOrOptions === "string") {
+        return {
+            logLevel: logLevelOrOptions
+        };
+    }
+    return logLevelOrOptions;
+}
+function attachRecipe(factory, plan) {
+    const loggerFactory = applyRecipe(factory, plan);
+    const chain = {
+        withPinoPretty (logLevelOrOptions) {
+            const pretty = parsePrettyArg(logLevelOrOptions);
+            return attachRecipe(factory, {
+                ...plan,
+                pretty: {
+                    ...plan.pretty,
+                    ...pretty
+                },
+                logLevel: pretty.logLevel ?? plan.logLevel
+            });
+        },
+        withPinoRoll (options) {
+            return attachRecipe(factory, {
+                ...plan,
+                roll: options,
+                logLevel: options.logLevel ?? plan.logLevel
+            });
+        }
+    };
+    return Object.assign(loggerFactory, chain, {
+        and: chain
+    });
+}
+/**
+ * Guard a worker transport so failures (roll EEXIST, worker exit) neither
+ * crash the process nor spam stderr on every subsequent log write.
+ */ function createSafeTransport(options) {
+    return guardTransport(pino.transport(options));
+}
+function adapterForTransport(transport) {
+    if (transport == null) {
+        return new PinoAdapter({});
+    }
+    return new PinoAdapter({}, createSafeTransport(transport));
+}
+function applyRecipe(factory, plan) {
+    const adapter = adapterForTransport(pinoRecipe.transport(plan));
+    return factory.configure({
+        options: {
+            logLevel: plan.logLevel ?? DefaultLogLevel
+        },
+        adapter
+    });
+}
 function configureScribe(factory, options, config) {
     const environment = process.env.NODE_ENV ?? DefaultEnvironment;
-    const configs = Array.isArray(config) ? config : [
+    const configs = (Array.isArray(config) ? config : config != null ? [
         config
-    ];
-    const transports = configs.filter((config)=>config.environment && config.environment === environment || true);
-    if (transports.length > 1) {
+    ] : []).filter((item)=>item.environment == null || item.environment === environment);
+    if (configs.length > 1) {
         throw new LoggingConfigurationError(`There should only be one configuration per environment for logging`);
     }
-    const transport = transports.at(0)?.transports;
-    const adapter = new PinoAdapter({
-        transport
-    });
+    const adapter = adapterForTransport(configs.at(0)?.transports);
     return factory.configure({
-        options,
+        options: {
+            ...options,
+            logLevel: options?.logLevel ?? DefaultLogLevel
+        },
         adapter
     });
 }
+/** @deprecated Use {@link guardTransport} — kept for callers/tests from the silence-only era. */ function silenceErrors(transport) {
+    return guardTransport(transport);
+}
+export const pinoTransport = {
+    createSafeTransport,
+    guardTransport,
+    silenceErrors
+};
 
-//# sourceMappingURL=data:application/json;base64,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
+//# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["/home/runner/work/decohere/decohere/projects/scribe/scribe-pino/src/scribe-pino.ts"],"sourcesContent":["import { extension } from \"@decohere/nexus/extensibility\";\nimport { DefaultEnvironment, type Environment } from \"@decohere/nexus/system\";\nimport {\n\ttype DefaultLevels,\n\tDefaultLogLevel,\n\ttype Logger,\n\tLoggingConfigurationError,\n\ttype ScribeOptions,\n\tscribe,\n} from \"@decohere/scribe\";\nimport pino, {\n\ttype DestinationStream,\n\ttype TransportMultiOptions,\n\ttype TransportPipelineOptions,\n\ttype TransportSingleOptions,\n} from \"pino\";\n\nimport { PinoAdapter } from \"./pino.adapater.js\";\nimport {\n\ttype PinoPrettyRecipeOptions,\n\ttype PinoRecipePlan,\n\ttype PinoRollRecipeOptions,\n\tpinoRecipe,\n} from \"./pino.recipe.js\";\nimport { type GuardedTransport, guardTransport } from \"./pino.transport-guard.js\";\n\nexport type { GuardedTransport } from \"./pino.transport-guard.js\";\nexport { guardTransport } from \"./pino.transport-guard.js\";\n\ntype TransportOptions =\n\t| TransportSingleOptions\n\t| TransportMultiOptions\n\t| TransportPipelineOptions;\n\ntype TransportConfig = {\n\tenvironment?: Environment;\n\ttransports: TransportOptions;\n};\n\ntype CustomLevelOptions<T extends string = never, CustomOnly extends true = undefined> = {\n\tscribe?: ScribeOptions<T, CustomOnly>;\n\ttransports?: TransportConfig | TransportConfig[];\n};\n\nexport type PinoLoggerFactory = (name?: string) => Logger;\n\nexport type PinoRecipeChain = {\n\twithPinoPretty(\n\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t): PinoRecipe;\n\twithPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;\n};\n\nexport type PinoRecipe = PinoLoggerFactory &\n\tPinoRecipeChain & {\n\t\treadonly and: PinoRecipeChain;\n\t};\n\ndeclare module \"@decohere/scribe\" {\n\tinterface scribe {\n\t\twithPino(\n\t\t\ttransports: TransportConfig | TransportConfig[],\n\t\t\tloglevel?: DefaultLevels | string,\n\t\t): PinoLoggerFactory;\n\t\t/**\n\t\t * Colorized pretty transport. Development only unless `{ when: \"always\" }`.\n\t\t * Chain with `.and.withPinoRoll({ file })`. Production writes JSON to stdout\n\t\t * so log shipping stays outside the process.\n\t\t */\n\t\twithPinoPretty(\n\t\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t\t): PinoRecipe;\n\t\t/**\n\t\t * Rolling log files. Development only unless `{ when: \"always\" }`.\n\t\t * Do not enable in production — ship stdout from a sidecar or platform agent.\n\t\t * `symlink` defaults off; enabling it can race under multi-worker / HMR.\n\t\t */\n\t\twithPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;\n\t\twithPinoCustom<T extends string = never, CustomOnly extends true = undefined>(\n\t\t\toptions?: CustomLevelOptions<T, CustomOnly>,\n\t\t): PinoLoggerFactory;\n\t}\n\tnamespace scribe {\n\t\tfunction withPino(\n\t\t\ttransports: TransportConfig | TransportConfig[],\n\t\t\tloglevel?: DefaultLevels | string,\n\t\t): PinoLoggerFactory;\n\t\tfunction withPinoPretty(\n\t\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t\t): PinoRecipe;\n\t\tfunction withPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;\n\t\tfunction withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(\n\t\t\toptions?: CustomLevelOptions<T, CustomOnly>,\n\t\t): PinoLoggerFactory;\n\t}\n}\n\nexport class PinoExtensions {\n\t@extension(scribe, { static: true })\n\tpublic static withPino(\n\t\tfactory: scribe,\n\t\tconfig: TransportConfig | TransportConfig[],\n\t\tlogLevel?: DefaultLevels | string,\n\t) {\n\t\treturn configureScribe(factory, { logLevel }, config);\n\t}\n\n\t@extension(scribe, { static: true })\n\tpublic static withPinoPretty(\n\t\tfactory: scribe,\n\t\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n\t) {\n\t\tconst pretty = parsePrettyArg(logLevelOrOptions);\n\t\treturn attachRecipe(factory, { pretty, logLevel: pretty.logLevel });\n\t}\n\n\t@extension(scribe, { static: true })\n\tpublic static withPinoRoll(factory: scribe, options: PinoRollRecipeOptions) {\n\t\treturn attachRecipe(factory, { roll: options, logLevel: options.logLevel });\n\t}\n\n\t@extension(scribe, { static: true })\n\tpublic static withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(\n\t\tfactory: scribe,\n\t\toptions?: CustomLevelOptions<T, CustomOnly>,\n\t) {\n\t\tconst { scribe, transports } = options ?? {};\n\t\treturn configureScribe(factory, scribe, transports);\n\t}\n}\n\nfunction parsePrettyArg(\n\tlogLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions,\n): PinoPrettyRecipeOptions {\n\tif (logLevelOrOptions == null) {\n\t\treturn {};\n\t}\n\tif (typeof logLevelOrOptions === \"string\") {\n\t\treturn { logLevel: logLevelOrOptions };\n\t}\n\treturn logLevelOrOptions;\n}\n\nfunction attachRecipe(factory: scribe, plan: PinoRecipePlan): PinoRecipe {\n\tconst loggerFactory = applyRecipe(factory, plan);\n\tconst chain: PinoRecipeChain = {\n\t\twithPinoPretty(logLevelOrOptions) {\n\t\t\tconst pretty = parsePrettyArg(logLevelOrOptions);\n\t\t\treturn attachRecipe(factory, {\n\t\t\t\t...plan,\n\t\t\t\tpretty: { ...plan.pretty, ...pretty },\n\t\t\t\tlogLevel: pretty.logLevel ?? plan.logLevel,\n\t\t\t});\n\t\t},\n\t\twithPinoRoll(options) {\n\t\t\treturn attachRecipe(factory, {\n\t\t\t\t...plan,\n\t\t\t\troll: options,\n\t\t\t\tlogLevel: options.logLevel ?? plan.logLevel,\n\t\t\t});\n\t\t},\n\t};\n\treturn Object.assign(loggerFactory, chain, { and: chain });\n}\n\n/**\n * Guard a worker transport so failures (roll EEXIST, worker exit) neither\n * crash the process nor spam stderr on every subsequent log write.\n */\nfunction createSafeTransport(options: TransportOptions): DestinationStream {\n\treturn guardTransport(pino.transport(options));\n}\n\nfunction adapterForTransport(transport?: TransportOptions): PinoAdapter {\n\tif (transport == null) {\n\t\treturn new PinoAdapter({});\n\t}\n\treturn new PinoAdapter({}, createSafeTransport(transport));\n}\n\nfunction applyRecipe(factory: scribe, plan: PinoRecipePlan): PinoLoggerFactory {\n\tconst adapter = adapterForTransport(pinoRecipe.transport(plan));\n\treturn factory.configure({\n\t\toptions: { logLevel: plan.logLevel ?? DefaultLogLevel },\n\t\tadapter,\n\t});\n}\n\nfunction configureScribe<T extends string = never, CustomOnly extends true | false = false>(\n\tfactory: scribe,\n\toptions: ScribeOptions<T, CustomOnly>,\n\tconfig?: TransportConfig | TransportConfig[],\n) {\n\tconst environment = process.env.NODE_ENV ?? DefaultEnvironment;\n\tconst configs = (Array.isArray(config) ? config : config != null ? [config] : []).filter(\n\t\t(item) => item.environment == null || item.environment === environment,\n\t);\n\n\tif (configs.length > 1) {\n\t\tthrow new LoggingConfigurationError(\n\t\t\t`There should only be one configuration per environment for logging`,\n\t\t);\n\t}\n\n\tconst adapter = adapterForTransport(configs.at(0)?.transports);\n\treturn factory.configure({\n\t\toptions: { ...options, logLevel: options?.logLevel ?? DefaultLogLevel },\n\t\tadapter,\n\t});\n}\n\n/** @deprecated Use {@link guardTransport} — kept for callers/tests from the silence-only era. */\nfunction silenceErrors(transport: {\n\ton(event: \"error\", listener: (err: Error) => void): unknown;\n\twrite?: (...args: never[]) => unknown;\n}): GuardedTransport {\n\treturn guardTransport(transport as DestinationStream);\n}\n\nexport const pinoTransport = { createSafeTransport, guardTransport, silenceErrors };\n"],"names":["extension","DefaultEnvironment","DefaultLogLevel","LoggingConfigurationError","scribe","pino","PinoAdapter","pinoRecipe","guardTransport","PinoExtensions","withPino","factory","config","logLevel","configureScribe","withPinoPretty","logLevelOrOptions","pretty","parsePrettyArg","attachRecipe","withPinoRoll","options","roll","withPinoCustom","transports","static","plan","loggerFactory","applyRecipe","chain","Object","assign","and","createSafeTransport","transport","adapterForTransport","adapter","configure","environment","process","env","NODE_ENV","configs","Array","isArray","filter","item","length","at","silenceErrors","pinoTransport"],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/scribe-pino",
-  "version": "0.0.1-dev.7",
+  "version": "0.0.1-dev.70",
   "description": "Pino adapter for @decohere/scribe",
   "keywords": [
     "typescript",
@@ -23,9 +23,21 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/nexus": "0.0.1-dev.7",
-    "@decohere/scribe": "0.0.1-dev.7",
+    "@decohere/nexus": "0.0.1-dev.70",
+    "@decohere/scribe": "0.0.1-dev.70",
     "pino": "^10.3.0"
   },
-  "devDependencies": {}
+  "devDependencies": {},
+  "peerDependencies": {
+    "pino-pretty": "^13.0.0",
+    "pino-roll": "^4.0.0"
+  },
+  "peerDependenciesMeta": {
+    "pino-pretty": {
+      "optional": true
+    },
+    "pino-roll": {
+      "optional": true
+    }
+  }
 }

package/types/src/index.d.ts

@@ -1,2 +1,3 @@
 export * from "./pino.adapater.js";
+export * from "./pino.recipe.js";
 export * from "./scribe-pino.js";

package/types/src/pino.adapater.d.ts

@@ -8,8 +8,16 @@ export declare class PinoAdapter extends LogAdapter {
     private _pino;
     private readonly options;
     private readonly stream;
+    private disposed;
+    private retired;
     constructor(options: pino.LoggerOptions, stream?: pino.DestinationStream);
     configure<T extends string = never, CustomOnly extends true | false = false>(scribeOptions: ScribeOptions<T, CustomOnly>): void;
     getLogger<T extends string = never, CustomOnly extends true | false = false>(name: string): Logger<T, CustomOnly>;
     flush(cb?: () => void): void;
+    /**
+     * Immediately stop accepting writes into the destination (ThreadStream).
+     * Does not wait for flush — use `stop()` for async drain after retire.
+     */
+    retire(): void;
+    [Symbol.asyncDispose](): Promise<void>;
 }

package/types/src/pino.recipe.d.ts

@@ -0,0 +1,31 @@
+import { type Environment } from "@decohere/nexus/system";
+import type { TransportMultiOptions, TransportSingleOptions } from "pino";
+/** Pretty and roll are local-dev conveniences. Production ships JSON on stdout. */
+export type PinoWhen = "development" | "always";
+export type PinoPrettyRecipeOptions = {
+    colorize?: boolean;
+    logLevel?: string;
+    when?: PinoWhen;
+};
+export type PinoRollRecipeOptions = {
+    file: string;
+    size?: string;
+    frequency?: string | number;
+    keep?: number;
+    mkdir?: boolean;
+    symlink?: boolean;
+    logLevel?: string;
+    when?: PinoWhen;
+};
+export type PinoRecipePlan = {
+    pretty?: PinoPrettyRecipeOptions;
+    roll?: PinoRollRecipeOptions;
+    logLevel?: string;
+};
+declare function currentEnvironment(): Environment;
+declare function transport(plan: PinoRecipePlan, environment?: Environment): TransportSingleOptions | TransportMultiOptions | undefined;
+export declare const pinoRecipe: {
+    transport: typeof transport;
+    currentEnvironment: typeof currentEnvironment;
+};
+export {};

package/types/src/pino.transport-guard.d.ts

@@ -0,0 +1,10 @@
+import type { DestinationStream } from "pino";
+export type GuardedTransport = DestinationStream & {
+    readonly retired: boolean;
+    retire(reason?: string): void;
+};
+/**
+ * Wrap a pino worker transport so a dead ThreadStream cannot spam or crash.
+ * On first error / write throw: report once, destroy, no-op further writes.
+ */
+export declare function guardTransport(transport: DestinationStream): GuardedTransport;

package/types/src/scribe-pino.d.ts

@@ -1,24 +1,69 @@
 import { type Environment } from "@decohere/nexus/system";
 import { type DefaultLevels, type Logger, type ScribeOptions, scribe } from "@decohere/scribe";
-import type { TransportMultiOptions, TransportPipelineOptions, TransportSingleOptions } from "pino";
+import { type DestinationStream, type TransportMultiOptions, type TransportPipelineOptions, type TransportSingleOptions } from "pino";
+import { type PinoPrettyRecipeOptions, type PinoRollRecipeOptions } from "./pino.recipe.js";
+import { type GuardedTransport, guardTransport } from "./pino.transport-guard.js";
+export type { GuardedTransport } from "./pino.transport-guard.js";
+export { guardTransport } from "./pino.transport-guard.js";
+type TransportOptions = TransportSingleOptions | TransportMultiOptions | TransportPipelineOptions;
 type TransportConfig = {
     environment?: Environment;
-    transports: TransportSingleOptions | TransportMultiOptions | TransportPipelineOptions;
+    transports: TransportOptions;
 };
 type CustomLevelOptions<T extends string = never, CustomOnly extends true = undefined> = {
     scribe?: ScribeOptions<T, CustomOnly>;
     transports?: TransportConfig | TransportConfig[];
 };
+export type PinoLoggerFactory = (name?: string) => Logger;
+export type PinoRecipeChain = {
+    withPinoPretty(logLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions): PinoRecipe;
+    withPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;
+};
+export type PinoRecipe = PinoLoggerFactory & PinoRecipeChain & {
+    readonly and: PinoRecipeChain;
+};
 declare module "@decohere/scribe" {
     interface scribe {
-        withPino(transports: TransportConfig | TransportConfig[], loglevel?: DefaultLevels | string): (name?: string) => Logger;
-        withPinoPretty(logLevel?: DefaultLevels | string): (name?: string) => Logger;
-        withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(options?: CustomLevelOptions<T, CustomOnly>): (name?: string) => Logger<T, CustomOnly>;
+        withPino(transports: TransportConfig | TransportConfig[], loglevel?: DefaultLevels | string): PinoLoggerFactory;
+        /**
+         * Colorized pretty transport. Development only unless `{ when: "always" }`.
+         * Chain with `.and.withPinoRoll({ file })`. Production writes JSON to stdout
+         * so log shipping stays outside the process.
+         */
+        withPinoPretty(logLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions): PinoRecipe;
+        /**
+         * Rolling log files. Development only unless `{ when: "always" }`.
+         * Do not enable in production — ship stdout from a sidecar or platform agent.
+         * `symlink` defaults off; enabling it can race under multi-worker / HMR.
+         */
+        withPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;
+        withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(options?: CustomLevelOptions<T, CustomOnly>): PinoLoggerFactory;
+    }
+    namespace scribe {
+        function withPino(transports: TransportConfig | TransportConfig[], loglevel?: DefaultLevels | string): PinoLoggerFactory;
+        function withPinoPretty(logLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions): PinoRecipe;
+        function withPinoRoll(options: PinoRollRecipeOptions): PinoRecipe;
+        function withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(options?: CustomLevelOptions<T, CustomOnly>): PinoLoggerFactory;
     }
 }
 export declare class PinoExtensions {
-    static withPino(factory: scribe, config: TransportConfig | TransportConfig[], logLevel?: DefaultLevels | string): any;
-    static withPinoPretty(factory: scribe, logLevel?: DefaultLevels | string): any;
-    static withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(factory: scribe, options?: CustomLevelOptions<T, CustomOnly>): any;
+    static withPino(factory: scribe, config: TransportConfig | TransportConfig[], logLevel?: DefaultLevels | string): (name?: string) => Logger<never, false>;
+    static withPinoPretty(factory: scribe, logLevelOrOptions?: DefaultLevels | string | PinoPrettyRecipeOptions): PinoRecipe;
+    static withPinoRoll(factory: scribe, options: PinoRollRecipeOptions): PinoRecipe;
+    static withPinoCustom<T extends string = never, CustomOnly extends true = undefined>(factory: scribe, options?: CustomLevelOptions<T, CustomOnly>): (name?: string) => Logger<T, CustomOnly>;
 }
-export {};
+/**
+ * Guard a worker transport so failures (roll EEXIST, worker exit) neither
+ * crash the process nor spam stderr on every subsequent log write.
+ */
+declare function createSafeTransport(options: TransportOptions): DestinationStream;
+/** @deprecated Use {@link guardTransport} — kept for callers/tests from the silence-only era. */
+declare function silenceErrors(transport: {
+    on(event: "error", listener: (err: Error) => void): unknown;
+    write?: (...args: never[]) => unknown;
+}): GuardedTransport;
+export declare const pinoTransport: {
+    createSafeTransport: typeof createSafeTransport;
+    guardTransport: typeof guardTransport;
+    silenceErrors: typeof silenceErrors;
+};