@wovin/core 0.1.36 → 0.2.2

package/dist/types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,cAAc,0BAA0B,CAAA"}
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../src/types.ts"],"names":[],"mappings":"AAAA,cAAc,6BAA6B,CAAA"}

package/dist/{types.min.js → types.js}

@@ -1,4 +1,4 @@
-import "./chunk-5MMGBK2U.min.js";
+import "./chunk-E46VTKTZ.js";
 import {
   BOOL,
   Bool,
@@ -10,8 +10,7 @@ import {
   Str,
   arrayIfSingle,
   checkParityTB
-} from "./chunk-HYMC7W6S.min.js";
-import "./chunk-PHITDXZT.min.js";
+} from "./chunk-ZAADLBSB.js";
 export {
   BOOL,
   Bool,
@@ -24,4 +23,4 @@ export {
   arrayIfSingle,
   checkParityTB
 };
-//# sourceMappingURL=types.min.js.map
+//# sourceMappingURL=types.js.map

package/dist/utils/debug-name.d.ts

@@ -0,0 +1,13 @@
+import type { Applog, DatalogQueryPattern } from '../applog/datom-types.ts';
+import type { Thread } from '../thread/basic.ts';
+export declare const createDebugName: ({ caller, thread, pattern, args }: {
+    caller?: string;
+    thread?: Thread | Applog[];
+    pattern?: DatalogQueryPattern | DatalogQueryPattern[] | string;
+    args?: any;
+}) => string;
+export declare const createDebugNameObj: (args: Parameters<typeof createDebugName>[0]) => {
+    readonly name: string;
+};
+export declare function prettifyThreadName(input: string): string;
+//# sourceMappingURL=debug-name.d.ts.map

package/dist/utils/debug-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"debug-name.d.ts","sourceRoot":"","sources":["../../src/utils/debug-name.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,MAAM,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAA;AAC3E,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAA;AAEhD,eAAO,MAAM,eAAe,GAAI,mCAAmC;IAClE,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,GAAG,MAAM,EAAE,CAAA;IAC1B,OAAO,CAAC,EAAE,mBAAmB,GAAG,mBAAmB,EAAE,GAAG,MAAM,CAAA;IAC9D,IAAI,CAAC,EAAE,GAAG,CAAA;CACV,WAMA,CAAA;AAED,eAAO,MAAM,kBAAkB,GAAI,MAAM,UAAU,CAAC,OAAO,eAAe,CAAC,CAAC,CAAC,CAAC;;CAE7E,CAAA;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAgCxD"}

package/dist/utils.d.ts

@@ -1,4 +1,4 @@
-import { Applog, ApplogEncNoCid } from './applog/datom-types';
+import { Applog, ApplogEncNoCid } from './applog/datom-types.ts';
 export declare const isTruthy: (l: Applog | ApplogEncNoCid) => boolean;
 export declare const keepTruthy: (arr: readonly any[]) => any[];
 //# sourceMappingURL=utils.d.ts.map

package/dist/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAA;AAE7D,eAAO,MAAM,QAAQ,GAAI,GAAG,MAAM,GAAG,cAAc,KAAG,OAAc,CAAA;AACpE,eAAO,MAAM,UAAU,GAAI,KAAK,SAAS,GAAG,EAAE,KAAG,GAAG,EAA0B,CAAA"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../src/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM,yBAAyB,CAAA;AAEhE,eAAO,MAAM,QAAQ,GAAI,GAAG,MAAM,GAAG,cAAc,KAAG,OAAc,CAAA;AACpE,eAAO,MAAM,UAAU,GAAI,KAAK,SAAS,GAAG,EAAE,KAAG,GAAG,EAA0B,CAAA"}

package/dist/utils.js

@@ -0,0 +1,9 @@
+import {
+  isTruthy,
+  keepTruthy
+} from "./chunk-YDAKBU6Q.js";
+export {
+  isTruthy,
+  keepTruthy
+};
+//# sourceMappingURL=utils.js.map

package/package.json

