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

package/src/applog/applog-utils.ts

@@ -0,0 +1,398 @@
+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))
+}
+
+export const compareApplogsByTs = (logA: Applog, logB: Applog, dir: 'asc' | 'desc' = 'asc') => isoDateStrCompare(logA.ts, logB.ts, dir)
+export const compareApplogsByEnAt = partial(objEqualByKeys, ['en', 'at'])
+
+/** Sort by TS (modifies the array, but also returns for ease of use)  */
+export function sortApplogsByTs(appLogArray: Applog[], dir: 'asc' | 'desc' = 'asc') {
+	return appLogArray.sort((a, b) => compareApplogsByTs(a, b, dir))
+}
+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()
+}

package/src/applog/datom-types.ts

@@ -0,0 +1,148 @@
+// import type { AgentHash } from '../pubsub/pubsub-types.ts'
+// import type { CID } from '@oddjs/odd'
+import { FormatRegistry, Static, TSchema, Type } from '@sinclair/typebox'
+import { TypeCompiler } from '@sinclair/typebox/compiler'
+import { CID } from 'multiformats/cid'
+import type { PartialBy, Tagged } from '../types/typescript-utils.ts'
+
+export const Nullable = <T extends TSchema>(schema: T) => Type.Union([schema, Type.Null()])
+export const EntityID_LENGTH = 7
+// const bagu = 'baguqeerav3h4b46j2pyxikqhtm5si5vhzsyrba2duhrtltfutrlmj42anmvq'
+// const k51q = 'k51qzi5uqu5dhe1bxxjxj144bj2a225o1681yobevns26xlxtsfidjgnpwknfd'
+const isCID = /^(k51qz|baguq)[0-9a-z]{56,57}$/ // FIXME: k51 is not really a CID, is it?
+const isShortHash = /^[0-9A-Fa-f]{7,8}$/g // TODO awkward why are some 7 and some 8 long
+// engine level: min 6 (lenient within reason)
+// note3 TBD... either fixed for all entity types VS 7 for pub/sub, 8 for tags, 9 for blocks, 10 for relations etc...
+
+FormatRegistry.Set('EntityID', (value) => !!value.match(isShortHash) || !!value.match(isCID))
+export const EntityID = Type.String() // HACK how to configure ID format?
+/*{  format: 'EntityID'  }*/
+export type EntityID = Static<typeof EntityID>
+
+export type AgentHash = Tagged<string, 'AgentHash'>
+export type DatomPart = string // TODO refactor
+export type CidString = Tagged<string, CID>
+export type IpnsString = Tagged<CidString, 'IPNS'>
+export type AgentID = EntityID
+export type Attribute = string
+export type ApplogValue = string | boolean | number | null // TODO: use Tagged types
+// ? allow objects? or just as serialized strings? Or serialize everything anyways?
+
+export interface Atom {
+	en: EntityID
+	at: Attribute
+	vl: ApplogValue
+}
+
+export type Timestamp = string
+export interface Applog extends Atom {
+	cid: CidString
+	pv: CidString | null // ? | CID
+	ts: Timestamp
+	ag: AgentHash
+}
+export type ApplogNoCid = Omit<Applog, 'cid'>
+export type ApplogOptionalCid = PartialBy<Applog, 'cid'>
+export type ApplogForInsert = PartialBy<ApplogNoCid, 'ts' | 'pv'>
+export type ApplogForInsertOptionalAgent = PartialBy<ApplogForInsert, 'ag'>
+
+export interface ApplogEnc {
+	cid: CidString
+	enc: Uint8Array
+	iv?: Uint8Array // iv may be needed if we prefer a different strategy for transmitting iv (odd appends a random iv to the payload via keystoreAES.(en|de)cryptBytes)
+}
+export type ApplogEncNoCid = Omit<ApplogEnc, 'cid'>
+
+export type ApplogArrayMaybeEncrypted = (Applog | ApplogEnc)[]
+export type ApplogArrayMaybeEncryptedRO = readonly (Applog | ApplogEnc)[]
+export type ApplogArrayNoCIDMaybeEncryptedRO = readonly (ApplogNoCid | ApplogEncNoCid)[]
+
+export type ApplogOfSomeSort = Applog | ApplogEnc | ApplogNoCid | ApplogEncNoCid | ApplogForInsert
+
+export const isEncryptedApplog = (l: ApplogOfSomeSort): l is ApplogEnc => (l as ApplogEnc)?.enc instanceof Uint8Array
+
+export type AtomPattern = Atom | Applog
+
+export interface DatalogStateIdentifier {
+	lastTS: Timestamp
+}
+
+// New generic type for fields that can be a value, an array of that, or a function
+export type ValueOrMatcher<T> = T | readonly T[] | ReadonlySet<T> | ((value: T) => boolean)
+// Generic type that applies ValueOrMatcher to each field of T
+export type WithMatchers<T extends Record<string, any>> = {
+	[K in keyof T & string as `${K}` | `!${K}`]?: ValueOrMatcher<T[K]>
+}
+
+export type DatalogQueryPattern = Partial<WithMatchers<Applog>>
+export type DatalogQueryPatternArray = DatalogQueryPattern[]
+export interface DatalogQuery<SELECT extends string> {
+	find: readonly SELECT[] // see: https://github.com/microsoft/TypeScript/issues/20965#issuecomment-868981458
+	where: DatalogQueryPatternArray
+	onlyLatest?: boolean
+}
+export type DatalogQueryResultEntry<SELECT extends string> = Record<
+	// SELECT,
+	StripPrefix<'?', SELECT>,
+	DatomPart
+>
+export type DatalogQueryResultRows<SELECT extends string> = DatalogQueryResultEntry<SELECT>[]
+// export type StripTest = StripPrefix<'?', '?A' | '?B'>
+// export type DatalogQueryResultEntryTEST = DatalogQueryResultEntry<'?A' | '?B'>
+// export type DatalogQueryResultEntryTESTX = MapKeysStripPrefix<'?A' | '?B', '?'>
+
+export interface SearchContext {
+	[key: string]: ApplogValue
+}
+export interface SearchContextWithLog {
+	context: SearchContext
+	applog?: Applog
+}
+
+export type ResultContext = SearchContext | null
+
+/* https://stackoverflow.com/a/72497461 */
+type StripPrefix<
+	TPrefix extends string,
+	T extends string,
+> = T extends `${TPrefix}${infer R}` ? R : never
+
+type MapKeysStripPrefix<SELECT extends string, TPrefix extends string> = {
+	[K in SELECT as StripPrefix<TPrefix, K>]: DatomPart
+}
+
+FormatRegistry.Set('CID', (value) => !!value.match(isCID))
+export const CIDTB = Type.String({ format: 'CID' })
+export type CIDTB = Static<typeof EntityID>
+
+const isURL = /^http([s]?):\/\/.*\..*/
+FormatRegistry.Set('URL', (value) => !!value.match(isURL))
+export const URL = Type.String({ format: 'URL' })
+export type URL = Static<typeof URL>
+
+export const AppLogNoCidTB = Type.Object({
+	en: EntityID, // EntityID
+	at: Type.String(), // Attribute
+	vl: Nullable(Type.Union([Type.String(), Type.Boolean(), Type.Number()])), // TODO refactor to semantic typesafe ApplogValue
+	ts: Type.String(), // Timestamp
+	ag: Type.String(), // AgentHash
+	pv: Nullable(CIDTB), // CidString
+})
+export type AppLogNoCidTB = Static<typeof AppLogNoCidTB> // type T = {
+
+export const AppLogNoCidTBC = TypeCompiler.Compile(AppLogNoCidTB)
+export const getApplogNoCidTypeErrors = (obj: any) => Array.from(AppLogNoCidTBC.Errors(obj))
+export const isValidApplogNoCid = AppLogNoCidTBC.Check.bind(AppLogNoCidTBC) // ? Include CID
+
+export const AppLogTB = Type.Composite([
+	Type.Object({
+		cid: CIDTB,
+	}),
+	AppLogNoCidTB,
+])
+export type AppLogTB = Static<typeof AppLogTB> // type T = {
+
+export const AppLogTBC = TypeCompiler.Compile(AppLogTB)
+export const getApplogTypeErrors = (obj: any) => Array.from(AppLogTBC.Errors(obj))
+export const isValidApplog = AppLogTBC.Check.bind(AppLogTBC) // ? Include CID
+// maybe useful for defaulting https://github.com/sinclairzx81/typebox#cast

