@wovin/core 0.1.35 → 0.2.0

package/src/applog/applog-utils.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest'
+import type { Applog } from './datom-types.ts'
+import { compareApplogsByTs, isLaterByTsAndPv, sortApplogsByTs } from './applog-utils.ts'
+
+const mkLog = (overrides: Partial<Applog>): Applog => ({
+	cid: 'cid-default' as any,
+	en: 'e1' as any,
+	at: 'name',
+	vl: 'value',
+	ts: '2026-04-25T00:00:00.000Z',
+	pv: null,
+	ag: 'agent' as any,
+	...overrides,
+})
+
+describe('compareApplogsByTs', () => {
+	it('orders by ts asc then by cid for tiebreak (transitive)', () => {
+		const a = mkLog({ cid: 'cid-a' as any, ts: '2026-04-25T00:00:00.000Z' })
+		const b = mkLog({ cid: 'cid-b' as any, ts: '2026-04-25T00:00:00.000Z' })
+		const c = mkLog({ cid: 'cid-c' as any, ts: '2026-04-25T00:00:00.001Z' })
+		const sorted = [c, b, a].slice().sort((x, y) => compareApplogsByTs(x, y))
+		expect(sorted.map(l => l.cid)).toEqual(['cid-a', 'cid-b', 'cid-c'])
+	})
+})
+
+describe('sortApplogsByTs — chain stabilization', () => {
+	const sameTs = '2026-04-25T00:00:00.000Z'
+
+	it('topologically orders 3 same-ts chain logs regardless of input order', () => {
+		// Chain: A → B → C (same en, at, ts)
+		const a = mkLog({ cid: 'aaa' as any, pv: null, ts: sameTs })
+		const b = mkLog({ cid: 'bbb' as any, pv: 'aaa' as any, ts: sameTs })
+		const c = mkLog({ cid: 'ccc' as any, pv: 'bbb' as any, ts: sameTs })
+
+		// Note: cid lex order is a, b, c — so for asc, the cid-only sort would coincidentally
+		// produce the right order. To prove chain awareness, use cids whose lex order differs.
+		const z = mkLog({ cid: 'zzz' as any, pv: null, ts: sameTs })
+		const y = mkLog({ cid: 'yyy' as any, pv: 'zzz' as any, ts: sameTs })
+		const x = mkLog({ cid: 'xxx' as any, pv: 'yyy' as any, ts: sameTs })
+
+		// asc: chain root first → z, y, x
+		const ascOrder = sortApplogsByTs([x, y, z].slice())
+		expect(ascOrder.map(l => l.cid)).toEqual(['zzz', 'yyy', 'xxx'])
+
+		// scrambled
+		const scrambled = sortApplogsByTs([y, z, x].slice())
+		expect(scrambled.map(l => l.cid)).toEqual(['zzz', 'yyy', 'xxx'])
+
+		// desc: chain tail first → x, y, z
+		const descOrder = sortApplogsByTs([z, x, y].slice(), 'desc')
+		expect(descOrder.map(l => l.cid)).toEqual(['xxx', 'yyy', 'zzz'])
+	})
+
+	it('does not reshuffle different (en, at) sub-groups within a same-ts cluster', () => {
+		// Same ts, two sub-groups, each with a chain
+		const a1 = mkLog({ cid: 'a1' as any, en: 'e1' as any, at: 'name', pv: null, ts: sameTs })
+		const a2 = mkLog({ cid: 'a2' as any, en: 'e1' as any, at: 'name', pv: 'a1' as any, ts: sameTs })
+		const b1 = mkLog({ cid: 'b1' as any, en: 'e2' as any, at: 'name', pv: null, ts: sameTs })
+		const b2 = mkLog({ cid: 'b2' as any, en: 'e2' as any, at: 'name', pv: 'b1' as any, ts: sameTs })
+
+		const sorted = sortApplogsByTs([a2, b2, a1, b1].slice())
+		// Each (en, at) sub-group must be in chain order. Cross-group order = cid-lex (preserved).
+		const e1Logs = sorted.filter(l => l.en === 'e1')
+		const e2Logs = sorted.filter(l => l.en === 'e2')
+		expect(e1Logs.map(l => l.cid)).toEqual(['a1', 'a2'])
+		expect(e2Logs.map(l => l.cid)).toEqual(['b1', 'b2'])
+	})
+
+	it('falls back to cid-lex order for non-chain-related same-ts logs', () => {
+		const x = mkLog({ cid: 'xxx' as any, pv: null, ts: sameTs })
+		const y = mkLog({ cid: 'yyy' as any, pv: null, ts: sameTs })
+		const sorted = sortApplogsByTs([y, x].slice())
+		expect(sorted.map(l => l.cid)).toEqual(['xxx', 'yyy'])
+	})
+})
+
+describe('isLaterByTsAndPv', () => {
+	const sameTs = '2026-04-25T00:00:00.000Z'
+
+	it('uses ts when ts differs', () => {
+		const earlier = mkLog({ cid: 'a' as any, ts: '2026-04-25T00:00:00.000Z' })
+		const later = mkLog({ cid: 'b' as any, ts: '2026-04-25T00:00:00.001Z' })
+		expect(isLaterByTsAndPv(later, earlier)).toBe(true)
+		expect(isLaterByTsAndPv(earlier, later)).toBe(false)
+	})
+
+	it('uses pv chain for same-ts same (en, at) logs', () => {
+		const a = mkLog({ cid: 'a' as any, pv: null, ts: sameTs })
+		const b = mkLog({ cid: 'b' as any, pv: 'a' as any, ts: sameTs })
+		expect(isLaterByTsAndPv(b, a)).toBe(true) // b chains after a
+		expect(isLaterByTsAndPv(a, b)).toBe(false)
+	})
+
+	it('falls back to cid-lex for same-ts unrelated logs', () => {
+		const x = mkLog({ cid: 'x' as any, pv: null, ts: sameTs })
+		const y = mkLog({ cid: 'y' as any, pv: null, ts: sameTs })
+		expect(isLaterByTsAndPv(y, x)).toBe(true)
+		expect(isLaterByTsAndPv(x, y)).toBe(false)
+	})
+
+	it('does not use pv when (en, at) differs', () => {
+		// Edge case: cid coincidence across keys must not be interpreted as a chain link
+		const a = mkLog({ cid: 'shared' as any, en: 'e1' as any, at: 'name', pv: null, ts: sameTs })
+		const b = mkLog({ cid: 'other' as any, en: 'e2' as any, at: 'name', pv: 'shared' as any, ts: sameTs })
+		// Same-ts, different (en, at) — should fall through to cid-lex
+		expect(isLaterByTsAndPv(b, a)).toBe('other'.localeCompare('shared') > 0)
+	})
+})

