@decohere/scribe-console 0.0.1-dev.125 → 0.0.1-dev.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decohere/scribe-console",
-  "version": "0.0.1-dev.125",
+  "version": "0.0.1-dev.5",
   "description": "JSON console adapter for @decohere/scribe: one JSON line per entry, for Workers, browsers, Deno, Bun and Node",
   "keywords": [
     "typescript",
@@ -10,15 +10,6 @@
     "cloudflare-workers",
     "decohere"
   ],
-  "homepage": "https://github.com/typesmiths/decohere/tree/main/projects/scribe/scribe-console#readme",
-  "bugs": {
-    "url": "https://github.com/typesmiths/decohere/issues"
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/typesmiths/decohere.git",
-    "directory": "projects/scribe/scribe-console"
-  },
   "license": "ISC",
   "author": "Typesmiths",
   "type": "module",
@@ -34,7 +25,7 @@
     "test": "echo \"Error: no test specified\" && exit 1"
   },
   "dependencies": {
-    "@decohere/scribe": "0.0.1-dev.125"
+    "@decohere/scribe": "0.0.1-dev.5"
   },
   "devDependencies": {}
 }

package/src/json-console.adapter.ts

@@ -0,0 +1,97 @@
+import { type LogEntry, LogEntryAdapter, LogLevels, serializeError } from "@decohere/scribe";
+
+export type JsonConsoleAdapterOptions = {
+	/**
+	 * Add `time` (ISO 8601) to every line. Off by default: hosts such as Workers
+	 * Logs and browser devtools stamp each line themselves.
+	 */
+	timestamp?: boolean;
+};
+
+type ConsoleMethod = "error" | "warn" | "info" | "debug";
+
+/**
+ * Writes one JSON object per entry, `{ level, name, msg, ...fields, err }`,
+ * through the console method of its level, so hosts that index JSON console
+ * lines (Workers Logs, browser devtools) see the level too. Uses nothing but
+ * `console` and `JSON`: it runs on Workers, in browsers, Deno, Bun and Node.
+ */
+export class JsonConsoleAdapter extends LogEntryAdapter {
+	private readonly timestamp: boolean;
+
+	public constructor(options: JsonConsoleAdapterOptions = {}) {
+		super();
+		this.timestamp = options.timestamp ?? false;
+	}
+
+	protected write(entry: LogEntry): void {
+		const method = methodFor(this.levels[entry.level] ?? LogLevels.info);
+		console[method](stringify(toLine(entry, this.timestamp)));
+	}
+}
+
+/**
+ * Custom levels pick the method of the default level at or below them:
+ * `fatal` and `error` → `console.error`, `warn` → `console.warn`, `info` →
+ * `console.info`, `debug` and `trace` → `console.debug` (`console.trace` would
+ * print a stack).
+ */
+function methodFor(value: number): ConsoleMethod {
+	if (value >= LogLevels.error) {
+		return "error";
+	}
+	if (value >= LogLevels.warn) {
+		return "warn";
+	}
+	if (value >= LogLevels.info) {
+		return "info";
+	}
+	return "debug";
+}
+
+/** `level`, `name`, `time` and `msg` are the entry's own; a field cannot replace them. */
+function toLine(entry: LogEntry, timestamp: boolean): Record<string, unknown> {
+	const line: Record<string, unknown> = { level: entry.level, name: entry.name };
+	if (timestamp) {
+		line.time = new Date().toISOString();
+	}
+	if (entry.msg !== undefined) {
+		line.msg = entry.msg;
+	}
+	for (const [key, value] of Object.entries(entry.fields)) {
+		if (!(key in line)) {
+			line[key] = value;
+		}
+	}
+	if (entry.err != null) {
+		line.err = entry.err;
+	}
+	return line;
+}
+
+/** `JSON.stringify` that survives cycles and bigints, and serializes nested errors. */
+function stringify(line: Record<string, unknown>): string {
+	const ancestors: object[] = [];
+	return JSON.stringify(line, function (this: unknown, _key: string, value: unknown) {
+		if (typeof value === "bigint") {
+			return value.toString();
+		}
+		if (value == null || typeof value !== "object") {
+			return value;
+		}
+		while (ancestors.length > 0 && ancestors.at(-1) !== this) {
+			ancestors.pop();
+		}
+		if (ancestors.includes(value)) {
+			return "[Circular]";
+		}
+		if (value instanceof Error) {
+			// Track the error too: its serialized properties may point back at it.
+			const serialized = serializeError(value);
+			ancestors.push(value, serialized);
+			return serialized;
+		}
+		ancestors.push(value);
+		return value;
+	});
+}