package/src/applog.ts

@@ -0,0 +1,3 @@
+export * from './applog/applog-helpers.ts'
+export * from './applog/applog-utils.ts'
+export * from './applog/datom-types.ts'

package/src/blockstore/index.ts

@@ -0,0 +1,36 @@
+import type { CID } from 'multiformats/cid'
+
+/** Minimal async block store interface — get/put/has. */
+export interface BlockStore {
+	get(cid: CID): Promise<Uint8Array>
+	put(cid: CID, bytes: Uint8Array): Promise<void>
+	has(cid: CID): Promise<boolean>
+}
+
+/**
+ * A block store that reads locally first, with optional remote fallback.
+ * On get: local hit → return; local miss + remote → fetch, write-back, return.
+ * put/has always operate on local only.
+ */
+export class LocalFirstBlockStore implements BlockStore {
+	constructor(
+		private local: BlockStore,
+		private remote?: Pick<BlockStore, 'get'>,
+	) {}
+
+	async get(cid: CID): Promise<Uint8Array> {
+		if (await this.local.has(cid)) return this.local.get(cid)
+		if (!this.remote) throw new Error(`Block not found: ${cid}`)
+		const bytes = await this.remote.get(cid)
+		await this.local.put(cid, bytes)
+		return bytes
+	}
+
+	put(cid: CID, bytes: Uint8Array): Promise<void> {
+		return this.local.put(cid, bytes)
+	}
+
+	has(cid: CID): Promise<boolean> {
+		return this.local.has(cid)
+	}
+}

package/src/blockstore.ts

@@ -0,0 +1 @@
+export * from './blockstore/index.ts'

package/src/index.ts

@@ -0,0 +1,8 @@
+export * from './applog.ts'
+export * from './ipfs.ts'
+export * from './pubsub.ts'
+export * from './query.ts'
+export * from './retrieve.ts'
+export * from './thread.ts'
+export * from './types.ts'
+// export * from './utils.ts'