@optimystic/db-p2p 0.28.0 → 1.0.0-beta.1

package/src/cluster/quorum-restore.ts

@@ -117,8 +117,10 @@ export function quorumSize(
  *
  * An unconfigured node resolves this to its `clusterSize` (default 10), so the floor of two binds and
  * a shrunken view gains nothing. The escape hatch for a real two-node deployment is one explicit
- * operator declaration — `clusterPolicy.assumedClusterSize: 2`, which does NOT also drop the
- * replication factor, or an honest `clusterSize: 2`.
+ * operator declaration, any of three: `clusterPolicy.repairCorroborationClusterSize: 2`, which moves
+ * only this yardstick; `clusterPolicy.assumedClusterSize: 2`, which also raises the membership
+ * admission gate's low-confidence write floor; or an honest `clusterSize: 2`. Only the last drops the
+ * replication factor.
  *
  * Shared by both restoration paths so the two can never drift apart on the rule that decides how
  * much trust a lone peer gets.

package/src/cluster/service.ts

@@ -1,19 +1,18 @@
 import { pipe } from 'it-pipe';
 import { decode as lpDecode, encode as lpEncode } from 'it-length-prefixed';
 import { peerIdFromString } from '@libp2p/peer-id';
-import type { Startable, Logger, Stream, Connection, StreamHandler, PeerId } from '@libp2p/interface';
+import type { Startable, Stream, Connection, StreamHandler, PeerId } from '@libp2p/interface';
 import type { ICluster, ClusterRecord } from '@optimystic/db-core';
 import { encodePeers, type RedirectPayload } from '../repo/redirect.js';
 import { toClusterErrorEnvelope } from './cluster-error.js';
 import { mergeRecordPeerAddresses, publishableAddrsForPeer, type AddressLog, type DirectionalConnection } from '../peer-address-book.js';
 import { MAX_CONTROL_MESSAGE_BYTES } from '../protocol-limits.js';
 import type { Uint8ArrayList } from 'uint8arraylist';
-import { createLogger } from '../logger.js';
+import { createLogger, type Logger } from '../logger.js';
 import { createInboundStreamAuthorization, type InboundStreamAuthorization, type InboundStreamAuthorizationInit } from '../inbound-authorization.js';
 import { registerProtocolHandler } from '../network/register-protocol-handler.js';
 
 interface BaseComponents {
-	logger: { forComponent: (name: string) => Logger },
 	registrar: {
 		handle: (protocol: string, handler: StreamHandler, options: any) => Promise<void>,
 		unhandle: (protocol: string) => Promise<void>
@@ -49,6 +48,12 @@ export interface ClusterServiceInit extends InboundStreamAuthorizationInit {
 	protocolPrefix?: string,
 	maxInboundStreams?: number,
 	maxOutboundStreams?: number,
+	/**
+	 * Sub-namespace this service logs under, i.e. the `<x>` in `optimystic:db-p2p:<x>`.
+	 * NOT a full namespace: an embedder cannot use this to move the service's lines outside the
+	 * `optimystic:db-p2p:*` tree `docs/debugging.md` tells operators to filter on.
+	 * Default: `cluster-service`.
+	 */
 	logPrefix?: string,
 	/**
 	 * Responsibility K - the replica set size for determining cluster membership.
@@ -74,11 +79,11 @@ export class ClusterService implements Startable {
 	private readonly maxOutboundStreams: number;
 	private readonly log: Logger;
 	/**
-	 * Sink for this service's `peer-address-book:*` lines. Deliberately NOT `this.log.error`, which
-	 * lands them under libp2p's `db-p2p:cluster:error` namespace — invisible to the
-	 * `DEBUG=optimystic:db-p2p:*` filter this package's docs recommend, and the reason
-	 * gotchoices/Optimystic#12 read a zero log count as proof the mechanism never ran. One tag
-	 * family, one namespace tree.
+	 * Sink for this service's `peer-address-book:*` lines. Deliberately NOT `this.log.error`: the
+	 * `peer-address-book:*` tag family is emitted from several unrelated call sites (this service,
+	 * `ClusterClient`, `Libp2pKeyPeerNetwork`) and must be filterable as ONE namespace, rather than
+	 * scattered across whichever service happened to be the ingress point. That scattering is what
+	 * gotchoices/Optimystic#12 read as proof the mechanism never ran. One tag family, one namespace.
 	 */
 	private readonly addressLog: AddressLog;
 	private readonly cluster: ICluster;
@@ -94,7 +99,7 @@ export class ClusterService implements Startable {
 		this.protocol = init.protocol ?? (init.protocolPrefix ?? '/db-p2p') + '/cluster/1.0.0';
 		this.maxInboundStreams = init.maxInboundStreams ?? 32;
 		this.maxOutboundStreams = init.maxOutboundStreams ?? 64;
-		this.log = components.logger.forComponent(init.logPrefix ?? 'db-p2p:cluster');
+		this.log = createLogger(init.logPrefix ?? 'cluster-service');
 		this.addressLog = createLogger('peer-address-book', components.peerId?.toString());
 		this.cluster = components.cluster;
 		this.running = false;

package/src/dispute/service.ts

@@ -1,14 +1,14 @@
 import { pipe } from 'it-pipe';
 import { decode as lpDecode, encode as lpEncode } from 'it-length-prefixed';
-import type { Startable, Logger, Stream, Connection, StreamHandler } from '@libp2p/interface';
+import type { Startable, Stream, Connection, StreamHandler } from '@libp2p/interface';
 import type { Uint8ArrayList } from 'uint8arraylist';
 import { MAX_CONTROL_MESSAGE_BYTES } from '../protocol-limits.js';
 import type { DisputeMessage } from './types.js';
 import type { DisputeService } from './dispute-service.js';
 import { registerProtocolHandler } from '../network/register-protocol-handler.js';
+import { createLogger, type Logger } from '../logger.js';
 
 interface BaseComponents {
-	logger: { forComponent: (name: string) => Logger };
 	registrar: {
 		handle: (protocol: string, handler: StreamHandler, options: any) => Promise<void>;
 		unhandle: (protocol: string) => Promise<void>;
@@ -48,7 +48,7 @@ export class DisputeProtocolService implements Startable {
 		this.protocol = init.protocol ?? (init.protocolPrefix ?? '/db-p2p') + '/dispute/1.0.0';
 		this.maxInboundStreams = init.maxInboundStreams ?? 16;
 		this.maxOutboundStreams = init.maxOutboundStreams ?? 32;
-		this.log = components.logger.forComponent('db-p2p:dispute');
+		this.log = createLogger('dispute-protocol');
 		this.disputeService = components.disputeService;
 		this.running = false;
 	}

package/src/libp2p-key-network.ts

@@ -304,8 +304,14 @@ export class Libp2pKeyPeerNetwork implements IKeyNetwork, IPeerNetwork {
 	/**
 	 * This node's own dialable addresses, as strings, memoized between address changes.
 	 *
-	 * `libp2p.getMultiaddrs()` is NOT cheap: on Node it re-derives announce addresses from
-	 * `os.networkInterfaces()`, a full NIC sweep measured at **3.19 ms of a 3.49 ms call**. Every
+	 * `libp2p.getMultiaddrs()` is NOT cheap **when this node has a wildcard listen address**:
+	 * expanding `0.0.0.0` across the host's interfaces goes through `os.networkInterfaces()`, a
+	 * full NIC sweep measured at **3.19 ms of a 3.49 ms call**. Measured per configuration on one
+	 * host: 4.44 ms/call with a TCP listener, **0.001 ms/call with no listen addrs at all** (an
+	 * edge/mobile client dialling out over websockets — nothing to expand, empty address list).
+	 * So the win here is real for listening peers (service and reference nodes, which commit too)
+	 * and near-zero for a dial-only client; do not quote the headline figure at a profile that
+	 * never pays it. Every
 	 * `findCluster` builds a cluster record containing self's addresses, and every commit calls
 	 * `findCluster` through `getClusterPeerIds` — so a cold `apply schema` paid one NIC sweep per
 	 * commit. On a solo node with zero peers that was ~13.8 ms per call and **49% of the whole

package/src/libp2p-node-base.ts

@@ -508,8 +508,10 @@ export async function createLibp2pNodeBase(
 		: options.onCommitCertificate;
 
 	// Every cluster-policy default lives in `cluster/cluster-policy.ts` — including WHY the admission
-	// gate and the repair corroboration floor resolve the one operator field
-	// (`clusterPolicy.assumedClusterSize`) to different values when it is absent. Resolved ONCE, here,
+	// gate and the repair corroboration floor resolve to different values when nothing is declared,
+	// and why they take TWO operator fields (`clusterPolicy.assumedClusterSize`, which sets both, and
+	// `clusterPolicy.repairCorroborationClusterSize`, which sets the repair yardstick alone so a host
+	// can tighten repair without also raising the low-confidence write floor). Resolved ONCE, here,
 	// before anything that reads a cluster size is constructed: `networkManagerService` below,
 	// `Libp2pKeyPeerNetwork`, and the spread-on-churn monitor init must all read `consensusConfig.clusterSize`
 	// rather than `options.clusterSize` directly, or they can each apply their own fallback default and
@@ -608,7 +610,6 @@ export async function createLibp2pNodeBase(
 					...inboundAuthorization
 				});
 				return serviceFactory({
-					logger: components.logger,
 					registrar: components.registrar,
 					cluster: clusterProxy,
 					// Identity for membership scoping on the update path. peerId is a core
@@ -652,7 +653,6 @@ export async function createLibp2pNodeBase(
 				// (getCluster(encode(blockKey)) → hashKey(encode(...))), matching the
 				// coordinator's findCluster(encode(blockId)) — same cohort, no spurious redirect.
 				return serviceFactory({
-					logger: components.logger,
 					registrar: components.registrar,
 					repo: repoProxy
 				});
@@ -664,7 +664,6 @@ export async function createLibp2pNodeBase(
 					...inboundAuthorization
 				});
 				return serviceFactory({
-					logger: components.logger,
 					registrar: components.registrar,
 					repo: repoProxy
 				});
@@ -689,9 +688,7 @@ export async function createLibp2pNodeBase(
 					// Read from the SAME resolved `consensusConfig` the member and coordinator read (whose
 					// coupling `assertSuperMajorityCoupling` below already asserts) — a third copy resolving
 					// its own default would defeat that.
-					superMajorityThreshold: consensusConfig.superMajorityThreshold,
-					// So this service's authorization denials reach the same error sink as the other three.
-					logger: components.logger
+					superMajorityThreshold: consensusConfig.superMajorityThreshold
 				});
 			},
 
@@ -1082,7 +1079,7 @@ export async function createLibp2pNodeBase(
 				// Spread is a resilience optimization, not a correctness requirement - a wiring
 				// failure (e.g. FRET briefly unavailable) must NOT hard-fail node startup, unlike the
 				// operator-opted-in cohortTopic block. Log and continue with spread inert.
-				((node as any).logger?.forComponent?.('db-p2p:spread-on-churn'))?.('init failed: %o', err);
+				wiringLog('spread-on-churn init failed: %o', err);
 			}
 		}
 
@@ -1108,7 +1105,13 @@ export async function createLibp2pNodeBase(
 		// Initialize Arachnode ring membership and restoration
 		const enableArachnode = options.arachnode?.enableRingZulu ?? true;
 		if (enableArachnode) {
-			const log = (node as any).logger?.forComponent?.('db-p2p:arachnode');
+			// A child of the file's own `node-wiring` channel (same nesting convention as
+			// `storage:restoration` and `network:get-manager`): these lines explain a half-started
+			// node, so `optimystic:db-p2p:node-wiring*` shows them next to the rest of the wiring
+			// story, while the child name still lets ring/rebalance chatter be filtered on its own.
+			// Unconditional — the previous `(node as any).logger?.forComponent?.(...)` reach-through
+			// silently dropped every one of these lines when the node exposed no logger.
+			const log = createLogger('node-wiring:arachnode');
 			const fret = (node as any).services?.fret as any;
 
 			if (fret) {
@@ -1150,7 +1153,7 @@ export async function createLibp2pNodeBase(
 				const arachnodeInfo = await ringSelector.createArachnodeInfo(peerId);
 				fretAdapter.setArachnodeInfo(arachnodeInfo);
 
-				log?.('Announced Arachnode membership: Ring %d', arachnodeInfo.ringDepth);
+				log('Announced Arachnode membership: Ring %d', arachnodeInfo.ringDepth);
 
 				// Setup restoration coordinator with FRET adapter
 				const restorationCoordinatorV2 = new RestorationCoordinator(
@@ -1253,7 +1256,7 @@ export async function createLibp2pNodeBase(
 								}
 								if (result.underReplicated.length > 0) {
 									const growthDiag = rebalanceMonitor.getGrowthDiagnostics();
-									log?.('cohort-growth: %d of %d grown blocks not confirmed on new peers this pass ' +
+									log('cohort-growth: %d of %d grown blocks not confirmed on new peers this pass ' +
 										'(awaiting-confirmation=%d given-up-pairs=%d)',
 										result.underReplicated.length, event.grown.size,
 										growthDiag.blocksAwaitingConfirmation, growthDiag.abandonedPairs);
@@ -1267,7 +1270,7 @@ export async function createLibp2pNodeBase(
 								// and a loud unbounded retry is the right way to surface one — silently abandoning
 								// the block would hide it and leave the block singly held. Revisit if a legitimate
 								// recoverable condition is ever allowed to throw out of the reaction.
-								log?.('rebalance reaction failed: %o', err);
+								log('rebalance reaction failed: %o', err);
 							});
 						});
 
@@ -1320,7 +1323,7 @@ export async function createLibp2pNodeBase(
 					} catch (err) {
 						// Rebalance is a resilience optimization, not a correctness requirement - a wiring
 						// failure (e.g. FRET briefly unavailable) must NOT hard-fail node startup.
-						log?.('rebalance wiring init failed: %o', err);
+						log('rebalance wiring init failed: %o', err);
 					}
 				}
 
@@ -1337,15 +1340,15 @@ export async function createLibp2pNodeBase(
 					if (!ringShift) return;
 					const transition = await ringSelector.shouldTransition();
 					if (transition.shouldMove && transition.direction && transition.newRingDepth !== undefined) {
-						log?.('Ring transition needed: moving %s to Ring %d', transition.direction, transition.newRingDepth);
+						log('Ring transition needed: moving %s to Ring %d', transition.direction, transition.newRingDepth);
 						try {
 							const outcome = await ringShift.executeShift({
 								direction: transition.direction,
 								newRingDepth: transition.newRingDepth
 							});
-							log?.('Ring shift outcome: %o', outcome);
+							log('Ring shift outcome: %o', outcome);
 						} catch (err) {
-							log?.('Ring shift failed: %o', err);
+							log('Ring shift failed: %o', err);
 						} finally {
 							// Measure the minimum dwell from the SETTLED shift (completed or rolled back), not
 							// just the trigger stamped inside shouldTransition (docs/arachnode-ring-handoff.md §1.3).
@@ -1361,7 +1364,7 @@ export async function createLibp2pNodeBase(
 					await originalStop();
 				};
 			} else {
-				log?.('FRET service not available, Arachnode disabled');
+				log('FRET service not available, Arachnode disabled');
 			}
 		}
 
@@ -1393,7 +1396,7 @@ export async function createLibp2pNodeBase(
 				await previousStop();
 			};
 			void seedOwnedBlocksFromStorage(rawStorage, ownedBlocks, () => seedStopping)
-				.catch((err) => ((node as any).logger?.forComponent?.('db-p2p:owned-block-seed'))?.('seed failed: %o', err));
+				.catch((err) => { wiringLog('owned-block-seed seed failed: %o', err); });
 		}
 
 		// [dispute-subsystem-dormant] The DisputeService object is constructed below so tests and

package/src/logger.ts

@@ -1,7 +1,181 @@
+import { base32 } from 'multiformats/bases/base32'
+import { base58btc } from 'multiformats/bases/base58'
+import { base64 } from 'multiformats/bases/base64'
 import debug from 'debug'
+import type { PeerId } from '@libp2p/interface'
+import type { Multiaddr } from '@multiformats/multiaddr'
+import type { CID } from 'multiformats/cid'
 
 const BASE_NAMESPACE = 'optimystic:db-p2p'
 
+/*
+ * Format specifiers, ported from `@libp2p/logger`'s `src/index.ts` (MIT, same license as this
+ * repo). Call sites in this package log lines like `'error handling X from %p - %e'`; those used
+ * to reach libp2p's own logger, which registers these. Without the port they would print the
+ * literal text `%p` / `%e`.
+ *
+ * NOTE: these are registered on the `debug` module instance THIS file imports. libp2p's own
+ * loggers use `weald` (via @libp2p/logger) and carry their own copy — the two registries are
+ * independent, and enabling one from test code does not enable the other.
+ *
+ * NOTE: `debug.formatters` is process-wide, and the other six packages' `createLogger` factories
+ * import the same `debug` module — so importing this file makes `%p`/`%e`/… work from their
+ * loggers too. Harmless today (no other package registers any specifier, and none of these letters
+ * is a `util.format` specifier except `%c`, whose Node meaning is a no-op that swallows its
+ * argument). If a second package ever registers one of these letters, last import wins silently;
+ * move the registry somewhere both can share rather than racing on it.
+ *
+ * NOTE: only `%e` is guaranteed not to throw — its call sites take a `catch`-bound `unknown`. The
+ * other six call `.toString()` / an encoder on whatever they are handed, so a caller that passes
+ * the wrong type turns a log line into an exception. That matches upstream; tighten them if a
+ * call site ever formats a value it did not construct.
+ *
+ * `%k` (`interface-datastore`'s `Key`) is deliberately NOT ported: `interface-datastore` is not a
+ * declared dependency of this package and no call site formats one. Add it if that changes.
+ */
+
+// Add a formatter for converting to a base58 string
+debug.formatters['b'] = (v?: Uint8Array): string => {
+	return v == null ? 'undefined' : base58btc.baseEncode(v)
+}
+
+// Add a formatter for converting to a base32 string
+debug.formatters['t'] = (v?: Uint8Array): string => {
+	return v == null ? 'undefined' : base32.baseEncode(v)
+}
+
+// Add a formatter for converting to a base64 string
+debug.formatters['m'] = (v?: Uint8Array): string => {
+	return v == null ? 'undefined' : base64.baseEncode(v)
+}
+
+// Add a formatter for stringifying peer ids
+debug.formatters['p'] = (v?: PeerId): string => {
+	return v == null ? 'undefined' : v.toString()
+}
+
+// Add a formatter for stringifying CIDs
+debug.formatters['c'] = (v?: CID): string => {
+	return v == null ? 'undefined' : v.toString()
+}
+
+// Add a formatter for stringifying Multiaddrs
+debug.formatters['a'] = (v?: Multiaddr): string => {
+	return v == null ? 'undefined' : v.toString()
+}
+
+function notEmpty(str?: string): string | undefined {
+	if (str == null) {
+		return
+	}
+
+	str = str.trim()
+
+	if (str.length === 0) {
+		return
+	}
+
+	return str
+}
+
+function formatError(v: Error, indent = ''): string {
+	const message = notEmpty(v.message)
+	const stack = notEmpty(v.stack)
+
+	// some browser errors (mostly from Firefox) have no message or no stack,
+	// sometimes both, sometimes neither. Sometimes the message is in the stack,
+	// sometimes it isn't so try to do *something* useful
+	if (message != null && stack != null) {
+		if (stack.includes(message)) {
+			return `${stack.split('\n').join(`\n${indent}`)}`
+		}
+
+		return `${message}\n${indent}${stack.split('\n').join(`\n${indent}`)}`
+	}
+
+	if (stack != null) {
+		return `${stack.split('\n').join(`\n${indent}`)}`
+	}
+
+	if (message != null) {
+		return `${message}`
+	}
+
+	return `${v.toString()}`
+}
+
+function isAggregateError(err?: any): err is AggregateError {
+	return err instanceof AggregateError || (err?.name === 'AggregateError' && Array.isArray(err.errors))
+}
+
+function printError(err: Error, indent = ''): string {
+	if (isAggregateError(err)) {
+		let output = formatError(err, indent)
+
+		if (err.errors.length > 0) {
+			indent = `${indent}    `
+
+			output += `\n${indent}${err.errors
+				.map(err => `${printError(err, `${indent}`)}`)
+				.join(`\n${indent}`)
+			}`
+		} else {
+			output += `\n${indent}[Error list was empty]`
+		}
+
+		return output.trim()
+	}
+
+	return formatError(err, indent)
+}
+
+// Add a formatter for stringifying Errors.
+//
+// A call site can hand `%e` anything — `catch (err)` binds `unknown`, and this package's `%e` sites
+// are all in catch blocks. This must never throw: a logger that throws turns a caught error into an
+// uncaught one at exactly the site that was trying to report it.
+//
+// The try/catch is a deliberate deviation from the upstream `@libp2p/logger` port. `formatError`'s
+// last resort is `${v.toString()}`, which raises for the two values that have no usable primitive
+// conversion — a null-prototype object (`throw Object.create(null)`) and a symbol. Upstream has the
+// same hole; here the stated contract is "never throw", so the fallback is explicit.
+debug.formatters['e'] = (v?: Error): string => {
+	if (v == null) {
+		return 'undefined'
+	}
+
+	try {
+		return printError(v)
+	} catch {
+		return '[unformattable error]'
+	}
+}
+
+/**
+ * A `debug` channel plus the severity sub-channels libp2p's own `Logger` exposes, so a call site
+ * can be moved between the two factories without changing what it calls.
+ *
+ * `error` and `trace` are ordinary child namespaces (`<namespace>:error`), so a wildcard filter
+ * the operator already uses — `optimystic:db-p2p:*` — keeps matching them. An EXACT-match filter
+ * (`DEBUG=optimystic:db-p2p:repo-service`) does not; that is the same caveat the peer-id suffix
+ * already carries, and `docs/debugging.md` already documents it.
+ *
+ * Unlike libp2p we do NOT conditionally stub out `trace`: libp2p builds a no-op unless a `:trace`
+ * namespace is explicitly enabled, but a disabled `debug` channel is already near-free, and the
+ * conditional version reads its enablement once at construction — wrong for anything built before
+ * `DEBUG` is set. `newScope` is deliberately omitted; `createLogger('parent:child')` says the same
+ * thing and nothing calls it.
+ *
+ * NOTE: because `trace` is a real channel, the wildcard `optimystic:db-p2p:*` that
+ * `docs/debugging.md` tells operators to set will also show trace lines. Nothing calls `.trace`
+ * yet, so that is currently free; if trace logging ever becomes voluminous, give the docs a
+ * narrower default filter rather than stubbing the channel back out.
+ */
+export interface Logger extends debug.Debugger {
+	error: debug.Debugger
+	trace: debug.Debugger
+}
+
 /**
  * Build a `debug` logger under `optimystic:db-p2p:<subNamespace>`, optionally suffixed with the
  * owning node's peer id (`:<first 12 chars>`) so lines from several nodes sharing one process —
@@ -17,10 +191,30 @@ const BASE_NAMESPACE = 'optimystic:db-p2p'
  * the three `peer-address-book` sinks); the package's other ~30 `createLogger` call sites
  * still log under a flat namespace. Thread a peer id through any of them if a future diagnosis
  * needs per-node attribution from that subsystem — the mechanism is already here.
+ *
+ * The peer-id suffix goes BEFORE `:error` / `:trace` — those are children of the concrete channel,
+ * so a two-node process gets `…:x:12D3KooWAb:error`, not `…:x:error:12D3KooWAb`.
+ */
+/*
+ * NOTE: `packages/db-p2p/test/logger.spec.ts` asserts that every namespace this package emits has
+ * a row in the db-p2p table of `docs/debugging.md`, and it finds them by scanning `src/` for
+ * `createLogger("…")` / `createLogger('…')` — STRING LITERALS ONLY. A namespace built from a
+ * variable (`createLogger(someName)`) is invisible to that guard, so it would go undocumented
+ * silently. No such call site exists today; the two that pass a fallback
+ * (`createLogger(init.logPrefix ?? 'repo-service')`) still carry the literal, which is what the
+ * scan picks up. If you ever need a fully computed namespace, document it by hand and say so here.
  */
-export function createLogger(subNamespace: string, peerId?: string): debug.Debugger {
+export function createLogger(subNamespace: string, peerId?: string): Logger {
 	const suffix = peerId ? `:${peerId.substring(0, 12)}` : ''
-	return debug(`${BASE_NAMESPACE}:${subNamespace}${suffix}`)
+	const namespace = `${BASE_NAMESPACE}:${subNamespace}${suffix}`
+	// NOTE: `Object.assign` onto the Debugger, never a spread into a fresh object. `debug` defines
+	// `enabled` as an accessor property on the function object it returns; assigning onto that
+	// object preserves the accessor, whereas spreading would flatten it to a construction-time
+	// snapshot boolean and silently break any `if (log.enabled)` guard.
+	return Object.assign(debug(namespace), {
+		error: debug(`${namespace}:error`),
+		trace: debug(`${namespace}:trace`)
+	})
 }
 
 export const verbose = typeof process !== 'undefined'