@@ -1,70 +1,78 @@
 {
   "name": "@wovin/core",
-  "version": "0.1.36",
+  "version": "0.2.2",
   "type": "module",
-  "main": "./dist/index.min.js",
-  "module": "./dist/index.min.js",
-  "browser": "./dist/index.min.js",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "browser": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
     ".": {
-      "import": "./dist/index.min.js",
+      "source": "./src/index.ts",
+      "import": "./dist/index.js",
       "types": "./dist/index.d.ts"
     },
     "./applog": {
-      "import": "./dist/applog.min.js",
+      "source": "./src/applog.ts",
+      "import": "./dist/applog.js",
       "types": "./dist/applog.d.ts"
     },
     "./blockstore": {
-      "import": "./dist/blockstore.min.js",
+      "source": "./src/blockstore.ts",
+      "import": "./dist/blockstore.js",
       "types": "./dist/blockstore.d.ts"
     },
     "./ipfs": {
-      "import": "./dist/ipfs.min.js",
+      "source": "./src/ipfs.ts",
+      "import": "./dist/ipfs.js",
       "types": "./dist/ipfs.d.ts"
     },
     "./pubsub": {
-      "import": "./dist/pubsub.min.js",
+      "source": "./src/pubsub.ts",
+      "import": "./dist/pubsub.js",
       "types": "./dist/pubsub.d.ts"
     },
     "./query": {
-      "import": "./dist/query.min.js",
+      "source": "./src/query.ts",
+      "import": "./dist/query.js",
       "types": "./dist/query.d.ts"
     },
     "./retrieve": {
-      "import": "./dist/retrieve.min.js",
+      "source": "./src/retrieve.ts",
+      "import": "./dist/retrieve.js",
       "types": "./dist/retrieve.d.ts"
     },
     "./thread": {
-      "import": "./dist/thread.min.js",
+      "source": "./src/thread.ts",
+      "import": "./dist/thread.js",
       "types": "./dist/thread.d.ts"
     },
     "./types": {
-      "import": "./dist/types.min.js",
+      "source": "./src/types.ts",
+      "import": "./dist/types.js",
       "types": "./dist/types.d.ts"
     },
     "./utils": {
-      "import": "./dist/utils.min.js",
+      "source": "./src/utils.ts",
+      "import": "./dist/utils.js",
       "types": "./dist/utils.d.ts"
     },
-    "./mobx": {
-      "import": "./dist/mobx.min.js",
-      "types": "./dist/mobx.d.ts"
-    },
     "./ipns": {
-      "import": "./dist/ipns.min.js",
+      "source": "./src/ipns.ts",
+      "import": "./dist/ipns.js",
       "types": "./dist/ipns.d.ts"
     }
   },
   "files": [
-    "./dist/"
+    "./dist/",
+    "./src/"
   ],
   "packageManager": "pnpm",
   "esm.sh": {
     "bundle": false
   },
   "peerDependencies": {
-    "@sinclair/typebox": "^0.31.28"
+    "@sinclair/typebox": ">=0.31.28 <1"
   },
   "dependencies": {
     "@ipld/car": "^5.4.2",
@@ -78,8 +86,6 @@
     "iso-signatures": "^0.5.1",
     "iso-ucan": "^0.4.2",
     "lodash-es": "^4.17.21",
-    "mobx": "^6.13.7",
-    "mobx-utils": "^6.1.1",
     "@libp2p/crypto": "^5.0.0",
     "ipns": "^10.1.2",
     "multiformats": "^13.4.1",
@@ -93,6 +99,7 @@
     "tsup": "^8.5.0",
     "typescript": "^5.9.2",
     "vite": "^7.1.7",
+    "vitest": "^3.1.3",
     "tsupconfig": "^0.0.0"
   },
   "repository": {
@@ -109,6 +116,8 @@
     "dev:code": "tsup --watch",
     "dev:types": "tsc --emitDeclarationOnly --declaration --watch",
     "lint": "eslint .",
+    "test": "vitest run",
+    "test:watch": "vitest",
     "clean": "rm -rf .turbo && rm -rf node_modules && rm -rf dist",
     "pub": "npm publish --tag latest --access=public"
   }

package/src/applog/applog-helpers.ts

