@wovin/core 0.0.0-ciao-mobx-955482e8

package/src/thread/basic.ts

@@ -0,0 +1,209 @@
+import { Logger } from 'besonders-logger'
+import { createBLAKE3 } from 'hash-wasm'
+import { pick } from 'lodash-es'
+import { CID } from 'multiformats'
+import { arraysContainSameElements } from '../applog/applog-utils.ts'
+import { areApplogsEqual } from '../applog/applog-utils.ts'
+import { type Applog, ApplogForInsert, CidString } from '../applog/datom-types.ts'
+import type { SubscribableArray, ArrayEvent } from '../query/subscribable.ts'
+import { isArrayInitEvent } from '../query/subscribable.ts'
+import { areCidsEqual } from '../ipfs/ipfs-utils.ts'
+import { prettifyThreadName } from '../utils/debug-name.ts'
+import { arrayIfSingle, ArrayOrSingle } from '../types/typescript-utils.ts'
+
+const { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO, { prefix: '[thread]' })
+
+export type ThreadEvent = ArrayEvent<Applog>
+/** @deprecated Use isArrayInitEvent from @wovin/core/query */
+export const isInitEvent = isArrayInitEvent
+
+export type ApplogsOrThread = Thread | readonly Applog[]
+
+// const blakeHasher = await createBLAKE3()
+
+export abstract class Thread implements SubscribableArray<Applog> {
+	readonly filters: readonly string[]
+	readonly parents: Thread[] | readonly Thread[] | null
+	protected _derivedSubscribers: ((event: ThreadEvent) => void)[] = []
+	protected _subscribers: ((event: ThreadEvent) => void)[] = []
+	/** Monotonic counter incremented on every mutation. Used by memoizedFn to invalidate caches. */
+	_version = 0
+
+	constructor(
+		readonly name: string, /* = null */
+		parents: ArrayOrSingle<Thread> | readonly Thread[] | null,
+		filters: readonly string[],
+		protected _applogs: Applog[] = [],
+	) {
+		this.parents = parents === null ? null : arrayIfSingle(parents) as readonly Thread[]
+		this.filters = filters // ? uniq([...parents?.map(p => p.filters), filters])
+		if (this.parents?.length === 0) {
+			WARN(`[Thread] empty parents array`, name) // just to see where it happens, is actually mostly fine
+		}
+	}
+
+	get readOnly() {
+		if (this.parents.length !== 1) return true // ? multi-parent writable stream? - we don't have a use-case for this yet, but could this be a thing?
+		return this.parents[0].readOnly
+	}
+
+	public insert(appLogsToInsert: ArrayOrSingle<ApplogForInsert>) {
+		if (this.readOnly) throw ERROR(`[Thread] insert() called on read-only thread:`, this.nameAndSizeUntracked)
+		if (!this.parents) throw ERROR(`[Thread] insert() called on non-writable thread without parents:`, this.nameAndSizeUntracked)
+		if (this.parents?.length !== 1) throw ERROR(`[Thread] insert() called on thread with multiple parents:`, this.nameAndSizeUntracked)
+		return this.parents[0].insert(appLogsToInsert)
+	}
+	public insertRaw(appLogsToInsert: readonly Applog[]) {
+		if (this.readOnly) throw ERROR(`[Thread] insertRaw() called on read-only thread:`, this.nameAndSizeUntracked)
+		if (!this.parents) throw ERROR(`[Thread] insertRaw() called on non-writable thread without parents:`, this.nameAndSizeUntracked)
+		if (this.parents?.length !== 1) throw ERROR(`[Thread] insertRaw() called on thread with multiple parents:`, this.nameAndSizeUntracked)
+		return this.parents[0].insertRaw(appLogsToInsert)
+	}
+
+	subscribe(callback: (event: ThreadEvent) => void, type?: 'derived' | 'reaction') {
+		const list = type === 'derived' ? this._derivedSubscribers : this._subscribers
+		list.push(callback)
+		return () => {
+			const idx = list.indexOf(callback)
+			if (idx >= 0) list.splice(idx, 1)
+		}
+	}
+
+	protected notifySubscribers(event: ThreadEvent) {
+		this._version++
+		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)
+		}
+		const subs = [...this._subscribers]
+		for (const subscriber of subs) {
+			subscriber(event)
+		}
+	}
+
+	// ── SubscribableArray<Applog> ──
+	get items(): readonly Applog[] { return this._applogs }
+
+	dispose() {
+		this._derivedSubscribers.length = 0
+		this._subscribers.length = 0
+	}
+
+	get applogs(): readonly Applog[] /* (i) only type hint, not actually immutable */ {
+		// VERBOSE.isDisabled || trace()
+		return this._applogs
+	}
+	get applogsCids(): readonly CidString[] {
+		return this._applogs.map(l => l.cid)
+	}
+	get applogsCidSet(): ReadonlySet<CidString> {
+		return new Set(this._applogs.map(l => l.cid))
+	}
+
+	public map<R>(fn: (applog: Applog) => R) {
+		// if (!this.applogs.map) throw ERROR(`thread.applogs is not an array?!`, this.applogs)
+		return this.applogs.map(fn)
+	}
+	public get findLast() {
+		return this.applogs.findLast.bind(this.applogs)
+	}
+	public get findFirst() {
+		return this.applogs.find.bind(this.applogs)
+	}
+
+	get firstLog() {
+		return this.applogs[0]
+	}
+	get latestLog() {
+		return this.applogs[this.applogs.length - 1]
+	}
+	public hasApplog(applog: Applog, byRef: boolean) {
+		if (byRef) {
+			return this.applogs.includes(applog)
+		} else {
+			if (!applog.cid) throw ERROR(`[hasApplogs] applog without CID:`, applog) // trying to make this be always the case
+			return this.hasApplogCid(applog.cid)
+			// const keySet = Object.keys(applog) / / HACK: sanity check to catch bugs
+			// return !!this.applogs.find(log => {
+			// 	if (!arraysContainSameElements(keySet, Object.keys(log))) {
+			// 		/* throw */ ERROR(`[hasApplog] field set mismatch:`, { applog, log }) / / HACK: properly handle this
+			// 		return comparer.structural(pick(log, ['en', 'at', 'vl', 'ag', 'ts']), pick(applog, ['en', 'at', 'vl', 'ag', 'ts']))
+			// 	}
+			// 	return areApplogsEqual(log, applog)
+			// })
+		}
+	}
+	public hasApplogCid(cid: CID | CidString) {
+		return this.applogsCidSet.has(cid.toString()) // O(1) via Set vs O(n) via includes
+	}
+	get applogsByCid() {
+		return new Map(this.applogs.map(log => [log.cid, log]))
+	}
+	public getApplog(cid: CID | CidString) {
+		return this.applogsByCid.get(cid.toString())
+		// 	.find(function findApplogInThread(log) {
+		// 	return areCidsEqual(log.cid, cid)
+		// })
+	}
+
+	public hasApplogWithDiffTs(applog: ApplogForInsert) {
+		// HACK this is basically as inefficient as it gets
+		return this.applogs.find(existing => (
+			existing.en === applog.en
+			&& existing.at === applog.at
+			&& existing.vl === applog.vl
+			&& existing.ag === applog.ag
+		))
+	}
+
+	// get stateHash() {
+	// 	blakeHasher.init()
+	// 	for (const log of this.applogs) {
+	// 		blakeHasher.update(log.cid)
+	// 	}
+	// 	return blakeHasher.digest()
+	// }
+
+	get isEmpty() {
+		return this.size === 0
+	}
+	get size() {
+		return this.applogs.length
+	}
+	get length() {
+		return this.applogs.length
+	}
+	get untrackedSize() {
+		return this.size
+	}
+	get nameAndSizeUntracked() {
+		return `${this.name} (${this.size})`
+	}
+	get prettyName() {
+		return prettifyThreadName(this.name)
+	}
+	get hasParents() {
+		return !!this.parents?.length
+	}
+}
+
+export const getLogsFromThread = (logsOrThread: ApplogsOrThread) => logsOrThread instanceof Thread ? logsOrThread.applogs : logsOrThread
+
+export class StaticThread extends Thread {
+	static fromArray(applogs: Applog[], name?: string) {
+		return new StaticThread(name || 'static', null, [], applogs)
+	}
+	constructor(
+		name: string, /* = null */
+		parents: ArrayOrSingle<Thread> | readonly Thread[] | null,
+		filters: readonly string[],
+		_applogs: Applog[],
+	) {
+		super(name, parents, filters, _applogs)
+	}
+
+	get readOnly() {
+		return true
+	}
+}

