@wovin/core 0.1.35 → 0.2.0

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,227 @@
+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 { type DeltaContext, type DeltaEvent, MappedThread, type ThreadDerivation } 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 derivation: ThreadDerivation = {
+		compute: (parents) => {
+			if (parents.length !== 1) {
+				throw ERROR(`rollingFilter requires exactly one parent`, { parents: parents.length })
+			}
+			return filter(parents[0].applogs)
+		},
+		mapDelta: (delta, { state }) => {
+			const mappedDelta: DeltaEvent = {
+				added: filter(delta.added),
+				removed: delta.removed?.filter(log => state.includes(log)),
+			}
+			VERBOSE(
+				`rollingFilter{${thread.nameAndSizeUntracked} | ${opts.name ? ` '${opts.name}'}` : ''} parentUpdate`,
+				pattern,
+				delta,
+				'=>',
+				mappedDelta,
+			)
+			return mappedDelta
+		},
+	}
+	return new MappedThread(
+		`${thread.name} | ${opts.name || `rollingFilter{${stringify(pattern)}}`}`,
+		thread,
+		[...thread.filters, ...(opts.extraFilterName ? [opts.extraFilterName] : [])],
+		derivation,
+	)
+}, {
+	argsDebugName: (thread, pattern, opts) => createDebugName({ caller: 'rollingFilter', thread, pattern, args: opts }),
+})
+
+export const rollingMapper = memoizedFn('rollingMapper', function rollingMapper(
+	thread: Thread,
+	derivation: ThreadDerivation,
+	opts: { name?: string; extraFilterName?: string } = {},
+) {
+	return new MappedThread(
+		`${thread.name} | ${opts.name || `rollingMapper`}`,
+		thread,
+		[...thread.filters, ...(opts.extraFilterName ? [opts.extraFilterName] as const : [] as const)],
+		derivation,
+	)
+}, {
+	argsDebugName: (thread, _derivation, 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 derivation: ThreadDerivation = {
+		compute(parents) {
+			if (parents.length !== 1) {
+				throw ERROR(`simpleApplogMapper requires exactly one parent`, { parents: parents.length })
+			}
+			const [parent] = parents
+			mappedTo.clear()
+			return mapLogs(parent.applogs, parent)
+		},
+		mapDelta: (delta, { state }) => {
+			const mappedDelta: DeltaEvent = {
+				added: mapLogs(delta.added, thread),
+				removed: delta.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
+				}).filter(log => state.includes(log)),
+			}
+			VERBOSE(
+				`simpleApplogMapper{${thread.nameAndSizeUntracked} | ${opts?.name ? ` '${opts?.name}'}` : ''} parentUpdate`,
+				delta,
+				'=>',
+				mappedDelta,
+			)
+			return mappedDelta
+		},
+	}
+	const mappedThread = rollingMapper(thread, derivation, opts)
+	VERBOSE.isDisabled || VERBOSE(`simpleApplogMapper<${thread.nameAndSizeUntracked}> initial mapped to`, mappedThread.applogs)
+	return mappedThread
+}

package/src/thread/indexes.ts