@@ -0,0 +1,155 @@
+import { Logger } from 'besonders-logger'
+import { encodeApplogAndGetCid } from '../ipfs/ipfs-utils.ts'
+import { lastWriteWins } from '../query/basic.ts'
+import { MappedThread, rollingFilter, Thread, ThreadOnlyCurrent, type ThreadDerivation } from '../thread.ts'
+import { PartialBy } from '../types/typescript-utils.ts'
+import { dateNowIso, objEqualByKeys, removeDuplicateAppLogs, sortApplogsByTs } from './applog-utils.ts'
+import {
+	Applog,
+	ApplogForInsert,
+	ApplogForInsertOptionalAgent,
+	ApplogNoCid,
+	AgentHash,
+	CidString,
+	getApplogTypeErrors,
+	isValidApplog,
+	Timestamp,
+} from './datom-types.ts'
+
+const { WARN, LOG, DEBUG, VERBOSE, ERROR } = Logger.setup(Logger.INFO) // eslint-disable-line no-unused-vars
+
+export function ensureTsPvAndFinalizeApplogs(appLogsToInsert: ApplogForInsert[], threadForPv: Thread) {
+	DEBUG(`[ensureTsPvAndFinalizeApplogs] ENTER - ${appLogsToInsert.length} applogs, thread size=${threadForPv.size}`)
+	const ts = dateNowIso()
+	// const currentThread = lastWriteWins(threadForPv, { tolerateAlreadyFiltered: true }) // HACK to get `pv` from last write
+	const currentThread = threadForPv // HACK to not do un-cached lastWriteWins
+
+	// Within-batch (en, at) duplicates produce same-ts logs whose `pv` all point to the
+	// pre-batch tail (not to each other) — chain order is then ambiguous and the second
+	// insert is at the mercy of cid lex tie-break. Caller bug; warn so it's findable.
+	const seenInBatch = new Set<string>()
+	for (const log of appLogsToInsert) {
+		const key = log.en + '|' + log.at
+		if (seenInBatch.has(key)) {
+			WARN(
+				`[ensureTsPvAndFinalizeApplogs] within-batch duplicate (en, at)=(${log.en}, ${log.at}) — chain-pv won't link these; consider separate insert calls`,
+				{ log },
+			)
+			break // one warning per batch is plenty
+		}
+		seenInBatch.add(key)
+	}
+
+	DEBUG(`[ensureTsPvAndFinalizeApplogs] About to map over applogs`)
+	const mapped = appLogsToInsert.map((log, idx) => {
+		DEBUG(`[ensureTsPvAndFinalizeApplogs] Processing applog ${idx + 1}/${appLogsToInsert.length}`)
+		const result = finalizeApplogForInsert(log, { ts, threadForPv: currentThread })
+		DEBUG(`[ensureTsPvAndFinalizeApplogs] Finalized applog ${idx + 1}/${appLogsToInsert.length}`)
+		return result
+	})
+	DEBUG(`[ensureTsPvAndFinalizeApplogs] EXIT - mapped ${mapped.length} applogs`)
+	return mapped
+}
+export function ensureTsPvAndFinalizeApplog(applogToInsert: ApplogForInsert, threadForPv: Thread) {
+	return ensureTsPvAndFinalizeApplogs([applogToInsert], threadForPv)[0]
+}
+
+export function finalizeApplogForInsert(
+	log: ApplogForInsert,
+	{ ts, threadForPv }: { ts?: string; threadForPv?: Thread /*OnlyCurrent*/ } = {},
+) {
+	DEBUG(`[finalizeApplogForInsert] ENTER - en=${log.en}, at=${log.at}`)
+	DEBUG(`[finalizeApplogForInsert] About to call withTs`)
+	const logWithTs = withTs(log, ts ?? dateNowIso())
+	DEBUG(`[finalizeApplogForInsert] About to call withPvFrom (thread size=${threadForPv?.size ?? 'null'})`)
+	const logWithPv = withPvFrom(logWithTs, threadForPv)
+	DEBUG(`[finalizeApplogForInsert] About to call encodeApplogAndGetCid`)
+	const cid = encodeApplogAndGetCid(logWithPv).toString() as CidString
+	DEBUG(`[finalizeApplogForInsert] CID created: ${cid}`)
+	if ((log as Applog).cid && (log as Applog).cid !== cid) WARN(`[finalizeApplogForInsert] overwriting wrong CID`, { log, cid, logWithPv })
+	const logWithCid = { ...logWithPv, cid } satisfies Applog
+	DEBUG(`[finalizeApplogForInsert] About to validate applog`)
+	if (!isValidApplog(logWithCid)) {
+		throw ERROR(`Bogus Applog ${JSON.stringify(logWithCid)}`, getApplogTypeErrors(logWithCid))
+	}
+	DEBUG(`[finalizeApplogForInsert] EXIT - CID=${cid}`)
+	return Object.freeze(logWithCid)
+}
+
+export function hasAg(log: ApplogForInsertOptionalAgent): log is ApplogForInsert {
+	return !!log.ag
+}
+export function hasTs(log: ApplogForInsert): log is Omit<ApplogForInsert, 'ts'> & { ts: Timestamp } {
+	return !!log.ts
+}
+export function hasPv(log: ApplogForInsert): log is ApplogForInsert & { pv: string } {
+	return !!log.pv
+}
+
+export function withTs(log: ApplogForInsert, ts: Timestamp) {
+	return hasTs(log) ? log : { ...log, ts }
+}
+export function withAg(log: ApplogForInsertOptionalAgent, ag: AgentHash) {
+	return hasAg(log) ? log : { ...log, ag }
+}
+export function withPvFrom(log: PartialBy<ApplogNoCid, 'pv'>, thread: Thread /*OnlyCurrent*/ | null) {
+	DEBUG(`[withPvFrom] ENTER - en=${log.en}, at=${log.at}, hasPv=${log.pv !== undefined}`)
+	if (log.pv !== undefined) {
+		DEBUG(`[withPvFrom] EXIT early - pv already set`)
+		return log as ApplogNoCid // TODO: ? devMode WARN if it's different for catching bugs)
+	}
+	if (!thread) {
+		if (!hasPv(log)) throw ERROR(`[withPvFrom] no thread and no pv:`, log)
+		DEBUG(`[withPvFrom] EXIT - no thread, returning log with existing pv`)
+		return log // satisfies Pick<Applog, 'pv'>
+	} else {
+		const { en, at } = log
+		DEBUG(`[withPvFrom] About to call thread.findLast for en=${en}, at=${at}, thread.size=${thread.size}`)
+		const prevLog = thread.findLast(l => l.en == en && l.at == at) // HACK to not do lastWriteWins calc
+		DEBUG(`[withPvFrom] findLast completed, found=${!!prevLog}`)
+		// const prevLogs = rollingFilter(thread, { en, at }) // ? use some non-reactive filter here?
+		// if (prevLogs.size > 1) throw ERROR(`[withPvFrom] unexpected previous count:`, prevLogs.size, { log, prevLogs, thread }) // `thread` arg must be only current
+		// let prevLog = prevLogs.isEmpty ? null : prevLogs.applogs[0]
+		// const isMatchingPv = prevLog?.cid === log.pv
+		DEBUG(`[withPvFrom] About to check equality`)
+		if (objEqualByKeys(['en', 'at', 'vl', 'ts', 'ag'], log, prevLog)) {
+			throw ERROR(`[withPvFrom] Same as previous:`, { log, pv: prevLog, thread }) // bug catcher
+		}
+		// if (log.pv && !isMatchingPv) { // ineffective bc. shortcut in the beginning of this func
+		// 	WARN(`[withPvFrom] different than pre-set pv:`, { queriedPv: prevLog, logPv: log.pv })
+		// }
+		const prevLogCid = (log.pv !== undefined ? log.pv : prevLog?.cid) ?? null
+		DEBUG(`[withPvFrom] EXIT - prevLogCid=${prevLogCid}`)
+		return { ...log, pv: prevLogCid }
+	}
+}
+export function joinThreads(threads: ReadonlyArray<Thread>) {
+	const derivation: ThreadDerivation = {
+		compute(parents) {
+			if (parents.length < 2) DEBUG(`joinThreads with count=${parents.length}`) // ? EmptyThread
+			return sortApplogsByTs(
+				removeDuplicateAppLogs(parents.flatMap(s => {
+					const logs = s.applogs
+					if (!logs) {
+						ERROR(`falsy applogs of thread`, s)
+						throw new Error(`falsy applogs of thread`)
+					}
+					return logs
+				}), 'cleanup'),
+			)
+		},
+		mapDelta: (delta, { source, parents, state }) => ({
+			added: delta.added.filter(log => !state.includes(log)),
+			removed: delta.removed?.filter(log =>
+				state.includes(log) &&
+				!parents.some(p => p !== source && p.hasApplog(log, true))
+			),
+		}),
+	}
+	return new MappedThread(
+		`join(~ ${threads.map(s => s.name).join(', ')})`,
+		threads,
+		['?'], // HACK this basically says "we're not sure what filters are applied"
+		derivation,
+	)
+}

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)
+	})
+})