package/src/thread/filters.ts

@@ -0,0 +1,234 @@
+import { Logger } from 'besonders-logger'
+import stringify from 'safe-stable-stringify'
+import { finalizeApplogForInsert } from '../applog/applog-helpers.ts'
+import { dateNowIso, matchPartStatic } from '../applog/applog-utils.ts'
+import { Applog, ApplogForInsert, ApplogValue, CidString, DatalogQueryPattern, ValueOrMatcher } from '../applog/datom-types.ts'
+import { createDebugName } from '../utils/debug-name.ts'
+import { memoizedFn } from '../query/memoized.ts'
+import { SubscribableImpl } from '../query/subscribable.ts'
+import type { Subscribable } from '../query/subscribable.ts'
+import { isInitEvent, Thread, ThreadEvent } from './basic.ts'
+import { ApplogEventMapper, MappedThread } from './mapped.ts'
+
+const { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO) // eslint-disable-line no-unused-vars
+
+export const rollingFilter = memoizedFn('rollingFilter', function rollingFilter(
+	thread: Thread,
+	pattern: DatalogQueryPattern,
+	opts: { name?: string; extraFilterName?: string } = {},
+) {
+	const filter = makeFilter(pattern)
+
+	const initialLogs = filter(thread.applogs)
+
+	const handleUpdateEvent: ApplogEventMapper = (event) => {
+		let mappedEvent: ThreadEvent
+		if (isInitEvent(event)) {
+			mappedEvent = { init: filter(event.init) }
+		} else {
+			mappedEvent = {
+				added: filter(event.added),
+				removed: event.removed, // whatever's removed shall be removed
+			}
+		}
+		VERBOSE(
+			`rollingFilter{${thread.nameAndSizeUntracked} | ${opts.name ? ` '${opts.name}'}` : ''} parentUpdate`,
+			pattern,
+			event,
+			'=>',
+			mappedEvent,
+		)
+		return mappedEvent
+	}
+	const mappedThread = new MappedThread(
+		`${thread.name} | ${opts.name || `rollingFilter{${stringify(pattern)}}`}`,
+		thread,
+		[...thread.filters, ...(opts.extraFilterName ? [opts.extraFilterName] : [])],
+		initialLogs,
+		handleUpdateEvent,
+	)
+
+	return mappedThread
+}, {
+	argsDebugName: (thread, pattern, opts) => createDebugName({ caller: 'rollingFilter', thread, pattern, args: opts }),
+})
+
+export const rollingMapper = memoizedFn('rollingMapper', function rollingMapper(
+	thread: Thread,
+	eventMapper: ApplogEventMapper,
+	opts: { name?: string; extraFilterName?: string } = {},
+) {
+	const initialMapResult = eventMapper.call(null, { init: thread.applogs }, thread)
+	if (!isInitEvent(initialMapResult)) {
+		throw ERROR('Initial run must return init event')
+	}
+	const initialLogs = initialMapResult.init
+
+	return new MappedThread(
+		`${thread.name} | ${opts.name || `rollingMapper`}`,
+		thread,
+		[...thread.filters, ...(opts.extraFilterName ? [opts.extraFilterName] as const : [] as const)],
+		// @ts-expect-error readonly.... FIXME
+		initialLogs,
+		eventMapper,
+	)
+}, {
+	argsDebugName: (thread, _mapper, opts) => createDebugName({ caller: 'rollingMapper', thread, args: opts }),
+})
+
+export const rollingAcc = memoizedFn(
+	'rollingAcc',
+	function rollingAcc<ACC>(
+		thread: Thread,
+		acc: ACC,
+		eventMapper: (event: ThreadEvent, acc: ACC) => void,
+		opts: { name?: string } = {},
+	): Subscribable<ACC> {
+		eventMapper({ init: thread.applogs }, acc) // Do initial mapping
+
+		const result = new SubscribableImpl<ACC>(acc, () =>
+			thread.subscribe(event => {
+				eventMapper(event, acc)
+				result._set(acc) // notify — same reference but contents mutated
+			}, 'derived'),
+			{ equals: false }, // accumulator is mutated in-place
+		)
+
+		return result
+	},
+	{ argsDebugName: (thread, _acc, _mapper, opts) => `rollingAcc{${thread.nameAndSizeUntracked}${opts?.name ? ` | ${opts?.name}` : ''}}` },
+)
+
+export const getUntrackedPattern = function getUntrackedPattern(
+	pattern: DatalogQueryPattern,
+) {
+	if (!Object.entries(pattern).length) {
+		throw new Error(`Pattern is empty`)
+	}
+	return pattern
+}
+export function makeFilter(
+	pattern: DatalogQueryPattern,
+) {
+	return function madeFilter(logs: readonly Applog[]) {
+		return logs.filter(function madeFilterSingleLog(applog) {
+			for (const field of Object.keys(pattern)) {
+				let patternValue = pattern[field] // (i) not using .entries bc. https://gists.cwidanage.com/2018/06/how-to-iterate-over-object-entries-in.html
+				if (patternValue === undefined) continue // undefined in pattern means "no constraint/query on this field"
+				const applogValue = applog[field.startsWith('!') ? field.slice(1) : field]
+				const patternValT: ValueOrMatcher<ApplogValue> = patternValue
+				if (!matchPartStatic(field as keyof Applog, patternValT, applogValue)) {
+					return false
+				}
+			}
+			return true
+		})
+	}
+}
+
+/**
+ * // ! think twice before using
+ */
+export const getUntrackedFilterResults = function getUntrackedFilterResults(
+	thread: Thread,
+	pattern: DatalogQueryPattern,
+	opts: { name?: string } = {},
+) {
+	const untrackedPattern = getUntrackedPattern(pattern)
+	const filter = makeFilter(untrackedPattern)
+	return filter(thread.applogs)
+}
+
+///////////////////////////
+// FILTERED THREAD TYPES //
+///////////////////////////
+export type ThreadWithFilter<T extends string> = Thread & {
+	filters: readonly T[]
+}
+export function hasFilter<T extends string>(thread: Thread, filter: T): thread is ThreadWithFilter<T> {
+	return thread.filters.includes(filter)
+}
+export function assertRaw(thread: Thread) /* : thread is ThreadWithoutFilters */ {
+	if (thread.filters.length) {
+		WARN(`[assertRaw] but '${thread.nameAndSizeUntracked}' has filters:`, thread.filters)
+	}
+	return thread as ThreadWithoutFilters
+}
+export function assertOnlyCurrent(thread: Thread) /* : thread is ThreadOnlyCurrent */ {
+	if (
+		!hasFilter(thread, 'lastWriteWins') ||
+		!hasFilter(thread, 'withoutDeleted')
+	) throw ERROR(`should be filtered thread, but is:`, thread.filters)
+	return thread
+}
+export type ThreadOnlyCurrent = ThreadWithFilter<'lastWriteWins'>
+export type ThreadNoDeleted = ThreadWithFilter<'withoutDeleted'>
+export type ThreadOnlyCurrentNoDeleted = ThreadWithFilter<'lastWriteWins' | 'withoutDeleted'>
+export type ThreadWithoutFilters = Thread & { filters: [] }
+
+/** Re-export for convenience */
+export const asReadOnly = MappedThread.asReadOnly
+
+//////////////////
+// MISC HELPERS //
+//////////////////
+
+export type ApplogMapper = (log: Applog, sourceThread: Thread) => ApplogForInsert
+export const simpleApplogMapper = function simpleApplogMapper(
+	thread: Thread,
+	logMapper: ApplogMapper,
+	opts: { name?: string; extraFilterName?: string } = {},
+) {
+	const mappedTo = new Map<CidString, Applog>() // source log CID to result log
+	const mapLogs = (applogs: readonly Applog[], thread: Thread) => {
+		const ts = dateNowIso()
+		return applogs.map(log => {
+			const mapped = logMapper(log, thread)
+			let mapTo: Applog
+			if (mapped === log) {
+				mapTo = log
+			} else {
+				if ((mapped as Applog).cid === log.cid) {
+					delete (mapped as Applog).cid // for convenience of not needing to remove it in the mapper
+				}
+				mapTo = finalizeApplogForInsert(mapped, {
+					ts,
+					threadForPv: null, // ? should not be inferred, right?
+				})
+			}
+			mappedTo.set(log.cid, mapTo)
+			return mapTo
+		})
+	}
+
+	const handleUpdateEvent: ApplogEventMapper = (event) => {
+		let mappedEvent: ThreadEvent
+		if (isInitEvent(event)) {
+			mappedEvent = { init: mapLogs(event.init, thread) }
+		} else {
+			mappedEvent = {
+				added: mapLogs(event.added, thread),
+				removed: event.removed.map(removedSourceLog => {
+					const mappedLog = mappedTo.get(removedSourceLog.cid)
+					if (!mappedLog) {
+						throw ERROR(`[simpleApplogMapper] Parent remove event for Applog that we don't know about`, { removedSourceLog })
+					}
+					mappedTo.delete(removedSourceLog.cid)
+					return mappedLog
+				}),
+			}
+		}
+		VERBOSE(
+			`simpleApplogMapper{${thread.nameAndSizeUntracked} | ${opts?.name ? ` '${opts?.name}'}` : ''} parentUpdate`,
+			event,
+			'=>',
+			mappedEvent,
+		)
+		// console.trace('rollingFilter.addFiltered', getObserverTree(observableArr))
+		// trace()
+		return mappedEvent
+	}
+	const mappedThread = rollingMapper(thread, handleUpdateEvent, opts)
+	VERBOSE.isDisabled || VERBOSE(`simpleApplogMapper<${thread.nameAndSizeUntracked}> initial mapped to`, mappedThread.applogs)
+	return mappedThread
+}