package/tests/json-console.adapter.integration.spec.ts

@@ -0,0 +1,156 @@
+/**
+ * JSON console adapter through the public API (`scribe.configure` / `scribe.logger`):
+ * one JSON line per entry, through the console method of its level.
+ */
+import { scribe } from "@decohere/scribe";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { JsonConsoleAdapter } from "../src/json-console.adapter.js";
+
+afterEach(async () => {
+	vi.unstubAllGlobals();
+	vi.restoreAllMocks();
+	await scribe.stop();
+});
+
+type Method = "error" | "warn" | "info" | "debug" | "log";
+
+/** Lines per console method, parsed. */
+function captureConsole(): Record<Method, Record<string, unknown>[]> {
+	const lines: Record<Method, Record<string, unknown>[]> = {
+		error: [],
+		warn: [],
+		info: [],
+		debug: [],
+		log: [],
+	};
+	for (const method of Object.keys(lines) as Method[]) {
+		vi.spyOn(console, method).mockImplementation((line: string) => {
+			lines[method].push(JSON.parse(line) as Record<string, unknown>);
+		});
+	}
+	return lines;
+}
+
+describe("JsonConsoleAdapter", () => {
+	it("writes { level, name, msg, ...fields } through the method of each level", () => {
+		const lines = captureConsole();
+		scribe.configure({ adapter: new JsonConsoleAdapter(), options: { logLevel: "trace" } });
+		const log = scribe.logger("Worker");
+		log.fatal("down");
+		log.error("failed");
+		log.warn("slow", { ms: 900 });
+		log.info("ready");
+		log.debug("cache miss");
+		log.trace("step");
+
+		expect(lines.error).toEqual([
+			{ level: "fatal", name: "Worker", msg: "down" },
+			{ level: "error", name: "Worker", msg: "failed" },
+		]);
+		expect(lines.warn).toEqual([{ level: "warn", name: "Worker", msg: "slow", ms: 900 }]);
+		expect(lines.info).toEqual([{ level: "info", name: "Worker", msg: "ready" }]);
+		expect(lines.debug).toEqual([
+			{ level: "debug", name: "Worker", msg: "cache miss" },
+			{ level: "trace", name: "Worker", msg: "step" },
+		]);
+		expect(lines.log).toEqual([]);
+	});
+
+	it("filters below the configured level", () => {
+		const lines = captureConsole();
+		scribe.configure({ adapter: new JsonConsoleAdapter(), options: { logLevel: "warn" } });
+		scribe.logger("Worker").info("hidden");
+		expect(lines.info).toEqual([]);
+	});
+
+	it("routes custom levels by their value", () => {
+		const lines = captureConsole();
+		scribe.configure({
+			adapter: new JsonConsoleAdapter(),
+			options: { logLevel: "trace", customLevels: { audit: 45, metric: 25 } },
+		});
+		const log = scribe.logger<"audit" | "metric">("Billing");
+		log.audit("sealed");
+		log.metric("latency", { ms: 12 });
+		expect(lines.warn).toEqual([{ level: "audit", name: "Billing", msg: "sealed" }]);
+		expect(lines.debug).toEqual([
+			{ level: "metric", name: "Billing", msg: "latency", ms: 12 },
+		]);
+	});
+
+	it("writes errors with their causes, and child fields", () => {
+		const lines = captureConsole();
+		scribe.configure({ adapter: new JsonConsoleAdapter() });
+		const err = new Error("fetch failed", { cause: new Error("connection reset") });
+		scribe.logger("Http").child({ requestId: "r-1" }).error("upstream failed", err);
+
+		expect(lines.error).toEqual([
+			{
+				level: "error",
+				name: "Http",
+				msg: "upstream failed",
+				requestId: "r-1",
+				err: {
+					name: "Error",
+					message: "fetch failed",
+					stack: expect.stringContaining("Error: fetch failed"),
+					cause: {
+						name: "Error",
+						message: "connection reset",
+						stack: expect.stringContaining("Error: connection reset"),
+					},
+				},
+			},
+		]);
+	});
+
+	it("keeps level and name from fields, and survives cycles and bigints", () => {
+		const lines = captureConsole();
+		scribe.configure({ adapter: new JsonConsoleAdapter() });
+		const loop: Record<string, unknown> = { id: 1 };
+		loop.self = loop;
+		const err = Object.assign(new Error("odd"), { self: undefined as unknown });
+		err.self = err;
+		scribe.logger("Odd").info("probe", { level: "fake", name: "fake", loop, big: 10n, err });
+
+		expect(lines.info).toEqual([
+			{
+				level: "info",
+				name: "Odd",
+				msg: "probe",
+				loop: { id: 1, self: "[Circular]" },
+				big: "10",
+				err: expect.objectContaining({ message: "odd" }),
+			},
+		]);
+	});
+
+	it("adds time when asked", () => {
+		const lines = captureConsole();
+		scribe.configure({ adapter: new JsonConsoleAdapter({ timestamp: true }) });
+		scribe.logger("Clock").info("tick");
+		expect(lines.info[0].time).toEqual(expect.stringMatching(/^\d{4}-\d{2}-\d{2}T/));
+	});
+
+	it("censors the redaction keys", () => {
+		const lines = captureConsole();
+		scribe.configure({ adapter: new JsonConsoleAdapter() });
+		scribe.logger("Auth").info("login", { auth: { token: "t-659" } });
+		expect(lines.info).toEqual([
+			{ level: "info", name: "Auth", msg: "login", auth: { token: "[Redacted]" } },
+		]);
+	});
+
+	/** #659 — the point of the package: no Node globals at all. */
+	it("runs where there is no process global", () => {
+		const lines = captureConsole();
+		vi.stubGlobal("process", undefined);
+		try {
+			scribe.configure({ adapter: new JsonConsoleAdapter() });
+			scribe.logger("Browser").info("ready");
+		} finally {
+			vi.unstubAllGlobals();
+		}
+		expect(lines.info).toEqual([{ level: "info", name: "Browser", msg: "ready" }]);
+	});
+});