@@ -0,0 +1,250 @@
+import { Logger } from 'besonders-logger'
+import { Applog, ApplogValue, EntityID } from '../applog/datom-types.ts'
+import { memoizedFn } from '../query/memoized.ts'
+import { SubscribableImpl, type Subscribable } from '../query/subscribable.ts'
+import { isInitEvent, Thread } from './basic.ts'
+import { rollingFilter } from './filters.ts'
+
+const { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO) // eslint-disable-line no-unused-vars
+
+/**
+ * Live index of applogs grouped by entity ID. Memoized per thread — one subscription
+ * per thread regardless of how many consumers call this. Updated incrementally on
+ * each parent event (O(event-size)). Lookup is O(1) via `map.get(en)`.
+ *
+ * Subscriber order: registers a 'derived' subscription on `thread` at first call. By
+ * the FIFO subscriber-order convention (`thread/basic.ts:notifySubscribers`),
+ * consumers that subscribe to `thread` AFTER calling `applogsByEntity(thread)` will
+ * see an up-to-date index when their handler runs.
+ */
+export const applogsByEntity = memoizedFn(
+	'applogsByEntity',
+	function applogsByEntity(thread: Thread): ReadonlyMap<EntityID, readonly Applog[]> {
+		const map = new Map<EntityID, Applog[]>()
+
+		const add = (log: Applog) => {
+			let arr = map.get(log.en)
+			if (!arr) {
+				arr = []
+				map.set(log.en, arr)
+			}
+			arr.push(log)
+		}
+		const remove = (log: Applog) => {
+			const arr = map.get(log.en)
+			if (!arr) return
+			const idx = arr.indexOf(log)
+			if (idx >= 0) arr.splice(idx, 1)
+			if (arr.length === 0) map.delete(log.en)
+		}
+
+		for (const log of thread.applogs) add(log)
+
+		thread.subscribe(event => {
+			if (isInitEvent(event)) {
+				map.clear()
+				for (const log of event.init) add(log)
+			} else {
+				for (const log of event.added) add(log)
+				if (event.removed) for (const log of event.removed) remove(log)
+			}
+		}, 'derived')
+
+		return map
+	},
+)
+
+/**
+ * Live index of applogs grouped by value for a given attribute. Value-based counterpart
+ * to `applogsByEntity` (which groups by entity ID).
+ *
+ * Uses `rollingFilter` internally for the attribute filter (memoized, shared with any
+ * other code filtering by the same attribute).
+ *
+ * Returns a `Subscribable` with lazy upstream activation:
+ * - Snapshot use: read `.value` — zero subscription overhead
+ * - Reactive use: `.subscribe()` activates the chain for incremental updates
+ */
+export const applogsByAttrValue = memoizedFn(
+	'applogsByAttrValue',
+	function applogsByAttrValue(
+		thread: Thread,
+		attr: string,
+	): Subscribable<ReadonlyMap<ApplogValue, readonly Applog[]>> {
+		const map = new Map<ApplogValue, Applog[]>()
+
+		const add = (log: Applog) => {
+			let arr = map.get(log.vl)
+			if (!arr) {
+				arr = []
+				map.set(log.vl, arr)
+			}
+			arr.push(log)
+		}
+		const remove = (log: Applog) => {
+			const arr = map.get(log.vl)
+			if (!arr) return
+			const idx = arr.indexOf(log)
+			if (idx >= 0) arr.splice(idx, 1)
+			if (arr.length === 0) map.delete(log.vl)
+		}
+
+		const filtered = rollingFilter(thread, { at: attr })
+
+		// Initial build from current filtered state
+		for (const log of filtered.applogs) add(log)
+
+		const result = new SubscribableImpl<ReadonlyMap<ApplogValue, readonly Applog[]>>(
+			map,
+			() => filtered.subscribe(event => {
+				if (isInitEvent(event)) {
+					map.clear()
+					for (const log of event.init) add(log)
+				} else {
+					if (event.removed) for (const log of event.removed) remove(log)
+					for (const log of event.added) add(log)
+				}
+				result._set(map)
+			}, 'derived'),
+			{ equals: false },
+		)
+		return result
+	},
+)
+
+// ── entityLinkIndex ─────────────────────────────────────────────
+
+export interface LinkEntry {
+	/** The link entity's own ID */
+	linkId: EntityID
+	/** Value of attrA on this link entity */
+	aValue: EntityID
+	/** Value of attrB on this link entity */
+	bValue: EntityID
+}
+
+export interface EntityLinkIndexValue {
+	/** Lookup by attrA value → link entries (each has linkId + bValue) */
+	byA: ReadonlyMap<EntityID, readonly LinkEntry[]>
+	/** Lookup by attrB value → link entries (each has linkId + aValue) */
+	byB: ReadonlyMap<EntityID, readonly LinkEntry[]>
+}
+
+/**
+ * Live bidirectional index for entity-link relations: a common wovin pattern where
+ * a **link entity** connects two targets via two attributes.
+ *
+ * Example: note3 relations use a relation entity with `relation/block` (→ child block)
+ * and `relation/childOf` (→ parent block).
+ *
+ * Returns a `Subscribable` with lazy upstream activation:
+ * - Snapshot use: read `.value` — zero subscription overhead
+ * - Reactive use: `.subscribe()` activates the chain for incremental updates
+ *
+ * Link entity IDs are included in entries so consumers can look up full link state
+ * via `applogsByEntity`.
+ */
+export const entityLinkIndex = memoizedFn(
+	'entityLinkIndex',
+	function entityLinkIndex(
+		thread: Thread,
+		attrA: string,
+		attrB: string,
+	): Subscribable<EntityLinkIndexValue> {
+		const byA = new Map<EntityID, LinkEntry[]>()
+		const byB = new Map<EntityID, LinkEntry[]>()
+
+		// Internal state: track partial link entities (only one attr seen so far)
+		const aByLink = new Map<EntityID, EntityID>()  // linkId → aValue
+		const bByLink = new Map<EntityID, EntityID>()  // linkId → bValue
+
+		function addLink(linkId: EntityID, aValue: EntityID, bValue: EntityID) {
+			const entry: LinkEntry = { linkId, aValue, bValue }
+			let arrA = byA.get(aValue)
+			if (!arrA) { arrA = []; byA.set(aValue, arrA) }
+			arrA.push(entry)
+			let arrB = byB.get(bValue)
+			if (!arrB) { arrB = []; byB.set(bValue, arrB) }
+			arrB.push(entry)
+		}
+
+		function removeLink(linkId: EntityID, aValue: EntityID, bValue: EntityID) {
+			const arrA = byA.get(aValue)
+			if (arrA) {
+				const idx = arrA.findIndex(e => e.linkId === linkId)
+				if (idx >= 0) arrA.splice(idx, 1)
+				if (arrA.length === 0) byA.delete(aValue)
+			}
+			const arrB = byB.get(bValue)
+			if (arrB) {
+				const idx = arrB.findIndex(e => e.linkId === linkId)
+				if (idx >= 0) arrB.splice(idx, 1)
+				if (arrB.length === 0) byB.delete(bValue)
+			}
+		}
+
+		function processLog(log: Applog) {
+			if (log.at === attrA) {
+				aByLink.set(log.en, log.vl as EntityID)
+				const bVal = bByLink.get(log.en)
+				if (bVal !== undefined) {
+					addLink(log.en, log.vl as EntityID, bVal)
+				}
+			} else if (log.at === attrB) {
+				bByLink.set(log.en, log.vl as EntityID)
+				const aVal = aByLink.get(log.en)
+				if (aVal !== undefined) {
+					addLink(log.en, aVal, log.vl as EntityID)
+				}
+			}
+		}
+
+		function removeLog(log: Applog) {
+			if (log.at === attrA) {
+				const aVal = aByLink.get(log.en)
+				const bVal = bByLink.get(log.en)
+				if (aVal !== undefined && bVal !== undefined) {
+					removeLink(log.en, aVal, bVal)
+				}
+				aByLink.delete(log.en)
+			} else if (log.at === attrB) {
+				const aVal = aByLink.get(log.en)
+				const bVal = bByLink.get(log.en)
+				if (aVal !== undefined && bVal !== undefined) {
+					removeLink(log.en, aVal, bVal)
+				}
+				bByLink.delete(log.en)
+			}
+		}
+
+		function buildFull(applogs: readonly Applog[]) {
+			byA.clear()
+			byB.clear()
+			aByLink.clear()
+			bByLink.clear()
+			for (const log of applogs) processLog(log)
+		}
+
+		const filtered = rollingFilter(thread, { at: [attrA, attrB] })
+
+		// Initial build
+		buildFull(filtered.applogs)
+
+		const value: EntityLinkIndexValue = { byA, byB }
+		const result = new SubscribableImpl<EntityLinkIndexValue>(
+			value,
+			() => filtered.subscribe(event => {
+				if (isInitEvent(event)) {
+					buildFull(event.init)
+				} else {
+					// Process removes before adds (LWW updates appear as remove+add)
+					if (event.removed) for (const log of event.removed) removeLog(log)
+					for (const log of event.added) processLog(log)
+				}
+				result._set(value)
+			}, 'derived'),
+			{ equals: false },
+		)
+		return result
+	},
+)