@wovin/core 0.3.3 → 0.3.4

package/src/ipns/ipns-record.ts

@@ -95,8 +95,25 @@ export async function resolveIPNSSequence(
 	return 0n
 }
 
-/** Regex to detect Kubo IPNS sequence conflict in error messages */
-const SEQ_CONFLICT_RE = /existing IPNS record has sequence (\d+) >= new record sequence (\d+)/
+/**
+ * Regex to detect Kubo IPNS sequence conflict in error messages.
+ *
+ * Matches messages like:
+ *   "existing IPNS record has sequence 406 >= new record sequence 406"
+ *
+ * The operator between the two sequence numbers is matched as an opaque
+ * non-whitespace token (`\S{1,12}`) on purpose: Go's JSON encoder HTML-escapes
+ * `>` to `>`, so the string that actually reaches us through the storage
+ * proxy reads `... sequence 406 >= new record sequence 406 ...`. A regex
+ * hard-coded to `>=` (or even a non-digit bridge like `\D+`, which trips over
+ * the digits inside `>`) would silently fail to match, the
+ * sequence-coherence retry below would never fire, and the publish would
+ * surface the generic "All IPNS publish targets failed" error instead of
+ * self-healing.
+ *
+ * Capture 1 = existing (server) sequence, capture 2 = rejected (new) sequence.
+ */
+const SEQ_CONFLICT_RE = /existing IPNS record has sequence (\d+) \S{1,12} new record sequence (\d+)/
 
 /**
  * Options for {@link publishIPNSRecord}.
@@ -145,7 +162,7 @@ export async function publishIPNSRecord(
 	let sequence: bigint | undefined
 	let bumpFloor: bigint | undefined
 
-	for (let attempt = 0; ; attempt++) {
+	for (let attempt = 0;; attempt++) {
 		// Compute next sequence on first pass or after a conflict bump
 		if (sequence === undefined) {
 			sequence = await pickNextSequence(ipnsName, targets)
@@ -171,9 +188,7 @@ export async function publishIPNSRecord(
 		}
 
 		// Check if any failure is a sequence conflict we can recover from
-		const conflictReasons = failures.filter(({ r }) =>
-			SEQ_CONFLICT_RE.test(typeof r.reason === 'string' ? r.reason : String(r.reason)),
-		)
+		const conflictReasons = failures.filter(({ r }) => SEQ_CONFLICT_RE.test(typeof r.reason === 'string' ? r.reason : String(r.reason)))
 
 		if (conflictReasons.length > 0 && attempt < maxBumps) {
 			// Parse the highest existing sequence from each conflict error
@@ -189,7 +204,7 @@ export async function publishIPNSRecord(
 			if (bump > sequence) {
 				console.warn(
 					`[publishIPNSRecord] Sequence conflict: server seq ${bump - 1n} >= current ${sequence}, ` +
-					`bumping to ${bump} (attempt ${attempt + 1}/${maxBumps})`,
+						`bumping to ${bump} (attempt ${attempt + 1}/${maxBumps})`,
 				)
 				sequence = bump
 				continue
@@ -208,7 +223,7 @@ export async function publishIPNSRecord(
 		if (conflictReasons.length > 0) {
 			throw new Error(
 				`IPNS sequence conflict not resolved after ${Math.min(attempt + 1, maxBumps)} bumps. ` +
-				`All publish targets failed: ${failures.map(({ r, name }) => `${name}: ${r.reason}`).join('; ')}`,
+					`All publish targets failed: ${failures.map(({ r, name }) => `${name}: ${r.reason}`).join('; ')}`,
 			)
 		}
 		throw new Error(

package/src/ipns/ipns-watcher.ts

@@ -17,21 +17,21 @@ const { WARN, LOG, DEBUG, ERROR } = Logger.setup(Logger.INFO) // eslint-disable-
  * these to fail at runtime and handle the error in their `onError` handler.
  */
 function buildWsUrl(nameBaseUrl: string, name: string) {
-	const base = nameBaseUrl.replace(/\/+$/, '').replace(/^http/, 'ws')
-	return `${base}/${name}/watch`
+	const base = nameBaseUrl.replace(/\/+$/, '').replace(/\/name$/, '').replace(/^http/, 'ws')
+	return `${base}/name/${name}/watch`
 }
 function buildHttpUrl(nameBaseUrl: string, name: string) {
-	const base = nameBaseUrl.replace(/\/+$/, '')
-	return `${base}/${name}`
+	const base = nameBaseUrl.replace(/\/+$/, '').replace(/\/name$/, '')
+	return `${base}/name/${name}`
 }
 
 function requireNameBaseUrl(nameBaseUrl: string | undefined, fn: string): string {
 	if (!nameBaseUrl) {
 		throw new Error(
 			`[${fn}] nameBaseUrl is required. The legacy default `
-			+ `https://name.web3.storage is shut down. Pass the base URL of a naming `
-			+ `service that supports WebSocket subscriptions to /name/<ipns>/watch `
-			+ `and HTTP GET on /name/<ipns>.`,
+				+ `https://name.web3.storage is shut down. Pass the base URL of a naming `
+				+ `service that supports WebSocket subscriptions to /name/<ipns>/watch `
+				+ `and HTTP GET on /name/<ipns>.`,
 		)
 	}
 	return nameBaseUrl
@@ -261,8 +261,7 @@ export class IpnsWatcher {
 			// Check for current state on first connect if requested
 			if (this.isFirstConnect && (options.fetchInitialState ?? false)) {
 				this.checkForMissedUpdates()
-			}
-			// Check for missed updates on reconnect
+			} // Check for missed updates on reconnect
 			else if (!this.isFirstConnect && (options.catchUpOnReconnect ?? true)) {
 				this.checkForMissedUpdates()
 			}
@@ -449,8 +448,8 @@ export class IpnsWatcher {
 			const silenceDuration = this.lastMessageAt
 				? now.getTime() - this.lastMessageAt.getTime()
 				: this.connectedAt
-					? now.getTime() - this.connectedAt.getTime()
-					: 0
+				? now.getTime() - this.connectedAt.getTime()
+				: 0
 
 			const staleInfo: StaleConnectionInfo = {
 				connectedAt: this.connectedAt ?? now,

package/src/pubsub/snap-push.ts

@@ -3,6 +3,7 @@ import { Logger } from 'besonders-logger'
 import { CID } from 'multiformats/cid'
 import stringify from 'safe-stable-stringify'
 import { ensureTsPvAndFinalizeApplog } from '../applog/applog-helpers.ts'
+import { applogsSummary } from '../applog/applog-utils.ts'
 import type {
 	Applog,
 	ApplogArrayMaybeEncrypted,
@@ -159,10 +160,31 @@ export async function prepareSnapshotForPush(
 	const applogsToEncode = keepTruthy(maybeEncryptedApplogs)
 	const infologsToEncode = keepTruthy(infoLogs)
 	if (!applogsToEncode.length) {
-		throw ERROR('no valid applogs', { agent, maybeEncryptedApplogs, infoLogs, applogsToEncode, infologsToEncode, prevSnapCID })
+		// all applogs were filtered out as falsy — show raw→kept counts + a sample so we can see what came in
+		throw ERROR('no valid applogs', {
+			agent: agent.did,
+			prevSnapCID: prevSnapCID?.toString(),
+			counts: {
+				rawApplogs: maybeEncryptedApplogs.length,
+				keptApplogs: applogsToEncode.length,
+				rawInfo: infoLogs.length,
+				keptInfo: infologsToEncode.length,
+			},
+			rawApplogsSample: applogsSummary(maybeEncryptedApplogs),
+		})
 	}
 	if (!infologsToEncode.length) {
-		throw ERROR('no valid infologs', { agent, maybeEncryptedApplogs, infoLogs, applogsToEncode, infologsToEncode, prevSnapCID })
+		throw ERROR('no valid infologs', {
+			agent: agent.did,
+			prevSnapCID: prevSnapCID?.toString(),
+			counts: {
+				rawApplogs: maybeEncryptedApplogs.length,
+				keptApplogs: applogsToEncode.length,
+				rawInfo: infoLogs.length,
+				keptInfo: infologsToEncode.length,
+			},
+			rawInfoSample: applogsSummary(infoLogs),
+		})
 	}
 	const encodedSnapshot = await encodeSnapshotAsCar(agent, applogsToEncode, infologsToEncode, prevSnapCID, prevCounter)
 	DEBUG('inPrepareSnapshotForPush', { encodedSnapshot })
@@ -253,7 +275,7 @@ export async function encodeSnapshotApplogsAsCar(
 	applogs: ApplogArrayMaybeEncryptedRO,
 ) {
 	const encoded = await encodeApplogsAsIPLD(applogs)
-	if (!encoded) throw ERROR('invalid applogs cannot continue', { applogs, encoded })
+	if (!encoded) throw ERROR('invalid applogs cannot continue', { encoded, applogs: applogsSummary(applogs) })
 	const { cids, encodedApplogs } = encoded
 	const root = { applogs: cids }
 	const encodedRoot = await encodeBlockOriginal(root)

package/src/query/basic.ts

@@ -1,10 +1,26 @@
-import { AgentHash, Applog, ApplogValue, CidString, DatalogQueryPattern, EntityID, SearchContext, ValueOrMatcher } from '../applog/datom-types.ts'
+import {
+	AgentHash,
+	Applog,
+	ApplogValue,
+	CidString,
+	DatalogQueryPattern,
+	EntityID,
+	SearchContext,
+	ValueOrMatcher,
+} from '../applog/datom-types.ts'
 
 import { Logger } from 'besonders-logger'
 
 import { isEmpty } from 'lodash-es'
 import stringify from 'safe-stable-stringify'
-import { isLaterByTsAndPv, isoDateStrCompare, isVariable, resolveOrRemoveVariables, sortApplogsByTs } from '../applog/applog-utils.ts'
+import {
+	applogsSummary,
+	isLaterByTsAndPv,
+	isoDateStrCompare,
+	isVariable,
+	resolveOrRemoveVariables,
+	sortApplogsByTs,
+} from '../applog/applog-utils.ts'
 import { createDebugName } from '../utils/debug-name.ts'
 import { isInitEvent, StaticThread, Thread, ThreadEvent } from '../thread/basic.ts'
 import { hasFilter, makeFilter, rollingFilter, rollingMapper, ThreadOnlyCurrent } from '../thread/filters.ts'
@@ -239,10 +255,8 @@ export const withoutDeleted = memoizedFn('withoutDeleted', function withoutDelet
 			// Pass-through: a parent log goes through to subscribers iff the entity
 			// wasn't hidden before AND isn't hidden now. Transitions are owned by the
 			// synthetic streams above.
-			const passAdded = delta.added.filter(log =>
-				!hiddenBefore.has(log.en) && !isHidden(log.en))
-			const passRemoved = delta.removed?.filter(log =>
-				!hiddenBefore.has(log.en)) ?? []
+			const passAdded = delta.added.filter(log => !hiddenBefore.has(log.en) && !isHidden(log.en))
+			const passRemoved = delta.removed?.filter(log => !hiddenBefore.has(log.en)) ?? []
 
 			return {
 				added: [...passAdded, ...syntheticAdditions],
@@ -324,21 +338,28 @@ export function queryStepOnce(
 		const matchingLogs = filter(thread.applogs)
 		const varMapper = createObjMapper(variablesToFill)
 
-		const nodes = matchingLogs.map(log => makeQueryNode(
-			log, node, varMapper,
-			createDebugName({
-				caller: 'QueryNode',
-				thread,
-				pattern: `${stringify(Object.assign({}, node?.variables, varMapper(log)))}@${stringify(patternWithResolvedVars)}`,
-			}),
-		))
+		const nodes = matchingLogs.map(log =>
+			makeQueryNode(
+				log,
+				node,
+				varMapper,
+				createDebugName({
+					caller: 'QueryNode',
+					thread,
+					pattern: `${stringify(Object.assign({}, node?.variables, varMapper(log)))}@${stringify(patternWithResolvedVars)}`,
+				}),
+			)
+		)
 
 		if (VERBOSE.isEnabled) VERBOSE(`[queryStepOnce.doQuery] nodes:`, nodes.map(n => n.variables))
 		if (opts.debug) {
-			LOG(`[queryStepOnce] step result:`, nodes.map(({ variables, logsOfThisNode: thread }) => ({
-				variables,
-				thread,
-			})))
+			LOG(
+				`[queryStepOnce] step result:`,
+				nodes.map(({ variables, logsOfThisNode: thread }) => ({
+					variables,
+					thread,
+				})),
+			)
 		}
 
 		return nodes
@@ -404,7 +425,9 @@ export const liveQueryStep = memoizedFn('liveQueryStep', function liveQueryStep(
 
 		function makeNode(log: Applog): QueryNode {
 			return makeQueryNode(
-				log, node, varMapper,
+				log,
+				node,
+				varMapper,
 				createDebugName({
 					caller: 'QueryNode',
 					thread: applogsMatchingStatic,
@@ -418,31 +441,33 @@ export const liveQueryStep = memoizedFn('liveQueryStep', function liveQueryStep(
 
 		if (VERBOSE.isEnabled) VERBOSE(`[liveQueryStep.doQuery] initial nodes:`, initialNodes.map(n => n.variables))
 		if (opts.debug) {
-			LOG(`[liveQueryStep] step result:`, initialNodes.map(({ variables, logsOfThisNode: thread }) => ({
-				variables,
-				thread,
-			})))
+			LOG(
+				`[liveQueryStep] step result:`,
+				initialNodes.map(({ variables, logsOfThisNode: thread }) => ({
+					variables,
+					thread,
+				})),
+			)
 		}
 
 		// Upstream subscription activates lazily — only when someone subscribes to us
 		const result = new SubscribableArrayImpl<QueryNode>(
 			initialNodes,
-			() => applogsMatchingStatic.subscribe((event) => {
-				if (isInitEvent(event)) {
-					result._reset(event.init.map(makeNode))
-				} else {
-					if (event.added.length) {
-						result._push(...event.added.map(makeNode))
-					}
-					if (event.removed?.length) {
-						const removedCids = new Set(event.removed.map(log => log.cid))
-						const toRemove = result.items.filter(qn =>
-							removedCids.has(qn.logsOfThisNode.applogs[0]?.cid)
-						)
-						if (toRemove.length) result._remove(toRemove)
+			() =>
+				applogsMatchingStatic.subscribe((event) => {
+					if (isInitEvent(event)) {
+						result._reset(event.init.map(makeNode))
+					} else {
+						if (event.added.length) {
+							result._push(...event.added.map(makeNode))
+						}
+						if (event.removed?.length) {
+							const removedCids = new Set(event.removed.map(log => log.cid))
+							const toRemove = result.items.filter(qn => removedCids.has(qn.logsOfThisNode.applogs[0]?.cid))
+							if (toRemove.length) result._remove(toRemove)
+						}
 					}
-				}
-			}, 'derived'),
+				}, 'derived'),
 		)
 		return result
 	}
@@ -466,9 +491,9 @@ export const liveQueryStep = memoizedFn('liveQueryStep', function liveQueryStep(
 		initialItems,
 		() => {
 			const subsByInputNode = new Map<QueryNode, {
-				inner: SubscribableArray<QueryNode>,
-				unsub: Unsubscribe,
-				nodes: QueryNode[],
+				inner: SubscribableArray<QueryNode>
+				unsub: Unsubscribe
+				nodes: QueryNode[]
 			}>()
 
 			function wireInner(inputNode: QueryNode, inner: SubscribableArray<QueryNode>): QueryNode[] {
@@ -521,7 +546,8 @@ export const liveQueryStep = memoizedFn('liveQueryStep', function liveQueryStep(
 			const prevUnsub = nodeSet.subscribe((event) => {
 				if (isArrayInitEvent(event)) {
 					for (const [, entry] of subsByInputNode) {
-						entry.unsub(); entry.inner.dispose()
+						entry.unsub()
+						entry.inner.dispose()
 					}
 					subsByInputNode.clear()
 					const allNodes: QueryNode[] = []
@@ -550,7 +576,8 @@ export const liveQueryStep = memoizedFn('liveQueryStep', function liveQueryStep(
 			return () => {
 				prevUnsub()
 				for (const [, entry] of subsByInputNode) {
-					entry.unsub(); entry.inner.dispose()
+					entry.unsub()
+					entry.inner.dispose()
 				}
 				subsByInputNode.clear()
 			}
@@ -688,7 +715,10 @@ export const liveQueryNot = memoizedFn('liveQueryNot', function liveQueryNot(
 				}
 			}, 'derived')
 
-			return () => { threadUnsub(); upstreamUnsub() }
+			return () => {
+				threadUnsub()
+				upstreamUnsub()
+			}
 		},
 	)
 
@@ -755,27 +785,28 @@ export const liveFilterAndMap = memoizedFn('liveFilterAndMap', function liveFilt
 	const initial = filtered.applogs.map(mapAndTrack)
 	const result = new SubscribableArrayImpl<R>(
 		initial,
-		() => filtered.subscribe((event) => {
-			if (isInitEvent(event)) {
-				cidToMapped.clear()
-				result._reset(event.init.map(mapAndTrack))
-			} else {
-				if (event.added.length) result._push(...event.added.map(mapAndTrack))
-				if (event.removed?.length) {
-					const toRemove: R[] = []
-					for (const log of event.removed) {
-						const r = cidToMapped.get(log.cid)
-						if (r === undefined) {
-							WARN(`[liveFilterAndMap] removed log not in cidToMapped`, { log })
-							continue
+		() =>
+			filtered.subscribe((event) => {
+				if (isInitEvent(event)) {
+					cidToMapped.clear()
+					result._reset(event.init.map(mapAndTrack))
+				} else {
+					if (event.added.length) result._push(...event.added.map(mapAndTrack))
+					if (event.removed?.length) {
+						const toRemove: R[] = []
+						for (const log of event.removed) {
+							const r = cidToMapped.get(log.cid)
+							if (r === undefined) {
+								WARN(`[liveFilterAndMap] removed log not in cidToMapped`, { log })
+								continue
+							}
+							cidToMapped.delete(log.cid)
+							toRemove.push(r)
 						}
-						cidToMapped.delete(log.cid)
-						toRemove.push(r)
+						if (toRemove.length) result._remove(toRemove)
 					}
-					if (toRemove.length) result._remove(toRemove)
 				}
-			}
-		}, 'derived'),
+			}, 'derived'),
 	)
 	return result
 }, { argsDebugName: (thread, pattern) => createDebugName({ caller: 'liveFilterAndMap', thread, pattern }) })
@@ -809,9 +840,10 @@ export const liveQueryAndMap = memoizedFn('liveQueryAndMap', function liveQueryA
 
 	const result = new SubscribableArrayImpl<R>(
 		computeAll(),
-		() => live.subscribe(() => {
-			result._reset(computeAll())
-		}, 'derived'),
+		() =>
+			live.subscribe(() => {
+				result._reset(computeAll())
+			}, 'derived'),
 	)
 	return result
 }, { argsDebugName: (thread, pattern) => createDebugName({ caller: 'liveQueryAndMap', thread, pattern }) })
@@ -856,9 +888,10 @@ export const liveQueryEntity = memoizedFn('liveQueryEntity', function liveQueryE
 
 	const result = new SubscribableImpl<Record<string, ApplogValue> | null>(
 		compute(),
-		() => filtered.subscribe(() => {
-			result._set(compute())
-		}, 'derived'),
+		() =>
+			filtered.subscribe(() => {
+				result._set(compute())
+			}, 'derived'),
 	)
 	return result
 }, {
@@ -882,9 +915,10 @@ export const liveEntityAt = memoizedFn('liveEntityAt', function liveEntityAt<T e
 
 	const result = new SubscribableImpl<T | null>(
 		compute(),
-		() => filtered.subscribe(() => {
-			result._set(compute())
-		}, 'derived'),
+		() =>
+			filtered.subscribe(() => {
+				result._set(compute())
+			}, 'derived'),
 	)
 	return result
 }, {
@@ -968,7 +1002,10 @@ export const liveEntityOverlapCount = memoizedFn(
 			() => {
 				const unsub1 = threadA.subscribe(() => result._set(compute()), 'derived')
 				const unsub2 = threadB.subscribe(() => result._set(compute()), 'derived')
-				return () => { unsub1(); unsub2() }
+				return () => {
+					unsub1()
+					unsub2()
+				}
 			},
 		)
 		return result
@@ -985,7 +1022,9 @@ export const querySingle = memoizedFn('querySingle', function querySingle(
 	if (result.isEmpty) return null
 	if (result.size > 1) throw ERROR(`[querySingle] got`, result.size, `results:`, result)
 	const logsOfThisNode = result.nodes[0].logsOfThisNode
-	if (logsOfThisNode.size != 1) throw ERROR(`[querySingle] single result, but got`, logsOfThisNode.size, `logs:`, logsOfThisNode.applogs)
+	if (logsOfThisNode.size != 1) {
+		throw ERROR(`[querySingle] single result, but got`, logsOfThisNode.size, `logs:`, applogsSummary(logsOfThisNode.applogs))
+	}
 	return logsOfThisNode.applogs[0]
 }, {
 	argsDebugName: (thread, pattern) => createDebugName({ caller: 'querySingle', thread, pattern }),
@@ -1031,9 +1070,10 @@ export const liveQuerySingle = memoizedFn('liveQuerySingle', function liveQueryS
 
 	const result = new SubscribableImpl<Applog | null>(
 		compute(),
-		() => live.subscribe(() => {
-			result._set(compute())
-		}),
+		() =>
+			live.subscribe(() => {
+				result._set(compute())
+			}),
 	)
 	return result
 }, {
@@ -1063,9 +1103,10 @@ export const liveQuerySingleAndMap = memoizedFn(
 
 		const result = new SubscribableImpl<any>(
 			compute(),
-			() => liveSingle.subscribe(() => {
-				result._set(compute())
-			}),
+			() =>
+				liveSingle.subscribe(() => {
+					result._set(compute())
+				}),
 		)
 		return result
 	},
@@ -1214,7 +1255,8 @@ function warnIfDisjointQuerySteps(patterns: DatalogQueryPattern[]) {
 		if (stepVars.size === 0) {
 			WARN(
 				`[query] Step ${i} has no variables — it produces identical results regardless of previous steps (cartesian product).`,
-				`Patterns:`, patterns,
+				`Patterns:`,
+				patterns,
 			)
 			continue
 		}
@@ -1225,7 +1267,8 @@ function warnIfDisjointQuerySteps(patterns: DatalogQueryPattern[]) {
 				`This produces a cartesian product instead of a join.`,
 				`Step ${i} variables: {${[...stepVars].join(', ')}}`,
 				`Reachable from prior steps: {${[...reachable].join(', ')}}`,
-				`Patterns:`, patterns,
+				`Patterns:`,
+				patterns,
 			)
 		}
 		for (const v of stepVars) reachable.add(v)

package/src/thread/basic.ts

@@ -71,7 +71,10 @@ export abstract class Thread implements SubscribableArray<Applog> {
 
 	protected notifySubscribers(event: ThreadEvent) {
 		this._version++
-		DEBUG(`[thread: ${this.name}] notifying`, this._derivedSubscribers.length, 'derived +', this._subscribers.length, 'subscribers of', { ...event, subs: this._subscribers })
+		DEBUG(`[thread: ${this.name}] notifying`, this._derivedSubscribers.length, 'derived +', this._subscribers.length, 'subscribers of', {
+			...event,
+			subs: this._subscribers,
+		})
 		const derived = [...this._derivedSubscribers] // snapshot — safe if a subscriber unsubs during iteration
 		for (const subscriber of derived) {
 			subscriber(event)
@@ -83,7 +86,9 @@ export abstract class Thread implements SubscribableArray<Applog> {
 	}
 
 	// ── SubscribableArray<Applog> ──
-	get items(): readonly Applog[] { return this._applogs }
+	get items(): readonly Applog[] {
+		return this._applogs
+	}
 
 	dispose() {
 		this._derivedSubscribers.length = 0
@@ -186,6 +191,20 @@ export abstract class Thread implements SubscribableArray<Applog> {
 	get hasParents() {
 		return !!this.parents?.length
 	}
+
+	// Compact representation for server-side / plain console logging (Node's util.inspect).
+	// ⚠ Only consulted by Node — browser devtools ignore this symbol and keep rendering the
+	// live, expandable object, so passing `thread` to a logger stays clickable in devtools
+	// while no longer splatting every applog + the whole parent chain + subscribers to stdout.
+	[Symbol.for('nodejs.util.inspect.custom')]() {
+		// Must never throw — an inspect that throws breaks the very error log it's part of.
+		// e.g. `ERROR('falsy applogs of thread', s)` where s._applogs is malformed.
+		try {
+			return `${this.constructor.name}<${this.nameAndSizeUntracked}${this.filters?.length ? ` |${this.filters.join(',')}` : ''}>`
+		} catch {
+			return `${this.constructor.name}<${this.name} (size?)>`
+		}
+	}
 }
 
 export const getLogsFromThread = (logsOrThread: ApplogsOrThread) => logsOrThread instanceof Thread ? logsOrThread.applogs : logsOrThread

package/src/thread/mapped.ts

@@ -1,15 +1,22 @@
 import { Logger } from 'besonders-logger'
 import { DebouncedFunc, pull, sortedIndexBy } from 'lodash-es'
 import { Applog, ApplogForInsert } from '../applog/datom-types.ts'
+import { applogsSummary } from '../applog/applog-utils.ts'
 import { arrayIfSingle } from '../types/typescript-utils.ts'
 import { isInitEvent, Thread, ThreadEvent } from './basic.ts'
 
 const { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO) // eslint-disable-line no-unused-vars
 
+/** Bounded, debuggable one-line summary of a ThreadEvent (init vs added/removed with counts + samples). */
+const threadEventSummary = (e: ThreadEvent) =>
+	isInitEvent(e)
+		? `init ${applogsSummary(e.init)}`
+		: `added ${applogsSummary(e.added)}${e.removed ? ` removed ${applogsSummary(e.removed)}` : ''}`
+
 // ── ThreadDerivation ────────────────────────────────────────────
 
 /** Delta event — only incremental changes (no init) */
-export type DeltaEvent = { added: readonly Applog[], removed: readonly Applog[] | null }
+export type DeltaEvent = { added: readonly Applog[]; removed: readonly Applog[] | null }
 
 /** Context passed to mapDelta — explicit deps, no `this` needed */
 export interface DeltaContext {
@@ -210,9 +217,10 @@ export class MappedThread extends Thread {
 						this._applogs.splice(idx, 1)
 					} else {
 						throw ERROR(`MappedThread{${this.name}} toRemove: log not found`, toRemove, {
-							thread: this,
-							event,
-							result,
+							thread: this.nameAndSizeUntracked,
+							currentLogs: applogsSummary(this._applogs),
+							event: threadEventSummary(event),
+							result: threadEventSummary(result),
 						})
 					}
 				}

package/src/thread/utils.ts

@@ -3,7 +3,7 @@ import { curry, debounce, partial, pull, uniq, uniqBy, uniqWith } from 'lodash-e
 
 import { CID } from 'multiformats'
 import { ensureTsPvAndFinalizeApplogs, joinThreads } from '../applog/applog-helpers.ts'
-import { compareApplogsByEnAt, compareApplogsByTs, objEqualByKeys } from '../applog/applog-utils.ts'
+import { applogsSummary, compareApplogsByEnAt, compareApplogsByTs, objEqualByKeys } from '../applog/applog-utils.ts'
 import { Applog, ApplogForInsert, CidString, EntityID } from '../applog/datom-types.ts'
 import { Thread } from './basic.ts'
 import { MappedThread } from './mapped.ts'
@@ -39,7 +39,7 @@ export function debounceWrites(
 	let insertQueue: Array<Applog | ApplogForInsert> = []
 
 	const debouncedCommit = debounce(() => {
-		WARN(`Debounce tail`, { thread, mappedThread, insertQueue })
+		DEBUG(`Debounce tail`, { thread: thread.nameAndSizeUntracked, queued: applogsSummary(insertQueue) })
 		const toInsert = ensureTsPvAndFinalizeApplogs(
 			// ? uniq, sure - but which one is used? (update: seems the first one, so reverse)
 			uniqWith(insertQueue.reverse(), removeDuplicatesWith),
@@ -49,7 +49,7 @@ export function debounceWrites(
 		insertQueue.splice(0, insertQueue.length) // clear queue
 	}, wait)
 	const handleInsert = (applogs: Applog[] | ApplogForInsert[]) => {
-		DEBUG(`Debounce input:`, applogs, { thread, mappedThread, insertQueue })
+		DEBUG(`Debounce input:`, applogsSummary(applogs), { thread: thread.nameAndSizeUntracked, queued: insertQueue.length })
 		insertQueue.push(...applogs)
 		debouncedCommit()
 		return null // don't insert anything
@@ -131,8 +131,8 @@ export const excludeApplogsContainedIn = (
 	const excludeCids: Set<string> = exclude instanceof Set
 		? new Set([...exclude].map(c => c.toString()))
 		: exclude instanceof Thread
-			? new Set(exclude.applogsCids)
-			: new Set(exclude.map(a => a.cid))
+		? new Set(exclude.applogsCids)
+		: new Set(exclude.map(a => a.cid))
 
 	return applogs.filter(applog => {
 		if (!applog.cid) {