package/LICENSE

@@ -1,15 +0,0 @@
-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/commonjs/src/index.js

@@ -1,18 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-_export_star(require("./json-console.adapter.js"), exports);
-function _export_star(from, to) {
-    Object.keys(from).forEach(function(k) {
-        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
-            Object.defineProperty(to, k, {
-                enumerable: true,
-                get: function() {
-                    return from[k];
-                }
-            });
-        }
-    });
-    return from;
-}

package/commonjs/src/json-console.adapter.js

@@ -1,85 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", {
-    value: true
-});
-Object.defineProperty(exports, "JsonConsoleAdapter", {
-    enumerable: true,
-    get: function() {
-        return JsonConsoleAdapter;
-    }
-});
-const _scribe = require("@decohere/scribe");
-class JsonConsoleAdapter extends _scribe.LogEntryAdapter {
-    timestamp;
-    constructor(options = {}){
-        super();
-        this.timestamp = options.timestamp ?? false;
-    }
-    write(entry) {
-        const method = methodFor(this.levels[entry.level] ?? _scribe.LogLevels.info);
-        console[method](stringify(toLine(entry, this.timestamp)));
-    }
-}
-/**
- * Custom levels pick the method of the default level at or below them:
- * `fatal` and `error` → `console.error`, `warn` → `console.warn`, `info` →
- * `console.info`, `debug` and `trace` → `console.debug` (`console.trace` would
- * print a stack).
- */ function methodFor(value) {
-    if (value >= _scribe.LogLevels.error) {
-        return "error";
-    }
-    if (value >= _scribe.LogLevels.warn) {
-        return "warn";
-    }
-    if (value >= _scribe.LogLevels.info) {
-        return "info";
-    }
-    return "debug";
-}
-/** `level`, `name`, `time` and `msg` are the entry's own; a field cannot replace them. */ function toLine(entry, timestamp) {
-    const line = {
-        level: entry.level,
-        name: entry.name
-    };
-    if (timestamp) {
-        line.time = new Date().toISOString();
-    }
-    if (entry.msg !== undefined) {
-        line.msg = entry.msg;
-    }
-    for (const [key, value] of Object.entries(entry.fields)){
-        if (!(key in line)) {
-            line[key] = value;
-        }
-    }
-    if (entry.err != null) {
-        line.err = entry.err;
-    }
-    return line;
-}
-/** `JSON.stringify` that survives cycles and bigints, and serializes nested errors. */ function stringify(line) {
-    const ancestors = [];
-    return JSON.stringify(line, function(_key, value) {
-        if (typeof value === "bigint") {
-            return value.toString();
-        }
-        if (value == null || typeof value !== "object") {
-            return value;
-        }
-        while(ancestors.length > 0 && ancestors.at(-1) !== this){
-            ancestors.pop();
-        }
-        if (ancestors.includes(value)) {
-            return "[Circular]";
-        }
-        if (value instanceof Error) {
-            // Track the error too: its serialized properties may point back at it.
-            const serialized = (0, _scribe.serializeError)(value);
-            ancestors.push(value, serialized);
-            return serialized;
-        }
-        ancestors.push(value);
-        return value;
-    });
-}