package/src/thread/mapped.ts

@@ -0,0 +1,166 @@
+import { Logger } from 'besonders-logger'
+import { DebouncedFunc, pull, sortedIndexBy } from 'lodash-es'
+import { Applog, ApplogForInsert } from '../applog/datom-types.ts'
+import { isInitEvent, Thread, ThreadEvent } from './basic.ts'
+
+const { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO) // eslint-disable-line no-unused-vars
+
+export type ApplogEventMapper = (this: MappedThread, event: ThreadEvent, sourceThread: Thread) => ThreadEvent
+// export type ApplogWriteMapper<T extends Applog[] | ApplogForInsert[]> = (this: MappedThread, applogs: T) => T | null // FIXME: the TS generics don't actually work how I want them to
+export type ApplogWriteMapper = (this: MappedThread, applogs: Applog[] | ApplogForInsert[]) => Applog[] | ApplogForInsert[] | null
+
+export class MappedThread extends Thread {
+	static mapWrites(parent: Thread, name: string, mapper: ApplogWriteMapper) {
+		return new MappedThread(
+			`${name}<${parent.nameAndSizeUntracked}>`,
+			parent,
+			parent.filters,
+			// @ts-expect-error ? what's the proper way
+			parent._applogs,
+			null,
+			mapper,
+		)
+	}
+	static asReadOnly(parent: Thread) {
+		if (parent.readOnly) return parent // already read-only, no need to wrap
+		return new MappedThread(
+			`readOnly(${parent.name})`,
+			parent,
+			parent.filters,
+			// @ts-expect-error ? what's the proper way
+			parent._applogs,
+			null,
+			null,
+			true, // readOnly
+		)
+	}
+	private _parentSubscriptions: Map<Thread, (() => void)> = null // mapped to unsubscribe function
+
+	constructor(
+		readonly name: string,
+		parents: Thread | readonly Thread[],
+		filters: readonly string[],
+		readonly _initialLogs: Applog[],
+		private _eventMapper: ApplogEventMapper | null,
+		private _writeMapper: ApplogWriteMapper = null,
+		private _readOnly?: boolean,
+	) {
+		super(
+			name,
+			parents,
+			filters,
+			_eventMapper ?
+				[..._initialLogs] // clone — mapped thread manages its own array
+				: _initialLogs, // if we don't map events, we just re-use the array and then don't need to subscribe
+		)
+
+		if (_eventMapper) { // if we don't map events, we just re-use the array and then don't need to subscribe
+			this.subscribeToParents()
+		}
+	}
+
+	public insert(appLogsToInsert: ApplogForInsert[]) {
+		if (this.readOnly) throw ERROR(`[MappedThread] insert() called on read-only thread:`, this.nameAndSizeUntracked)
+		const mapped = this._writeMapper ? this._writeMapper(appLogsToInsert) : appLogsToInsert
+		if (this._writeMapper && !mapped) return
+		return this.parents.forEach(parent => parent.insert(mapped))
+	}
+	public insertRaw(appLogsToInsert: Applog[]) {
+		if (this.readOnly) throw ERROR(`[MappedThread] insertRaw() called on read-only thread:`, this.nameAndSizeUntracked)
+		const mapped = this._writeMapper ? this._writeMapper(appLogsToInsert) : appLogsToInsert
+		if (this._writeMapper && !mapped) return
+		return this.parents.forEach(parent => parent.insertRaw(mapped as Applog[]))
+	}
+
+	private subscribeToParents() {
+		this._parentSubscriptions = new Map()
+		if (!this.parents.length) {
+			WARN(`MappedThread has no parents`, this)
+		}
+		VERBOSE(`[MappedThread: ${this.name}] subscribing to parents:`, this.parents.map(p => p.name))
+
+		for (const p of this.parents) {
+			VERBOSE(`[MappedThread: ${this.name}] sub to parent`, p.nameAndSizeUntracked)
+			const sub = this.onParentUpdate.bind(this, p)
+			const unsubscribe = p.subscribe(sub, 'derived')
+			this._parentSubscriptions.set(p, unsubscribe)
+		}
+	}
+
+	/** Tear down parent subscriptions and clear internal state */
+	dispose() {
+		if (this._parentSubscriptions) {
+			for (const [, unsubscribe] of this._parentSubscriptions) {
+				unsubscribe()
+			}
+			this._parentSubscriptions = null
+		}
+	}
+
+	/** Swap parents at runtime — re-subscribes and recomputes applogs, notifying downstream */
+	setParents(newParents: readonly Thread[]) {
+		this.dispose()
+		;(this as { parents: readonly Thread[] }).parents = newParents
+		this.subscribeToParents()
+		this.triggerRemap()
+	}
+
+	subscribe(callback: (event: ThreadEvent) => void, type?: 'derived' | 'reaction') {
+		if (!this._parentSubscriptions) {
+			this.subscribeToParents()
+		}
+		return super.subscribe(callback, type)
+	}
+
+	/**
+	 * // HACK to trigger remap on pattern change in rollingFilter
+	 * should not be used lightly
+	 */
+	triggerRemap() {
+		if (!this._eventMapper) throw ERROR(`triggerRemap on a thread that is not actually mapping?!`, this.nameAndSizeUntracked)
+		DEBUG(`MappedThread{${this.nameAndSizeUntracked}} triggerRemap`)
+		if (this.parents.length !== 1) {
+			WARN(`MappedThread{${this.nameAndSizeUntracked}} triggerRemap with parentCount=${this.parents.length} - not meant for this`)
+		}
+		this.parents.forEach(p => {
+			this.onParentUpdate(p, { init: [...p.applogs] })
+		})
+	}
+
+	protected onParentUpdate(thread: Thread, event: ThreadEvent) {
+		VERBOSE(`MappedThread{${this.nameAndSizeUntracked}} parentUpdate`, event)
+		const mapResult = this._eventMapper ? this._eventMapper(event, thread) : event
+		if (this._eventMapper) {
+			VERBOSE(`MappedThread{${this.nameAndSizeUntracked}} parentUpdate => mapped`, mapResult)
+			if (isInitEvent(mapResult)) {
+				this._applogs.length = 0
+				this._applogs.push(...mapResult.init)
+			} else {
+				for (const log of mapResult.added) {
+					// insert at right location to maintain sort order
+					this._applogs.splice(sortedIndexBy(this._applogs, log, 'ts'), 0, log)
+				}
+				if (mapResult.removed) {
+					for (const toRemove of mapResult.removed) {
+						const idx = this._applogs.indexOf(toRemove)
+						if (idx >= 0) {
+							this._applogs.splice(idx, 1)
+						} else if (!isInitEvent(event) && event.removed?.includes(toRemove)) {
+							DEBUG(`Ignoring remove event for non-existent because it was part of parent event's removed`, toRemove, event) // ? convenience? - or is this a code smell?
+						} else {
+							throw ERROR(`MappedThread{${this.name}} toRemove contained log that doesn't exist`, toRemove, {
+								thread: this,
+								event,
+								mapResult,
+							})
+						}
+					}
+				}
+			}
+		} // (i) else, the _applogs is reactive to parent automatically, so no need
+		this.notifySubscribers(mapResult)
+	}
+	get readOnly() {
+		return this._readOnly ?? false
+	}
+}