package/src/applog/applog-utils.ts

@@ -0,0 +1,507 @@
+import { Logger } from 'besonders-logger'
+import { isBefore } from 'date-fns'
+import { partial, pick } from 'lodash-es'
+import { isEqual } from 'lodash-es'
+import stringify from 'safe-stable-stringify'
+import type {
+	Applog,
+	ApplogForInsert,
+	ApplogValue,
+	DatalogQueryPattern,
+	DatalogQueryResultEntry,
+	ResultContext,
+	SearchContext,
+	ValueOrMatcher,
+} from './datom-types.ts'
+
+const { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO) // eslint-disable-line no-unused-vars
+
+export const isoDateStrCompare = (strA: string, strB: string, dir: 'asc' | 'desc' = 'asc') =>
+	dir === 'asc'
+		? strA.localeCompare(strB, 'en-US')
+		: strB.localeCompare(strA, 'en-US')
+export const objEqualByKeys = (keys: string[], objA: object, objB: object) => {
+	return isEqual(pick(objA, keys), pick(objB, keys))
+}
+
+/** Transitive total-order comparator over (ts, cid). Safe for `Array.sort`. */
+export const compareApplogsByTs = (logA: Applog, logB: Applog, dir: 'asc' | 'desc' = 'asc') => {
+	const tsCmp = isoDateStrCompare(logA.ts, logB.ts, dir)
+	if (tsCmp !== 0) return tsCmp
+	return dir === 'asc' ? logA.cid.localeCompare(logB.cid) : logB.cid.localeCompare(logA.cid)
+}
+export const compareApplogsByEnAt = partial(objEqualByKeys, ['en', 'at'])
+
+/**
+ * Pairwise: is `a` strictly later than `b` per (ts, pv-chain, cid)?
+ *
+ * NOT TRANSITIVE. Use only for two-log decisions (e.g. lastWriteWins replacement
+ * check). Do NOT pass to `Array.sort` — it can produce cycles at 3+ chain links
+ * and break the engine's sort.
+ */
+export function isLaterByTsAndPv(a: Applog, b: Applog): boolean {
+	const tsCmp = isoDateStrCompare(a.ts, b.ts)
+	if (tsCmp !== 0) return tsCmp > 0
+	if (a.en === b.en && a.at === b.at) {
+		if (a.pv === b.cid) return true
+		if (b.pv === a.cid) return false
+	}
+	return a.cid.localeCompare(b.cid) > 0
+}
+
+/**
+ * Sort applogs in chain-aware order (modifies array, also returns for chaining).
+ *
+ * Two-phase:
+ * 1. Transitive `(ts, cid)` `Array.sort` — fast, total-order, common case.
+ * 2. For each contiguous same-ts cluster (rare), chain-stabilize via `pv`
+ *    so chain-tail logs land last (asc) / first (desc) within their (en, at)
+ *    sub-group. Cross-group order within a cluster stays cid-lex.
+ *
+ * No-tie inputs pay only one linear scan past `Array.sort`.
+ */
+export function sortApplogsByTs(appLogArray: Applog[], dir: 'asc' | 'desc' = 'asc') {
+	appLogArray.sort((a, b) => compareApplogsByTs(a, b, dir))
+	let i = 0
+	while (i < appLogArray.length) {
+		let j = i + 1
+		while (j < appLogArray.length && appLogArray[j].ts === appLogArray[i].ts) j++
+		if (j - i > 1) chainStabilizeCluster(appLogArray, i, j, dir)
+		i = j
+	}
+	return appLogArray
+}
+
+/**
+ * Re-order applogs[from..to-1] (all sharing `ts`) so each (en, at) sub-group
+ * appears in pv-chain order. Cross-group positions in the cluster are preserved
+ * — only logs within the same (en, at) sub-group get reshuffled.
+ */
+function chainStabilizeCluster(applogs: Applog[], from: number, to: number, dir: 'asc' | 'desc') {
+	const groups = new Map<string, Applog[]>()
+	for (let k = from; k < to; k++) {
+		const log = applogs[k]
+		const key = log.en + '|' + log.at
+		const existing = groups.get(key)
+		if (existing) existing.push(log)
+		else groups.set(key, [log])
+	}
+	// All groups singleton — nothing to do (the common case)
+	if (groups.size === to - from) return
+
+	const orderedByGroup = new Map<string, Applog[]>()
+	for (const [key, logs] of groups) {
+		orderedByGroup.set(key, logs.length === 1 ? logs : topoSortByPv(logs, dir))
+	}
+	const cursors = new Map<string, number>()
+	for (let k = from; k < to; k++) {
+		const key = applogs[k].en + '|' + applogs[k].at
+		const cursor = cursors.get(key) ?? 0
+		applogs[k] = orderedByGroup.get(key)![cursor]
+		cursors.set(key, cursor + 1)
+	}
+}
+
+/**
+ * Topologically order `logs` (all sharing en, at, ts) by pv-chain.
+ * asc → root-first; desc → tail-first. Forks / multi-roots: tie-break by cid.
+ */
+function topoSortByPv(logs: Applog[], dir: 'asc' | 'desc'): Applog[] {
+	const cidSet = new Set(logs.map(l => l.cid))
+	const childrenByPv = new Map<string, Applog[]>()
+	const roots: Applog[] = []
+	for (const log of logs) {
+		if (log.pv && cidSet.has(log.pv)) {
+			const children = childrenByPv.get(log.pv)
+			if (children) children.push(log)
+			else childrenByPv.set(log.pv, [log])
+		} else {
+			roots.push(log)
+		}
+	}
+	const lexCmp = (a: Applog, b: Applog) => a.cid.localeCompare(b.cid)
+	roots.sort(lexCmp)
+	for (const children of childrenByPv.values()) children.sort(lexCmp)
+
+	const result: Applog[] = []
+	const visited = new Set<string>()
+	const stack = [...roots].reverse()
+	while (stack.length > 0) {
+		const log = stack.pop()!
+		if (visited.has(log.cid)) continue
+		visited.add(log.cid)
+		result.push(log)
+		const children = childrenByPv.get(log.cid)
+		if (children) for (let i = children.length - 1; i >= 0; i--) stack.push(children[i])
+	}
+	// Defensive: cycle (shouldn't happen with content-addressed pv) — append unvisited
+	if (result.length < logs.length) {
+		for (const log of logs) if (!visited.has(log.cid)) result.push(log)
+	}
+	return dir === 'desc' ? result.reverse() : result
+}
+export const isTsBefore = (log: Applog, logToCompare: Applog) => isBefore(new Date(log.ts), new Date(logToCompare.ts))
+export const uniqueEnFromAppLogs = (appLogArray: Applog[]) => [...new Set(appLogArray.map(eachLog => eachLog.en))]
+export const areApplogsEqual = (logA: Applog, logB: Applog) => isEqual(logA, logB)
+
+export type RemoveDuplicateAppLogsMode = 'safety' | 'cleanup'
+
+const warnMissingRemoveDuplicateMode = () => {
+	WARN(`[removeDuplicateAppLogs] mode not set; pass 'safety' or 'cleanup' for optimal behavior`)
+}
+
+const removeDuplicateAppLogsCleanup = (appLogArray: Applog[]) => {
+	const logMap = new Map<string, Applog>()
+	const verboseEnabled = VERBOSE.isEnabled
+	for (const eachLog of appLogArray) {
+		if (!eachLog) {
+			ERROR(`falsy entry in applogs`, appLogArray)
+			throw new Error(`falsy entry in applogs`)
+		}
+		if (!eachLog.cid) {
+			ERROR(`applog with missing CID`, eachLog)
+			throw new Error(`applog with missing CID`)
+		}
+		const key = eachLog.cid
+		const existing = logMap.get(key)
+		if (existing) {
+			if (verboseEnabled) VERBOSE(`Skipping duplicate applog:`, [existing, eachLog])
+		} else {
+			logMap.set(key, eachLog)
+		}
+	}
+	return Array.from(logMap.values())
+}
+
+const removeDuplicateAppLogsSafety = (appLogArray: Applog[]) => {
+	const seen = new Set<string>()
+	const verboseEnabled = VERBOSE.isEnabled
+	const existingByCid = verboseEnabled ? new Map<string, Applog>() : null
+	let result: Applog[] | null = null
+	let index = 0
+	for (const eachLog of appLogArray) {
+		if (!eachLog) {
+			ERROR(`falsy entry in applogs`, appLogArray)
+			throw new Error(`falsy entry in applogs`)
+		}
+		if (!eachLog.cid) {
+			ERROR(`applog with missing CID`, eachLog)
+			throw new Error(`applog with missing CID`)
+		}
+		const key = eachLog.cid
+		if (seen.has(key)) {
+			if (!result) {
+				result = appLogArray.slice(0, index)
+			}
+			if (verboseEnabled) VERBOSE(`Skipping duplicate applog:`, [existingByCid?.get(key), eachLog])
+		} else {
+			seen.add(key)
+			if (existingByCid) existingByCid.set(key, eachLog)
+			if (result) result.push(eachLog)
+		}
+		index++
+	}
+	return result ?? appLogArray
+}
+
+/**
+ * Deduplicate applogs by CID.
+ * - safety: fast duplicate check; returns original array if no duplicates found.
+ * - cleanup: optimized for merged arrays with likely duplicates.
+ */
+export const removeDuplicateAppLogs = (appLogArray: Applog[], mode?: RemoveDuplicateAppLogsMode) => {
+	if (!mode) {
+		warnMissingRemoveDuplicateMode()
+		return removeDuplicateAppLogsCleanup(appLogArray)
+	}
+	return mode === 'safety'
+		? removeDuplicateAppLogsSafety(appLogArray)
+		: removeDuplicateAppLogsCleanup(appLogArray)
+}
+
+// export const removeDuplicateAndMaybeDeletedAppLogs = (ds: Thread, appLogArray: Applog[], removeDeletedEntities = true) => {
+// 	const logMap = new Map()
+// 	for (const eachLog of appLogArray) {
+// 		if (!removeDeletedEntities || ds.entityIsDeleted(eachLog.en))
+// 			logMap.set(stringify(eachLog), eachLog)
+// 	}
+// 	return Array.from(logMap.values())
+// }
+
+export const getHashID = (stringifiable: any, lngth = 8) => cyrb53hash(stringify(stringifiable), 31, lngth) as string
+
+export function isVariable(x: any): x is string {
+	return typeof x === 'string' && x.startsWith('?')
+}
+export function variableNameWithoutQuestionmark(str: string) {
+	return str.slice(1)
+}
+// export function isMatcher(x: any): x is string {
+// 	return
+// }
+export function isStaticPattern(x: any): x is ApplogValue {
+	if (!['string', 'boolean', 'number', 'function'].includes(typeof x)) WARN(`Unhandled pattern value type:`, typeof x, x)
+	return !isVariable(x) && ['string', 'boolean', 'number'].includes(typeof x)
+}
+// export function isIgnorePattern(x: any): boolean {
+// 	return x === '_'
+// }
+
+/*
+ * In a pattern from a Query:
+ * - variables that don't have a value in the search context:
+ *   - remove from pattern
+ *   - add to variableToFill as: { en: 'movieID' } (useful for mapTo)
+ * - variables that have a value set:
+ *   - replace placeholder with actual value
+ */
+export function resolveOrRemoveVariables(pattern: DatalogQueryPattern, candidate: SearchContext) {
+	let variablesToFill = {} as Partial<{ [key in keyof Applog]: string }>
+	const newPattern: DatalogQueryPattern = {}
+	for (const [patternKey, patternValue] of Object.entries(pattern)) {
+		if (isVariable(patternValue)) {
+			const varName = variableNameWithoutQuestionmark(patternValue)
+			const candidateValue = candidate[varName]
+			if (candidateValue) {
+				newPattern[patternKey] = candidateValue
+				// & not adding it to newPattern
+			} else {
+				variablesToFill[patternKey] = varName
+			}
+		} else {
+			newPattern[patternKey] = patternValue // keep static value
+		}
+	}
+
+	return [newPattern, variablesToFill] as const
+}
+
+function matchVariable(variable: string, triplePart: ApplogValue, context: SearchContext): SearchContext {
+	if (context.hasOwnProperty(variable)) {
+		// TODO: fix lint error with: if (Object.hasOwnProperty.call(context, variable)) {
+		const bound = context[variable]
+		const match = matchPart(bound, triplePart, context)
+		// if (VERBOSE.isEnabled) VERBOSE('[matchVariable] match?', variable, bound, match)
+		return match
+	}
+	// if (VERBOSE.isEnabled) VERBOSE('[matchVariable] initializing variable', variable, 'to', triplePart)
+	return { ...context, [variable]: triplePart }
+}
+
+export function matchPartStatic(field: keyof Applog, patternPart: ValueOrMatcher<ApplogValue>, atomPart: ApplogValue): boolean {
+	// if (VERBOSE.isEnabled) VERBOSE('[matchPartStatic]', field, patternPart, patternPart === atomPart ? '===' : '!==', atomPart)
+	let result
+	if (patternPart) {
+		const typ = typeof patternPart
+		if (typ === 'string') {
+			result = patternPart === atomPart // shortcut for most common use-case
+		} else if (typ === 'function') {
+			result = (patternPart as Function)(atomPart)
+		} else if (typeof (patternPart as any).has === 'function') {
+			result = (patternPart as Set<any>).has(atomPart)
+		} else if (Array.isArray(patternPart) && !Array.isArray(atomPart) /* ? how to handle array values */) {
+			result = patternPart.includes(atomPart)
+		} // if (field === 'at' && typ === 'string' && patternPart.endsWith('*')) {
+		// 	return typeof atomPart === 'string' && atomPart.startsWith(patternPart.slice(0, -1))
+		// }
+		else {
+			result = patternPart === atomPart
+		}
+	} else {
+		result = patternPart === atomPart
+	}
+
+	// if (VERBOSE.isEnabled) VERBOSE('[matchPartStatic] =>', field.startsWith('!') ? '!' : '', result)
+	if (field.charAt(0) === '!') {
+		return !result
+	} else {
+		return result
+	}
+}
+export function matchPart(patternPart: ValueOrMatcher<ApplogValue>, atomPart: ApplogValue, context: SearchContext): ResultContext {
+	if (!context) {
+		// if (VERBOSE.isEnabled) VERBOSE('[matchPart] no context')
+		return null
+	}
+	if (typeof patternPart === 'string') {
+		if (isVariable(patternPart)) {
+			return matchVariable(patternPart, atomPart, context)
+		} /* TODO: else if (isIgnorePattern(patternPart)) {
+			return matchVariable(patternPart, atomPart, context)
+		} */
+	}
+	// if (VERBOSE.isEnabled) VERBOSE('[matchPart]', patternPart, patternPart === atomPart ? '===' : '!==', atomPart)
+	if (typeof patternPart === 'function') {
+		return patternPart(atomPart) ? context : null
+	}
+	return patternPart === atomPart ? context : null
+}
+
+/**
+ * Check if pattern matches triple with context substitutions
+ */
+export function matchPattern(pattern: DatalogQueryPattern, applog: Applog, context: SearchContext): ResultContext {
+	return Object.entries(pattern).reduce((context, [field, patternValue]) => {
+		const applogValue = applog[field]
+		// @ts-expect-error wtf no idea //HACK: ts weird
+		const patternValT: ValueOrMatcher<ApplogValue> = patternValue
+		return matchPart(patternValT, applogValue, context)
+	}, context)
+}
+
+export function actualize<SELECT extends string>(context: ResultContext, find: readonly SELECT[]): DatalogQueryResultEntry<SELECT> {
+	return Object.fromEntries(find.map((findField) => {
+		if (context === null) {
+			throw new Error(`actualize context is null ${find}`)
+		}
+		return [
+			isVariable(findField) ? findField.replace(/^\?/, '') : findField,
+			isVariable(findField) ? context[findField] : findField,
+		]
+	})) as DatalogQueryResultEntry<SELECT>
+}
+const sum = function sum(array: number[]) {
+	var num = 0
+	for (var i = 0, l = array.length; i < l; i++) num += array[i]
+	return num
+}
+const mean = function mean(array: number[]) {
+	return sum(array) / array.length
+}
+export const arrStats = {
+	max: function(array: number[]) {
+		return Math.max.apply(null, array)
+	},
+
+	min: function(array: number[]) {
+		return Math.min.apply(null, array)
+	},
+
+	range: function(array: number[]) {
+		return arrStats.max(array) - arrStats.min(array)
+	},
+
+	midrange: function(array: number[]) {
+		return arrStats.range(array) / 2
+	},
+
+	sum,
+
+	mean,
+
+	average: mean,
+
+	median: function(array: number[]) {
+		array.sort(function(a, b) {
+			return a - b
+		})
+		var mid = array.length / 2
+		return mid % 1 ? array[mid - 0.5] : (array[mid - 1] + array[mid]) / 2
+	},
+
+	modes: function(array: number[]) {
+		if (!array.length) return []
+		var modeMap = {},
+			maxCount = 0,
+			modes = []
+
+		array.forEach(function(val) {
+			if (!modeMap[val]) modeMap[val] = 1
+			else modeMap[val]++
+
+			if (modeMap[val] > maxCount) {
+				modes = [val]
+				maxCount = modeMap[val]
+			} else if (modeMap[val] === maxCount) {
+				modes.push(val)
+				maxCount = modeMap[val]
+			}
+		})
+		return modes
+	},
+
+	variance: function(array: number[]) {
+		var mean = arrStats.mean(array)
+		return arrStats.mean(array.map(function(num) {
+			return Math.pow(num - mean, 2)
+		}))
+	},
+
+	standardDeviation: function(array: number[]) {
+		return Math.sqrt(arrStats.variance(array))
+	},
+
+	meanAbsoluteDeviation: function(array: number[]) {
+		var mean = arrStats.mean(array)
+		return arrStats.mean(array.map(function(num) {
+			return Math.abs(num - mean)
+		}))
+	},
+
+	zScores: function(array: number[]) {
+		var mean = arrStats.mean(array)
+		var standardDeviation = arrStats.standardDeviation(array)
+		return array.map(function(num) {
+			return (num - mean) / standardDeviation
+		})
+	},
+}
+
+// Function aliases:
+arrStats.average = arrStats.mean
+
+export const tsNearlySame = (timeA: string, timeB: string) => timeB.startsWith(timeA.slice(0, timeA.length - 4)) // HACK: to quickly check if same second
+
+/*
+				cyrb53 (c) 2018 bryc (github.com/bryc)
+				A fast and simple hash function with decent collision resistance.
+				Largely inspired by MurmurHash2/3, but with a focus on speed/simplicity.
+				Public domain. Attribution appreciated.
+
+	ripped from https://github.com/bryc/code/blob/mast`er/jshash/experimental/cyrb53.js
+*/
+export const cyrb53hash = function(
+	str: string,
+	seed = 13,
+	strLength: number, /* = 0 */
+) {
+	if (!str?.length) {
+		throw new Error(`Empty string: ${str}`)
+	}
+
+	let h1 = 0xdeadbeef ^ seed
+	let h2 = 0x41c6ce57 ^ seed
+	for (let i = 0, ch; i < str.length; i++) {
+		ch = str.charCodeAt(i)
+		h1 = Math.imul(h1 ^ ch, 2654435761)
+		h2 = Math.imul(h2 ^ ch, 1597334677)
+	}
+	h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507) ^ Math.imul(h2 ^ (h2 >>> 13), 3266489909)
+	h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507) ^ Math.imul(h1 ^ (h1 >>> 13), 3266489909)
+	// if (strLength) {
+	const asHex = (4294967296 * (2097151 & h2) + (h1 >>> 0)).toString(16)
+	return asHex.slice(-strLength).padStart(strLength, '0')
+	// }
+	// // if not specified return as 16 digit integer
+	// return 4294967296 * (2097151 & h2) + (h1 >>> 0)
+}
+export function arraysContainSameElements(arr1, arr2) {
+	if (arr1.length !== arr2.length) {
+		return false
+	}
+
+	const sortedArr1 = [...arr1].sort()
+	const sortedArr2 = [...arr2].sort()
+
+	for (let i = 0; i < sortedArr1.length; i++) {
+		if (sortedArr1[i] !== sortedArr2[i]) {
+			return false
+		}
+	}
+
+	return true
+}
+export function dateNowIso(): string {
+	const now = new Date()
+	return now.toISOString()
+}