package/es6/src/json-console.adapter.js

@@ -1,80 +0,0 @@
-import { LogEntryAdapter, LogLevels, serializeError } from "@decohere/scribe";
-/**
- * Writes one JSON object per entry, `{ level, name, msg, ...fields, err }`,
- * through the console method of its level, so hosts that index JSON console
- * lines (Workers Logs, browser devtools) see the level too. Uses nothing but
- * `console` and `JSON`: it runs on Workers, in browsers, Deno, Bun and Node.
- */ export class JsonConsoleAdapter extends LogEntryAdapter {
-    timestamp;
-    constructor(options = {}){
-        super();
-        this.timestamp = options.timestamp ?? false;
-    }
-    write(entry) {
-        const method = methodFor(this.levels[entry.level] ?? LogLevels.info);
-        console[method](stringify(toLine(entry, this.timestamp)));
-    }
-}
-/**
- * Custom levels pick the method of the default level at or below them:
- * `fatal` and `error` → `console.error`, `warn` → `console.warn`, `info` →
- * `console.info`, `debug` and `trace` → `console.debug` (`console.trace` would
- * print a stack).
- */ function methodFor(value) {
-    if (value >= LogLevels.error) {
-        return "error";
-    }
-    if (value >= LogLevels.warn) {
-        return "warn";
-    }
-    if (value >= LogLevels.info) {
-        return "info";
-    }
-    return "debug";
-}
-/** `level`, `name`, `time` and `msg` are the entry's own; a field cannot replace them. */ function toLine(entry, timestamp) {
-    const line = {
-        level: entry.level,
-        name: entry.name
-    };
-    if (timestamp) {
-        line.time = new Date().toISOString();
-    }
-    if (entry.msg !== undefined) {
-        line.msg = entry.msg;
-    }
-    for (const [key, value] of Object.entries(entry.fields)){
-        if (!(key in line)) {
-            line[key] = value;
-        }
-    }
-    if (entry.err != null) {
-        line.err = entry.err;
-    }
-    return line;
-}
-/** `JSON.stringify` that survives cycles and bigints, and serializes nested errors. */ function stringify(line) {
-    const ancestors = [];
-    return JSON.stringify(line, function(_key, value) {
-        if (typeof value === "bigint") {
-            return value.toString();
-        }
-        if (value == null || typeof value !== "object") {
-            return value;
-        }
-        while(ancestors.length > 0 && ancestors.at(-1) !== this){
-            ancestors.pop();
-        }
-        if (ancestors.includes(value)) {
-            return "[Circular]";
-        }
-        if (value instanceof Error) {
-            // Track the error too: its serialized properties may point back at it.
-            const serialized = serializeError(value);
-            ancestors.push(value, serialized);
-            return serialized;
-        }
-        ancestors.push(value);
-        return value;
-    });
-}

package/types/src/index.d.ts

@@ -1 +0,0 @@
-export * from "./json-console.adapter.js";

package/types/src/json-console.adapter.d.ts

@@ -1,19 +0,0 @@
-import { type LogEntry, LogEntryAdapter } from "@decohere/scribe";
-export type JsonConsoleAdapterOptions = {
-    /**
-     * Add `time` (ISO 8601) to every line. Off by default: hosts such as Workers
-     * Logs and browser devtools stamp each line themselves.
-     */
-    timestamp?: boolean;
-};
-/**
- * Writes one JSON object per entry, `{ level, name, msg, ...fields, err }`,
- * through the console method of its level, so hosts that index JSON console
- * lines (Workers Logs, browser devtools) see the level too. Uses nothing but
- * `console` and `JSON`: it runs on Workers, in browsers, Deno, Bun and Node.
- */
-export declare class JsonConsoleAdapter extends LogEntryAdapter {
-    private readonly timestamp;
-    constructor(options?: JsonConsoleAdapterOptions);
-    protected write(entry: LogEntry): void;
-}